From c044a0f9b96fc348e32afc0e80572887a7ea2cfa Mon Sep 17 00:00:00 2001
From: Enrico Sorichetti <e.sorichetti@alice.it>
Date: Thu, 15 Mar 2012 10:10:53 +0100
Subject: [PATCH 01/16] moved the HHC17527 message to msgenu.h

---
 hRexx.c          |  2 --
 hRexx_readme.txt | 24 +++++++++++++++++++++++-
 msgenu.h         |  1 +
 3 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/hRexx.c b/hRexx.c
index 5b5d9d37..3d83e7dc 100644
--- a/hRexx.c
+++ b/hRexx.c
@@ -18,8 +18,6 @@
 
 #if defined(ENABLE_OBJECT_REXX) || defined(ENABLE_REGINA_REXX)
 
-#define HHC17527 "REXX(%s) Has been AUTO started/enabled"
-
 #include "hRexx.h"
 
 // forward references
diff --git a/hRexx_readme.txt b/hRexx_readme.txt
index 73ea8a08..b1df9669 100644
--- a/hRexx_readme.txt
+++ b/hRexx_readme.txt
@@ -89,8 +89,30 @@ well You are all smart enough to understand how it works
 enoug documenation for now! I am fed up of writing :-)
 
 ! oops I forgot an important thing ...
-! when starting/enabling object rexx receiving a 1002 error is not really
+! when starting/enabling object rexx, receiving a 1002 error is not really
 ! a RXAPI_MEMFAIL
 ! it is a consequence of the RXAPI daemon not being active
 ! it should be enough to start it according to the documentation
 ! or have it autostarted at ipl/boot time
+
+I tested with a standard ooRexx and Regina Rexx installation
+and as long the installer sets up correctly the path for dynamic libraries
+the hercules rexx interface will find them
+( tested on fedora core 15, both oorexx and regina )
+
+if the installation is <not standard> then it is a user task to
+setup properly the overall environment
+for example defining the relevant symlinks from /usr/<whatever> to the
+relative paths for the non standared rexx installation
+from :
+/usr/bin to <rexx>/bin
+/usr/lib to <rexx>/lib ( on some linux[es] regina uses lib64 )
+the above are needed to run, to compile
+/usr/include to <rexx>/include
+
+please let me know of standard installations where the Rexx interface
+fails to find the dynamic libraries
+
+
+
+
diff --git a/msgenu.h b/msgenu.h
index b2ef48a0..4fb933ff 100644
--- a/msgenu.h
+++ b/msgenu.h
@@ -1955,6 +1955,7 @@ do { \
 #define HHC17524 "REXX(%s) Stop/Disable invalid in a single REXX environment"
 #define HHC17525 "REXX(%s) Has been started/enabled"
 #define HHC17526 "REXX(%s) Has been stopped/disabled"
+#define HHC17527 "REXX(%s) Has been AUTO started/enabled"
 
 #define HHC17530 "REXX(%s) %s"
 #define HHC17531 "REXX(%s) Dynamic library '%s' open/load error"

From d9c5b5fef3cb798e938979643b5feadf38478768 Mon Sep 17 00:00:00 2001
From: Jan Jaeger <jan.jaeger@westnet.com.au>
Date: Thu, 15 Mar 2012 21:05:06 +1100
Subject: [PATCH 02/16] Minor updates

---
 chsc.c     | 10 ++++++----
 hstructs.h |  1 +
 qeth.c     |  7 ++++++-
 3 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/chsc.c b/chsc.c
index 7796316f..d29de79d 100644
--- a/chsc.c
+++ b/chsc.c
@@ -67,6 +67,7 @@ CHSC_RSP4 *chsc_rsp4 = (CHSC_RSP4 *)(chsc_rsp+1);
         memset(chsc_rsp4, 0, sizeof(CHSC_RSP4) );
         if((dev = find_device_by_subchan((LCSS_TO_SSID(lcss) << 16)|sch)))
         {
+            int n;
             chsc_rsp4->sch_val = 1;
             if(dev->pmcw.flag5 & PMCW5_V)
                 chsc_rsp4->dev_val = 1;
@@ -76,10 +77,10 @@ CHSC_RSP4 *chsc_rsp4 = (CHSC_RSP4 *)(chsc_rsp+1);
             chsc_rsp4->path_mask = dev->pmcw.pim;
             STORE_HW(chsc_rsp4->sch, sch);
             memcpy(chsc_rsp4->chpid, dev->pmcw.chpid, 8);
-#if 1 // ZZTEST
-            chsc_rsp4->fla_valid_mask = 0x80;
-            STORE_HW(chsc_rsp4->fla[0], ((dev->devnum & 0xff00) >> 8));
-#endif
+            chsc_rsp4->fla_valid_mask = dev->pmcw.pim;
+            for(n = 0; n < 7; n++)
+                if(dev->pmcw.pim & (0x80 >> n))
+                    STORE_HW(chsc_rsp4->fla[n], dev->fla[n]);
         }
     }
 
@@ -187,6 +188,7 @@ U16 req_len, rsp_len;
     CHSC_AI(chsc_rsp10->general_char,12) |= CHSC_BI(12); /* Dynamic IO */
 #if defined(FEATURE_QUEUED_DIRECT_IO)
     CHSC_AI(chsc_rsp10->general_char,41) |= CHSC_BI(41); /* Adapter Interruption Facility */
+    CHSC_AI(chsc_rsp10->chsc_char,1) |= CHSC_BI(1);
 #endif /*defined(FEATURE_QUEUED_DIRECT_IO)*/
     if(sysblk.mss)
         CHSC_AI(chsc_rsp10->general_char,45) |= CHSC_BI(45); /* Multiple CSS */
diff --git a/hstructs.h b/hstructs.h
index e089f178..4b07c40b 100644
--- a/hstructs.h
+++ b/hstructs.h
@@ -1079,6 +1079,7 @@ struct DEVBLK {                         /* Device configuration block*/
 #define DEV_SYS_LOCAL   0xffff          /* Local system active on dev*/
         BYTE    drvpwd[11];             /* Password for drive        */
         BYTE    sensemm[5];             /* Manuf. & model for sense  */
+        U16     fla[8];                 /* Full Link Address Array   */
 
         /*  control flags...                                         */
         unsigned int                    /* Flags                     */
diff --git a/qeth.c b/qeth.c
index 01472990..23b80451 100644
--- a/qeth.c
+++ b/qeth.c
@@ -43,7 +43,7 @@
 #include "qeth.h"
 #include "tuntap.h"
 
-// #define QETH_DEBUG
+#define QETH_DEBUG
 
 #if defined(DEBUG) && !defined(QETH_DEBUG)
  #define QETH_DEBUG
@@ -487,6 +487,7 @@ U32 ackseq;
                             TRACE("Query SubCommands\n");
                             STORE_FW(qry->suppcm,IPA_SAP_SUPP);
 // STORE_FW(qry->suppcm, 0xFFFFFFFF); /* ZZ */
+STORE_FW(qry->suppcm, 0xFFFFFFFF); /* ZZ */
                             STORE_HW(sap->rc,IPA_RC_OK);
                             STORE_HW(ipa->rc,IPA_RC_OK);
                         }
@@ -631,6 +632,8 @@ U32 ackseq;
                 TRACE("L3 Query IP Assist\n");
                 STORE_FW(ipa->ipas,IPA_SUPP);
 // STORE_FW(ipa->ipas, 0xFFFFFFFF); /* ZZ */
+STORE_FW(ipa->ipas, 0xFFFFFFFF); /* ZZ */
+// STORE_FW(ipa->ipas, IPA_SETADAPTERPARMS); /* ZZ */
                 STORE_HW(ipa->rc,IPA_RC_OK);
                 break;
 
@@ -1144,6 +1147,8 @@ int i;
     memcpy(dev->devid, sense_id_bytes, sizeof(sense_id_bytes));
     dev->devtype = dev->devid[1] << 8 | dev->devid[2];
 
+    dev->fla[0] = 0x0101;
+
     if(!(grouped = group_device(dev,OSA_GROUP_SIZE)) && !dev->member)
     {
         dev->group->grp_data = grp = malloc(sizeof(OSA_GRP));

From d16e607709de0835cefdc93b5ac83f41b0cec171 Mon Sep 17 00:00:00 2001
From: Jan Jaeger <jan.jaeger@westnet.com.au>
Date: Thu, 15 Mar 2012 21:34:54 +1100
Subject: [PATCH 03/16] Turn debug off in qeth.c

---
 qeth.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/qeth.c b/qeth.c
index 23b80451..390a435c 100644
--- a/qeth.c
+++ b/qeth.c
@@ -43,7 +43,7 @@
 #include "qeth.h"
 #include "tuntap.h"
 
-#define QETH_DEBUG
+// #define QETH_DEBUG
 
 #if defined(DEBUG) && !defined(QETH_DEBUG)
  #define QETH_DEBUG
@@ -487,7 +487,6 @@ U32 ackseq;
                             TRACE("Query SubCommands\n");
                             STORE_FW(qry->suppcm,IPA_SAP_SUPP);
 // STORE_FW(qry->suppcm, 0xFFFFFFFF); /* ZZ */
-STORE_FW(qry->suppcm, 0xFFFFFFFF); /* ZZ */
                             STORE_HW(sap->rc,IPA_RC_OK);
                             STORE_HW(ipa->rc,IPA_RC_OK);
                         }
@@ -632,8 +631,6 @@ STORE_FW(qry->suppcm, 0xFFFFFFFF); /* ZZ */
                 TRACE("L3 Query IP Assist\n");
                 STORE_FW(ipa->ipas,IPA_SUPP);
 // STORE_FW(ipa->ipas, 0xFFFFFFFF); /* ZZ */
-STORE_FW(ipa->ipas, 0xFFFFFFFF); /* ZZ */
-// STORE_FW(ipa->ipas, IPA_SETADAPTERPARMS); /* ZZ */
                 STORE_HW(ipa->rc,IPA_RC_OK);
                 break;
 
@@ -1149,6 +1146,9 @@ int i;
 
     dev->fla[0] = 0x0101;
 
+    if(IS_OSA_DATA_DEVICE(dev))
+        dev->pmcw.flag4 |= PMCW4_Q;
+
     if(!(grouped = group_device(dev,OSA_GROUP_SIZE)) && !dev->member)
     {
         dev->group->grp_data = grp = malloc(sizeof(OSA_GRP));
@@ -1229,8 +1229,8 @@ int i;
 
     if(grouped)
     {
-        for(i = 0; i < OSA_GROUP_SIZE; i++)
-            dev->group->memdev[i]->pmcw.flag4 |= PMCW4_Q;
+//      for(i = 0; i < OSA_GROUP_SIZE; i++)
+//          dev->group->memdev[i]->pmcw.flag4 |= PMCW4_Q;
     }
 
     return 0;

From 0e5533687a52a4e03c352e20e258addde77af4ff Mon Sep 17 00:00:00 2001
From: Jan Jaeger <jan.jaeger@westnet.com.au>
Date: Thu, 15 Mar 2012 22:43:42 +1100
Subject: [PATCH 04/16] Ensure PCWM4_Q is set on OSA data device

---
 qeth.c | 34 ++++++++++++++++++----------------
 1 file changed, 18 insertions(+), 16 deletions(-)

diff --git a/qeth.c b/qeth.c
index 390a435c..f617098e 100644
--- a/qeth.c
+++ b/qeth.c
@@ -1146,9 +1146,6 @@ int i;
 
     dev->fla[0] = 0x0101;
 
-    if(IS_OSA_DATA_DEVICE(dev))
-        dev->pmcw.flag4 |= PMCW4_Q;
-
     if(!(grouped = group_device(dev,OSA_GROUP_SIZE)) && !dev->member)
     {
         dev->group->grp_data = grp = malloc(sizeof(OSA_GRP));
@@ -1229,6 +1226,7 @@ int i;
 
     if(grouped)
     {
+        dev->group->memdev[OSA_DATA_DEVICE]->pmcw.flag4 |= PMCW4_Q;
 //      for(i = 0; i < OSA_GROUP_SIZE; i++)
 //          dev->group->memdev[i]->pmcw.flag4 |= PMCW4_Q;
     }
@@ -1372,29 +1370,33 @@ static int qeth_ssqd_desc ( DEVBLK *dev, void *desc )
 
     STORE_HW(chsc_rsp24->sch, dev->subchan);
 
-    chsc_rsp24->flags |= ( CHSC_FLAG_QDIO_CAPABILITY | CHSC_FLAG_VALIDITY );
+    if(dev->pmcw.flag4 & PMCW4_Q)
+    {
+
+        chsc_rsp24->flags |= ( CHSC_FLAG_QDIO_CAPABILITY | CHSC_FLAG_VALIDITY );
 
-    chsc_rsp24->qdioac1 |= ( AC1_SIGA_INPUT_NEEDED | AC1_SIGA_OUTPUT_NEEDED );
-    chsc_rsp24->qdioac1 |= AC1_AUTOMATIC_SYNC_ON_OUT_PCI;
+        chsc_rsp24->qdioac1 |= ( AC1_SIGA_INPUT_NEEDED | AC1_SIGA_OUTPUT_NEEDED );
+        chsc_rsp24->qdioac1 |= AC1_AUTOMATIC_SYNC_ON_OUT_PCI;
 
 #if defined(_FEATURE_QEBSM)
-    if(FACILITY_ENABLED_DEV(QEBSM))
-    {
-        STORE_DW(chsc_rsp24->sch_token, IOID2TKN((dev->ssid << 16) | dev->subchan));
-        chsc_rsp24->qdioac1 |= ( AC1_SC_QEBSM_AVAILABLE | AC1_SC_QEBSM_ENABLED );
-    }
+        if(FACILITY_ENABLED_DEV(QEBSM))
+        {
+            STORE_DW(chsc_rsp24->sch_token, IOID2TKN((dev->ssid << 16) | dev->subchan));
+            chsc_rsp24->qdioac1 |= ( AC1_SC_QEBSM_AVAILABLE | AC1_SC_QEBSM_ENABLED );
+        }
 #endif /*defined(_FEATURE_QEBSM)*/
 
 #if defined(_FEATURE_QDIO_THININT)
-    if(FACILITY_ENABLED_DEV(QDIO_THININT))
-        chsc_rsp24->qdioac1 |= AC1_AUTOMATIC_SYNC_ON_THININT;
+        if(FACILITY_ENABLED_DEV(QDIO_THININT))
+            chsc_rsp24->qdioac1 |= AC1_AUTOMATIC_SYNC_ON_THININT;
 #endif /*defined(_FEATURE_QDIO_THININT)*/
 
 #if 1 // ZZTEST
-      chsc_rsp24->icnt = QDIO_MAXQ;
-      chsc_rsp24->ocnt = QDIO_MAXQ;
-      chsc_rsp24->mbccnt = 0x04;
+          chsc_rsp24->icnt = QDIO_MAXQ;
+          chsc_rsp24->ocnt = QDIO_MAXQ;
+          chsc_rsp24->mbccnt = 0x04;
 #endif
+    }
 
     return 0;
 }

From 4b673086defd97e4a162d4cd89d703f80f444f75 Mon Sep 17 00:00:00 2001
From: Jan Jaeger <jan.jaeger@westnet.com.au>
Date: Fri, 16 Mar 2012 08:52:09 +1100
Subject: [PATCH 05/16] Add bit 8 to general characteristics

---
 chsc.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/chsc.c b/chsc.c
index d29de79d..23eac5eb 100644
--- a/chsc.c
+++ b/chsc.c
@@ -189,6 +189,7 @@ U16 req_len, rsp_len;
 #if defined(FEATURE_QUEUED_DIRECT_IO)
     CHSC_AI(chsc_rsp10->general_char,41) |= CHSC_BI(41); /* Adapter Interruption Facility */
     CHSC_AI(chsc_rsp10->chsc_char,1) |= CHSC_BI(1);
+    CHSC_AI(chsc_rsp10->chsc_char,8) |= CHSC_BI(8);
 #endif /*defined(FEATURE_QUEUED_DIRECT_IO)*/
     if(sysblk.mss)
         CHSC_AI(chsc_rsp10->general_char,45) |= CHSC_BI(45); /* Multiple CSS */

From 41fcdb59298ce2f834f22aeab84d3cc57608d175 Mon Sep 17 00:00:00 2001
From: Jan Jaeger <jan.jaeger@westnet.com.au>
Date: Fri, 16 Mar 2012 11:06:22 +1100
Subject: [PATCH 06/16] Add missing activity control on adapter interrupt

---
 qeth.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/qeth.c b/qeth.c
index f617098e..bd2e2e84 100644
--- a/qeth.c
+++ b/qeth.c
@@ -779,7 +779,7 @@ OSA_IEAR *iear = (OSA_IEAR*)rdev->qrspbf;
 static void raise_adapter_interrupt(DEVBLK *dev)
 {
     obtain_lock(&dev->lock);
-    dev->pciscsw.flag2 |= SCSW2_Q;
+    dev->pciscsw.flag2 |= SCSW2_Q | SCSW2_FC_START;
     dev->pciscsw.flag3 |= SCSW3_SC_INTER | SCSW3_SC_PEND;
     dev->pciscsw.chanstat = CSW_PCI;
     QUEUE_IO_INTERRUPT(&dev->pciioint);

From e0550aad1412071c222ea4801fc7840bf75e0d10 Mon Sep 17 00:00:00 2001
From: Jan Jaeger <jan.jaeger@westnet.com.au>
Date: Fri, 16 Mar 2012 18:55:22 +1100
Subject: [PATCH 07/16] Simpfy macros - no functional change

---
 chsc.c | 40 ++++++++++++++++++++--------------------
 chsc.h |  8 ++++++--
 2 files changed, 26 insertions(+), 22 deletions(-)

diff --git a/chsc.c b/chsc.c
index 23eac5eb..31de6b21 100644
--- a/chsc.c
+++ b/chsc.c
@@ -178,42 +178,42 @@ U16 req_len, rsp_len;
     memset(chsc_rsp10->chsc_char, 0, sizeof(chsc_rsp10->chsc_char));
 
 #if defined(FEATURE_REGION_RELOCATE)
-    CHSC_AI(chsc_rsp10->general_char,2) |= CHSC_BI(2);
-    CHSC_AI(chsc_rsp10->general_char,5) |= CHSC_BI(5);
+    CHSC_SB(chsc_rsp10->general_char,2);
+    CHSC_SB(chsc_rsp10->general_char,5);
 #endif
 #if defined(FEATURE_CANCEL_IO_FACILITY)
-    CHSC_AI(chsc_rsp10->general_char,6) |= CHSC_BI(6);
+    CHSC_SB(chsc_rsp10->general_char,6);
 #endif
-    CHSC_AI(chsc_rsp10->general_char,7) |= CHSC_BI(7);   /* Concurrent Sense */
-    CHSC_AI(chsc_rsp10->general_char,12) |= CHSC_BI(12); /* Dynamic IO */
+    CHSC_SB(chsc_rsp10->general_char,7);         /* Concurrent Sense */
+    CHSC_SB(chsc_rsp10->general_char,12);              /* Dynamic IO */
 #if defined(FEATURE_QUEUED_DIRECT_IO)
-    CHSC_AI(chsc_rsp10->general_char,41) |= CHSC_BI(41); /* Adapter Interruption Facility */
-    CHSC_AI(chsc_rsp10->chsc_char,1) |= CHSC_BI(1);
-    CHSC_AI(chsc_rsp10->chsc_char,8) |= CHSC_BI(8);
+    CHSC_SB(chsc_rsp10->general_char,41);  /* Adapter Interruption Facility */
+    CHSC_SB(chsc_rsp10->chsc_char,1);
+    CHSC_SB(chsc_rsp10->chsc_char,8);
 #endif /*defined(FEATURE_QUEUED_DIRECT_IO)*/
     if(sysblk.mss)
-        CHSC_AI(chsc_rsp10->general_char,45) |= CHSC_BI(45); /* Multiple CSS */
-//  CHSC_AI(chsc_rsp10->general_char,46) |= CHSC_BI(46); /* FCS */
-//  CHSC_AI(chsc_rsp10->general_char,48) |= CHSC_BI(48); /* Ext MB */
+        CHSC_SB(chsc_rsp10->general_char,45);        /* Multiple CSS */
+//  CHSC_SB(chsc_rsp10->general_char,46);                     /* FCS */
+//  CHSC_SB(chsc_rsp10->general_char,48);                  /* Ext MB */
 #if defined(_FEATURE_QDIO_TDD)
     if(FACILITY_ENABLED(QDIO_TDD, regs))
-        CHSC_AI(chsc_rsp10->general_char,56) |= CHSC_BI(56); /* AIF Time Delay Disablement fac*/
+        CHSC_SB(chsc_rsp10->general_char,56);  /* AIF Time Delay Disablement fac*/
 #endif /*defined(_FEATURE_QDIO_TDD)*/
 #if defined(_FEATURE_QEBSM)
     if(FACILITY_ENABLED(QEBSM, regs))
-        CHSC_AI(chsc_rsp10->general_char,58) |= CHSC_BI(58);
+        CHSC_SB(chsc_rsp10->general_char,58);
 #endif /*defined(_FEATURE_QEBSM)*/
 #if defined(_FEATURE_QDIO_THININT)
     if(FACILITY_ENABLED(QDIO_THININT, regs))
-        CHSC_AI(chsc_rsp10->general_char,67) |= CHSC_BI(67); /* OSA/FCP Thin interrupts */
+        CHSC_SB(chsc_rsp10->general_char,67);  /* OSA/FCP Thin interrupts */
 #endif /*defined(_FEATURE_QDIO_THININT)*/
-//  CHSC_AI(chsc_rsp10->general_char,82) |= CHSC_BI(82); /* CIB */
-//  CHSC_AI(chsc_rsp10->general_char,88) |= CHSC_BI(88); /* FCX */
+//  CHSC_SB(chsc_rsp10->general_char,82);                     /* CIB */
+//  CHSC_SB(chsc_rsp10->general_char,88);                     /* FCX */
 
-//  CHSC_AI(chsc_rsp10->chsc_char,84) |= CHSC_BI(84); /* SECM */
-//  CHSC_AI(chsc_rsp10->chsc_char,86) |= CHSC_BI(86); /* SCMC */
-//  CHSC_AI(chsc_rsp10->chsc_char,107) |= CHSC_BI(107); /* Set Channel Subsystem Char */
-//  CHSC_AI(chsc_rsp10->chsc_char,108) |= CHSC_BI(108); /* Fast CHSCs */
+//  CHSC_SB(chsc_rsp10->chsc_char,84);                       /* SECM */
+//  CHSC_SB(chsc_rsp10->chsc_char,86);                       /* SCMC */
+//  CHSC_SB(chsc_rsp10->chsc_char,107); /* Set Channel Subsystem Char */
+//  CHSC_SB(chsc_rsp10->chsc_char,108);                /* Fast CHSCs */
 
     /* Store request OK */
     STORE_HW(chsc_rsp->rsp,CHSC_REQ_OK);
diff --git a/chsc.h b/chsc.h
index 975f6756..f814d3c0 100644
--- a/chsc.h
+++ b/chsc.h
@@ -13,8 +13,12 @@
 #define _CHSC_H
 
 
-#define CHSC_AI(_array, _bitno) ((_array)[((_bitno)/32)][(((_bitno)%32)/8)])
-#define CHSC_BI(_bitno) (0x80 >> (((_bitno)%32)%8))
+#define _CHSC_AI(_array, _bitno) ((_array)[((_bitno)/32)][(((_bitno)%32)/8)])
+#define _CHSC_BI(_bitno) (0x80 >> (((_bitno)%32)%8))
+#define CHSC_SB(_array, _bitno)                                       \
+  do {                                                                \
+      _CHSC_AI((_array), (_bitno)) |= _CHSC_BI((_bitno));             \
+  } while (0)
 
 
 typedef struct _CHSC_REQ {

From 623d2aed11fb1236f23187455f61cda2822f643e Mon Sep 17 00:00:00 2001
From: Enrico Sorichetti <e.sorichetti@alice.it>
Date: Sat, 17 Mar 2012 15:24:56 +0100
Subject: [PATCH 08/16] decNumber 3.68

---
 decNumber/ICU-license.html |    90 +-
 decNumber/decBasic.h       |  3911 +++++++++
 decNumber/decCommon.h      |  1840 +++++
 decNumber/decContext.c     |   628 +-
 decNumber/decContext.h     |   422 +-
 decNumber/decDPD.h         |  1987 +++--
 decNumber/decDouble.c      |   140 +
 decNumber/decDouble.h      |   155 +
 decNumber/decNumber.c      | 14787 +++++++++++++++++++----------------
 decNumber/decNumber.h      |   326 +-
 decNumber/decNumber.rc     |     9 +-
 decNumber/decNumberLocal.h |   957 ++-
 decNumber/decPacked.c      |   443 +-
 decNumber/decPacked.h      |   102 +-
 decNumber/decQuad.c        |   135 +
 decNumber/decQuad.h        |   177 +
 decNumber/decSingle.c      |    71 +
 decNumber/decSingle.h      |    86 +
 decNumber/decimal128.c     |  1118 ++-
 decNumber/decimal128.h     |   184 +-
 decNumber/decimal32.c      |   957 ++-
 decNumber/decimal32.h      |   182 +-
 decNumber/decimal64.c      |  1678 ++--
 decNumber/decimal64.h      |   186 +-
 decNumber/decnumber.pdf    |   Bin 140054 -> 1416382 bytes
 decNumber/example1.c       |    38 +
 decNumber/example2.c       |    52 +
 decNumber/example3.c       |    64 +
 decNumber/example4.c       |    61 +
 decNumber/example5.c       |    36 +
 decNumber/example6.c       |    61 +
 decNumber/example7.c       |    35 +
 decNumber/example8.c       |    39 +
 decNumber/readme.txt       |   166 +-
 decNumber_readme.txt       |    65 +
 35 files changed, 20439 insertions(+), 10749 deletions(-)
 create mode 100644 decNumber/decBasic.h
 create mode 100644 decNumber/decCommon.h
 create mode 100644 decNumber/decDouble.c
 create mode 100644 decNumber/decDouble.h
 create mode 100644 decNumber/decQuad.c
 create mode 100644 decNumber/decQuad.h
 create mode 100644 decNumber/decSingle.c
 create mode 100644 decNumber/decSingle.h
 create mode 100644 decNumber/example1.c
 create mode 100644 decNumber/example2.c
 create mode 100644 decNumber/example3.c
 create mode 100644 decNumber/example4.c
 create mode 100644 decNumber/example5.c
 create mode 100644 decNumber/example6.c
 create mode 100644 decNumber/example7.c
 create mode 100644 decNumber/example8.c
 create mode 100644 decNumber_readme.txt

diff --git a/decNumber/ICU-license.html b/decNumber/ICU-license.html
index 00d356d4..bc99e8bf 100644
--- a/decNumber/ICU-license.html
+++ b/decNumber/ICU-license.html
@@ -1,45 +1,45 @@
-<html>
-
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=us-ascii"></meta>
-<title>ICU License - ICU 1.8.1 and later</title>
-</head>
-
-<body>
-<h1>ICU License - ICU 1.8.1 and later</h1>
-<pre>
-COPYRIGHT AND PERMISSION NOTICE
-
-Copyright (c) 1995-2005 International Business Machines Corporation and others
-All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, and/or sell copies of the Software, and to permit persons
-to whom the Software is furnished to do so, provided that the above
-copyright notice(s) and this permission notice appear in all copies of
-the Software and that both the above copyright notice(s) and this
-permission notice appear in supporting documentation.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
-OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
-HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
-INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
-FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
-NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
-WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-
-Except as contained in this notice, the name of a copyright holder
-shall not be used in advertising or otherwise to promote the sale, use
-or other dealings in this Software without prior written authorization
-of the copyright holder.
-
---------------------------------------------------------------------------------
-All trademarks and registered trademarks mentioned herein are the property of their respective owners.
-</pre>
-</body>
-</html>
+<html>
+
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=us-ascii"></meta>
+<title>ICU License - ICU 1.8.1 and later</title>
+</head>
+
+<body>
+<h1>ICU License - ICU 1.8.1 and later</h1>
+<pre>
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright (c) 1995-2005 International Business Machines Corporation and others
+All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, provided that the above
+copyright notice(s) and this permission notice appear in all copies of
+the Software and that both the above copyright notice(s) and this
+permission notice appear in supporting documentation.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
+INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
+FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder
+shall not be used in advertising or otherwise to promote the sale, use
+or other dealings in this Software without prior written authorization
+of the copyright holder.
+
+--------------------------------------------------------------------------------
+All trademarks and registered trademarks mentioned herein are the property of their respective owners.
+</pre>
+</body>
+</html>
diff --git a/decNumber/decBasic.h b/decNumber/decBasic.h
new file mode 100644
index 00000000..5c531bac
--- /dev/null
+++ b/decNumber/decBasic.h
@@ -0,0 +1,3911 @@
+#if !defined(DECBASIC)
+#define DECBASIC
+/* ------------------------------------------------------------------ */
+/* decBasic.h -- common base code for Basic decimal types             */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2010.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is included in the package as decNumber.pdf.  This   */
+/* document is also available in HTML, together with specifications,  */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+/* This module comprises code that is shared between decDouble and    */
+/* decQuad (but not decSingle).  The main arithmetic operations are   */
+/* here (Add, Subtract, Multiply, FMA, and Division operators).       */
+/*                                                                    */
+/* Unlike decNumber, parameterization takes place at compile time     */
+/* rather than at runtime.  The parameters are set in the decDouble.c */
+/* (etc.) files, which then include this one to produce the compiled  */
+/* code.  The functions here, therefore, are code shared between      */
+/* multiple formats.                                                  */
+/*                                                                    */
+/* This must be included after decCommon.h.                           */
+/* ------------------------------------------------------------------ */
+// Names here refer to decFloat rather than to decDouble, etc., and
+// the functions are in strict alphabetical order.
+
+// The compile-time flags SINGLE, DOUBLE, and QUAD are set up in
+// decCommon.h
+#if !defined(QUAD)
+  #error decBasic.h must be included after decCommon.h
+#endif
+#if SINGLE
+  #error Routines in decBasic.h are for decDouble and decQuad only
+#endif
+
+/* Private constants */
+#define DIVIDE      0x80000000     // Divide operations [as flags]
+#define REMAINDER   0x40000000     // ..
+#define DIVIDEINT   0x20000000     // ..
+#define REMNEAR     0x10000000     // ..
+
+/* Private functions (local, used only by routines in this module) */
+static decFloat *decDivide(decFloat *, const decFloat *,
+                              const decFloat *, decContext *, uInt);
+static decFloat *decCanonical(decFloat *, const decFloat *);
+static void      decFiniteMultiply(bcdnum *, uByte *, const decFloat *,
+                              const decFloat *);
+static decFloat *decInfinity(decFloat *, const decFloat *);
+static decFloat *decInvalid(decFloat *, decContext *);
+static decFloat *decNaNs(decFloat *, const decFloat *, const decFloat *,
+                              decContext *);
+static Int       decNumCompare(const decFloat *, const decFloat *, Flag);
+static decFloat *decToIntegral(decFloat *, const decFloat *, decContext *,
+                              enum rounding, Flag);
+static uInt      decToInt32(const decFloat *, decContext *, enum rounding,
+                              Flag, Flag);
+
+/* ------------------------------------------------------------------ */
+/* decCanonical -- copy a decFloat, making canonical                  */
+/*                                                                    */
+/*   result gets the canonicalized df                                 */
+/*   df     is the decFloat to copy and make canonical                */
+/*   returns result                                                   */
+/*                                                                    */
+/* This is exposed via decFloatCanonical for Double and Quad only.    */
+/* This works on specials, too; no error or exception is possible.    */
+/* ------------------------------------------------------------------ */
+static decFloat * decCanonical(decFloat *result, const decFloat *df) {
+  uInt encode, precode, dpd;       // work
+  uInt inword, uoff, canon;        // ..
+  Int  n;                          // counter (down)
+  if (df!=result) *result=*df;     // effect copy if needed
+  if (DFISSPECIAL(result)) {
+    if (DFISINF(result)) return decInfinity(result, df); // clean Infinity
+    // is a NaN
+    DFWORD(result, 0)&=~ECONNANMASK;    // clear ECON except selector
+    if (DFISCCZERO(df)) return result;  // coefficient continuation is 0
+    // drop through to check payload
+    }
+  // return quickly if the coefficient continuation is canonical
+  { // declare block
+  #if DOUBLE
+    uInt sourhi=DFWORD(df, 0);
+    uInt sourlo=DFWORD(df, 1);
+    if (CANONDPDOFF(sourhi, 8)
+     && CANONDPDTWO(sourhi, sourlo, 30)
+     && CANONDPDOFF(sourlo, 20)
+     && CANONDPDOFF(sourlo, 10)
+     && CANONDPDOFF(sourlo, 0)) return result;
+  #elif QUAD
+    uInt sourhi=DFWORD(df, 0);
+    uInt sourmh=DFWORD(df, 1);
+    uInt sourml=DFWORD(df, 2);
+    uInt sourlo=DFWORD(df, 3);
+    if (CANONDPDOFF(sourhi, 4)
+     && CANONDPDTWO(sourhi, sourmh, 26)
+     && CANONDPDOFF(sourmh, 16)
+     && CANONDPDOFF(sourmh, 6)
+     && CANONDPDTWO(sourmh, sourml, 28)
+     && CANONDPDOFF(sourml, 18)
+     && CANONDPDOFF(sourml, 8)
+     && CANONDPDTWO(sourml, sourlo, 30)
+     && CANONDPDOFF(sourlo, 20)
+     && CANONDPDOFF(sourlo, 10)
+     && CANONDPDOFF(sourlo, 0)) return result;
+  #endif
+  } // block
+
+  // Loop to repair a non-canonical coefficent, as needed
+  inword=DECWORDS-1;               // current input word
+  uoff=0;                          // bit offset of declet
+  encode=DFWORD(result, inword);
+  for (n=DECLETS-1; n>=0; n--) {   // count down declets of 10 bits
+    dpd=encode>>uoff;
+    uoff+=10;
+    if (uoff>32) {                 // crossed uInt boundary
+      inword--;
+      encode=DFWORD(result, inword);
+      uoff-=32;
+      dpd|=encode<<(10-uoff);      // get pending bits
+      }
+    dpd&=0x3ff;                    // clear uninteresting bits
+    if (dpd<0x16e) continue;       // must be canonical
+    canon=BIN2DPD[DPD2BIN[dpd]];   // determine canonical declet
+    if (canon==dpd) continue;      // have canonical declet
+    // need to replace declet
+    if (uoff>=10) {                // all within current word
+      encode&=~(0x3ff<<(uoff-10)); // clear the 10 bits ready for replace
+      encode|=canon<<(uoff-10);    // insert the canonical form
+      DFWORD(result, inword)=encode;    // .. and save
+      continue;
+      }
+    // straddled words
+    precode=DFWORD(result, inword+1);   // get previous
+    precode&=0xffffffff>>(10-uoff);     // clear top bits
+    DFWORD(result, inword+1)=precode|(canon<<(32-(10-uoff)));
+    encode&=0xffffffff<<uoff;           // clear bottom bits
+    encode|=canon>>(10-uoff);           // insert canonical
+    DFWORD(result, inword)=encode;      // .. and save
+    } // n
+  return result;
+  } // decCanonical
+
+/* ------------------------------------------------------------------ */
+/* decDivide -- divide operations                                     */
+/*                                                                    */
+/*   result gets the result of dividing dfl by dfr:                   */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   op     is the operation selector                                 */
+/*   returns result                                                   */
+/*                                                                    */
+/* op is one of DIVIDE, REMAINDER, DIVIDEINT, or REMNEAR.             */
+/* ------------------------------------------------------------------ */
+#define DIVCOUNT  0                // 1 to instrument subtractions counter
+#define DIVBASE   ((uInt)BILLION)  // the base used for divide
+#define DIVOPLEN  DECPMAX9         // operand length ('digits' base 10**9)
+#define DIVACCLEN (DIVOPLEN*3)     // accumulator length (ditto)
+static decFloat * decDivide(decFloat *result, const decFloat *dfl,
+                            const decFloat *dfr, decContext *set, uInt op) {
+  decFloat quotient;               // for remainders
+  bcdnum num;                      // for final conversion
+  uInt   acc[DIVACCLEN];           // coefficent in base-billion ..
+  uInt   div[DIVOPLEN];            // divisor in base-billion ..
+  uInt   quo[DIVOPLEN+1];          // quotient in base-billion ..
+  uByte  bcdacc[(DIVOPLEN+1)*9+2]; // for quotient in BCD, +1, +1
+  uInt   *msua, *msud, *msuq;      // -> msu of acc, div, and quo
+  Int    divunits, accunits;       // lengths
+  Int    quodigits;                // digits in quotient
+  uInt   *lsua, *lsuq;             // -> current acc and quo lsus
+  Int    length, multiplier;       // work
+  uInt   carry, sign;              // ..
+  uInt   *ua, *ud, *uq;            // ..
+  uByte  *ub;                      // ..
+  uInt   uiwork;                   // for macros
+  uInt   divtop;                   // top unit of div adjusted for estimating
+  #if DIVCOUNT
+  static uInt maxcount=0;          // worst-seen subtractions count
+  uInt   divcount=0;               // subtractions count [this divide]
+  #endif
+
+  // calculate sign
+  num.sign=(DFWORD(dfl, 0)^DFWORD(dfr, 0)) & DECFLOAT_Sign;
+
+  if (DFISSPECIAL(dfl) || DFISSPECIAL(dfr)) { // either is special?
+    // NaNs are handled as usual
+    if (DFISNAN(dfl) || DFISNAN(dfr)) return decNaNs(result, dfl, dfr, set);
+    // one or two infinities
+    if (DFISINF(dfl)) {
+      if (DFISINF(dfr)) return decInvalid(result, set); // Two infinities bad
+      if (op&(REMAINDER|REMNEAR)) return decInvalid(result, set); // as is rem
+      // Infinity/x is infinite and quiet, even if x=0
+      DFWORD(result, 0)=num.sign;
+      return decInfinity(result, result);
+      }
+    // must be x/Infinity -- remainders are lhs
+    if (op&(REMAINDER|REMNEAR)) return decCanonical(result, dfl);
+    // divides: return zero with correct sign and exponent depending
+    // on op (Etiny for divide, 0 for divideInt)
+    decFloatZero(result);
+    if (op==DIVIDEINT) DFWORD(result, 0)|=num.sign; // add sign
+     else DFWORD(result, 0)=num.sign;        // zeros the exponent, too
+    return result;
+    }
+  // next, handle zero operands (x/0 and 0/x)
+  if (DFISZERO(dfr)) {                       // x/0
+    if (DFISZERO(dfl)) {                     // 0/0 is undefined
+      decFloatZero(result);
+      DFWORD(result, 0)=DECFLOAT_qNaN;
+      set->status|=DEC_Division_undefined;
+      return result;
+      }
+    if (op&(REMAINDER|REMNEAR)) return decInvalid(result, set); // bad rem
+    set->status|=DEC_Division_by_zero;
+    DFWORD(result, 0)=num.sign;
+    return decInfinity(result, result);      // x/0 -> signed Infinity
+    }
+  num.exponent=GETEXPUN(dfl)-GETEXPUN(dfr);  // ideal exponent
+  if (DFISZERO(dfl)) {                       // 0/x (x!=0)
+    // if divide, result is 0 with ideal exponent; divideInt has
+    // exponent=0, remainders give zero with lower exponent
+    if (op&DIVIDEINT) {
+      decFloatZero(result);
+      DFWORD(result, 0)|=num.sign;           // add sign
+      return result;
+      }
+    if (!(op&DIVIDE)) {                      // a remainder
+      // exponent is the minimum of the operands
+      num.exponent=MINI(GETEXPUN(dfl), GETEXPUN(dfr));
+      // if the result is zero the sign shall be sign of dfl
+      num.sign=DFWORD(dfl, 0)&DECFLOAT_Sign;
+      }
+    bcdacc[0]=0;
+    num.msd=bcdacc;                          // -> 0
+    num.lsd=bcdacc;                          // ..
+    return decFinalize(result, &num, set);   // [divide may clamp exponent]
+    } // 0/x
+  // [here, both operands are known to be finite and non-zero]
+
+  // extract the operand coefficents into 'units' which are
+  // base-billion; the lhs is high-aligned in acc and the msu of both
+  // acc and div is at the right-hand end of array (offset length-1);
+  // the quotient can need one more unit than the operands as digits
+  // in it are not necessarily aligned neatly; further, the quotient
+  // may not start accumulating until after the end of the initial
+  // operand in acc if that is small (e.g., 1) so the accumulator
+  // must have at least that number of units extra (at the ls end)
+  GETCOEFFBILL(dfl, acc+DIVACCLEN-DIVOPLEN);
+  GETCOEFFBILL(dfr, div);
+  // zero the low uInts of acc
+  acc[0]=0;
+  acc[1]=0;
+  acc[2]=0;
+  acc[3]=0;
+  #if DOUBLE
+    #if DIVOPLEN!=2
+      #error Unexpected Double DIVOPLEN
+    #endif
+  #elif QUAD
+  acc[4]=0;
+  acc[5]=0;
+  acc[6]=0;
+  acc[7]=0;
+    #if DIVOPLEN!=4
+      #error Unexpected Quad DIVOPLEN
+    #endif
+  #endif
+
+  // set msu and lsu pointers
+  msua=acc+DIVACCLEN-1;       // [leading zeros removed below]
+  msuq=quo+DIVOPLEN;
+  //[loop for div will terminate because operands are non-zero]
+  for (msud=div+DIVOPLEN-1; *msud==0;) msud--;
+  // the initial least-significant unit of acc is set so acc appears
+  // to have the same length as div.
+  // This moves one position towards the least possible for each
+  // iteration
+  divunits=(Int)(msud-div+1); // precalculate
+  lsua=msua-divunits+1;       // initial working lsu of acc
+  lsuq=msuq;                  // and of quo
+
+  // set up the estimator for the multiplier; this is the msu of div,
+  // plus two bits from the unit below (if any) rounded up by one if
+  // there are any non-zero bits or units below that [the extra two
+  // bits makes for a much better estimate when the top unit is small]
+  divtop=*msud<<2;
+  if (divunits>1) {
+    uInt *um=msud-1;
+    uInt d=*um;
+    if (d>=750000000) {divtop+=3; d-=750000000;}
+     else if (d>=500000000) {divtop+=2; d-=500000000;}
+     else if (d>=250000000) {divtop++; d-=250000000;}
+    if (d) divtop++;
+     else for (um--; um>=div; um--) if (*um) {
+      divtop++;
+      break;
+      }
+    } // >1 unit
+
+  #if DECTRACE
+  {Int i;
+  printf("----- div=");
+  for (i=divunits-1; i>=0; i--) printf("%09ld ", (LI)div[i]);
+  printf("\n");}
+  #endif
+
+  // now collect up to DECPMAX+1 digits in the quotient (this may
+  // need OPLEN+1 uInts if unaligned)
+  quodigits=0;                // no digits yet
+  for (;; lsua--) {           // outer loop -- each input position
+    #if DECCHECK
+    if (lsua<acc) {
+      printf("Acc underrun...\n");
+      break;
+      }
+    #endif
+    #if DECTRACE
+    printf("Outer: quodigits=%ld acc=", (LI)quodigits);
+    for (ua=msua; ua>=lsua; ua--) printf("%09ld ", (LI)*ua);
+    printf("\n");
+    #endif
+    *lsuq=0;                  // default unit result is 0
+    for (;;) {                // inner loop -- calculate quotient unit
+      // strip leading zero units from acc (either there initially or
+      // from subtraction below); this may strip all if exactly 0
+      for (; *msua==0 && msua>=lsua;) msua--;
+      accunits=(Int)(msua-lsua+1);                // [maybe 0]
+      // subtraction is only necessary and possible if there are as
+      // least as many units remaining in acc for this iteration as
+      // there are in div
+      if (accunits<divunits) {
+        if (accunits==0) msua++;                  // restore
+        break;
+        }
+
+      // If acc is longer than div then subtraction is definitely
+      // possible (as msu of both is non-zero), but if they are the
+      // same length a comparison is needed.
+      // If a subtraction is needed then a good estimate of the
+      // multiplier for the subtraction is also needed in order to
+      // minimise the iterations of this inner loop because the
+      // subtractions needed dominate division performance.
+      if (accunits==divunits) {
+        // compare the high divunits of acc and div:
+        // acc<div:  this quotient unit is unchanged; subtraction
+        //           will be possible on the next iteration
+        // acc==div: quotient gains 1, set acc=0
+        // acc>div:  subtraction necessary at this position
+        for (ud=msud, ua=msua; ud>div; ud--, ua--) if (*ud!=*ua) break;
+        // [now at first mismatch or lsu]
+        if (*ud>*ua) break;                       // next time...
+        if (*ud==*ua) {                           // all compared equal
+          *lsuq+=1;                               // increment result
+          msua=lsua;                              // collapse acc units
+          *msua=0;                                // .. to a zero
+          break;
+          }
+
+        // subtraction necessary; estimate multiplier [see above]
+        // if both *msud and *msua are small it is cost-effective to
+        // bring in part of the following units (if any) to get a
+        // better estimate (assume some other non-zero in div)
+        #define DIVLO 1000000U
+        #define DIVHI (DIVBASE/DIVLO)
+        #if DECUSE64
+          if (divunits>1) {
+            // there cannot be a *(msud-2) for DECDOUBLE so next is
+            // an exact calculation unless DECQUAD (which needs to
+            // assume bits out there if divunits>2)
+            uLong mul=(uLong)*msua * DIVBASE + *(msua-1);
+            uLong div=(uLong)*msud * DIVBASE + *(msud-1);
+            #if QUAD
+            if (divunits>2) div++;
+            #endif
+            mul/=div;
+            multiplier=(Int)mul;
+            }
+           else multiplier=*msua/(*msud);
+        #else
+          if (divunits>1 && *msua<DIVLO && *msud<DIVLO) {
+            multiplier=(*msua*DIVHI + *(msua-1)/DIVLO)
+                      /(*msud*DIVHI + *(msud-1)/DIVLO +1);
+            }
+           else multiplier=(*msua<<2)/divtop;
+        #endif
+        }
+       else {                                     // accunits>divunits
+        // msud is one unit 'lower' than msua, so estimate differently
+        #if DECUSE64
+          uLong mul;
+          // as before, bring in extra digits if possible
+          if (divunits>1 && *msua<DIVLO && *msud<DIVLO) {
+            mul=((uLong)*msua * DIVHI * DIVBASE) + *(msua-1) * DIVHI
+               + *(msua-2)/DIVLO;
+            mul/=(*msud*DIVHI + *(msud-1)/DIVLO +1);
+            }
+           else if (divunits==1) {
+            mul=(uLong)*msua * DIVBASE + *(msua-1);
+            mul/=*msud;       // no more to the right
+            }
+           else {
+            mul=(uLong)(*msua) * (uInt)(DIVBASE<<2)
+                + (*(msua-1)<<2);
+            mul/=divtop;      // [divtop already allows for sticky bits]
+            }
+          multiplier=(Int)mul;
+        #else
+          multiplier=*msua * ((DIVBASE<<2)/divtop);
+        #endif
+        }
+      if (multiplier==0) multiplier=1;            // marginal case
+      *lsuq+=multiplier;
+
+      #if DIVCOUNT
+      // printf("Multiplier: %ld\n", (LI)multiplier);
+      divcount++;
+      #endif
+
+      // Carry out the subtraction  acc-(div*multiplier); for each
+      // unit in div, do the multiply, split to units (see
+      // decFloatMultiply for the algorithm), and subtract from acc
+      #define DIVMAGIC  2305843009U               // 2**61/10**9
+      #define DIVSHIFTA 29
+      #define DIVSHIFTB 32
+      carry=0;
+      for (ud=div, ua=lsua; ud<=msud; ud++, ua++) {
+        uInt lo, hop;
+        #if DECUSE64
+          uLong sub=(uLong)multiplier*(*ud)+carry;
+          if (sub<DIVBASE) {
+            carry=0;
+            lo=(uInt)sub;
+            }
+           else {
+            hop=(uInt)(sub>>DIVSHIFTA);
+            carry=(uInt)(((uLong)hop*DIVMAGIC)>>DIVSHIFTB);
+            // the estimate is now in hi; now calculate sub-hi*10**9
+            // to get the remainder (which will be <DIVBASE))
+            lo=(uInt)sub;
+            lo-=carry*DIVBASE;                    // low word of result
+            if (lo>=DIVBASE) {
+              lo-=DIVBASE;                        // correct by +1
+              carry++;
+              }
+            }
+        #else // 32-bit
+          uInt hi;
+          // calculate multiplier*(*ud) into hi and lo
+          LONGMUL32HI(hi, *ud, multiplier);       // get the high word
+          lo=multiplier*(*ud);                    // .. and the low
+          lo+=carry;                              // add the old hi
+          carry=hi+(lo<carry);                    // .. with any carry
+          if (carry || lo>=DIVBASE) {             // split is needed
+            hop=(carry<<3)+(lo>>DIVSHIFTA);       // hi:lo/2**29
+            LONGMUL32HI(carry, hop, DIVMAGIC);    // only need the high word
+            // [DIVSHIFTB is 32, so carry can be used directly]
+            // the estimate is now in carry; now calculate hi:lo-est*10**9;
+            // happily the top word of the result is irrelevant because it
+            // will always be zero so this needs only one multiplication
+            lo-=(carry*DIVBASE);
+            // the correction here will be at most +1; do it
+            if (lo>=DIVBASE) {
+              lo-=DIVBASE;
+              carry++;
+              }
+            }
+        #endif
+        if (lo>*ua) {              // borrow needed
+          *ua+=DIVBASE;
+          carry++;
+          }
+        *ua-=lo;
+        } // ud loop
+      if (carry) *ua-=carry;       // accdigits>divdigits [cannot borrow]
+      } // inner loop
+
+    // the outer loop terminates when there is either an exact result
+    // or enough digits; first update the quotient digit count and
+    // pointer (if any significant digits)
+    #if DECTRACE
+    if (*lsuq || quodigits) printf("*lsuq=%09ld\n", (LI)*lsuq);
+    #endif
+    if (quodigits) {
+      quodigits+=9;                // had leading unit earlier
+      lsuq--;
+      if (quodigits>DECPMAX+1) break;   // have enough
+      }
+     else if (*lsuq) {             // first quotient digits
+      const uInt *pow;
+      for (pow=DECPOWERS; *lsuq>=*pow; pow++) quodigits++;
+      lsuq--;
+      // [cannot have >DECPMAX+1 on first unit]
+      }
+
+    if (*msua!=0) continue;        // not an exact result
+    // acc is zero iff used all of original units and zero down to lsua
+    // (must also continue to original lsu for correct quotient length)
+    if (lsua>acc+DIVACCLEN-DIVOPLEN) continue;
+    for (; msua>lsua && *msua==0;) msua--;
+    if (*msua==0 && msua==lsua) break;
+    } // outer loop
+
+  // all of the original operand in acc has been covered at this point
+  // quotient now has at least DECPMAX+2 digits
+  // *msua is now non-0 if inexact and sticky bits
+  // lsuq is one below the last uint of the quotient
+  lsuq++;                          // set -> true lsu of quo
+  if (*msua) *lsuq|=1;             // apply sticky bit
+
+  // quo now holds the (unrounded) quotient in base-billion; one
+  // base-billion 'digit' per uInt.
+  #if DECTRACE
+  printf("DivQuo:");
+  for (uq=msuq; uq>=lsuq; uq--) printf(" %09ld", (LI)*uq);
+  printf("\n");
+  #endif
+
+  // Now convert to BCD for rounding and cleanup, starting from the
+  // most significant end [offset by one into bcdacc to leave room
+  // for a possible carry digit if rounding for REMNEAR is needed]
+  for (uq=msuq, ub=bcdacc+1; uq>=lsuq; uq--, ub+=9) {
+    uInt top, mid, rem;                 // work
+    if (*uq==0) {                       // no split needed
+      UBFROMUI(ub, 0);                  // clear 9 BCD8s
+      UBFROMUI(ub+4, 0);                // ..
+      *(ub+8)=0;                        // ..
+      continue;
+      }
+    // *uq is non-zero -- split the base-billion digit into
+    // hi, mid, and low three-digits
+    #define divsplit9 1000000           // divisor
+    #define divsplit6 1000              // divisor
+    // The splitting is done by simple divides and remainders,
+    // assuming the compiler will optimize these [GCC does]
+    top=*uq/divsplit9;
+    rem=*uq%divsplit9;
+    mid=rem/divsplit6;
+    rem=rem%divsplit6;
+    // lay out the nine BCD digits (plus one unwanted byte)
+    UBFROMUI(ub,   UBTOUI(&BIN2BCD8[top*4]));
+    UBFROMUI(ub+3, UBTOUI(&BIN2BCD8[mid*4]));
+    UBFROMUI(ub+6, UBTOUI(&BIN2BCD8[rem*4]));
+    } // BCD conversion loop
+  ub--;                                 // -> lsu
+
+  // complete the bcdnum; quodigits is correct, so the position of
+  // the first non-zero is known
+  num.msd=bcdacc+1+(msuq-lsuq+1)*9-quodigits;
+  num.lsd=ub;
+
+  // make exponent adjustments, etc
+  if (lsua<acc+DIVACCLEN-DIVOPLEN) {    // used extra digits
+    num.exponent-=(Int)((acc+DIVACCLEN-DIVOPLEN-lsua)*9);
+    // if the result was exact then there may be up to 8 extra
+    // trailing zeros in the overflowed quotient final unit
+    if (*msua==0) {
+      for (; *ub==0;) ub--;             // drop zeros
+      num.exponent+=(Int)(num.lsd-ub);  // and adjust exponent
+      num.lsd=ub;
+      }
+    } // adjustment needed
+
+  #if DIVCOUNT
+  if (divcount>maxcount) {              // new high-water nark
+    maxcount=divcount;
+    printf("DivNewMaxCount: %ld\n", (LI)maxcount);
+    }
+  #endif
+
+  if (op&DIVIDE) return decFinalize(result, &num, set); // all done
+
+  // Is DIVIDEINT or a remainder; there is more to do -- first form
+  // the integer (this is done 'after the fact', unlike as in
+  // decNumber, so as not to tax DIVIDE)
+
+  // The first non-zero digit will be in the first 9 digits, known
+  // from quodigits and num.msd, so there is always space for DECPMAX
+  // digits
+
+  length=(Int)(num.lsd-num.msd+1);
+  //printf("Length exp: %ld %ld\n", (LI)length, (LI)num.exponent);
+
+  if (length+num.exponent>DECPMAX) { // cannot fit
+    decFloatZero(result);
+    DFWORD(result, 0)=DECFLOAT_qNaN;
+    set->status|=DEC_Division_impossible;
+    return result;
+    }
+
+  if (num.exponent>=0) {           // already an int, or need pad zeros
+    for (ub=num.lsd+1; ub<=num.lsd+num.exponent; ub++) *ub=0;
+    num.lsd+=num.exponent;
+    }
+   else {                          // too long: round or truncate needed
+    Int drop=-num.exponent;
+    if (!(op&REMNEAR)) {           // simple truncate
+      num.lsd-=drop;
+      if (num.lsd<num.msd) {       // truncated all
+        num.lsd=num.msd;           // make 0
+        *num.lsd=0;                // .. [sign still relevant]
+        }
+      }
+     else {                        // round to nearest even [sigh]
+      // round-to-nearest, in-place; msd is at or to right of bcdacc+1
+      // (this is a special case of Quantize -- q.v. for commentary)
+      uByte *roundat;              // -> re-round digit
+      uByte reround;               // reround value
+      *(num.msd-1)=0;              // in case of left carry, or make 0
+      if (drop<length) roundat=num.lsd-drop+1;
+       else if (drop==length) roundat=num.msd;
+       else roundat=num.msd-1;     // [-> 0]
+      reround=*roundat;
+      for (ub=roundat+1; ub<=num.lsd; ub++) {
+        if (*ub!=0) {
+          reround=DECSTICKYTAB[reround];
+          break;
+          }
+        } // check stickies
+      if (roundat>num.msd) num.lsd=roundat-1;
+       else {
+        num.msd--;                           // use the 0 ..
+        num.lsd=num.msd;                     // .. at the new MSD place
+        }
+      if (reround!=0) {                      // discarding non-zero
+        uInt bump=0;
+        // rounding is DEC_ROUND_HALF_EVEN always
+        if (reround>5) bump=1;               // >0.5 goes up
+         else if (reround==5)                // exactly 0.5000 ..
+          bump=*(num.lsd) & 0x01;            // .. up iff [new] lsd is odd
+        if (bump!=0) {                       // need increment
+          // increment the coefficient; this might end up with 1000...
+          ub=num.lsd;
+          for (; UBTOUI(ub-3)==0x09090909; ub-=4) UBFROMUI(ub-3, 0);
+          for (; *ub==9; ub--) *ub=0;        // at most 3 more
+          *ub+=1;
+          if (ub<num.msd) num.msd--;         // carried
+          } // bump needed
+        } // reround!=0
+      } // remnear
+    } // round or truncate needed
+  num.exponent=0;                            // all paths
+  //decShowNum(&num, "int");
+
+  if (op&DIVIDEINT) return decFinalize(result, &num, set); // all done
+
+  // Have a remainder to calculate
+  decFinalize(&quotient, &num, set);         // lay out the integer so far
+  DFWORD(&quotient, 0)^=DECFLOAT_Sign;       // negate it
+  sign=DFWORD(dfl, 0);                       // save sign of dfl
+  decFloatFMA(result, &quotient, dfr, dfl, set);
+  if (!DFISZERO(result)) return result;
+  // if the result is zero the sign shall be sign of dfl
+  DFWORD(&quotient, 0)=sign;                 // construct decFloat of sign
+  return decFloatCopySign(result, result, &quotient);
+  } // decDivide
+
+/* ------------------------------------------------------------------ */
+/* decFiniteMultiply -- multiply two finite decFloats                 */
+/*                                                                    */
+/*   num    gets the result of multiplying dfl and dfr                */
+/*   bcdacc .. with the coefficient in this array                     */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*                                                                    */
+/* This effects the multiplication of two decFloats, both known to be */
+/* finite, leaving the result in a bcdnum ready for decFinalize (for  */
+/* use in Multiply) or in a following addition (FMA).                 */
+/*                                                                    */
+/* bcdacc must have space for at least DECPMAX9*18+1 bytes.           */
+/* No error is possible and no status is set.                         */
+/* ------------------------------------------------------------------ */
+// This routine has two separate implementations of the core
+// multiplication; both using base-billion.  One uses only 32-bit
+// variables (Ints and uInts) or smaller; the other uses uLongs (for
+// multiplication and addition only).  Both implementations cover
+// both arithmetic sizes (DOUBLE and QUAD) in order to allow timing
+// comparisons.  In any one compilation only one implementation for
+// each size can be used, and if DECUSE64 is 0 then use of the 32-bit
+// version is forced.
+//
+// Historical note: an earlier version of this code also supported the
+// 256-bit format and has been preserved.  That is somewhat trickier
+// during lazy carry splitting because the initial quotient estimate
+// (est) can exceed 32 bits.
+
+#define MULTBASE  ((uInt)BILLION)  // the base used for multiply
+#define MULOPLEN  DECPMAX9         // operand length ('digits' base 10**9)
+#define MULACCLEN (MULOPLEN*2)              // accumulator length (ditto)
+#define LEADZEROS (MULACCLEN*9 - DECPMAX*2) // leading zeros always
+
+// Assertions: exponent not too large and MULACCLEN is a multiple of 4
+#if DECEMAXD>9
+  #error Exponent may overflow when doubled for Multiply
+#endif
+#if MULACCLEN!=(MULACCLEN/4)*4
+  // This assumption is used below only for initialization
+  #error MULACCLEN is not a multiple of 4
+#endif
+
+static void decFiniteMultiply(bcdnum *num, uByte *bcdacc,
+                              const decFloat *dfl, const decFloat *dfr) {
+  uInt   bufl[MULOPLEN];           // left  coefficient (base-billion)
+  uInt   bufr[MULOPLEN];           // right coefficient (base-billion)
+  uInt   *ui, *uj;                 // work
+  uByte  *ub;                      // ..
+  uInt   uiwork;                   // for macros
+
+  #if DECUSE64
+  uLong  accl[MULACCLEN];          // lazy accumulator (base-billion+)
+  uLong  *pl;                      // work -> lazy accumulator
+  uInt   acc[MULACCLEN];           // coefficent in base-billion ..
+  #else
+  uInt   acc[MULACCLEN*2];         // accumulator in base-billion ..
+  #endif
+  uInt   *pa;                      // work -> accumulator
+  //printf("Base10**9: OpLen=%d MulAcclen=%d\n", OPLEN, MULACCLEN);
+
+  /* Calculate sign and exponent */
+  num->sign=(DFWORD(dfl, 0)^DFWORD(dfr, 0)) & DECFLOAT_Sign;
+  num->exponent=GETEXPUN(dfl)+GETEXPUN(dfr); // [see assertion above]
+
+  /* Extract the coefficients and prepare the accumulator */
+  // the coefficients of the operands are decoded into base-billion
+  // numbers in uInt arrays (bufl and bufr, LSD at offset 0) of the
+  // appropriate size.
+  GETCOEFFBILL(dfl, bufl);
+  GETCOEFFBILL(dfr, bufr);
+  #if DECTRACE && 0
+    printf("CoeffbL:");
+    for (ui=bufl+MULOPLEN-1; ui>=bufl; ui--) printf(" %08lx", (LI)*ui);
+    printf("\n");
+    printf("CoeffbR:");
+    for (uj=bufr+MULOPLEN-1; uj>=bufr; uj--) printf(" %08lx", (LI)*uj);
+    printf("\n");
+  #endif
+
+  // start the 64-bit/32-bit differing paths...
+#if DECUSE64
+
+  // zero the accumulator
+  #if MULACCLEN==4
+    accl[0]=0; accl[1]=0; accl[2]=0; accl[3]=0;
+  #else                                      // use a loop
+    // MULACCLEN is a multiple of four, asserted above
+    for (pl=accl; pl<accl+MULACCLEN; pl+=4) {
+      *pl=0; *(pl+1)=0; *(pl+2)=0; *(pl+3)=0;// [reduce overhead]
+      } // pl
+  #endif
+
+  /* Effect the multiplication */
+  // The multiplcation proceeds using MFC's lazy-carry resolution
+  // algorithm from decNumber.  First, the multiplication is
+  // effected, allowing accumulation of the partial products (which
+  // are in base-billion at each column position) into 64 bits
+  // without resolving back to base=billion after each addition.
+  // These 64-bit numbers (which may contain up to 19 decimal digits)
+  // are then split using the Clark & Cowlishaw algorithm (see below).
+  // [Testing for 0 in the inner loop is not really a 'win']
+  for (ui=bufr; ui<bufr+MULOPLEN; ui++) { // over each item in rhs
+    if (*ui==0) continue;                 // product cannot affect result
+    pl=accl+(ui-bufr);                    // where to add the lhs
+    for (uj=bufl; uj<bufl+MULOPLEN; uj++, pl++) { // over each item in lhs
+      // if (*uj==0) continue;            // product cannot affect result
+      *pl+=((uLong)*ui)*(*uj);
+      } // uj
+    } // ui
+
+  // The 64-bit carries must now be resolved; this means that a
+  // quotient/remainder has to be calculated for base-billion (1E+9).
+  // For this, Clark & Cowlishaw's quotient estimation approach (also
+  // used in decNumber) is needed, because 64-bit divide is generally
+  // extremely slow on 32-bit machines, and may be slower than this
+  // approach even on 64-bit machines.  This algorithm splits X
+  // using:
+  //
+  //   magic=2**(A+B)/1E+9;   // 'magic number'
+  //   hop=X/2**A;            // high order part of X (by shift)
+  //   est=magic*hop/2**B     // quotient estimate (may be low by 1)
+  //
+  // A and B are quite constrained; hop and magic must fit in 32 bits,
+  // and 2**(A+B) must be as large as possible (which is 2**61 if
+  // magic is to fit).  Further, maxX increases with the length of
+  // the operands (and hence the number of partial products
+  // accumulated); maxX is OPLEN*(10**18), which is up to 19 digits.
+  //
+  // It can be shown that when OPLEN is 2 then the maximum error in
+  // the estimated quotient is <1, but for larger maximum x the
+  // maximum error is above 1 so a correction that is >1 may be
+  // needed.  Values of A and B are chosen to satisfy the constraints
+  // just mentioned while minimizing the maximum error (and hence the
+  // maximum correction), as shown in the following table:
+  //
+  //   Type    OPLEN   A   B     maxX    maxError  maxCorrection
+  //   ---------------------------------------------------------
+  //   DOUBLE    2    29  32  <2*10**18    0.63       1
+  //   QUAD      4    30  31  <4*10**18    1.17       2
+  //
+  // In the OPLEN==2 case there is most choice, but the value for B
+  // of 32 has a big advantage as then the calculation of the
+  // estimate requires no shifting; the compiler can extract the high
+  // word directly after multiplying magic*hop.
+  #define MULMAGIC 2305843009U          // 2**61/10**9  [both cases]
+  #if DOUBLE
+    #define MULSHIFTA 29
+    #define MULSHIFTB 32
+  #elif QUAD
+    #define MULSHIFTA 30
+    #define MULSHIFTB 31
+  #else
+    #error Unexpected type
+  #endif
+
+  #if DECTRACE
+  printf("MulAccl:");
+  for (pl=accl+MULACCLEN-1; pl>=accl; pl--)
+    printf(" %08lx:%08lx", (LI)(*pl>>32), (LI)(*pl&0xffffffff));
+  printf("\n");
+  #endif
+
+  for (pl=accl, pa=acc; pl<accl+MULACCLEN; pl++, pa++) { // each column position
+    uInt lo, hop;                       // work
+    uInt est;                           // cannot exceed 4E+9
+    if (*pl>=MULTBASE) {
+      // *pl holds a binary number which needs to be split
+      hop=(uInt)(*pl>>MULSHIFTA);
+      est=(uInt)(((uLong)hop*MULMAGIC)>>MULSHIFTB);
+      // the estimate is now in est; now calculate hi:lo-est*10**9;
+      // happily the top word of the result is irrelevant because it
+      // will always be zero so this needs only one multiplication
+      lo=(uInt)(*pl-((uLong)est*MULTBASE));  // low word of result
+      // If QUAD, the correction here could be +2
+      if (lo>=MULTBASE) {
+        lo-=MULTBASE;                   // correct by +1
+        est++;
+        #if QUAD
+        // may need to correct by +2
+        if (lo>=MULTBASE) {
+          lo-=MULTBASE;
+          est++;
+          }
+        #endif
+        }
+      // finally place lo as the new coefficient 'digit' and add est to
+      // the next place up [this is safe because this path is never
+      // taken on the final iteration as *pl will fit]
+      *pa=lo;
+      *(pl+1)+=est;
+      } // *pl needed split
+     else {                             // *pl<MULTBASE
+      *pa=(uInt)*pl;                    // just copy across
+      }
+    } // pl loop
+
+#else  // 32-bit
+  for (pa=acc;; pa+=4) {                     // zero the accumulator
+    *pa=0; *(pa+1)=0; *(pa+2)=0; *(pa+3)=0;  // [reduce overhead]
+    if (pa==acc+MULACCLEN*2-4) break;        // multiple of 4 asserted
+    } // pa
+
+  /* Effect the multiplication */
+  // uLongs are not available (and in particular, there is no uLong
+  // divide) but it is still possible to use MFC's lazy-carry
+  // resolution algorithm from decNumber.  First, the multiplication
+  // is effected, allowing accumulation of the partial products
+  // (which are in base-billion at each column position) into 64 bits
+  // [with the high-order 32 bits in each position being held at
+  // offset +ACCLEN from the low-order 32 bits in the accumulator].
+  // These 64-bit numbers (which may contain up to 19 decimal digits)
+  // are then split using the Clark & Cowlishaw algorithm (see
+  // below).
+  for (ui=bufr;; ui++) {                // over each item in rhs
+    uInt hi, lo;                        // words of exact multiply result
+    pa=acc+(ui-bufr);                   // where to add the lhs
+    for (uj=bufl;; uj++, pa++) {        // over each item in lhs
+      LONGMUL32HI(hi, *ui, *uj);        // calculate product of digits
+      lo=(*ui)*(*uj);                   // ..
+      *pa+=lo;                          // accumulate low bits and ..
+      *(pa+MULACCLEN)+=hi+(*pa<lo);     // .. high bits with any carry
+      if (uj==bufl+MULOPLEN-1) break;
+      }
+    if (ui==bufr+MULOPLEN-1) break;
+    }
+
+  // The 64-bit carries must now be resolved; this means that a
+  // quotient/remainder has to be calculated for base-billion (1E+9).
+  // For this, Clark & Cowlishaw's quotient estimation approach (also
+  // used in decNumber) is needed, because 64-bit divide is generally
+  // extremely slow on 32-bit machines.  This algorithm splits X
+  // using:
+  //
+  //   magic=2**(A+B)/1E+9;   // 'magic number'
+  //   hop=X/2**A;            // high order part of X (by shift)
+  //   est=magic*hop/2**B     // quotient estimate (may be low by 1)
+  //
+  // A and B are quite constrained; hop and magic must fit in 32 bits,
+  // and 2**(A+B) must be as large as possible (which is 2**61 if
+  // magic is to fit).  Further, maxX increases with the length of
+  // the operands (and hence the number of partial products
+  // accumulated); maxX is OPLEN*(10**18), which is up to 19 digits.
+  //
+  // It can be shown that when OPLEN is 2 then the maximum error in
+  // the estimated quotient is <1, but for larger maximum x the
+  // maximum error is above 1 so a correction that is >1 may be
+  // needed.  Values of A and B are chosen to satisfy the constraints
+  // just mentioned while minimizing the maximum error (and hence the
+  // maximum correction), as shown in the following table:
+  //
+  //   Type    OPLEN   A   B     maxX    maxError  maxCorrection
+  //   ---------------------------------------------------------
+  //   DOUBLE    2    29  32  <2*10**18    0.63       1
+  //   QUAD      4    30  31  <4*10**18    1.17       2
+  //
+  // In the OPLEN==2 case there is most choice, but the value for B
+  // of 32 has a big advantage as then the calculation of the
+  // estimate requires no shifting; the high word is simply
+  // calculated from multiplying magic*hop.
+  #define MULMAGIC 2305843009U          // 2**61/10**9  [both cases]
+  #if DOUBLE
+    #define MULSHIFTA 29
+    #define MULSHIFTB 32
+  #elif QUAD
+    #define MULSHIFTA 30
+    #define MULSHIFTB 31
+  #else
+    #error Unexpected type
+  #endif
+
+  #if DECTRACE
+  printf("MulHiLo:");
+  for (pa=acc+MULACCLEN-1; pa>=acc; pa--)
+    printf(" %08lx:%08lx", (LI)*(pa+MULACCLEN), (LI)*pa);
+  printf("\n");
+  #endif
+
+  for (pa=acc;; pa++) {                 // each low uInt
+    uInt hi, lo;                        // words of exact multiply result
+    uInt hop, estlo;                    // work
+    #if QUAD
+    uInt esthi;                         // ..
+    #endif
+
+    lo=*pa;
+    hi=*(pa+MULACCLEN);                 // top 32 bits
+    // hi and lo now hold a binary number which needs to be split
+
+    #if DOUBLE
+      hop=(hi<<3)+(lo>>MULSHIFTA);      // hi:lo/2**29
+      LONGMUL32HI(estlo, hop, MULMAGIC);// only need the high word
+      // [MULSHIFTB is 32, so estlo can be used directly]
+      // the estimate is now in estlo; now calculate hi:lo-est*10**9;
+      // happily the top word of the result is irrelevant because it
+      // will always be zero so this needs only one multiplication
+      lo-=(estlo*MULTBASE);
+      // esthi=0;                       // high word is ignored below
+      // the correction here will be at most +1; do it
+      if (lo>=MULTBASE) {
+        lo-=MULTBASE;
+        estlo++;
+        }
+    #elif QUAD
+      hop=(hi<<2)+(lo>>MULSHIFTA);      // hi:lo/2**30
+      LONGMUL32HI(esthi, hop, MULMAGIC);// shift will be 31 ..
+      estlo=hop*MULMAGIC;               // .. so low word needed
+      estlo=(esthi<<1)+(estlo>>MULSHIFTB); // [just the top bit]
+      // esthi=0;                       // high word is ignored below
+      lo-=(estlo*MULTBASE);             // as above
+      // the correction here could be +1 or +2
+      if (lo>=MULTBASE) {
+        lo-=MULTBASE;
+        estlo++;
+        }
+      if (lo>=MULTBASE) {
+        lo-=MULTBASE;
+        estlo++;
+        }
+    #else
+      #error Unexpected type
+    #endif
+
+    // finally place lo as the new accumulator digit and add est to
+    // the next place up; this latter add could cause a carry of 1
+    // to the high word of the next place
+    *pa=lo;
+    *(pa+1)+=estlo;
+    // esthi is always 0 for DOUBLE and QUAD so this is skipped
+    // *(pa+1+MULACCLEN)+=esthi;
+    if (*(pa+1)<estlo) *(pa+1+MULACCLEN)+=1; // carry
+    if (pa==acc+MULACCLEN-2) break;          // [MULACCLEN-1 will never need split]
+    } // pa loop
+#endif
+
+  // At this point, whether using the 64-bit or the 32-bit paths, the
+  // accumulator now holds the (unrounded) result in base-billion;
+  // one base-billion 'digit' per uInt.
+  #if DECTRACE
+  printf("MultAcc:");
+  for (pa=acc+MULACCLEN-1; pa>=acc; pa--) printf(" %09ld", (LI)*pa);
+  printf("\n");
+  #endif
+
+  // Now convert to BCD for rounding and cleanup, starting from the
+  // most significant end
+  pa=acc+MULACCLEN-1;
+  if (*pa!=0) num->msd=bcdacc+LEADZEROS;// drop known lead zeros
+   else {                               // >=1 word of leading zeros
+    num->msd=bcdacc;                    // known leading zeros are gone
+    pa--;                               // skip first word ..
+    for (; *pa==0; pa--) if (pa==acc) break; // .. and any more leading 0s
+    }
+  for (ub=bcdacc;; pa--, ub+=9) {
+    if (*pa!=0) {                       // split(s) needed
+      uInt top, mid, rem;               // work
+      // *pa is non-zero -- split the base-billion acc digit into
+      // hi, mid, and low three-digits
+      #define mulsplit9 1000000         // divisor
+      #define mulsplit6 1000            // divisor
+      // The splitting is done by simple divides and remainders,
+      // assuming the compiler will optimize these where useful
+      // [GCC does]
+      top=*pa/mulsplit9;
+      rem=*pa%mulsplit9;
+      mid=rem/mulsplit6;
+      rem=rem%mulsplit6;
+      // lay out the nine BCD digits (plus one unwanted byte)
+      UBFROMUI(ub,   UBTOUI(&BIN2BCD8[top*4]));
+      UBFROMUI(ub+3, UBTOUI(&BIN2BCD8[mid*4]));
+      UBFROMUI(ub+6, UBTOUI(&BIN2BCD8[rem*4]));
+      }
+     else {                             // *pa==0
+      UBFROMUI(ub, 0);                  // clear 9 BCD8s
+      UBFROMUI(ub+4, 0);                // ..
+      *(ub+8)=0;                        // ..
+      }
+    if (pa==acc) break;
+    } // BCD conversion loop
+
+  num->lsd=ub+8;                        // complete the bcdnum ..
+
+  #if DECTRACE
+  decShowNum(num, "postmult");
+  decFloatShow(dfl, "dfl");
+  decFloatShow(dfr, "dfr");
+  #endif
+  return;
+  } // decFiniteMultiply
+
+/* ------------------------------------------------------------------ */
+/* decFloatAbs -- absolute value, heeding NaNs, etc.                  */
+/*                                                                    */
+/*   result gets the canonicalized df with sign 0                     */
+/*   df     is the decFloat to abs                                    */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* This has the same effect as decFloatPlus unless df is negative,    */
+/* in which case it has the same effect as decFloatMinus.  The        */
+/* effect is also the same as decFloatCopyAbs except that NaNs are    */
+/* handled normally (the sign of a NaN is not affected, and an sNaN   */
+/* will signal) and the result will be canonical.                     */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatAbs(decFloat *result, const decFloat *df,
+                       decContext *set) {
+  if (DFISNAN(df)) return decNaNs(result, df, NULL, set);
+  decCanonical(result, df);             // copy and check
+  DFBYTE(result, 0)&=~0x80;             // zero sign bit
+  return result;
+  } // decFloatAbs
+
+/* ------------------------------------------------------------------ */
+/* decFloatAdd -- add two decFloats                                   */
+/*                                                                    */
+/*   result gets the result of adding dfl and dfr:                    */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* ------------------------------------------------------------------ */
+#if QUAD
+// Table for testing MSDs for fastpath elimination; returns the MSD of
+// a decDouble or decQuad (top 6 bits tested) ignoring the sign.
+// Infinities return -32 and NaNs return -128 so that summing the two
+// MSDs also allows rapid tests for the Specials (see code below).
+const Int DECTESTMSD[64]={
+  0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5,   6,    7,
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 9, 8, 9, -32, -128,
+  0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5,   6,    7,
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 9, 8, 9, -32, -128};
+#else
+// The table for testing MSDs is shared between the modules
+extern const Int DECTESTMSD[64];
+#endif
+
+decFloat * decFloatAdd(decFloat *result,
+                       const decFloat *dfl, const decFloat *dfr,
+                       decContext *set) {
+  bcdnum num;                      // for final conversion
+  Int    bexpl, bexpr;             // left and right biased exponents
+  uByte  *ub, *us, *ut;            // work
+  uInt   uiwork;                   // for macros
+  #if QUAD
+  uShort uswork;                   // ..
+  #endif
+
+  uInt sourhil, sourhir;           // top words from source decFloats
+                                   // [valid only through end of
+                                   // fastpath code -- before swap]
+  uInt diffsign;                   // non-zero if signs differ
+  uInt carry;                      // carry: 0 or 1 before add loop
+  Int  overlap;                    // coefficient overlap (if full)
+  Int  summ;                       // sum of the MSDs
+  // the following buffers hold coefficients with various alignments
+  // (see commentary and diagrams below)
+  uByte acc[4+2+DECPMAX*3+8];
+  uByte buf[4+2+DECPMAX*2];
+  uByte *umsd, *ulsd;              // local MSD and LSD pointers
+
+  #if DECLITEND
+    #define CARRYPAT 0x01000000    // carry=1 pattern
+  #else
+    #define CARRYPAT 0x00000001    // carry=1 pattern
+  #endif
+
+  /* Start decoding the arguments */
+  // The initial exponents are placed into the opposite Ints to
+  // that which might be expected; there are two sets of data to
+  // keep track of (each decFloat and the corresponding exponent),
+  // and this scheme means that at the swap point (after comparing
+  // exponents) only one pair of words needs to be swapped
+  // whichever path is taken (thereby minimising worst-case path).
+  // The calculated exponents will be nonsense when the arguments are
+  // Special, but are not used in that path
+  sourhil=DFWORD(dfl, 0);          // LHS top word
+  summ=DECTESTMSD[sourhil>>26];    // get first MSD for testing
+  bexpr=DECCOMBEXP[sourhil>>26];   // get exponent high bits (in place)
+  bexpr+=GETECON(dfl);             // .. + continuation
+
+  sourhir=DFWORD(dfr, 0);          // RHS top word
+  summ+=DECTESTMSD[sourhir>>26];   // sum MSDs for testing
+  bexpl=DECCOMBEXP[sourhir>>26];
+  bexpl+=GETECON(dfr);
+
+  // here bexpr has biased exponent from lhs, and vice versa
+
+  diffsign=(sourhil^sourhir)&DECFLOAT_Sign;
+
+  // now determine whether to take a fast path or the full-function
+  // slow path.  The slow path must be taken when:
+  //   -- both numbers are finite, and:
+  //         the exponents are different, or
+  //         the signs are different, or
+  //         the sum of the MSDs is >8 (hence might overflow)
+  // specialness and the sum of the MSDs can be tested at once using
+  // the summ value just calculated, so the test for specials is no
+  // longer on the worst-case path (as of 3.60)
+
+  if (summ<=8) {                   // MSD+MSD is good, or there is a special
+    if (summ<0) {                  // there is a special
+      // Inf+Inf would give -64; Inf+finite is -32 or higher
+      if (summ<-64) return decNaNs(result, dfl, dfr, set);  // one or two NaNs
+      // two infinities with different signs is invalid
+      if (summ==-64 && diffsign) return decInvalid(result, set);
+      if (DFISINF(dfl)) return decInfinity(result, dfl);    // LHS is infinite
+      return decInfinity(result, dfr);                      // RHS must be Inf
+      }
+    // Here when both arguments are finite; fast path is possible
+    // (currently only for aligned and same-sign)
+    if (bexpr==bexpl && !diffsign) {
+      uInt tac[DECLETS+1];              // base-1000 coefficient
+      uInt encode;                      // work
+
+      // Get one coefficient as base-1000 and add the other
+      GETCOEFFTHOU(dfl, tac);           // least-significant goes to [0]
+      ADDCOEFFTHOU(dfr, tac);
+      // here the sum of the MSDs (plus any carry) will be <10 due to
+      // the fastpath test earlier
+
+      // construct the result; low word is the same for both formats
+      encode =BIN2DPD[tac[0]];
+      encode|=BIN2DPD[tac[1]]<<10;
+      encode|=BIN2DPD[tac[2]]<<20;
+      encode|=BIN2DPD[tac[3]]<<30;
+      DFWORD(result, (DECBYTES/4)-1)=encode;
+
+      // collect next two declets (all that remains, for Double)
+      encode =BIN2DPD[tac[3]]>>2;
+      encode|=BIN2DPD[tac[4]]<<8;
+
+      #if QUAD
+      // complete and lay out middling words
+      encode|=BIN2DPD[tac[5]]<<18;
+      encode|=BIN2DPD[tac[6]]<<28;
+      DFWORD(result, 2)=encode;
+
+      encode =BIN2DPD[tac[6]]>>4;
+      encode|=BIN2DPD[tac[7]]<<6;
+      encode|=BIN2DPD[tac[8]]<<16;
+      encode|=BIN2DPD[tac[9]]<<26;
+      DFWORD(result, 1)=encode;
+
+      // and final two declets
+      encode =BIN2DPD[tac[9]]>>6;
+      encode|=BIN2DPD[tac[10]]<<4;
+      #endif
+
+      // add exponent continuation and sign (from either argument)
+      encode|=sourhil & (ECONMASK | DECFLOAT_Sign);
+
+      // create lookup index = MSD + top two bits of biased exponent <<4
+      tac[DECLETS]|=(bexpl>>DECECONL)<<4;
+      encode|=DECCOMBFROM[tac[DECLETS]]; // add constructed combination field
+      DFWORD(result, 0)=encode;          // complete
+
+      // decFloatShow(result, ">");
+      return result;
+      } // fast path OK
+    // drop through to slow path
+    } // low sum or Special(s)
+
+  /* Slow path required -- arguments are finite and might overflow,   */
+  /* or require alignment, or might have different signs              */
+
+  // now swap either exponents or argument pointers
+  if (bexpl<=bexpr) {
+    // original left is bigger
+    Int bexpswap=bexpl;
+    bexpl=bexpr;
+    bexpr=bexpswap;
+    // printf("left bigger\n");
+    }
+   else {
+    const decFloat *dfswap=dfl;
+    dfl=dfr;
+    dfr=dfswap;
+    // printf("right bigger\n");
+    }
+  // [here dfl and bexpl refer to the datum with the larger exponent,
+  // of if the exponents are equal then the original LHS argument]
+
+  // if lhs is zero then result will be the rhs (now known to have
+  // the smaller exponent), which also may need to be tested for zero
+  // for the weird IEEE 754 sign rules
+  if (DFISZERO(dfl)) {
+    decCanonical(result, dfr);               // clean copy
+    // "When the sum of two operands with opposite signs is
+    // exactly zero, the sign of that sum shall be '+' in all
+    // rounding modes except round toward -Infinity, in which
+    // mode that sign shall be '-'."
+    if (diffsign && DFISZERO(result)) {
+      DFWORD(result, 0)&=~DECFLOAT_Sign;     // assume sign 0
+      if (set->round==DEC_ROUND_FLOOR) DFWORD(result, 0)|=DECFLOAT_Sign;
+      }
+    return result;
+    } // numfl is zero
+  // [here, LHS is non-zero; code below assumes that]
+
+  // Coefficients layout during the calculations to follow:
+  //
+  //       Overlap case:
+  //       +------------------------------------------------+
+  // acc:  |0000|      coeffa      | tail B |               |
+  //       +------------------------------------------------+
+  // buf:  |0000| pad0s |      coeffb       |               |
+  //       +------------------------------------------------+
+  //
+  //       Touching coefficients or gap:
+  //       +------------------------------------------------+
+  // acc:  |0000|      coeffa      | gap |      coeffb      |
+  //       +------------------------------------------------+
+  //       [buf not used or needed; gap clamped to Pmax]
+
+  // lay out lhs coefficient into accumulator; this starts at acc+4
+  // for decDouble or acc+6 for decQuad so the LSD is word-
+  // aligned; the top word gap is there only in case a carry digit
+  // is prefixed after the add -- it does not need to be zeroed
+  #if DOUBLE
+    #define COFF 4                      // offset into acc
+  #elif QUAD
+    UBFROMUS(acc+4, 0);                 // prefix 00
+    #define COFF 6                      // offset into acc
+  #endif
+
+  GETCOEFF(dfl, acc+COFF);              // decode from decFloat
+  ulsd=acc+COFF+DECPMAX-1;
+  umsd=acc+4;                           // [having this here avoids
+
+  #if DECTRACE
+  {bcdnum tum;
+  tum.msd=umsd;
+  tum.lsd=ulsd;
+  tum.exponent=bexpl-DECBIAS;
+  tum.sign=DFWORD(dfl, 0) & DECFLOAT_Sign;
+  decShowNum(&tum, "dflx");}
+  #endif
+
+  // if signs differ, take ten's complement of lhs (here the
+  // coefficient is subtracted from all-nines; the 1 is added during
+  // the later add cycle -- zeros to the right do not matter because
+  // the complement of zero is zero); these are fixed-length inverts
+  // where the lsd is known to be at a 4-byte boundary (so no borrow
+  // possible)
+  carry=0;                              // assume no carry
+  if (diffsign) {
+    carry=CARRYPAT;                     // for +1 during add
+    UBFROMUI(acc+ 4, 0x09090909-UBTOUI(acc+ 4));
+    UBFROMUI(acc+ 8, 0x09090909-UBTOUI(acc+ 8));
+    UBFROMUI(acc+12, 0x09090909-UBTOUI(acc+12));
+    UBFROMUI(acc+16, 0x09090909-UBTOUI(acc+16));
+    #if QUAD
+    UBFROMUI(acc+20, 0x09090909-UBTOUI(acc+20));
+    UBFROMUI(acc+24, 0x09090909-UBTOUI(acc+24));
+    UBFROMUI(acc+28, 0x09090909-UBTOUI(acc+28));
+    UBFROMUI(acc+32, 0x09090909-UBTOUI(acc+32));
+    UBFROMUI(acc+36, 0x09090909-UBTOUI(acc+36));
+    #endif
+    } // diffsign
+
+  // now process the rhs coefficient; if it cannot overlap lhs then
+  // it can be put straight into acc (with an appropriate gap, if
+  // needed) because no actual addition will be needed (except
+  // possibly to complete ten's complement)
+  overlap=DECPMAX-(bexpl-bexpr);
+  #if DECTRACE
+  printf("exps: %ld %ld\n", (LI)(bexpl-DECBIAS), (LI)(bexpr-DECBIAS));
+  printf("Overlap=%ld carry=%08lx\n", (LI)overlap, (LI)carry);
+  #endif
+
+  if (overlap<=0) {                     // no overlap possible
+    uInt gap;                           // local work
+    // since a full addition is not needed, a ten's complement
+    // calculation started above may need to be completed
+    if (carry) {
+      for (ub=ulsd; *ub==9; ub--) *ub=0;
+      *ub+=1;
+      carry=0;                          // taken care of
+      }
+    // up to DECPMAX-1 digits of the final result can extend down
+    // below the LSD of the lhs, so if the gap is >DECPMAX then the
+    // rhs will be simply sticky bits.  In this case the gap is
+    // clamped to DECPMAX and the exponent adjusted to suit [this is
+    // safe because the lhs is non-zero].
+    gap=-overlap;
+    if (gap>DECPMAX) {
+      bexpr+=gap-1;
+      gap=DECPMAX;
+      }
+    ub=ulsd+gap+1;                      // where MSD will go
+    // Fill the gap with 0s; note that there is no addition to do
+    ut=acc+COFF+DECPMAX;                // start of gap
+    for (; ut<ub; ut+=4) UBFROMUI(ut, 0); // mind the gap
+    if (overlap<-DECPMAX) {             // gap was > DECPMAX
+      *ub=(uByte)(!DFISZERO(dfr));      // make sticky digit
+      }
+     else {                             // need full coefficient
+      GETCOEFF(dfr, ub);                // decode from decFloat
+      ub+=DECPMAX-1;                    // new LSD...
+      }
+    ulsd=ub;                            // save new LSD
+    } // no overlap possible
+
+   else {                               // overlap>0
+    // coefficients overlap (perhaps completely, although also
+    // perhaps only where zeros)
+    if (overlap==DECPMAX) {             // aligned
+      ub=buf+COFF;                      // where msd will go
+      #if QUAD
+      UBFROMUS(buf+4, 0);               // clear quad's 00
+      #endif
+      GETCOEFF(dfr, ub);                // decode from decFloat
+      }
+     else {                             // unaligned
+      ub=buf+COFF+DECPMAX-overlap;      // where MSD will go
+      // Fill the prefix gap with 0s; 8 will cover most common
+      // unalignments, so start with direct assignments (a loop is
+      // then used for any remaining -- the loop (and the one in a
+      // moment) is not then on the critical path because the number
+      // of additions is reduced by (at least) two in this case)
+      UBFROMUI(buf+4, 0);               // [clears decQuad 00 too]
+      UBFROMUI(buf+8, 0);
+      if (ub>buf+12) {
+        ut=buf+12;                      // start any remaining
+        for (; ut<ub; ut+=4) UBFROMUI(ut, 0); // fill them
+        }
+      GETCOEFF(dfr, ub);                // decode from decFloat
+
+      // now move tail of rhs across to main acc; again use direct
+      // copies for 8 digits-worth
+      UBFROMUI(acc+COFF+DECPMAX,   UBTOUI(buf+COFF+DECPMAX));
+      UBFROMUI(acc+COFF+DECPMAX+4, UBTOUI(buf+COFF+DECPMAX+4));
+      if (buf+COFF+DECPMAX+8<ub+DECPMAX) {
+        us=buf+COFF+DECPMAX+8;          // source
+        ut=acc+COFF+DECPMAX+8;          // target
+        for (; us<ub+DECPMAX; us+=4, ut+=4) UBFROMUI(ut, UBTOUI(us));
+        }
+      } // unaligned
+
+    ulsd=acc+(ub-buf+DECPMAX-1);        // update LSD pointer
+
+    // Now do the add of the non-tail; this is all nicely aligned,
+    // and is over a multiple of four digits (because for Quad two
+    // zero digits were added on the left); words in both acc and
+    // buf (buf especially) will often be zero
+    // [byte-by-byte add, here, is about 15% slower total effect than
+    // the by-fours]
+
+    // Now effect the add; this is harder on a little-endian
+    // machine as the inter-digit carry cannot use the usual BCD
+    // addition trick because the bytes are loaded in the wrong order
+    // [this loop could be unrolled, but probably scarcely worth it]
+
+    ut=acc+COFF+DECPMAX-4;              // target LSW (acc)
+    us=buf+COFF+DECPMAX-4;              // source LSW (buf, to add to acc)
+
+    #if !DECLITEND
+    for (; ut>=acc+4; ut-=4, us-=4) {   // big-endian add loop
+      // bcd8 add
+      carry+=UBTOUI(us);                // rhs + carry
+      if (carry==0) continue;           // no-op
+      carry+=UBTOUI(ut);                // lhs
+      // Big-endian BCD adjust (uses internal carry)
+      carry+=0x76f6f6f6;                // note top nibble not all bits
+      // apply BCD adjust and save
+      UBFROMUI(ut, (carry & 0x0f0f0f0f) - ((carry & 0x60606060)>>4));
+      carry>>=31;                       // true carry was at far left
+      } // add loop
+    #else
+    for (; ut>=acc+4; ut-=4, us-=4) {   // little-endian add loop
+      // bcd8 add
+      carry+=UBTOUI(us);                // rhs + carry
+      if (carry==0) continue;           // no-op [common if unaligned]
+      carry+=UBTOUI(ut);                // lhs
+      // Little-endian BCD adjust; inter-digit carry must be manual
+      // because the lsb from the array will be in the most-significant
+      // byte of carry
+      carry+=0x76767676;                // note no inter-byte carries
+      carry+=(carry & 0x80000000)>>15;
+      carry+=(carry & 0x00800000)>>15;
+      carry+=(carry & 0x00008000)>>15;
+      carry-=(carry & 0x60606060)>>4;   // BCD adjust back
+      UBFROMUI(ut, carry & 0x0f0f0f0f); // clear debris and save
+      // here, final carry-out bit is at 0x00000080; move it ready
+      // for next word-add (i.e., to 0x01000000)
+      carry=(carry & 0x00000080)<<17;
+      } // add loop
+    #endif
+
+    #if DECTRACE
+    {bcdnum tum;
+    printf("Add done, carry=%08lx, diffsign=%ld\n", (LI)carry, (LI)diffsign);
+    tum.msd=umsd;  // acc+4;
+    tum.lsd=ulsd;
+    tum.exponent=0;
+    tum.sign=0;
+    decShowNum(&tum, "dfadd");}
+    #endif
+    } // overlap possible
+
+  // ordering here is a little strange in order to have slowest path
+  // first in GCC asm listing
+  if (diffsign) {                  // subtraction
+    if (!carry) {                  // no carry out means RHS<LHS
+      // borrowed -- take ten's complement
+      // sign is lhs sign
+      num.sign=DFWORD(dfl, 0) & DECFLOAT_Sign;
+
+      // invert the coefficient first by fours, then add one; space
+      // at the end of the buffer ensures the by-fours is always
+      // safe, but lsd+1 must be cleared to prevent a borrow
+      // if big-endian
+      #if !DECLITEND
+      *(ulsd+1)=0;
+      #endif
+      // there are always at least four coefficient words
+      UBFROMUI(umsd,    0x09090909-UBTOUI(umsd));
+      UBFROMUI(umsd+4,  0x09090909-UBTOUI(umsd+4));
+      UBFROMUI(umsd+8,  0x09090909-UBTOUI(umsd+8));
+      UBFROMUI(umsd+12, 0x09090909-UBTOUI(umsd+12));
+      #if DOUBLE
+        #define BNEXT 16
+      #elif QUAD
+        UBFROMUI(umsd+16, 0x09090909-UBTOUI(umsd+16));
+        UBFROMUI(umsd+20, 0x09090909-UBTOUI(umsd+20));
+        UBFROMUI(umsd+24, 0x09090909-UBTOUI(umsd+24));
+        UBFROMUI(umsd+28, 0x09090909-UBTOUI(umsd+28));
+        UBFROMUI(umsd+32, 0x09090909-UBTOUI(umsd+32));
+        #define BNEXT 36
+      #endif
+      if (ulsd>=umsd+BNEXT) {           // unaligned
+        // eight will handle most unaligments for Double; 16 for Quad
+        UBFROMUI(umsd+BNEXT,   0x09090909-UBTOUI(umsd+BNEXT));
+        UBFROMUI(umsd+BNEXT+4, 0x09090909-UBTOUI(umsd+BNEXT+4));
+        #if DOUBLE
+        #define BNEXTY (BNEXT+8)
+        #elif QUAD
+        UBFROMUI(umsd+BNEXT+8,  0x09090909-UBTOUI(umsd+BNEXT+8));
+        UBFROMUI(umsd+BNEXT+12, 0x09090909-UBTOUI(umsd+BNEXT+12));
+        #define BNEXTY (BNEXT+16)
+        #endif
+        if (ulsd>=umsd+BNEXTY) {        // very unaligned
+          ut=umsd+BNEXTY;               // -> continue
+          for (;;ut+=4) {
+            UBFROMUI(ut, 0x09090909-UBTOUI(ut)); // invert four digits
+            if (ut>=ulsd-3) break;      // all done
+            }
+          }
+        }
+      // complete the ten's complement by adding 1
+      for (ub=ulsd; *ub==9; ub--) *ub=0;
+      *ub+=1;
+      } // borrowed
+
+     else {                        // carry out means RHS>=LHS
+      num.sign=DFWORD(dfr, 0) & DECFLOAT_Sign;
+      // all done except for the special IEEE 754 exact-zero-result
+      // rule (see above); while testing for zero, strip leading
+      // zeros (which will save decFinalize doing it) (this is in
+      // diffsign path, so carry impossible and true umsd is
+      // acc+COFF)
+
+      // Check the initial coefficient area using the fast macro;
+      // this will often be all that needs to be done (as on the
+      // worst-case path when the subtraction was aligned and
+      // full-length)
+      if (ISCOEFFZERO(acc+COFF)) {
+        umsd=acc+COFF+DECPMAX-1;   // so far, so zero
+        if (ulsd>umsd) {           // more to check
+          umsd++;                  // to align after checked area
+          for (; UBTOUI(umsd)==0 && umsd+3<ulsd;) umsd+=4;
+          for (; *umsd==0 && umsd<ulsd;) umsd++;
+          }
+        if (*umsd==0) {            // must be true zero (and diffsign)
+          num.sign=0;              // assume +
+          if (set->round==DEC_ROUND_FLOOR) num.sign=DECFLOAT_Sign;
+          }
+        }
+      // [else was not zero, might still have leading zeros]
+      } // subtraction gave positive result
+    } // diffsign
+
+   else { // same-sign addition
+    num.sign=DFWORD(dfl, 0)&DECFLOAT_Sign;
+    #if DOUBLE
+    if (carry) {                   // only possible with decDouble
+      *(acc+3)=1;                  // [Quad has leading 00]
+      umsd=acc+3;
+      }
+    #endif
+    } // same sign
+
+  num.msd=umsd;                    // set MSD ..
+  num.lsd=ulsd;                    // .. and LSD
+  num.exponent=bexpr-DECBIAS;      // set exponent to smaller, unbiassed
+
+  #if DECTRACE
+  decFloatShow(dfl, "dfl");
+  decFloatShow(dfr, "dfr");
+  decShowNum(&num, "postadd");
+  #endif
+  return decFinalize(result, &num, set); // round, check, and lay out
+  } // decFloatAdd
+
+/* ------------------------------------------------------------------ */
+/* decFloatAnd -- logical digitwise AND of two decFloats              */
+/*                                                                    */
+/*   result gets the result of ANDing dfl and dfr                     */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result, which will be canonical with sign=0              */
+/*                                                                    */
+/* The operands must be positive, finite with exponent q=0, and       */
+/* comprise just zeros and ones; if not, Invalid operation results.   */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatAnd(decFloat *result,
+                       const decFloat *dfl, const decFloat *dfr,
+                       decContext *set) {
+  if (!DFISUINT01(dfl) || !DFISUINT01(dfr)
+   || !DFISCC01(dfl)   || !DFISCC01(dfr)) return decInvalid(result, set);
+  // the operands are positive finite integers (q=0) with just 0s and 1s
+  #if DOUBLE
+   DFWORD(result, 0)=ZEROWORD
+                   |((DFWORD(dfl, 0) & DFWORD(dfr, 0))&0x04009124);
+   DFWORD(result, 1)=(DFWORD(dfl, 1) & DFWORD(dfr, 1))&0x49124491;
+  #elif QUAD
+   DFWORD(result, 0)=ZEROWORD
+                   |((DFWORD(dfl, 0) & DFWORD(dfr, 0))&0x04000912);
+   DFWORD(result, 1)=(DFWORD(dfl, 1) & DFWORD(dfr, 1))&0x44912449;
+   DFWORD(result, 2)=(DFWORD(dfl, 2) & DFWORD(dfr, 2))&0x12449124;
+   DFWORD(result, 3)=(DFWORD(dfl, 3) & DFWORD(dfr, 3))&0x49124491;
+  #endif
+  return result;
+  } // decFloatAnd
+
+/* ------------------------------------------------------------------ */
+/* decFloatCanonical -- copy a decFloat, making canonical             */
+/*                                                                    */
+/*   result gets the canonicalized df                                 */
+/*   df     is the decFloat to copy and make canonical                */
+/*   returns result                                                   */
+/*                                                                    */
+/* This works on specials, too; no error or exception is possible.    */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatCanonical(decFloat *result, const decFloat *df) {
+  return decCanonical(result, df);
+  } // decFloatCanonical
+
+/* ------------------------------------------------------------------ */
+/* decFloatClass -- return the class of a decFloat                    */
+/*                                                                    */
+/*   df is the decFloat to test                                       */
+/*   returns the decClass that df falls into                          */
+/* ------------------------------------------------------------------ */
+enum decClass decFloatClass(const decFloat *df) {
+  Int exp;                         // exponent
+  if (DFISSPECIAL(df)) {
+    if (DFISQNAN(df)) return DEC_CLASS_QNAN;
+    if (DFISSNAN(df)) return DEC_CLASS_SNAN;
+    // must be an infinity
+    if (DFISSIGNED(df)) return DEC_CLASS_NEG_INF;
+    return DEC_CLASS_POS_INF;
+    }
+  if (DFISZERO(df)) {              // quite common
+    if (DFISSIGNED(df)) return DEC_CLASS_NEG_ZERO;
+    return DEC_CLASS_POS_ZERO;
+    }
+  // is finite and non-zero; similar code to decFloatIsNormal, here
+  // [this could be speeded up slightly by in-lining decFloatDigits]
+  exp=GETEXPUN(df)                 // get unbiased exponent ..
+     +decFloatDigits(df)-1;        // .. and make adjusted exponent
+  if (exp>=DECEMIN) {              // is normal
+    if (DFISSIGNED(df)) return DEC_CLASS_NEG_NORMAL;
+    return DEC_CLASS_POS_NORMAL;
+    }
+  // is subnormal
+  if (DFISSIGNED(df)) return DEC_CLASS_NEG_SUBNORMAL;
+  return DEC_CLASS_POS_SUBNORMAL;
+  } // decFloatClass
+
+/* ------------------------------------------------------------------ */
+/* decFloatClassString -- return the class of a decFloat as a string  */
+/*                                                                    */
+/*   df is the decFloat to test                                       */
+/*   returns a constant string describing the class df falls into     */
+/* ------------------------------------------------------------------ */
+const char *decFloatClassString(const decFloat *df) {
+  enum decClass eclass=decFloatClass(df);
+  if (eclass==DEC_CLASS_POS_NORMAL)    return DEC_ClassString_PN;
+  if (eclass==DEC_CLASS_NEG_NORMAL)    return DEC_ClassString_NN;
+  if (eclass==DEC_CLASS_POS_ZERO)      return DEC_ClassString_PZ;
+  if (eclass==DEC_CLASS_NEG_ZERO)      return DEC_ClassString_NZ;
+  if (eclass==DEC_CLASS_POS_SUBNORMAL) return DEC_ClassString_PS;
+  if (eclass==DEC_CLASS_NEG_SUBNORMAL) return DEC_ClassString_NS;
+  if (eclass==DEC_CLASS_POS_INF)       return DEC_ClassString_PI;
+  if (eclass==DEC_CLASS_NEG_INF)       return DEC_ClassString_NI;
+  if (eclass==DEC_CLASS_QNAN)          return DEC_ClassString_QN;
+  if (eclass==DEC_CLASS_SNAN)          return DEC_ClassString_SN;
+  return DEC_ClassString_UN;           // Unknown
+  } // decFloatClassString
+
+/* ------------------------------------------------------------------ */
+/* decFloatCompare -- compare two decFloats; quiet NaNs allowed       */
+/*                                                                    */
+/*   result gets the result of comparing dfl and dfr                  */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result, which may be -1, 0, 1, or NaN (Unordered)        */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatCompare(decFloat *result,
+                           const decFloat *dfl, const decFloat *dfr,
+                           decContext *set) {
+  Int comp;                                  // work
+  // NaNs are handled as usual
+  if (DFISNAN(dfl) || DFISNAN(dfr)) return decNaNs(result, dfl, dfr, set);
+  // numeric comparison needed
+  comp=decNumCompare(dfl, dfr, 0);
+  decFloatZero(result);
+  if (comp==0) return result;
+  DFBYTE(result, DECBYTES-1)=0x01;      // LSD=1
+  if (comp<0) DFBYTE(result, 0)|=0x80;  // set sign bit
+  return result;
+  } // decFloatCompare
+
+/* ------------------------------------------------------------------ */
+/* decFloatCompareSignal -- compare two decFloats; all NaNs signal    */
+/*                                                                    */
+/*   result gets the result of comparing dfl and dfr                  */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result, which may be -1, 0, 1, or NaN (Unordered)        */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatCompareSignal(decFloat *result,
+                                 const decFloat *dfl, const decFloat *dfr,
+                                 decContext *set) {
+  Int comp;                                  // work
+  // NaNs are handled as usual, except that all NaNs signal
+  if (DFISNAN(dfl) || DFISNAN(dfr)) {
+    set->status|=DEC_Invalid_operation;
+    return decNaNs(result, dfl, dfr, set);
+    }
+  // numeric comparison needed
+  comp=decNumCompare(dfl, dfr, 0);
+  decFloatZero(result);
+  if (comp==0) return result;
+  DFBYTE(result, DECBYTES-1)=0x01;      // LSD=1
+  if (comp<0) DFBYTE(result, 0)|=0x80;  // set sign bit
+  return result;
+  } // decFloatCompareSignal
+
+/* ------------------------------------------------------------------ */
+/* decFloatCompareTotal -- compare two decFloats with total ordering  */
+/*                                                                    */
+/*   result gets the result of comparing dfl and dfr                  */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   returns result, which may be -1, 0, or 1                         */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatCompareTotal(decFloat *result,
+                                const decFloat *dfl, const decFloat *dfr) {
+  Int  comp;                                 // work
+  uInt uiwork;                               // for macros
+  #if QUAD
+  uShort uswork;                             // ..
+  #endif
+  if (DFISNAN(dfl) || DFISNAN(dfr)) {
+    Int nanl, nanr;                          // work
+    // morph NaNs to +/- 1 or 2, leave numbers as 0
+    nanl=DFISSNAN(dfl)+DFISQNAN(dfl)*2;      // quiet > signalling
+    if (DFISSIGNED(dfl)) nanl=-nanl;
+    nanr=DFISSNAN(dfr)+DFISQNAN(dfr)*2;
+    if (DFISSIGNED(dfr)) nanr=-nanr;
+    if (nanl>nanr) comp=+1;
+     else if (nanl<nanr) comp=-1;
+     else { // NaNs are the same type and sign .. must compare payload
+      // buffers need +2 for QUAD
+      uByte bufl[DECPMAX+4];                 // for LHS coefficient + foot
+      uByte bufr[DECPMAX+4];                 // for RHS coefficient + foot
+      uByte *ub, *uc;                        // work
+      Int sigl;                              // signum of LHS
+      sigl=(DFISSIGNED(dfl) ? -1 : +1);
+
+      // decode the coefficients
+      // (shift both right two if Quad to make a multiple of four)
+      #if QUAD
+        UBFROMUS(bufl, 0);
+        UBFROMUS(bufr, 0);
+      #endif
+      GETCOEFF(dfl, bufl+QUAD*2);            // decode from decFloat
+      GETCOEFF(dfr, bufr+QUAD*2);            // ..
+      // all multiples of four, here
+      comp=0;                                // assume equal
+      for (ub=bufl, uc=bufr; ub<bufl+DECPMAX+QUAD*2; ub+=4, uc+=4) {
+        uInt ui=UBTOUI(ub);
+        if (ui==UBTOUI(uc)) continue; // so far so same
+        // about to find a winner; go by bytes in case little-endian
+        for (;; ub++, uc++) {
+          if (*ub==*uc) continue;
+          if (*ub>*uc) comp=sigl;            // difference found
+           else comp=-sigl;                  // ..
+           break;
+          }
+        }
+      } // same NaN type and sign
+    }
+   else {
+    // numeric comparison needed
+    comp=decNumCompare(dfl, dfr, 1);    // total ordering
+    }
+  decFloatZero(result);
+  if (comp==0) return result;
+  DFBYTE(result, DECBYTES-1)=0x01;      // LSD=1
+  if (comp<0) DFBYTE(result, 0)|=0x80;  // set sign bit
+  return result;
+  } // decFloatCompareTotal
+
+/* ------------------------------------------------------------------ */
+/* decFloatCompareTotalMag -- compare magnitudes with total ordering  */
+/*                                                                    */
+/*   result gets the result of comparing abs(dfl) and abs(dfr)        */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   returns result, which may be -1, 0, or 1                         */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatCompareTotalMag(decFloat *result,
+                                const decFloat *dfl, const decFloat *dfr) {
+  decFloat a, b;                        // for copy if needed
+  // copy and redirect signed operand(s)
+  if (DFISSIGNED(dfl)) {
+    decFloatCopyAbs(&a, dfl);
+    dfl=&a;
+    }
+  if (DFISSIGNED(dfr)) {
+    decFloatCopyAbs(&b, dfr);
+    dfr=&b;
+    }
+  return decFloatCompareTotal(result, dfl, dfr);
+  } // decFloatCompareTotalMag
+
+/* ------------------------------------------------------------------ */
+/* decFloatCopy -- copy a decFloat as-is                              */
+/*                                                                    */
+/*   result gets the copy of dfl                                      */
+/*   dfl    is the decFloat to copy                                   */
+/*   returns result                                                   */
+/*                                                                    */
+/* This is a bitwise operation; no errors or exceptions are possible. */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatCopy(decFloat *result, const decFloat *dfl) {
+  if (dfl!=result) *result=*dfl;             // copy needed
+  return result;
+  } // decFloatCopy
+
+/* ------------------------------------------------------------------ */
+/* decFloatCopyAbs -- copy a decFloat as-is and set sign bit to 0     */
+/*                                                                    */
+/*   result gets the copy of dfl with sign bit 0                      */
+/*   dfl    is the decFloat to copy                                   */
+/*   returns result                                                   */
+/*                                                                    */
+/* This is a bitwise operation; no errors or exceptions are possible. */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatCopyAbs(decFloat *result, const decFloat *dfl) {
+  if (dfl!=result) *result=*dfl;        // copy needed
+  DFBYTE(result, 0)&=~0x80;             // zero sign bit
+  return result;
+  } // decFloatCopyAbs
+
+/* ------------------------------------------------------------------ */
+/* decFloatCopyNegate -- copy a decFloat as-is with inverted sign bit */
+/*                                                                    */
+/*   result gets the copy of dfl with sign bit inverted               */
+/*   dfl    is the decFloat to copy                                   */
+/*   returns result                                                   */
+/*                                                                    */
+/* This is a bitwise operation; no errors or exceptions are possible. */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatCopyNegate(decFloat *result, const decFloat *dfl) {
+  if (dfl!=result) *result=*dfl;        // copy needed
+  DFBYTE(result, 0)^=0x80;              // invert sign bit
+  return result;
+  } // decFloatCopyNegate
+
+/* ------------------------------------------------------------------ */
+/* decFloatCopySign -- copy a decFloat with the sign of another       */
+/*                                                                    */
+/*   result gets the result of copying dfl with the sign of dfr       */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   returns result                                                   */
+/*                                                                    */
+/* This is a bitwise operation; no errors or exceptions are possible. */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatCopySign(decFloat *result,
+                            const decFloat *dfl, const decFloat *dfr) {
+  uByte sign=(uByte)(DFBYTE(dfr, 0)&0x80);   // save sign bit
+  if (dfl!=result) *result=*dfl;             // copy needed
+  DFBYTE(result, 0)&=~0x80;                  // clear sign ..
+  DFBYTE(result, 0)=(uByte)(DFBYTE(result, 0)|sign); // .. and set saved
+  return result;
+  } // decFloatCopySign
+
+/* ------------------------------------------------------------------ */
+/* decFloatDigits -- return the number of digits in a decFloat        */
+/*                                                                    */
+/*   df is the decFloat to investigate                                */
+/*   returns the number of significant digits in the decFloat; a      */
+/*     zero coefficient returns 1 as does an infinity (a NaN returns  */
+/*     the number of digits in the payload)                           */
+/* ------------------------------------------------------------------ */
+// private macro to extract a declet according to provided formula
+// (form), and if it is non-zero then return the calculated digits
+// depending on the declet number (n), where n=0 for the most
+// significant declet; uses uInt dpd for work
+#define dpdlenchk(n, form)  dpd=(form)&0x3ff;     \
+  if (dpd) return (DECPMAX-1-3*(n))-(3-DPD2BCD8[dpd*4+3])
+// next one is used when it is known that the declet must be
+// non-zero, or is the final zero declet
+#define dpdlendun(n, form)  dpd=(form)&0x3ff;     \
+  if (dpd==0) return 1;                           \
+  return (DECPMAX-1-3*(n))-(3-DPD2BCD8[dpd*4+3])
+
+uInt decFloatDigits(const decFloat *df) {
+  uInt dpd;                        // work
+  uInt sourhi=DFWORD(df, 0);       // top word from source decFloat
+  #if QUAD
+  uInt sourmh, sourml;
+  #endif
+  uInt sourlo;
+
+  if (DFISINF(df)) return 1;
+  // A NaN effectively has an MSD of 0; otherwise if non-zero MSD
+  // then the coefficient is full-length
+  if (!DFISNAN(df) && DECCOMBMSD[sourhi>>26]) return DECPMAX;
+
+  #if DOUBLE
+    if (sourhi&0x0003ffff) {     // ends in first
+      dpdlenchk(0, sourhi>>8);
+      sourlo=DFWORD(df, 1);
+      dpdlendun(1, (sourhi<<2) | (sourlo>>30));
+      } // [cannot drop through]
+    sourlo=DFWORD(df, 1);  // sourhi not involved now
+    if (sourlo&0xfff00000) {     // in one of first two
+      dpdlenchk(1, sourlo>>30);  // very rare
+      dpdlendun(2, sourlo>>20);
+      } // [cannot drop through]
+    dpdlenchk(3, sourlo>>10);
+    dpdlendun(4, sourlo);
+    // [cannot drop through]
+
+  #elif QUAD
+    if (sourhi&0x00003fff) {     // ends in first
+      dpdlenchk(0, sourhi>>4);
+      sourmh=DFWORD(df, 1);
+      dpdlendun(1, ((sourhi)<<6) | (sourmh>>26));
+      } // [cannot drop through]
+    sourmh=DFWORD(df, 1);
+    if (sourmh) {
+      dpdlenchk(1, sourmh>>26);
+      dpdlenchk(2, sourmh>>16);
+      dpdlenchk(3, sourmh>>6);
+      sourml=DFWORD(df, 2);
+      dpdlendun(4, ((sourmh)<<4) | (sourml>>28));
+      } // [cannot drop through]
+    sourml=DFWORD(df, 2);
+    if (sourml) {
+      dpdlenchk(4, sourml>>28);
+      dpdlenchk(5, sourml>>18);
+      dpdlenchk(6, sourml>>8);
+      sourlo=DFWORD(df, 3);
+      dpdlendun(7, ((sourml)<<2) | (sourlo>>30));
+      } // [cannot drop through]
+    sourlo=DFWORD(df, 3);
+    if (sourlo&0xfff00000) {     // in one of first two
+      dpdlenchk(7, sourlo>>30);  // very rare
+      dpdlendun(8, sourlo>>20);
+      } // [cannot drop through]
+    dpdlenchk(9, sourlo>>10);
+    dpdlendun(10, sourlo);
+    // [cannot drop through]
+  #endif
+  } // decFloatDigits
+
+/* ------------------------------------------------------------------ */
+/* decFloatDivide -- divide a decFloat by another                     */
+/*                                                                    */
+/*   result gets the result of dividing dfl by dfr:                   */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* ------------------------------------------------------------------ */
+// This is just a wrapper.
+decFloat * decFloatDivide(decFloat *result,
+                          const decFloat *dfl, const decFloat *dfr,
+                          decContext *set) {
+  return decDivide(result, dfl, dfr, set, DIVIDE);
+  } // decFloatDivide
+
+/* ------------------------------------------------------------------ */
+/* decFloatDivideInteger -- integer divide a decFloat by another      */
+/*                                                                    */
+/*   result gets the result of dividing dfl by dfr:                   */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatDivideInteger(decFloat *result,
+                             const decFloat *dfl, const decFloat *dfr,
+                             decContext *set) {
+  return decDivide(result, dfl, dfr, set, DIVIDEINT);
+  } // decFloatDivideInteger
+
+/* ------------------------------------------------------------------ */
+/* decFloatFMA -- multiply and add three decFloats, fused             */
+/*                                                                    */
+/*   result gets the result of (dfl*dfr)+dff with a single rounding   */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   dff    is the final decFloat (fhs)                               */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatFMA(decFloat *result, const decFloat *dfl,
+                       const decFloat *dfr, const decFloat *dff,
+                       decContext *set) {
+
+  // The accumulator has the bytes needed for FiniteMultiply, plus
+  // one byte to the left in case of carry, plus DECPMAX+2 to the
+  // right for the final addition (up to full fhs + round & sticky)
+  #define FMALEN (ROUNDUP4(1+ (DECPMAX9*18+1) +DECPMAX+2))
+  uByte  acc[FMALEN];              // for multiplied coefficient in BCD
+                                   // .. and for final result
+  bcdnum mul;                      // for multiplication result
+  bcdnum fin;                      // for final operand, expanded
+  uByte  coe[ROUNDUP4(DECPMAX)];   // dff coefficient in BCD
+  bcdnum *hi, *lo;                 // bcdnum with higher/lower exponent
+  uInt   diffsign;                 // non-zero if signs differ
+  uInt   hipad;                    // pad digit for hi if needed
+  Int    padding;                  // excess exponent
+  uInt   carry;                    // +1 for ten's complement and during add
+  uByte  *ub, *uh, *ul;            // work
+  uInt   uiwork;                   // for macros
+
+  // handle all the special values [any special operand leads to a
+  // special result]
+  if (DFISSPECIAL(dfl) || DFISSPECIAL(dfr) || DFISSPECIAL(dff)) {
+    decFloat proxy;                // multiplication result proxy
+    // NaNs are handled as usual, giving priority to sNaNs
+    if (DFISSNAN(dfl) || DFISSNAN(dfr)) return decNaNs(result, dfl, dfr, set);
+    if (DFISSNAN(dff)) return decNaNs(result, dff, NULL, set);
+    if (DFISNAN(dfl) || DFISNAN(dfr)) return decNaNs(result, dfl, dfr, set);
+    if (DFISNAN(dff)) return decNaNs(result, dff, NULL, set);
+    // One or more of the three is infinite
+    // infinity times zero is bad
+    decFloatZero(&proxy);
+    if (DFISINF(dfl)) {
+      if (DFISZERO(dfr)) return decInvalid(result, set);
+      decInfinity(&proxy, &proxy);
+      }
+     else if (DFISINF(dfr)) {
+      if (DFISZERO(dfl)) return decInvalid(result, set);
+      decInfinity(&proxy, &proxy);
+      }
+    // compute sign of multiplication and place in proxy
+    DFWORD(&proxy, 0)|=(DFWORD(dfl, 0)^DFWORD(dfr, 0))&DECFLOAT_Sign;
+    if (!DFISINF(dff)) return decFloatCopy(result, &proxy);
+    // dff is Infinite
+    if (!DFISINF(&proxy)) return decInfinity(result, dff);
+    // both sides of addition are infinite; different sign is bad
+    if ((DFWORD(dff, 0)&DECFLOAT_Sign)!=(DFWORD(&proxy, 0)&DECFLOAT_Sign))
+      return decInvalid(result, set);
+    return decFloatCopy(result, &proxy);
+    }
+
+  /* Here when all operands are finite */
+
+  // First multiply dfl*dfr
+  decFiniteMultiply(&mul, acc+1, dfl, dfr);
+  // The multiply is complete, exact and unbounded, and described in
+  // mul with the coefficient held in acc[1...]
+
+  // now add in dff; the algorithm is essentially the same as
+  // decFloatAdd, but the code is different because the code there
+  // is highly optimized for adding two numbers of the same size
+  fin.exponent=GETEXPUN(dff);           // get dff exponent and sign
+  fin.sign=DFWORD(dff, 0)&DECFLOAT_Sign;
+  diffsign=mul.sign^fin.sign;           // note if signs differ
+  fin.msd=coe;
+  fin.lsd=coe+DECPMAX-1;
+  GETCOEFF(dff, coe);                   // extract the coefficient
+
+  // now set hi and lo so that hi points to whichever of mul and fin
+  // has the higher exponent and lo points to the other [don't care,
+  // if the same].  One coefficient will be in acc, the other in coe.
+  if (mul.exponent>=fin.exponent) {
+    hi=&mul;
+    lo=&fin;
+    }
+   else {
+    hi=&fin;
+    lo=&mul;
+    }
+
+  // remove leading zeros on both operands; this will save time later
+  // and make testing for zero trivial (tests are safe because acc
+  // and coe are rounded up to uInts)
+  for (; UBTOUI(hi->msd)==0 && hi->msd+3<hi->lsd;) hi->msd+=4;
+  for (; *hi->msd==0 && hi->msd<hi->lsd;) hi->msd++;
+  for (; UBTOUI(lo->msd)==0 && lo->msd+3<lo->lsd;) lo->msd+=4;
+  for (; *lo->msd==0 && lo->msd<lo->lsd;) lo->msd++;
+
+  // if hi is zero then result will be lo (which has the smaller
+  // exponent), which also may need to be tested for zero for the
+  // weird IEEE 754 sign rules
+  if (*hi->msd==0) {                         // hi is zero
+    // "When the sum of two operands with opposite signs is
+    // exactly zero, the sign of that sum shall be '+' in all
+    // rounding modes except round toward -Infinity, in which
+    // mode that sign shall be '-'."
+    if (diffsign) {
+      if (*lo->msd==0) {                     // lo is zero
+        lo->sign=0;
+        if (set->round==DEC_ROUND_FLOOR) lo->sign=DECFLOAT_Sign;
+        } // diffsign && lo=0
+      } // diffsign
+    return decFinalize(result, lo, set);     // may need clamping
+    } // numfl is zero
+  // [here, both are minimal length and hi is non-zero]
+  // (if lo is zero then padding with zeros may be needed, below)
+
+  // if signs differ, take the ten's complement of hi (zeros to the
+  // right do not matter because the complement of zero is zero); the
+  // +1 is done later, as part of the addition, inserted at the
+  // correct digit
+  hipad=0;
+  carry=0;
+  if (diffsign) {
+    hipad=9;
+    carry=1;
+    // exactly the correct number of digits must be inverted
+    for (uh=hi->msd; uh<hi->lsd-3; uh+=4) UBFROMUI(uh, 0x09090909-UBTOUI(uh));
+    for (; uh<=hi->lsd; uh++) *uh=(uByte)(0x09-*uh);
+    }
+
+  // ready to add; note that hi has no leading zeros so gap
+  // calculation does not have to be as pessimistic as in decFloatAdd
+  // (this is much more like the arbitrary-precision algorithm in
+  // Rexx and decNumber)
+
+  // padding is the number of zeros that would need to be added to hi
+  // for its lsd to be aligned with the lsd of lo
+  padding=hi->exponent-lo->exponent;
+  // printf("FMA pad %ld\n", (LI)padding);
+
+  // the result of the addition will be built into the accumulator,
+  // starting from the far right; this could be either hi or lo, and
+  // will be aligned
+  ub=acc+FMALEN-1;                 // where lsd of result will go
+  ul=lo->lsd;                      // lsd of rhs
+
+  if (padding!=0) {                // unaligned
+    // if the msd of lo is more than DECPMAX+2 digits to the right of
+    // the original msd of hi then it can be reduced to a single
+    // digit at the right place, as it stays clear of hi digits
+    // [it must be DECPMAX+2 because during a subtraction the msd
+    // could become 0 after a borrow from 1.000 to 0.9999...]
+
+    Int hilen=(Int)(hi->lsd-hi->msd+1); // length of hi
+    Int lolen=(Int)(lo->lsd-lo->msd+1); // and of lo
+
+    if (hilen+padding-lolen > DECPMAX+2) {   // can reduce lo to single
+      // make sure it is virtually at least DECPMAX from hi->msd, at
+      // least to right of hi->lsd (in case of destructive subtract),
+      // and separated by at least two digits from either of those
+      // (the tricky DOUBLE case is when hi is a 1 that will become a
+      // 0.9999... by subtraction:
+      //   hi:   1                                   E+16
+      //   lo:    .................1000000000000000  E-16
+      // which for the addition pads to:
+      //   hi:   1000000000000000000                 E-16
+      //   lo:    .................1000000000000000  E-16
+      Int newexp=MINI(hi->exponent, hi->exponent+hilen-DECPMAX)-3;
+
+      // printf("FMA reduce: %ld\n", (LI)reduce);
+      lo->lsd=lo->msd;                       // to single digit [maybe 0]
+      lo->exponent=newexp;                   // new lowest exponent
+      padding=hi->exponent-lo->exponent;     // recalculate
+      ul=lo->lsd;                            // .. and repoint
+      }
+
+    // padding is still > 0, but will fit in acc (less leading carry slot)
+    #if DECCHECK
+      if (padding<=0) printf("FMA low padding: %ld\n", (LI)padding);
+      if (hilen+padding+1>FMALEN)
+        printf("FMA excess hilen+padding: %ld+%ld \n", (LI)hilen, (LI)padding);
+      // printf("FMA padding: %ld\n", (LI)padding);
+    #endif
+
+    // padding digits can now be set in the result; one or more of
+    // these will come from lo; others will be zeros in the gap
+    for (; ul-3>=lo->msd && padding>3; padding-=4, ul-=4, ub-=4) {
+      UBFROMUI(ub-3, UBTOUI(ul-3));          // [cannot overlap]
+      }
+    for (; ul>=lo->msd && padding>0; padding--, ul--, ub--) *ub=*ul;
+    for (;padding>0; padding--, ub--) *ub=0; // mind the gap
+    }
+
+  // addition now complete to the right of the rightmost digit of hi
+  uh=hi->lsd;
+
+  // dow do the add from hi->lsd to the left
+  // [bytewise, because either operand can run out at any time]
+  // carry was set up depending on ten's complement above
+  // first assume both operands have some digits
+  for (;; ub--) {
+    if (uh<hi->msd || ul<lo->msd) break;
+    *ub=(uByte)(carry+(*uh--)+(*ul--));
+    carry=0;
+    if (*ub<10) continue;
+    *ub-=10;
+    carry=1;
+    } // both loop
+
+  if (ul<lo->msd) {           // to left of lo
+    for (;; ub--) {
+      if (uh<hi->msd) break;
+      *ub=(uByte)(carry+(*uh--));  // [+0]
+      carry=0;
+      if (*ub<10) continue;
+      *ub-=10;
+      carry=1;
+      } // hi loop
+    }
+   else {                     // to left of hi
+    for (;; ub--) {
+      if (ul<lo->msd) break;
+      *ub=(uByte)(carry+hipad+(*ul--));
+      carry=0;
+      if (*ub<10) continue;
+      *ub-=10;
+      carry=1;
+      } // lo loop
+    }
+
+  // addition complete -- now handle carry, borrow, etc.
+  // use lo to set up the num (its exponent is already correct, and
+  // sign usually is)
+  lo->msd=ub+1;
+  lo->lsd=acc+FMALEN-1;
+  // decShowNum(lo, "lo");
+  if (!diffsign) {                 // same-sign addition
+    if (carry) {                   // carry out
+      *ub=1;                       // place the 1 ..
+      lo->msd--;                   // .. and update
+      }
+    } // same sign
+   else {                          // signs differed (subtraction)
+    if (!carry) {                  // no carry out means hi<lo
+      // borrowed -- take ten's complement of the right digits
+      lo->sign=hi->sign;           // sign is lhs sign
+      for (ul=lo->msd; ul<lo->lsd-3; ul+=4) UBFROMUI(ul, 0x09090909-UBTOUI(ul));
+      for (; ul<=lo->lsd; ul++) *ul=(uByte)(0x09-*ul); // [leaves ul at lsd+1]
+      // complete the ten's complement by adding 1 [cannot overrun]
+      for (ul--; *ul==9; ul--) *ul=0;
+      *ul+=1;
+      } // borrowed
+     else {                        // carry out means hi>=lo
+      // sign to use is lo->sign
+      // all done except for the special IEEE 754 exact-zero-result
+      // rule (see above); while testing for zero, strip leading
+      // zeros (which will save decFinalize doing it)
+      for (; UBTOUI(lo->msd)==0 && lo->msd+3<lo->lsd;) lo->msd+=4;
+      for (; *lo->msd==0 && lo->msd<lo->lsd;) lo->msd++;
+      if (*lo->msd==0) {           // must be true zero (and diffsign)
+        lo->sign=0;                // assume +
+        if (set->round==DEC_ROUND_FLOOR) lo->sign=DECFLOAT_Sign;
+        }
+      // [else was not zero, might still have leading zeros]
+      } // subtraction gave positive result
+    } // diffsign
+
+  #if DECCHECK
+  // assert no left underrun
+  if (lo->msd<acc) {
+    printf("FMA underrun by %ld \n", (LI)(acc-lo->msd));
+    }
+  #endif
+
+  return decFinalize(result, lo, set);  // round, check, and lay out
+  } // decFloatFMA
+
+/* ------------------------------------------------------------------ */
+/* decFloatFromInt -- initialise a decFloat from an Int               */
+/*                                                                    */
+/*   result gets the converted Int                                    */
+/*   n      is the Int to convert                                     */
+/*   returns result                                                   */
+/*                                                                    */
+/* The result is Exact; no errors or exceptions are possible.         */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatFromInt32(decFloat *result, Int n) {
+  uInt u=(uInt)n;                       // copy as bits
+  uInt encode;                          // work
+  DFWORD(result, 0)=ZEROWORD;           // always
+  #if QUAD
+    DFWORD(result, 1)=0;
+    DFWORD(result, 2)=0;
+  #endif
+  if (n<0) {                            // handle -n with care
+    // [This can be done without the test, but is then slightly slower]
+    u=(~u)+1;
+    DFWORD(result, 0)|=DECFLOAT_Sign;
+    }
+  // Since the maximum value of u now is 2**31, only the low word of
+  // result is affected
+  encode=BIN2DPD[u%1000];
+  u/=1000;
+  encode|=BIN2DPD[u%1000]<<10;
+  u/=1000;
+  encode|=BIN2DPD[u%1000]<<20;
+  u/=1000;                              // now 0, 1, or 2
+  encode|=u<<30;
+  DFWORD(result, DECWORDS-1)=encode;
+  return result;
+  } // decFloatFromInt32
+
+/* ------------------------------------------------------------------ */
+/* decFloatFromUInt -- initialise a decFloat from a uInt              */
+/*                                                                    */
+/*   result gets the converted uInt                                   */
+/*   n      is the uInt to convert                                    */
+/*   returns result                                                   */
+/*                                                                    */
+/* The result is Exact; no errors or exceptions are possible.         */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatFromUInt32(decFloat *result, uInt u) {
+  uInt encode;                          // work
+  DFWORD(result, 0)=ZEROWORD;           // always
+  #if QUAD
+    DFWORD(result, 1)=0;
+    DFWORD(result, 2)=0;
+  #endif
+  encode=BIN2DPD[u%1000];
+  u/=1000;
+  encode|=BIN2DPD[u%1000]<<10;
+  u/=1000;
+  encode|=BIN2DPD[u%1000]<<20;
+  u/=1000;                              // now 0 -> 4
+  encode|=u<<30;
+  DFWORD(result, DECWORDS-1)=encode;
+  DFWORD(result, DECWORDS-2)|=u>>2;     // rarely non-zero
+  return result;
+  } // decFloatFromUInt32
+
+/* ------------------------------------------------------------------ */
+/* decFloatInvert -- logical digitwise INVERT of a decFloat           */
+/*                                                                    */
+/*   result gets the result of INVERTing df                           */
+/*   df     is the decFloat to invert                                 */
+/*   set    is the context                                            */
+/*   returns result, which will be canonical with sign=0              */
+/*                                                                    */
+/* The operand must be positive, finite with exponent q=0, and        */
+/* comprise just zeros and ones; if not, Invalid operation results.   */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatInvert(decFloat *result, const decFloat *df,
+                          decContext *set) {
+  uInt sourhi=DFWORD(df, 0);            // top word of dfs
+
+  if (!DFISUINT01(df) || !DFISCC01(df)) return decInvalid(result, set);
+  // the operand is a finite integer (q=0)
+  #if DOUBLE
+   DFWORD(result, 0)=ZEROWORD|((~sourhi)&0x04009124);
+   DFWORD(result, 1)=(~DFWORD(df, 1))   &0x49124491;
+  #elif QUAD
+   DFWORD(result, 0)=ZEROWORD|((~sourhi)&0x04000912);
+   DFWORD(result, 1)=(~DFWORD(df, 1))   &0x44912449;
+   DFWORD(result, 2)=(~DFWORD(df, 2))   &0x12449124;
+   DFWORD(result, 3)=(~DFWORD(df, 3))   &0x49124491;
+  #endif
+  return result;
+  } // decFloatInvert
+
+/* ------------------------------------------------------------------ */
+/* decFloatIs -- decFloat tests (IsSigned, etc.)                      */
+/*                                                                    */
+/*   df is the decFloat to test                                       */
+/*   returns 0 or 1 in a uInt                                         */
+/*                                                                    */
+/* Many of these could be macros, but having them as real functions   */
+/* is a little cleaner (and they can be referred to here by the       */
+/* generic names)                                                     */
+/* ------------------------------------------------------------------ */
+uInt decFloatIsCanonical(const decFloat *df) {
+  if (DFISSPECIAL(df)) {
+    if (DFISINF(df)) {
+      if (DFWORD(df, 0)&ECONMASK) return 0;  // exponent continuation
+      if (!DFISCCZERO(df)) return 0;         // coefficient continuation
+      return 1;
+      }
+    // is a NaN
+    if (DFWORD(df, 0)&ECONNANMASK) return 0; // exponent continuation
+    if (DFISCCZERO(df)) return 1;            // coefficient continuation
+    // drop through to check payload
+    }
+  { // declare block
+  #if DOUBLE
+    uInt sourhi=DFWORD(df, 0);
+    uInt sourlo=DFWORD(df, 1);
+    if (CANONDPDOFF(sourhi, 8)
+     && CANONDPDTWO(sourhi, sourlo, 30)
+     && CANONDPDOFF(sourlo, 20)
+     && CANONDPDOFF(sourlo, 10)
+     && CANONDPDOFF(sourlo, 0)) return 1;
+  #elif QUAD
+    uInt sourhi=DFWORD(df, 0);
+    uInt sourmh=DFWORD(df, 1);
+    uInt sourml=DFWORD(df, 2);
+    uInt sourlo=DFWORD(df, 3);
+    if (CANONDPDOFF(sourhi, 4)
+     && CANONDPDTWO(sourhi, sourmh, 26)
+     && CANONDPDOFF(sourmh, 16)
+     && CANONDPDOFF(sourmh, 6)
+     && CANONDPDTWO(sourmh, sourml, 28)
+     && CANONDPDOFF(sourml, 18)
+     && CANONDPDOFF(sourml, 8)
+     && CANONDPDTWO(sourml, sourlo, 30)
+     && CANONDPDOFF(sourlo, 20)
+     && CANONDPDOFF(sourlo, 10)
+     && CANONDPDOFF(sourlo, 0)) return 1;
+  #endif
+  } // block
+  return 0;    // a declet is non-canonical
+  }
+
+uInt decFloatIsFinite(const decFloat *df) {
+  return !DFISSPECIAL(df);
+  }
+uInt decFloatIsInfinite(const decFloat *df) {
+  return DFISINF(df);
+  }
+uInt decFloatIsInteger(const decFloat *df) {
+  return DFISINT(df);
+  }
+uInt decFloatIsLogical(const decFloat *df) {
+  return DFISUINT01(df) & DFISCC01(df);
+  }
+uInt decFloatIsNaN(const decFloat *df) {
+  return DFISNAN(df);
+  }
+uInt decFloatIsNegative(const decFloat *df) {
+  return DFISSIGNED(df) && !DFISZERO(df) && !DFISNAN(df);
+  }
+uInt decFloatIsNormal(const decFloat *df) {
+  Int exp;                         // exponent
+  if (DFISSPECIAL(df)) return 0;
+  if (DFISZERO(df)) return 0;
+  // is finite and non-zero
+  exp=GETEXPUN(df)                 // get unbiased exponent ..
+     +decFloatDigits(df)-1;        // .. and make adjusted exponent
+  return (exp>=DECEMIN);           // < DECEMIN is subnormal
+  }
+uInt decFloatIsPositive(const decFloat *df) {
+  return !DFISSIGNED(df) && !DFISZERO(df) && !DFISNAN(df);
+  }
+uInt decFloatIsSignaling(const decFloat *df) {
+  return DFISSNAN(df);
+  }
+uInt decFloatIsSignalling(const decFloat *df) {
+  return DFISSNAN(df);
+  }
+uInt decFloatIsSigned(const decFloat *df) {
+  return DFISSIGNED(df);
+  }
+uInt decFloatIsSubnormal(const decFloat *df) {
+  if (DFISSPECIAL(df)) return 0;
+  // is finite
+  if (decFloatIsNormal(df)) return 0;
+  // it is <Nmin, but could be zero
+  if (DFISZERO(df)) return 0;
+  return 1;                                  // is subnormal
+  }
+uInt decFloatIsZero(const decFloat *df) {
+  return DFISZERO(df);
+  } // decFloatIs...
+
+/* ------------------------------------------------------------------ */
+/* decFloatLogB -- return adjusted exponent, by 754 rules             */
+/*                                                                    */
+/*   result gets the adjusted exponent as an integer, or a NaN etc.   */
+/*   df     is the decFloat to be examined                            */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* Notable cases:                                                     */
+/*   A<0 -> Use |A|                                                   */
+/*   A=0 -> -Infinity (Division by zero)                              */
+/*   A=Infinite -> +Infinity (Exact)                                  */
+/*   A=1 exactly -> 0 (Exact)                                         */
+/*   NaNs are propagated as usual                                     */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatLogB(decFloat *result, const decFloat *df,
+                        decContext *set) {
+  Int ae;                                    // adjusted exponent
+  if (DFISNAN(df)) return decNaNs(result, df, NULL, set);
+  if (DFISINF(df)) {
+    DFWORD(result, 0)=0;                     // need +ve
+    return decInfinity(result, result);      // canonical +Infinity
+    }
+  if (DFISZERO(df)) {
+    set->status|=DEC_Division_by_zero;       // as per 754
+    DFWORD(result, 0)=DECFLOAT_Sign;         // make negative
+    return decInfinity(result, result);      // canonical -Infinity
+    }
+  ae=GETEXPUN(df)                       // get unbiased exponent ..
+    +decFloatDigits(df)-1;              // .. and make adjusted exponent
+  // ae has limited range (3 digits for DOUBLE and 4 for QUAD), so
+  // it is worth using a special case of decFloatFromInt32
+  DFWORD(result, 0)=ZEROWORD;           // always
+  if (ae<0) {
+    DFWORD(result, 0)|=DECFLOAT_Sign;   // -0 so far
+    ae=-ae;
+    }
+  #if DOUBLE
+    DFWORD(result, 1)=BIN2DPD[ae];      // a single declet
+  #elif QUAD
+    DFWORD(result, 1)=0;
+    DFWORD(result, 2)=0;
+    DFWORD(result, 3)=(ae/1000)<<10;    // is <10, so need no DPD encode
+    DFWORD(result, 3)|=BIN2DPD[ae%1000];
+  #endif
+  return result;
+  } // decFloatLogB
+
+/* ------------------------------------------------------------------ */
+/* decFloatMax -- return maxnum of two operands                       */
+/*                                                                    */
+/*   result gets the chosen decFloat                                  */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* If just one operand is a quiet NaN it is ignored.                  */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatMax(decFloat *result,
+                       const decFloat *dfl, const decFloat *dfr,
+                       decContext *set) {
+  Int comp;
+  if (DFISNAN(dfl)) {
+    // sNaN or both NaNs leads to normal NaN processing
+    if (DFISNAN(dfr) || DFISSNAN(dfl)) return decNaNs(result, dfl, dfr, set);
+    return decCanonical(result, dfr);        // RHS is numeric
+    }
+  if (DFISNAN(dfr)) {
+    // sNaN leads to normal NaN processing (both NaN handled above)
+    if (DFISSNAN(dfr)) return decNaNs(result, dfl, dfr, set);
+    return decCanonical(result, dfl);        // LHS is numeric
+    }
+  // Both operands are numeric; numeric comparison needed -- use
+  // total order for a well-defined choice (and +0 > -0)
+  comp=decNumCompare(dfl, dfr, 1);
+  if (comp>=0) return decCanonical(result, dfl);
+  return decCanonical(result, dfr);
+  } // decFloatMax
+
+/* ------------------------------------------------------------------ */
+/* decFloatMaxMag -- return maxnummag of two operands                 */
+/*                                                                    */
+/*   result gets the chosen decFloat                                  */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* Returns according to the magnitude comparisons if both numeric and */
+/* unequal, otherwise returns maxnum                                  */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatMaxMag(decFloat *result,
+                       const decFloat *dfl, const decFloat *dfr,
+                       decContext *set) {
+  Int comp;
+  decFloat absl, absr;
+  if (DFISNAN(dfl) || DFISNAN(dfr)) return decFloatMax(result, dfl, dfr, set);
+
+  decFloatCopyAbs(&absl, dfl);
+  decFloatCopyAbs(&absr, dfr);
+  comp=decNumCompare(&absl, &absr, 0);
+  if (comp>0) return decCanonical(result, dfl);
+  if (comp<0) return decCanonical(result, dfr);
+  return decFloatMax(result, dfl, dfr, set);
+  } // decFloatMaxMag
+
+/* ------------------------------------------------------------------ */
+/* decFloatMin -- return minnum of two operands                       */
+/*                                                                    */
+/*   result gets the chosen decFloat                                  */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* If just one operand is a quiet NaN it is ignored.                  */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatMin(decFloat *result,
+                       const decFloat *dfl, const decFloat *dfr,
+                       decContext *set) {
+  Int comp;
+  if (DFISNAN(dfl)) {
+    // sNaN or both NaNs leads to normal NaN processing
+    if (DFISNAN(dfr) || DFISSNAN(dfl)) return decNaNs(result, dfl, dfr, set);
+    return decCanonical(result, dfr);        // RHS is numeric
+    }
+  if (DFISNAN(dfr)) {
+    // sNaN leads to normal NaN processing (both NaN handled above)
+    if (DFISSNAN(dfr)) return decNaNs(result, dfl, dfr, set);
+    return decCanonical(result, dfl);        // LHS is numeric
+    }
+  // Both operands are numeric; numeric comparison needed -- use
+  // total order for a well-defined choice (and +0 > -0)
+  comp=decNumCompare(dfl, dfr, 1);
+  if (comp<=0) return decCanonical(result, dfl);
+  return decCanonical(result, dfr);
+  } // decFloatMin
+
+/* ------------------------------------------------------------------ */
+/* decFloatMinMag -- return minnummag of two operands                 */
+/*                                                                    */
+/*   result gets the chosen decFloat                                  */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* Returns according to the magnitude comparisons if both numeric and */
+/* unequal, otherwise returns minnum                                  */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatMinMag(decFloat *result,
+                       const decFloat *dfl, const decFloat *dfr,
+                       decContext *set) {
+  Int comp;
+  decFloat absl, absr;
+  if (DFISNAN(dfl) || DFISNAN(dfr)) return decFloatMin(result, dfl, dfr, set);
+
+  decFloatCopyAbs(&absl, dfl);
+  decFloatCopyAbs(&absr, dfr);
+  comp=decNumCompare(&absl, &absr, 0);
+  if (comp<0) return decCanonical(result, dfl);
+  if (comp>0) return decCanonical(result, dfr);
+  return decFloatMin(result, dfl, dfr, set);
+  } // decFloatMinMag
+
+/* ------------------------------------------------------------------ */
+/* decFloatMinus -- negate value, heeding NaNs, etc.                  */
+/*                                                                    */
+/*   result gets the canonicalized 0-df                               */
+/*   df     is the decFloat to minus                                  */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* This has the same effect as 0-df where the exponent of the zero is */
+/* the same as that of df (if df is finite).                          */
+/* The effect is also the same as decFloatCopyNegate except that NaNs */
+/* are handled normally (the sign of a NaN is not affected, and an    */
+/* sNaN will signal), the result is canonical, and zero gets sign 0.  */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatMinus(decFloat *result, const decFloat *df,
+                         decContext *set) {
+  if (DFISNAN(df)) return decNaNs(result, df, NULL, set);
+  decCanonical(result, df);                       // copy and check
+  if (DFISZERO(df)) DFBYTE(result, 0)&=~0x80;     // turn off sign bit
+   else DFBYTE(result, 0)^=0x80;                  // flip sign bit
+  return result;
+  } // decFloatMinus
+
+/* ------------------------------------------------------------------ */
+/* decFloatMultiply -- multiply two decFloats                         */
+/*                                                                    */
+/*   result gets the result of multiplying dfl and dfr:               */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatMultiply(decFloat *result,
+                            const decFloat *dfl, const decFloat *dfr,
+                            decContext *set) {
+  bcdnum num;                      // for final conversion
+  uByte  bcdacc[DECPMAX9*18+1];    // for coefficent in BCD
+
+  if (DFISSPECIAL(dfl) || DFISSPECIAL(dfr)) { // either is special?
+    // NaNs are handled as usual
+    if (DFISNAN(dfl) || DFISNAN(dfr)) return decNaNs(result, dfl, dfr, set);
+    // infinity times zero is bad
+    if (DFISINF(dfl) && DFISZERO(dfr)) return decInvalid(result, set);
+    if (DFISINF(dfr) && DFISZERO(dfl)) return decInvalid(result, set);
+    // both infinite; return canonical infinity with computed sign
+    DFWORD(result, 0)=DFWORD(dfl, 0)^DFWORD(dfr, 0); // compute sign
+    return decInfinity(result, result);
+    }
+
+  /* Here when both operands are finite */
+  decFiniteMultiply(&num, bcdacc, dfl, dfr);
+  return decFinalize(result, &num, set); // round, check, and lay out
+  } // decFloatMultiply
+
+/* ------------------------------------------------------------------ */
+/* decFloatNextMinus -- next towards -Infinity                        */
+/*                                                                    */
+/*   result gets the next lesser decFloat                             */
+/*   dfl    is the decFloat to start with                             */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* This is 754 nextdown; Invalid is the only status possible (from    */
+/* an sNaN).                                                          */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatNextMinus(decFloat *result, const decFloat *dfl,
+                             decContext *set) {
+  decFloat delta;                       // tiny increment
+  uInt savestat;                        // saves status
+  enum rounding saveround;              // .. and mode
+
+  // +Infinity is the special case
+  if (DFISINF(dfl) && !DFISSIGNED(dfl)) {
+    DFSETNMAX(result);
+    return result;                      // [no status to set]
+    }
+  // other cases are effected by sutracting a tiny delta -- this
+  // should be done in a wider format as the delta is unrepresentable
+  // here (but can be done with normal add if the sign of zero is
+  // treated carefully, because no Inexactitude is interesting);
+  // rounding to -Infinity then pushes the result to next below
+  decFloatZero(&delta);                 // set up tiny delta
+  DFWORD(&delta, DECWORDS-1)=1;         // coefficient=1
+  DFWORD(&delta, 0)=DECFLOAT_Sign;      // Sign=1 + biased exponent=0
+  // set up for the directional round
+  saveround=set->round;                 // save mode
+  set->round=DEC_ROUND_FLOOR;           // .. round towards -Infinity
+  savestat=set->status;                 // save status
+  decFloatAdd(result, dfl, &delta, set);
+  // Add rules mess up the sign when going from +Ntiny to 0
+  if (DFISZERO(result)) DFWORD(result, 0)^=DECFLOAT_Sign; // correct
+  set->status&=DEC_Invalid_operation;   // preserve only sNaN status
+  set->status|=savestat;                // restore pending flags
+  set->round=saveround;                 // .. and mode
+  return result;
+  } // decFloatNextMinus
+
+/* ------------------------------------------------------------------ */
+/* decFloatNextPlus -- next towards +Infinity                         */
+/*                                                                    */
+/*   result gets the next larger decFloat                             */
+/*   dfl    is the decFloat to start with                             */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* This is 754 nextup; Invalid is the only status possible (from      */
+/* an sNaN).                                                          */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatNextPlus(decFloat *result, const decFloat *dfl,
+                            decContext *set) {
+  uInt savestat;                        // saves status
+  enum rounding saveround;              // .. and mode
+  decFloat delta;                       // tiny increment
+
+  // -Infinity is the special case
+  if (DFISINF(dfl) && DFISSIGNED(dfl)) {
+    DFSETNMAX(result);
+    DFWORD(result, 0)|=DECFLOAT_Sign;   // make negative
+    return result;                      // [no status to set]
+    }
+  // other cases are effected by sutracting a tiny delta -- this
+  // should be done in a wider format as the delta is unrepresentable
+  // here (but can be done with normal add if the sign of zero is
+  // treated carefully, because no Inexactitude is interesting);
+  // rounding to +Infinity then pushes the result to next above
+  decFloatZero(&delta);                 // set up tiny delta
+  DFWORD(&delta, DECWORDS-1)=1;         // coefficient=1
+  DFWORD(&delta, 0)=0;                  // Sign=0 + biased exponent=0
+  // set up for the directional round
+  saveround=set->round;                 // save mode
+  set->round=DEC_ROUND_CEILING;         // .. round towards +Infinity
+  savestat=set->status;                 // save status
+  decFloatAdd(result, dfl, &delta, set);
+  // Add rules mess up the sign when going from -Ntiny to -0
+  if (DFISZERO(result)) DFWORD(result, 0)^=DECFLOAT_Sign; // correct
+  set->status&=DEC_Invalid_operation;   // preserve only sNaN status
+  set->status|=savestat;                // restore pending flags
+  set->round=saveround;                 // .. and mode
+  return result;
+  } // decFloatNextPlus
+
+/* ------------------------------------------------------------------ */
+/* decFloatNextToward -- next towards a decFloat                      */
+/*                                                                    */
+/*   result gets the next decFloat                                    */
+/*   dfl    is the decFloat to start with                             */
+/*   dfr    is the decFloat to move toward                            */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* This is 754-1985 nextafter, as modified during revision (dropped   */
+/* from 754-2008); status may be set unless the result is a normal    */
+/* number.                                                            */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatNextToward(decFloat *result,
+                              const decFloat *dfl, const decFloat *dfr,
+                              decContext *set) {
+  decFloat delta;                       // tiny increment or decrement
+  decFloat pointone;                    // 1e-1
+  uInt  savestat;                       // saves status
+  enum  rounding saveround;             // .. and mode
+  uInt  deltatop;                       // top word for delta
+  Int   comp;                           // work
+
+  if (DFISNAN(dfl) || DFISNAN(dfr)) return decNaNs(result, dfl, dfr, set);
+  // Both are numeric, so Invalid no longer a possibility
+  comp=decNumCompare(dfl, dfr, 0);
+  if (comp==0) return decFloatCopySign(result, dfl, dfr); // equal
+  // unequal; do NextPlus or NextMinus but with different status rules
+
+  if (comp<0) { // lhs<rhs, do NextPlus, see above for commentary
+    if (DFISINF(dfl) && DFISSIGNED(dfl)) {   // -Infinity special case
+      DFSETNMAX(result);
+      DFWORD(result, 0)|=DECFLOAT_Sign;
+      return result;
+      }
+    saveround=set->round;                    // save mode
+    set->round=DEC_ROUND_CEILING;            // .. round towards +Infinity
+    deltatop=0;                              // positive delta
+    }
+   else { // lhs>rhs, do NextMinus, see above for commentary
+    if (DFISINF(dfl) && !DFISSIGNED(dfl)) {  // +Infinity special case
+      DFSETNMAX(result);
+      return result;
+      }
+    saveround=set->round;                    // save mode
+    set->round=DEC_ROUND_FLOOR;              // .. round towards -Infinity
+    deltatop=DECFLOAT_Sign;                  // negative delta
+    }
+  savestat=set->status;                      // save status
+  // Here, Inexact is needed where appropriate (and hence Underflow,
+  // etc.).  Therefore the tiny delta which is otherwise
+  // unrepresentable (see NextPlus and NextMinus) is constructed
+  // using the multiplication of FMA.
+  decFloatZero(&delta);                 // set up tiny delta
+  DFWORD(&delta, DECWORDS-1)=1;         // coefficient=1
+  DFWORD(&delta, 0)=deltatop;           // Sign + biased exponent=0
+  decFloatFromString(&pointone, "1E-1", set); // set up multiplier
+  decFloatFMA(result, &delta, &pointone, dfl, set);
+  // [Delta is truly tiny, so no need to correct sign of zero]
+  // use new status unless the result is normal
+  if (decFloatIsNormal(result)) set->status=savestat; // else goes forward
+  set->round=saveround;                 // restore mode
+  return result;
+  } // decFloatNextToward
+
+/* ------------------------------------------------------------------ */
+/* decFloatOr -- logical digitwise OR of two decFloats                */
+/*                                                                    */
+/*   result gets the result of ORing dfl and dfr                      */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result, which will be canonical with sign=0              */
+/*                                                                    */
+/* The operands must be positive, finite with exponent q=0, and       */
+/* comprise just zeros and ones; if not, Invalid operation results.   */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatOr(decFloat *result,
+                       const decFloat *dfl, const decFloat *dfr,
+                       decContext *set) {
+  if (!DFISUINT01(dfl) || !DFISUINT01(dfr)
+   || !DFISCC01(dfl)   || !DFISCC01(dfr)) return decInvalid(result, set);
+  // the operands are positive finite integers (q=0) with just 0s and 1s
+  #if DOUBLE
+   DFWORD(result, 0)=ZEROWORD
+                   |((DFWORD(dfl, 0) | DFWORD(dfr, 0))&0x04009124);
+   DFWORD(result, 1)=(DFWORD(dfl, 1) | DFWORD(dfr, 1))&0x49124491;
+  #elif QUAD
+   DFWORD(result, 0)=ZEROWORD
+                   |((DFWORD(dfl, 0) | DFWORD(dfr, 0))&0x04000912);
+   DFWORD(result, 1)=(DFWORD(dfl, 1) | DFWORD(dfr, 1))&0x44912449;
+   DFWORD(result, 2)=(DFWORD(dfl, 2) | DFWORD(dfr, 2))&0x12449124;
+   DFWORD(result, 3)=(DFWORD(dfl, 3) | DFWORD(dfr, 3))&0x49124491;
+  #endif
+  return result;
+  } // decFloatOr
+
+/* ------------------------------------------------------------------ */
+/* decFloatPlus -- add value to 0, heeding NaNs, etc.                 */
+/*                                                                    */
+/*   result gets the canonicalized 0+df                               */
+/*   df     is the decFloat to plus                                   */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* This has the same effect as 0+df where the exponent of the zero is */
+/* the same as that of df (if df is finite).                          */
+/* The effect is also the same as decFloatCopy except that NaNs       */
+/* are handled normally (the sign of a NaN is not affected, and an    */
+/* sNaN will signal), the result is canonical, and zero gets sign 0.  */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatPlus(decFloat *result, const decFloat *df,
+                        decContext *set) {
+  if (DFISNAN(df)) return decNaNs(result, df, NULL, set);
+  decCanonical(result, df);                       // copy and check
+  if (DFISZERO(df)) DFBYTE(result, 0)&=~0x80;     // turn off sign bit
+  return result;
+  } // decFloatPlus
+
+/* ------------------------------------------------------------------ */
+/* decFloatQuantize -- quantize a decFloat                            */
+/*                                                                    */
+/*   result gets the result of quantizing dfl to match dfr            */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs), which sets the exponent     */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* Unless there is an error or the result is infinite, the exponent   */
+/* of result is guaranteed to be the same as that of dfr.             */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatQuantize(decFloat *result,
+                            const decFloat *dfl, const decFloat *dfr,
+                            decContext *set) {
+  Int   explb, exprb;         // left and right biased exponents
+  uByte *ulsd;                // local LSD pointer
+  uByte *ub, *uc;             // work
+  Int   drop;                 // ..
+  uInt  dpd;                  // ..
+  uInt  encode;               // encoding accumulator
+  uInt  sourhil, sourhir;     // top words from source decFloats
+  uInt  uiwork;               // for macros
+  #if QUAD
+  uShort uswork;              // ..
+  #endif
+  // the following buffer holds the coefficient for manipulation
+  uByte buf[4+DECPMAX*3+2*QUAD];   // + space for zeros to left or right
+  #if DECTRACE
+  bcdnum num;                      // for trace displays
+  #endif
+
+  /* Start decoding the arguments */
+  sourhil=DFWORD(dfl, 0);          // LHS top word
+  explb=DECCOMBEXP[sourhil>>26];   // get exponent high bits (in place)
+  sourhir=DFWORD(dfr, 0);          // RHS top word
+  exprb=DECCOMBEXP[sourhir>>26];
+
+  if (EXPISSPECIAL(explb | exprb)) { // either is special?
+    // NaNs are handled as usual
+    if (DFISNAN(dfl) || DFISNAN(dfr)) return decNaNs(result, dfl, dfr, set);
+    // one infinity but not both is bad
+    if (DFISINF(dfl)!=DFISINF(dfr)) return decInvalid(result, set);
+    // both infinite; return canonical infinity with sign of LHS
+    return decInfinity(result, dfl);
+    }
+
+  /* Here when both arguments are finite */
+  // complete extraction of the exponents [no need to unbias]
+  explb+=GETECON(dfl);             // + continuation
+  exprb+=GETECON(dfr);             // ..
+
+  // calculate the number of digits to drop from the coefficient
+  drop=exprb-explb;                // 0 if nothing to do
+  if (drop==0) return decCanonical(result, dfl); // return canonical
+
+  // the coefficient is needed; lay it out into buf, offset so zeros
+  // can be added before or after as needed -- an extra heading is
+  // added so can safely pad Quad DECPMAX-1 zeros to the left by
+  // fours
+  #define BUFOFF (buf+4+DECPMAX)
+  GETCOEFF(dfl, BUFOFF);           // decode from decFloat
+  // [now the msd is at BUFOFF and the lsd is at BUFOFF+DECPMAX-1]
+
+  #if DECTRACE
+  num.msd=BUFOFF;
+  num.lsd=BUFOFF+DECPMAX-1;
+  num.exponent=explb-DECBIAS;
+  num.sign=sourhil & DECFLOAT_Sign;
+  decShowNum(&num, "dfl");
+  #endif
+
+  if (drop>0) {                         // [most common case]
+    // (this code is very similar to that in decFloatFinalize, but
+    // has many differences so is duplicated here -- so any changes
+    // may need to be made there, too)
+    uByte *roundat;                          // -> re-round digit
+    uByte reround;                           // reround value
+    // printf("Rounding; drop=%ld\n", (LI)drop);
+
+    // there is at least one zero needed to the left, in all but one
+    // exceptional (all-nines) case, so place four zeros now; this is
+    // needed almost always and makes rounding all-nines by fours safe
+    UBFROMUI(BUFOFF-4, 0);
+
+    // Three cases here:
+    //   1. new LSD is in coefficient (almost always)
+    //   2. new LSD is digit to left of coefficient (so MSD is
+    //      round-for-reround digit)
+    //   3. new LSD is to left of case 2 (whole coefficient is sticky)
+    // Note that leading zeros can safely be treated as useful digits
+
+    // [duplicate check-stickies code to save a test]
+    // [by-digit check for stickies as runs of zeros are rare]
+    if (drop<DECPMAX) {                      // NB lengths not addresses
+      roundat=BUFOFF+DECPMAX-drop;
+      reround=*roundat;
+      for (ub=roundat+1; ub<BUFOFF+DECPMAX; ub++) {
+        if (*ub!=0) {                        // non-zero to be discarded
+          reround=DECSTICKYTAB[reround];     // apply sticky bit
+          break;                             // [remainder don't-care]
+          }
+        } // check stickies
+      ulsd=roundat-1;                        // set LSD
+      }
+     else {                                  // edge case
+      if (drop==DECPMAX) {
+        roundat=BUFOFF;
+        reround=*roundat;
+        }
+       else {
+        roundat=BUFOFF-1;
+        reround=0;
+        }
+      for (ub=roundat+1; ub<BUFOFF+DECPMAX; ub++) {
+        if (*ub!=0) {                        // non-zero to be discarded
+          reround=DECSTICKYTAB[reround];     // apply sticky bit
+          break;                             // [remainder don't-care]
+          }
+        } // check stickies
+      *BUFOFF=0;                             // make a coefficient of 0
+      ulsd=BUFOFF;                           // .. at the MSD place
+      }
+
+    if (reround!=0) {                        // discarding non-zero
+      uInt bump=0;
+      set->status|=DEC_Inexact;
+
+      // next decide whether to increment the coefficient
+      if (set->round==DEC_ROUND_HALF_EVEN) { // fastpath slowest case
+        if (reround>5) bump=1;               // >0.5 goes up
+         else if (reround==5)                // exactly 0.5000 ..
+          bump=*ulsd & 0x01;                 // .. up iff [new] lsd is odd
+        } // r-h-e
+       else switch (set->round) {
+        case DEC_ROUND_DOWN: {
+          // no change
+          break;} // r-d
+        case DEC_ROUND_HALF_DOWN: {
+          if (reround>5) bump=1;
+          break;} // r-h-d
+        case DEC_ROUND_HALF_UP: {
+          if (reround>=5) bump=1;
+          break;} // r-h-u
+        case DEC_ROUND_UP: {
+          if (reround>0) bump=1;
+          break;} // r-u
+        case DEC_ROUND_CEILING: {
+          // same as _UP for positive numbers, and as _DOWN for negatives
+          if (!(sourhil&DECFLOAT_Sign) && reround>0) bump=1;
+          break;} // r-c
+        case DEC_ROUND_FLOOR: {
+          // same as _UP for negative numbers, and as _DOWN for positive
+          // [negative reround cannot occur on 0]
+          if (sourhil&DECFLOAT_Sign && reround>0) bump=1;
+          break;} // r-f
+        case DEC_ROUND_05UP: {
+          if (reround>0) { // anything out there is 'sticky'
+            // bump iff lsd=0 or 5; this cannot carry so it could be
+            // effected immediately with no bump -- but the code
+            // is clearer if this is done the same way as the others
+            if (*ulsd==0 || *ulsd==5) bump=1;
+            }
+          break;} // r-r
+        default: {      // e.g., DEC_ROUND_MAX
+          set->status|=DEC_Invalid_context;
+          #if DECCHECK
+          printf("Unknown rounding mode: %ld\n", (LI)set->round);
+          #endif
+          break;}
+        } // switch (not r-h-e)
+      // printf("ReRound: %ld  bump: %ld\n", (LI)reround, (LI)bump);
+
+      if (bump!=0) {                         // need increment
+        // increment the coefficient; this could give 1000... (after
+        // the all nines case)
+        ub=ulsd;
+        for (; UBTOUI(ub-3)==0x09090909; ub-=4) UBFROMUI(ub-3, 0);
+        // now at most 3 digits left to non-9 (usually just the one)
+        for (; *ub==9; ub--) *ub=0;
+        *ub+=1;
+        // [the all-nines case will have carried one digit to the
+        // left of the original MSD -- just where it is needed]
+        } // bump needed
+      } // inexact rounding
+
+    // now clear zeros to the left so exactly DECPMAX digits will be
+    // available in the coefficent -- the first word to the left was
+    // cleared earlier for safe carry; now add any more needed
+    if (drop>4) {
+      UBFROMUI(BUFOFF-8, 0);                 // must be at least 5
+      for (uc=BUFOFF-12; uc>ulsd-DECPMAX-3; uc-=4) UBFROMUI(uc, 0);
+      }
+    } // need round (drop>0)
+
+   else { // drop<0; padding with -drop digits is needed
+    // This is the case where an error can occur if the padded
+    // coefficient will not fit; checking for this can be done in the
+    // same loop as padding for zeros if the no-hope and zero cases
+    // are checked first
+    if (-drop>DECPMAX-1) {                   // cannot fit unless 0
+      if (!ISCOEFFZERO(BUFOFF)) return decInvalid(result, set);
+      // a zero can have any exponent; just drop through and use it
+      ulsd=BUFOFF+DECPMAX-1;
+      }
+     else { // padding will fit (but may still be too long)
+      // final-word mask depends on endianess
+      #if DECLITEND
+      static const uInt dmask[]={0, 0x000000ff, 0x0000ffff, 0x00ffffff};
+      #else
+      static const uInt dmask[]={0, 0xff000000, 0xffff0000, 0xffffff00};
+      #endif
+      // note that here zeros to the right are added by fours, so in
+      // the Quad case this could write 36 zeros if the coefficient has
+      // fewer than three significant digits (hence the +2*QUAD for buf)
+      for (uc=BUFOFF+DECPMAX;; uc+=4) {
+        UBFROMUI(uc, 0);
+        if (UBTOUI(uc-DECPMAX)!=0) {              // could be bad
+          // if all four digits should be zero, definitely bad
+          if (uc<=BUFOFF+DECPMAX+(-drop)-4)
+            return decInvalid(result, set);
+          // must be a 1- to 3-digit sequence; check more carefully
+          if ((UBTOUI(uc-DECPMAX)&dmask[(-drop)%4])!=0)
+            return decInvalid(result, set);
+          break;    // no need for loop end test
+          }
+        if (uc>=BUFOFF+DECPMAX+(-drop)-4) break;  // done
+        }
+      ulsd=BUFOFF+DECPMAX+(-drop)-1;
+      } // pad and check leading zeros
+    } // drop<0
+
+  #if DECTRACE
+  num.msd=ulsd-DECPMAX+1;
+  num.lsd=ulsd;
+  num.exponent=explb-DECBIAS;
+  num.sign=sourhil & DECFLOAT_Sign;
+  decShowNum(&num, "res");
+  #endif
+
+  /*------------------------------------------------------------------*/
+  /* At this point the result is DECPMAX digits, ending at ulsd, so   */
+  /* fits the encoding exactly; there is no possibility of error      */
+  /*------------------------------------------------------------------*/
+  encode=((exprb>>DECECONL)<<4) + *(ulsd-DECPMAX+1); // make index
+  encode=DECCOMBFROM[encode];                // indexed by (0-2)*16+msd
+  // the exponent continuation can be extracted from the original RHS
+  encode|=sourhir & ECONMASK;
+  encode|=sourhil&DECFLOAT_Sign;             // add the sign from LHS
+
+  // finally encode the coefficient
+  // private macro to encode a declet; this version can be used
+  // because all coefficient digits exist
+  #define getDPD3q(dpd, n) ub=ulsd-(3*(n))-2;                   \
+    dpd=BCD2DPD[(*ub*256)+(*(ub+1)*16)+*(ub+2)];
+
+  #if DOUBLE
+    getDPD3q(dpd, 4); encode|=dpd<<8;
+    getDPD3q(dpd, 3); encode|=dpd>>2;
+    DFWORD(result, 0)=encode;
+    encode=dpd<<30;
+    getDPD3q(dpd, 2); encode|=dpd<<20;
+    getDPD3q(dpd, 1); encode|=dpd<<10;
+    getDPD3q(dpd, 0); encode|=dpd;
+    DFWORD(result, 1)=encode;
+
+  #elif QUAD
+    getDPD3q(dpd,10); encode|=dpd<<4;
+    getDPD3q(dpd, 9); encode|=dpd>>6;
+    DFWORD(result, 0)=encode;
+    encode=dpd<<26;
+    getDPD3q(dpd, 8); encode|=dpd<<16;
+    getDPD3q(dpd, 7); encode|=dpd<<6;
+    getDPD3q(dpd, 6); encode|=dpd>>4;
+    DFWORD(result, 1)=encode;
+    encode=dpd<<28;
+    getDPD3q(dpd, 5); encode|=dpd<<18;
+    getDPD3q(dpd, 4); encode|=dpd<<8;
+    getDPD3q(dpd, 3); encode|=dpd>>2;
+    DFWORD(result, 2)=encode;
+    encode=dpd<<30;
+    getDPD3q(dpd, 2); encode|=dpd<<20;
+    getDPD3q(dpd, 1); encode|=dpd<<10;
+    getDPD3q(dpd, 0); encode|=dpd;
+    DFWORD(result, 3)=encode;
+  #endif
+  return result;
+  } // decFloatQuantize
+
+/* ------------------------------------------------------------------ */
+/* decFloatReduce -- reduce finite coefficient to minimum length      */
+/*                                                                    */
+/*   result gets the reduced decFloat                                 */
+/*   df     is the source decFloat                                    */
+/*   set    is the context                                            */
+/*   returns result, which will be canonical                          */
+/*                                                                    */
+/* This removes all possible trailing zeros from the coefficient;     */
+/* some may remain when the number is very close to Nmax.             */
+/* Special values are unchanged and no status is set unless df=sNaN.  */
+/* Reduced zero has an exponent q=0.                                  */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatReduce(decFloat *result, const decFloat *df,
+                          decContext *set) {
+  bcdnum num;                           // work
+  uByte buf[DECPMAX], *ub;              // coefficient and pointer
+  if (df!=result) *result=*df;          // copy, if needed
+  if (DFISNAN(df)) return decNaNs(result, df, NULL, set);   // sNaN
+  // zeros and infinites propagate too
+  if (DFISINF(df)) return decInfinity(result, df);     // canonical
+  if (DFISZERO(df)) {
+    uInt sign=DFWORD(df, 0)&DECFLOAT_Sign;
+    decFloatZero(result);
+    DFWORD(result, 0)|=sign;
+    return result;                      // exponent dropped, sign OK
+    }
+  // non-zero finite
+  GETCOEFF(df, buf);
+  ub=buf+DECPMAX-1;                     // -> lsd
+  if (*ub) return result;               // no trailing zeros
+  for (ub--; *ub==0;) ub--;             // terminates because non-zero
+  // *ub is the first non-zero from the right
+  num.sign=DFWORD(df, 0)&DECFLOAT_Sign; // set up number...
+  num.exponent=GETEXPUN(df)+(Int)(buf+DECPMAX-1-ub); // adjusted exponent
+  num.msd=buf;
+  num.lsd=ub;
+  return decFinalize(result, &num, set);
+  } // decFloatReduce
+
+/* ------------------------------------------------------------------ */
+/* decFloatRemainder -- integer divide and return remainder           */
+/*                                                                    */
+/*   result gets the remainder of dividing dfl by dfr:                */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatRemainder(decFloat *result,
+                             const decFloat *dfl, const decFloat *dfr,
+                             decContext *set) {
+  return decDivide(result, dfl, dfr, set, REMAINDER);
+  } // decFloatRemainder
+
+/* ------------------------------------------------------------------ */
+/* decFloatRemainderNear -- integer divide to nearest and remainder   */
+/*                                                                    */
+/*   result gets the remainder of dividing dfl by dfr:                */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* This is the IEEE remainder, where the nearest integer is used.     */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatRemainderNear(decFloat *result,
+                             const decFloat *dfl, const decFloat *dfr,
+                             decContext *set) {
+  return decDivide(result, dfl, dfr, set, REMNEAR);
+  } // decFloatRemainderNear
+
+/* ------------------------------------------------------------------ */
+/* decFloatRotate -- rotate the coefficient of a decFloat left/right  */
+/*                                                                    */
+/*   result gets the result of rotating dfl                           */
+/*   dfl    is the source decFloat to rotate                          */
+/*   dfr    is the count of digits to rotate, an integer (with q=0)   */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* The digits of the coefficient of dfl are rotated to the left (if   */
+/* dfr is positive) or to the right (if dfr is negative) without      */
+/* adjusting the exponent or the sign of dfl.                         */
+/*                                                                    */
+/* dfr must be in the range -DECPMAX through +DECPMAX.                */
+/* NaNs are propagated as usual.  An infinite dfl is unaffected (but  */
+/* dfr must be valid).  No status is set unless dfr is invalid or an  */
+/* operand is an sNaN.  The result is canonical.                      */
+/* ------------------------------------------------------------------ */
+#define PHALF (ROUNDUP(DECPMAX/2, 4))   // half length, rounded up
+decFloat * decFloatRotate(decFloat *result,
+                         const decFloat *dfl, const decFloat *dfr,
+                         decContext *set) {
+  Int rotate;                           // dfr as an Int
+  uByte buf[DECPMAX+PHALF];             // coefficient + half
+  uInt digits, savestat;                // work
+  bcdnum num;                           // ..
+  uByte *ub;                            // ..
+
+  if (DFISNAN(dfl)||DFISNAN(dfr)) return decNaNs(result, dfl, dfr, set);
+  if (!DFISINT(dfr)) return decInvalid(result, set);
+  digits=decFloatDigits(dfr);                    // calculate digits
+  if (digits>2) return decInvalid(result, set);  // definitely out of range
+  rotate=DPD2BIN[DFWORD(dfr, DECWORDS-1)&0x3ff]; // is in bottom declet
+  if (rotate>DECPMAX) return decInvalid(result, set); // too big
+  // [from here on no error or status change is possible]
+  if (DFISINF(dfl)) return decInfinity(result, dfl);  // canonical
+  // handle no-rotate cases
+  if (rotate==0 || rotate==DECPMAX) return decCanonical(result, dfl);
+  // a real rotate is needed: 0 < rotate < DECPMAX
+  // reduce the rotation to no more than half to reduce copying later
+  // (for QUAD in fact half + 2 digits)
+  if (DFISSIGNED(dfr)) rotate=-rotate;
+  if (abs(rotate)>PHALF) {
+    if (rotate<0) rotate=DECPMAX+rotate;
+     else rotate=rotate-DECPMAX;
+    }
+  // now lay out the coefficient, leaving room to the right or the
+  // left depending on the direction of rotation
+  ub=buf;
+  if (rotate<0) ub+=PHALF;    // rotate right, so space to left
+  GETCOEFF(dfl, ub);
+  // copy half the digits to left or right, and set num.msd
+  if (rotate<0) {
+    memcpy(buf, buf+DECPMAX, PHALF);
+    num.msd=buf+PHALF+rotate;
+    }
+   else {
+    memcpy(buf+DECPMAX, buf, PHALF);
+    num.msd=buf+rotate;
+    }
+  // fill in rest of num
+  num.lsd=num.msd+DECPMAX-1;
+  num.sign=DFWORD(dfl, 0)&DECFLOAT_Sign;
+  num.exponent=GETEXPUN(dfl);
+  savestat=set->status;                 // record
+  decFinalize(result, &num, set);
+  set->status=savestat;                 // restore
+  return result;
+  } // decFloatRotate
+
+/* ------------------------------------------------------------------ */
+/* decFloatSameQuantum -- test decFloats for same quantum             */
+/*                                                                    */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   returns 1 if the operands have the same quantum, 0 otherwise     */
+/*                                                                    */
+/* No error is possible and no status results.                        */
+/* ------------------------------------------------------------------ */
+uInt decFloatSameQuantum(const decFloat *dfl, const decFloat *dfr) {
+  if (DFISSPECIAL(dfl) || DFISSPECIAL(dfr)) {
+    if (DFISNAN(dfl) && DFISNAN(dfr)) return 1;
+    if (DFISINF(dfl) && DFISINF(dfr)) return 1;
+    return 0;  // any other special mixture gives false
+    }
+  if (GETEXP(dfl)==GETEXP(dfr)) return 1; // biased exponents match
+  return 0;
+  } // decFloatSameQuantum
+
+/* ------------------------------------------------------------------ */
+/* decFloatScaleB -- multiply by a power of 10, as per 754            */
+/*                                                                    */
+/*   result gets the result of the operation                          */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs), am integer (with q=0)       */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* This computes result=dfl x 10**dfr where dfr is an integer in the  */
+/* range +/-2*(emax+pmax), typically resulting from LogB.             */
+/* Underflow and Overflow (with Inexact) may occur.  NaNs propagate   */
+/* as usual.                                                          */
+/* ------------------------------------------------------------------ */
+#define SCALEBMAX 2*(DECEMAX+DECPMAX)   // D=800, Q=12356
+decFloat * decFloatScaleB(decFloat *result,
+                          const decFloat *dfl, const decFloat *dfr,
+                          decContext *set) {
+  uInt digits;                          // work
+  Int  expr;                            // dfr as an Int
+
+  if (DFISNAN(dfl)||DFISNAN(dfr)) return decNaNs(result, dfl, dfr, set);
+  if (!DFISINT(dfr)) return decInvalid(result, set);
+  digits=decFloatDigits(dfr);                // calculate digits
+
+  #if DOUBLE
+  if (digits>3) return decInvalid(result, set);   // definitely out of range
+  expr=DPD2BIN[DFWORD(dfr, 1)&0x3ff];             // must be in bottom declet
+  #elif QUAD
+  if (digits>5) return decInvalid(result, set);   // definitely out of range
+  expr=DPD2BIN[DFWORD(dfr, 3)&0x3ff]              // in bottom 2 declets ..
+      +DPD2BIN[(DFWORD(dfr, 3)>>10)&0x3ff]*1000;  // ..
+  #endif
+  if (expr>SCALEBMAX) return decInvalid(result, set);  // oops
+  // [from now on no error possible]
+  if (DFISINF(dfl)) return decInfinity(result, dfl);   // canonical
+  if (DFISSIGNED(dfr)) expr=-expr;
+  // dfl is finite and expr is valid
+  *result=*dfl;                              // copy to target
+  return decFloatSetExponent(result, set, GETEXPUN(result)+expr);
+  } // decFloatScaleB
+
+/* ------------------------------------------------------------------ */
+/* decFloatShift -- shift the coefficient of a decFloat left or right */
+/*                                                                    */
+/*   result gets the result of shifting dfl                           */
+/*   dfl    is the source decFloat to shift                           */
+/*   dfr    is the count of digits to shift, an integer (with q=0)    */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* The digits of the coefficient of dfl are shifted to the left (if   */
+/* dfr is positive) or to the right (if dfr is negative) without      */
+/* adjusting the exponent or the sign of dfl.                         */
+/*                                                                    */
+/* dfr must be in the range -DECPMAX through +DECPMAX.                */
+/* NaNs are propagated as usual.  An infinite dfl is unaffected (but  */
+/* dfr must be valid).  No status is set unless dfr is invalid or an  */
+/* operand is an sNaN.  The result is canonical.                      */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatShift(decFloat *result,
+                         const decFloat *dfl, const decFloat *dfr,
+                         decContext *set) {
+  Int    shift;                         // dfr as an Int
+  uByte  buf[DECPMAX*2];                // coefficient + padding
+  uInt   digits, savestat;              // work
+  bcdnum num;                           // ..
+  uInt   uiwork;                        // for macros
+
+  if (DFISNAN(dfl)||DFISNAN(dfr)) return decNaNs(result, dfl, dfr, set);
+  if (!DFISINT(dfr)) return decInvalid(result, set);
+  digits=decFloatDigits(dfr);                     // calculate digits
+  if (digits>2) return decInvalid(result, set);   // definitely out of range
+  shift=DPD2BIN[DFWORD(dfr, DECWORDS-1)&0x3ff];   // is in bottom declet
+  if (shift>DECPMAX) return decInvalid(result, set);   // too big
+  // [from here on no error or status change is possible]
+
+  if (DFISINF(dfl)) return decInfinity(result, dfl); // canonical
+  // handle no-shift and all-shift (clear to zero) cases
+  if (shift==0) return decCanonical(result, dfl);
+  if (shift==DECPMAX) {                      // zero with sign
+    uByte sign=(uByte)(DFBYTE(dfl, 0)&0x80); // save sign bit
+    decFloatZero(result);                    // make +0
+    DFBYTE(result, 0)=(uByte)(DFBYTE(result, 0)|sign); // and set sign
+    // [cannot safely use CopySign]
+    return result;
+    }
+  // a real shift is needed: 0 < shift < DECPMAX
+  num.sign=DFWORD(dfl, 0)&DECFLOAT_Sign;
+  num.exponent=GETEXPUN(dfl);
+  num.msd=buf;
+  GETCOEFF(dfl, buf);
+  if (DFISSIGNED(dfr)) { // shift right
+    // edge cases are taken care of, so this is easy
+    num.lsd=buf+DECPMAX-shift-1;
+    }
+   else { // shift left -- zero padding needed to right
+    UBFROMUI(buf+DECPMAX, 0);           // 8 will handle most cases
+    UBFROMUI(buf+DECPMAX+4, 0);         // ..
+    if (shift>8) memset(buf+DECPMAX+8, 0, 8+QUAD*18); // all other cases
+    num.msd+=shift;
+    num.lsd=num.msd+DECPMAX-1;
+    }
+  savestat=set->status;                 // record
+  decFinalize(result, &num, set);
+  set->status=savestat;                 // restore
+  return result;
+  } // decFloatShift
+
+/* ------------------------------------------------------------------ */
+/* decFloatSubtract -- subtract a decFloat from another               */
+/*                                                                    */
+/*   result gets the result of subtracting dfr from dfl:              */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatSubtract(decFloat *result,
+                            const decFloat *dfl, const decFloat *dfr,
+                            decContext *set) {
+  decFloat temp;
+  // NaNs must propagate without sign change
+  if (DFISNAN(dfr)) return decFloatAdd(result, dfl, dfr, set);
+  temp=*dfr;                                   // make a copy
+  DFBYTE(&temp, 0)^=0x80;                      // flip sign
+  return decFloatAdd(result, dfl, &temp, set); // and add to the lhs
+  } // decFloatSubtract
+
+/* ------------------------------------------------------------------ */
+/* decFloatToInt -- round to 32-bit binary integer (4 flavours)       */
+/*                                                                    */
+/*   df    is the decFloat to round                                   */
+/*   set   is the context                                             */
+/*   round is the rounding mode to use                                */
+/*   returns a uInt or an Int, rounded according to the name          */
+/*                                                                    */
+/* Invalid will always be signaled if df is a NaN, is Infinite, or is */
+/* outside the range of the target; Inexact will not be signaled for  */
+/* simple rounding unless 'Exact' appears in the name.                */
+/* ------------------------------------------------------------------ */
+uInt decFloatToUInt32(const decFloat *df, decContext *set,
+                      enum rounding round) {
+  return decToInt32(df, set, round, 0, 1);}
+
+uInt decFloatToUInt32Exact(const decFloat *df, decContext *set,
+                           enum rounding round) {
+  return decToInt32(df, set, round, 1, 1);}
+
+Int decFloatToInt32(const decFloat *df, decContext *set,
+                    enum rounding round) {
+  return (Int)decToInt32(df, set, round, 0, 0);}
+
+Int decFloatToInt32Exact(const decFloat *df, decContext *set,
+                         enum rounding round) {
+  return (Int)decToInt32(df, set, round, 1, 0);}
+
+/* ------------------------------------------------------------------ */
+/* decFloatToIntegral -- round to integral value (two flavours)       */
+/*                                                                    */
+/*   result gets the result                                           */
+/*   df     is the decFloat to round                                  */
+/*   set    is the context                                            */
+/*   round  is the rounding mode to use                               */
+/*   returns result                                                   */
+/*                                                                    */
+/* No exceptions, even Inexact, are raised except for sNaN input, or  */
+/* if 'Exact' appears in the name.                                    */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatToIntegralValue(decFloat *result, const decFloat *df,
+                                   decContext *set, enum rounding round) {
+  return decToIntegral(result, df, set, round, 0);}
+
+decFloat * decFloatToIntegralExact(decFloat *result, const decFloat *df,
+                                   decContext *set) {
+  return decToIntegral(result, df, set, set->round, 1);}
+
+/* ------------------------------------------------------------------ */
+/* decFloatXor -- logical digitwise XOR of two decFloats              */
+/*                                                                    */
+/*   result gets the result of XORing dfl and dfr                     */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs)                              */
+/*   set    is the context                                            */
+/*   returns result, which will be canonical with sign=0              */
+/*                                                                    */
+/* The operands must be positive, finite with exponent q=0, and       */
+/* comprise just zeros and ones; if not, Invalid operation results.   */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatXor(decFloat *result,
+                       const decFloat *dfl, const decFloat *dfr,
+                       decContext *set) {
+  if (!DFISUINT01(dfl) || !DFISUINT01(dfr)
+   || !DFISCC01(dfl)   || !DFISCC01(dfr)) return decInvalid(result, set);
+  // the operands are positive finite integers (q=0) with just 0s and 1s
+  #if DOUBLE
+   DFWORD(result, 0)=ZEROWORD
+                   |((DFWORD(dfl, 0) ^ DFWORD(dfr, 0))&0x04009124);
+   DFWORD(result, 1)=(DFWORD(dfl, 1) ^ DFWORD(dfr, 1))&0x49124491;
+  #elif QUAD
+   DFWORD(result, 0)=ZEROWORD
+                   |((DFWORD(dfl, 0) ^ DFWORD(dfr, 0))&0x04000912);
+   DFWORD(result, 1)=(DFWORD(dfl, 1) ^ DFWORD(dfr, 1))&0x44912449;
+   DFWORD(result, 2)=(DFWORD(dfl, 2) ^ DFWORD(dfr, 2))&0x12449124;
+   DFWORD(result, 3)=(DFWORD(dfl, 3) ^ DFWORD(dfr, 3))&0x49124491;
+  #endif
+  return result;
+  } // decFloatXor
+
+/* ------------------------------------------------------------------ */
+/* decInvalid -- set Invalid_operation result                         */
+/*                                                                    */
+/*   result gets a canonical NaN                                      */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* status has Invalid_operation added                                 */
+/* ------------------------------------------------------------------ */
+static decFloat *decInvalid(decFloat *result, decContext *set) {
+  decFloatZero(result);
+  DFWORD(result, 0)=DECFLOAT_qNaN;
+  set->status|=DEC_Invalid_operation;
+  return result;
+  } // decInvalid
+
+/* ------------------------------------------------------------------ */
+/* decInfinity -- set canonical Infinity with sign from a decFloat    */
+/*                                                                    */
+/*   result gets a canonical Infinity                                 */
+/*   df     is source decFloat (only the sign is used)                */
+/*   returns result                                                   */
+/*                                                                    */
+/* df may be the same as result                                       */
+/* ------------------------------------------------------------------ */
+static decFloat *decInfinity(decFloat *result, const decFloat *df) {
+  uInt sign=DFWORD(df, 0);         // save source signword
+  decFloatZero(result);            // clear everything
+  DFWORD(result, 0)=DECFLOAT_Inf | (sign & DECFLOAT_Sign);
+  return result;
+  } // decInfinity
+
+/* ------------------------------------------------------------------ */
+/* decNaNs -- handle NaN argument(s)                                  */
+/*                                                                    */
+/*   result gets the result of handling dfl and dfr, one or both of   */
+/*          which is a NaN                                            */
+/*   dfl    is the first decFloat (lhs)                               */
+/*   dfr    is the second decFloat (rhs) -- may be NULL for a single- */
+/*          operand operation                                         */
+/*   set    is the context                                            */
+/*   returns result                                                   */
+/*                                                                    */
+/* Called when one or both operands is a NaN, and propagates the      */
+/* appropriate result to res.  When an sNaN is found, it is changed   */
+/* to a qNaN and Invalid operation is set.                            */
+/* ------------------------------------------------------------------ */
+static decFloat *decNaNs(decFloat *result,
+                         const decFloat *dfl, const decFloat *dfr,
+                         decContext *set) {
+  // handle sNaNs first
+  if (dfr!=NULL && DFISSNAN(dfr) && !DFISSNAN(dfl)) dfl=dfr; // use RHS
+  if (DFISSNAN(dfl)) {
+    decCanonical(result, dfl);          // propagate canonical sNaN
+    DFWORD(result, 0)&=~(DECFLOAT_qNaN ^ DECFLOAT_sNaN); // quiet
+    set->status|=DEC_Invalid_operation;
+    return result;
+    }
+  // one or both is a quiet NaN
+  if (!DFISNAN(dfl)) dfl=dfr;           // RHS must be NaN, use it
+  return decCanonical(result, dfl);     // propagate canonical qNaN
+  } // decNaNs
+
+/* ------------------------------------------------------------------ */
+/* decNumCompare -- numeric comparison of two decFloats               */
+/*                                                                    */
+/*   dfl    is the left-hand decFloat, which is not a NaN             */
+/*   dfr    is the right-hand decFloat, which is not a NaN            */
+/*   tot    is 1 for total order compare, 0 for simple numeric        */
+/*   returns -1, 0, or +1 for dfl<dfr, dfl=dfr, dfl>dfr               */
+/*                                                                    */
+/* No error is possible; status and mode are unchanged.               */
+/* ------------------------------------------------------------------ */
+static Int decNumCompare(const decFloat *dfl, const decFloat *dfr, Flag tot) {
+  Int   sigl, sigr;                     // LHS and RHS non-0 signums
+  Int   shift;                          // shift needed to align operands
+  uByte *ub, *uc;                       // work
+  uInt  uiwork;                         // for macros
+  // buffers +2 if Quad (36 digits), need double plus 4 for safe padding
+  uByte bufl[DECPMAX*2+QUAD*2+4];       // for LHS coefficient + padding
+  uByte bufr[DECPMAX*2+QUAD*2+4];       // for RHS coefficient + padding
+
+  sigl=1;
+  if (DFISSIGNED(dfl)) {
+    if (!DFISSIGNED(dfr)) {             // -LHS +RHS
+      if (DFISZERO(dfl) && DFISZERO(dfr) && !tot) return 0;
+      return -1;                        // RHS wins
+      }
+    sigl=-1;
+    }
+  if (DFISSIGNED(dfr)) {
+    if (!DFISSIGNED(dfl)) {             // +LHS -RHS
+      if (DFISZERO(dfl) && DFISZERO(dfr) && !tot) return 0;
+      return +1;                        // LHS wins
+      }
+    }
+
+  // signs are the same; operand(s) could be zero
+  sigr=-sigl;                           // sign to return if abs(RHS) wins
+
+  if (DFISINF(dfl)) {
+    if (DFISINF(dfr)) return 0;         // both infinite & same sign
+    return sigl;                        // inf > n
+    }
+  if (DFISINF(dfr)) return sigr;        // n < inf [dfl is finite]
+
+  // here, both are same sign and finite; calculate their offset
+  shift=GETEXP(dfl)-GETEXP(dfr);        // [0 means aligned]
+  // [bias can be ignored -- the absolute exponent is not relevant]
+
+  if (DFISZERO(dfl)) {
+    if (!DFISZERO(dfr)) return sigr;    // LHS=0, RHS!=0
+    // both are zero, return 0 if both same exponent or numeric compare
+    if (shift==0 || !tot) return 0;
+    if (shift>0) return sigl;
+    return sigr;                        // [shift<0]
+    }
+   else {                               // LHS!=0
+    if (DFISZERO(dfr)) return sigl;     // LHS!=0, RHS=0
+    }
+  // both are known to be non-zero at this point
+
+  // if the exponents are so different that the coefficients do not
+  // overlap (by even one digit) then a full comparison is not needed
+  if (abs(shift)>=DECPMAX) {            // no overlap
+    // coefficients are known to be non-zero
+    if (shift>0) return sigl;
+    return sigr;                        // [shift<0]
+    }
+
+  // decode the coefficients
+  // (shift both right two if Quad to make a multiple of four)
+  #if QUAD
+    UBFROMUI(bufl, 0);
+    UBFROMUI(bufr, 0);
+  #endif
+  GETCOEFF(dfl, bufl+QUAD*2);           // decode from decFloat
+  GETCOEFF(dfr, bufr+QUAD*2);           // ..
+  if (shift==0) {                       // aligned; common and easy
+    // all multiples of four, here
+    for (ub=bufl, uc=bufr; ub<bufl+DECPMAX+QUAD*2; ub+=4, uc+=4) {
+      uInt ui=UBTOUI(ub);
+      if (ui==UBTOUI(uc)) continue;     // so far so same
+      // about to find a winner; go by bytes in case little-endian
+      for (;; ub++, uc++) {
+        if (*ub>*uc) return sigl;       // difference found
+        if (*ub<*uc) return sigr;       // ..
+        }
+      }
+    } // aligned
+   else if (shift>0) {                  // lhs to left
+    ub=bufl;                            // RHS pointer
+    // pad bufl so right-aligned; most shifts will fit in 8
+    UBFROMUI(bufl+DECPMAX+QUAD*2, 0);   // add eight zeros
+    UBFROMUI(bufl+DECPMAX+QUAD*2+4, 0); // ..
+    if (shift>8) {
+      // more than eight; fill the rest, and also worth doing the
+      // lead-in by fours
+      uByte *up;                        // work
+      uByte *upend=bufl+DECPMAX+QUAD*2+shift;
+      for (up=bufl+DECPMAX+QUAD*2+8; up<upend; up+=4) UBFROMUI(up, 0);
+      // [pads up to 36 in all for Quad]
+      for (;; ub+=4) {
+        if (UBTOUI(ub)!=0) return sigl;
+        if (ub+4>bufl+shift-4) break;
+        }
+      }
+    // check remaining leading digits
+    for (; ub<bufl+shift; ub++) if (*ub!=0) return sigl;
+    // now start the overlapped part; bufl has been padded, so the
+    // comparison can go for the full length of bufr, which is a
+    // multiple of 4 bytes
+    for (uc=bufr; ; uc+=4, ub+=4) {
+      uInt ui=UBTOUI(ub);
+      if (ui!=UBTOUI(uc)) {             // mismatch found
+        for (;; uc++, ub++) {           // check from left [little-endian?]
+          if (*ub>*uc) return sigl;     // difference found
+          if (*ub<*uc) return sigr;     // ..
+          }
+        } // mismatch
+      if (uc==bufr+QUAD*2+DECPMAX-4) break; // all checked
+      }
+    } // shift>0
+
+   else { // shift<0) .. RHS is to left of LHS; mirror shift>0
+    uc=bufr;                            // RHS pointer
+    // pad bufr so right-aligned; most shifts will fit in 8
+    UBFROMUI(bufr+DECPMAX+QUAD*2, 0);   // add eight zeros
+    UBFROMUI(bufr+DECPMAX+QUAD*2+4, 0); // ..
+    if (shift<-8) {
+      // more than eight; fill the rest, and also worth doing the
+      // lead-in by fours
+      uByte *up;                        // work
+      uByte *upend=bufr+DECPMAX+QUAD*2-shift;
+      for (up=bufr+DECPMAX+QUAD*2+8; up<upend; up+=4) UBFROMUI(up, 0);
+      // [pads up to 36 in all for Quad]
+      for (;; uc+=4) {
+        if (UBTOUI(uc)!=0) return sigr;
+        if (uc+4>bufr-shift-4) break;
+        }
+      }
+    // check remaining leading digits
+    for (; uc<bufr-shift; uc++) if (*uc!=0) return sigr;
+    // now start the overlapped part; bufr has been padded, so the
+    // comparison can go for the full length of bufl, which is a
+    // multiple of 4 bytes
+    for (ub=bufl; ; ub+=4, uc+=4) {
+      uInt ui=UBTOUI(ub);
+      if (ui!=UBTOUI(uc)) {             // mismatch found
+        for (;; ub++, uc++) {           // check from left [little-endian?]
+          if (*ub>*uc) return sigl;     // difference found
+          if (*ub<*uc) return sigr;     // ..
+          }
+        } // mismatch
+      if (ub==bufl+QUAD*2+DECPMAX-4) break; // all checked
+      }
+    } // shift<0
+
+  // Here when compare equal
+  if (!tot) return 0;                   // numerically equal
+  // total ordering .. exponent matters
+  if (shift>0) return sigl;             // total order by exponent
+  if (shift<0) return sigr;             // ..
+  return 0;
+  } // decNumCompare
+
+/* ------------------------------------------------------------------ */
+/* decToInt32 -- local routine to effect ToInteger conversions        */
+/*                                                                    */
+/*   df     is the decFloat to convert                                */
+/*   set    is the context                                            */
+/*   rmode  is the rounding mode to use                               */
+/*   exact  is 1 if Inexact should be signalled                       */
+/*   unsign is 1 if the result a uInt, 0 if an Int (cast to uInt)     */
+/*   returns 32-bit result as a uInt                                  */
+/*                                                                    */
+/* Invalid is set is df is a NaN, is infinite, or is out-of-range; in */
+/* these cases 0 is returned.                                         */
+/* ------------------------------------------------------------------ */
+static uInt decToInt32(const decFloat *df, decContext *set,
+                       enum rounding rmode, Flag exact, Flag unsign) {
+  Int  exp;                        // exponent
+  uInt sourhi, sourpen, sourlo;    // top word from source decFloat ..
+  uInt hi, lo;                     // .. penultimate, least, etc.
+  decFloat zero, result;           // work
+  Int  i;                          // ..
+
+  /* Start decoding the argument */
+  sourhi=DFWORD(df, 0);                 // top word
+  exp=DECCOMBEXP[sourhi>>26];           // get exponent high bits (in place)
+  if (EXPISSPECIAL(exp)) {              // is special?
+    set->status|=DEC_Invalid_operation; // signal
+    return 0;
+    }
+
+  /* Here when the argument is finite */
+  if (GETEXPUN(df)==0) result=*df;      // already a true integer
+   else {                               // need to round to integer
+    enum rounding saveround;            // saver
+    uInt savestatus;                    // ..
+    saveround=set->round;               // save rounding mode ..
+    savestatus=set->status;             // .. and status
+    set->round=rmode;                   // set mode
+    decFloatZero(&zero);                // make 0E+0
+    set->status=0;                      // clear
+    decFloatQuantize(&result, df, &zero, set); // [this may fail]
+    set->round=saveround;               // restore rounding mode ..
+    if (exact) set->status|=savestatus; // include Inexact
+     else set->status=savestatus;       // .. or just original status
+    }
+
+  // only the last four declets of the coefficient can contain
+  // non-zero; check for others (and also NaN or Infinity from the
+  // Quantize) first (see DFISZERO for explanation):
+  // decFloatShow(&result, "sofar");
+  #if DOUBLE
+  if ((DFWORD(&result, 0)&0x1c03ff00)!=0
+   || (DFWORD(&result, 0)&0x60000000)==0x60000000) {
+  #elif QUAD
+  if ((DFWORD(&result, 2)&0xffffff00)!=0
+   ||  DFWORD(&result, 1)!=0
+   || (DFWORD(&result, 0)&0x1c003fff)!=0
+   || (DFWORD(&result, 0)&0x60000000)==0x60000000) {
+  #endif
+    set->status|=DEC_Invalid_operation; // Invalid or out of range
+    return 0;
+    }
+  // get last twelve digits of the coefficent into hi & ho, base
+  // 10**9 (see GETCOEFFBILL):
+  sourlo=DFWORD(&result, DECWORDS-1);
+  lo=DPD2BIN0[sourlo&0x3ff]
+    +DPD2BINK[(sourlo>>10)&0x3ff]
+    +DPD2BINM[(sourlo>>20)&0x3ff];
+  sourpen=DFWORD(&result, DECWORDS-2);
+  hi=DPD2BIN0[((sourpen<<2) | (sourlo>>30))&0x3ff];
+
+  // according to request, check range carefully
+  if (unsign) {
+    if (hi>4 || (hi==4 && lo>294967295) || (hi+lo!=0 && DFISSIGNED(&result))) {
+      set->status|=DEC_Invalid_operation; // out of range
+      return 0;
+      }
+    return hi*BILLION+lo;
+    }
+  // signed
+  if (hi>2 || (hi==2 && lo>147483647)) {
+    // handle the usual edge case
+    if (lo==147483648 && hi==2 && DFISSIGNED(&result)) return 0x80000000;
+    set->status|=DEC_Invalid_operation; // truly out of range
+    return 0;
+    }
+  i=hi*BILLION+lo;
+  if (DFISSIGNED(&result)) i=-i;
+  return (uInt)i;
+  } // decToInt32
+
+/* ------------------------------------------------------------------ */
+/* decToIntegral -- local routine to effect ToIntegral value          */
+/*                                                                    */
+/*   result gets the result                                           */
+/*   df     is the decFloat to round                                  */
+/*   set    is the context                                            */
+/*   rmode  is the rounding mode to use                               */
+/*   exact  is 1 if Inexact should be signalled                       */
+/*   returns result                                                   */
+/* ------------------------------------------------------------------ */
+static decFloat * decToIntegral(decFloat *result, const decFloat *df,
+                                decContext *set, enum rounding rmode,
+                                Flag exact) {
+  Int  exp;                        // exponent
+  uInt sourhi;                     // top word from source decFloat
+  enum rounding saveround;         // saver
+  uInt savestatus;                 // ..
+  decFloat zero;                   // work
+
+  /* Start decoding the argument */
+  sourhi=DFWORD(df, 0);            // top word
+  exp=DECCOMBEXP[sourhi>>26];      // get exponent high bits (in place)
+
+  if (EXPISSPECIAL(exp)) {         // is special?
+    // NaNs are handled as usual
+    if (DFISNAN(df)) return decNaNs(result, df, NULL, set);
+    // must be infinite; return canonical infinity with sign of df
+    return decInfinity(result, df);
+    }
+
+  /* Here when the argument is finite */
+  // complete extraction of the exponent
+  exp+=GETECON(df)-DECBIAS;             // .. + continuation and unbias
+
+  if (exp>=0) return decCanonical(result, df); // already integral
+
+  saveround=set->round;                 // save rounding mode ..
+  savestatus=set->status;               // .. and status
+  set->round=rmode;                     // set mode
+  decFloatZero(&zero);                  // make 0E+0
+  decFloatQuantize(result, df, &zero, set); // 'integrate'; cannot fail
+  set->round=saveround;                 // restore rounding mode ..
+  if (!exact) set->status=savestatus;   // .. and status, unless exact
+  return result;
+  } // decToIntegral
+#endif /* !defined(DECBASIC) */
diff --git a/decNumber/decCommon.h b/decNumber/decCommon.h
new file mode 100644
index 00000000..3b93156d
--- /dev/null
+++ b/decNumber/decCommon.h
@@ -0,0 +1,1840 @@
+#if !defined(DECCOMMON)
+#define DECCOMMON
+
+/* ------------------------------------------------------------------ */
+/* decCommon.h -- common code for all three fixed-size types          */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2010.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is included in the package as decNumber.pdf.  This   */
+/* document is also available in HTML, together with specifications,  */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+/* This module comprises code that is shared between all the formats  */
+/* (decSingle, decDouble, and decQuad); it includes set and extract   */
+/* of format components, widening, narrowing, and string conversions. */
+/*                                                                    */
+/* Unlike decNumber, parameterization takes place at compile time     */
+/* rather than at runtime.  The parameters are set in the decDouble.c */
+/* (etc.) files, which then include this one to produce the compiled  */
+/* code.  The functions here, therefore, are code shared between      */
+/* multiple formats.                                                  */
+/* ------------------------------------------------------------------ */
+// Names here refer to decFloat rather than to decDouble, etc., and
+// the functions are in strict alphabetical order.
+// Constants, tables, and debug function(s) are included only for QUAD
+// (which will always be compiled if DOUBLE or SINGLE are used).
+//
+// Whenever a decContext is used, only the status may be set (using
+// OR) or the rounding mode read; all other fields are ignored and
+// untouched.
+
+// names for simpler testing and default context
+#if DECPMAX==7
+  #define SINGLE     1
+  #define DOUBLE     0
+  #define QUAD       0
+  #define DEFCONTEXT DEC_INIT_DECIMAL32
+#elif DECPMAX==16
+  #define SINGLE     0
+  #define DOUBLE     1
+  #define QUAD       0
+  #define DEFCONTEXT DEC_INIT_DECIMAL64
+#elif DECPMAX==34
+  #define SINGLE     0
+  #define DOUBLE     0
+  #define QUAD       1
+  #define DEFCONTEXT DEC_INIT_DECIMAL128
+#else
+  #error Unexpected DECPMAX value
+#endif
+
+/* Assertions */
+
+#if DECPMAX!=7 && DECPMAX!=16 && DECPMAX!=34
+  #error Unexpected Pmax (DECPMAX) value for this module
+#endif
+
+// Assert facts about digit characters, etc.
+#if ('9'&0x0f)!=9
+  #error This module assumes characters are of the form 0b....nnnn
+  // where .... are don't care 4 bits and nnnn is 0000 through 1001
+#endif
+#if ('9'&0xf0)==('.'&0xf0)
+  #error This module assumes '.' has a different mask than a digit
+#endif
+
+// Assert ToString lay-out conditions
+#if DECSTRING<DECPMAX+9
+  #error ToString needs at least 8 characters for lead-in and dot
+#endif
+#if DECPMAX+DECEMAXD+5 > DECSTRING
+  #error Exponent form can be too long for ToString to lay out safely
+#endif
+#if DECEMAXD > 4
+  #error Exponent form is too long for ToString to lay out
+  // Note: code for up to 9 digits exists in archives [decOct]
+#endif
+
+/* Private functions used here and possibly in decBasic.h, etc. */
+static decFloat * decFinalize(decFloat *, bcdnum *, decContext *);
+static Flag decBiStr(const char *, const char *, const char *);
+
+/* Macros and private tables; those which are not format-dependent    */
+/* are only included if decQuad is being built.                       */
+
+/* ------------------------------------------------------------------ */
+/* Combination field lookup tables (uInts to save measurable work)    */
+/*                                                                    */
+/*   DECCOMBEXP  - 2 most-significant-bits of exponent (00, 01, or    */
+/*                 10), shifted left for format, or DECFLOAT_Inf/NaN  */
+/*   DECCOMBWEXP - The same, for the next-wider format (unless QUAD)  */
+/*   DECCOMBMSD  - 4-bit most-significant-digit                       */
+/*                 [0 if the index is a special (Infinity or NaN)]    */
+/*   DECCOMBFROM - 5-bit combination field from EXP top bits and MSD  */
+/*                 (placed in uInt so no shift is needed)             */
+/*                                                                    */
+/* DECCOMBEXP, DECCOMBWEXP, and DECCOMBMSD are indexed by the sign    */
+/*   and 5-bit combination field (0-63, the second half of the table  */
+/*   identical to the first half)                                     */
+/* DECCOMBFROM is indexed by expTopTwoBits*16 + msd                   */
+/*                                                                    */
+/* DECCOMBMSD and DECCOMBFROM are not format-dependent and so are     */
+/* only included once, when QUAD is being built                       */
+/* ------------------------------------------------------------------ */
+static const uInt DECCOMBEXP[64]={
+  0, 0, 0, 0, 0, 0, 0, 0,
+  1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL,
+  1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL,
+  2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL,
+  2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL,
+  0,           0,           1<<DECECONL, 1<<DECECONL,
+  2<<DECECONL, 2<<DECECONL, DECFLOAT_Inf, DECFLOAT_NaN,
+  0, 0, 0, 0, 0, 0, 0, 0,
+  1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL,
+  1<<DECECONL, 1<<DECECONL, 1<<DECECONL, 1<<DECECONL,
+  2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL,
+  2<<DECECONL, 2<<DECECONL, 2<<DECECONL, 2<<DECECONL,
+  0,           0,           1<<DECECONL, 1<<DECECONL,
+  2<<DECECONL, 2<<DECECONL, DECFLOAT_Inf, DECFLOAT_NaN};
+#if !QUAD
+static const uInt DECCOMBWEXP[64]={
+  0, 0, 0, 0, 0, 0, 0, 0,
+  1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL,
+  1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL,
+  2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL,
+  2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL,
+  0,            0,            1<<DECWECONL, 1<<DECWECONL,
+  2<<DECWECONL, 2<<DECWECONL, DECFLOAT_Inf, DECFLOAT_NaN,
+  0, 0, 0, 0, 0, 0, 0, 0,
+  1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL,
+  1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL, 1<<DECWECONL,
+  2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL,
+  2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL, 2<<DECWECONL,
+  0,            0,            1<<DECWECONL, 1<<DECWECONL,
+  2<<DECWECONL, 2<<DECWECONL, DECFLOAT_Inf, DECFLOAT_NaN};
+#endif
+
+#if QUAD
+const uInt DECCOMBMSD[64]={
+  0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 9, 8, 9, 0, 0,
+  0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
+  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 9, 8, 9, 0, 0};
+
+const uInt DECCOMBFROM[48]={
+  0x00000000, 0x04000000, 0x08000000, 0x0C000000, 0x10000000, 0x14000000,
+  0x18000000, 0x1C000000, 0x60000000, 0x64000000, 0x00000000, 0x00000000,
+  0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x20000000, 0x24000000,
+  0x28000000, 0x2C000000, 0x30000000, 0x34000000, 0x38000000, 0x3C000000,
+  0x68000000, 0x6C000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+  0x00000000, 0x00000000, 0x40000000, 0x44000000, 0x48000000, 0x4C000000,
+  0x50000000, 0x54000000, 0x58000000, 0x5C000000, 0x70000000, 0x74000000,
+  0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000};
+
+/* ------------------------------------------------------------------ */
+/* Request and include the tables to use for conversions              */
+/* ------------------------------------------------------------------ */
+#define DEC_BCD2DPD  1        // 0-0x999 -> DPD
+#define DEC_BIN2DPD  1        // 0-999 -> DPD
+#define DEC_BIN2BCD8 1        // 0-999 -> ddd, len
+#define DEC_DPD2BCD8 1        // DPD -> ddd, len
+#define DEC_DPD2BIN  1        // DPD -> 0-999
+#define DEC_DPD2BINK 1        // DPD -> 0-999000
+#define DEC_DPD2BINM 1        // DPD -> 0-999000000
+#include "decDPD.h"           // source of the lookup tables
+
+#endif
+
+/* ----------------------------------------------------------------- */
+/* decBiStr -- compare string with pairwise options                  */
+/*                                                                   */
+/*   targ is the string to compare                                   */
+/*   str1 is one of the strings to compare against (length may be 0) */
+/*   str2 is the other; it must be the same length as str1           */
+/*                                                                   */
+/*   returns 1 if strings compare equal, (that is, targ is the same  */
+/*   length as str1 and str2, and each character of targ is in one   */
+/*   of str1 or str2 in the corresponding position), or 0 otherwise  */
+/*                                                                   */
+/* This is used for generic caseless compare, including the awkward  */
+/* case of the Turkish dotted and dotless Is.  Use as (for example): */
+/*   if (decBiStr(test, "mike", "MIKE")) ...                         */
+/* ----------------------------------------------------------------- */
+static Flag decBiStr(const char *targ, const char *str1, const char *str2) {
+  for (;;targ++, str1++, str2++) {
+    if (*targ!=*str1 && *targ!=*str2) return 0;
+    // *targ has a match in one (or both, if terminator)
+    if (*targ=='\0') break;
+    } // forever
+  return 1;
+  } // decBiStr
+
+/* ------------------------------------------------------------------ */
+/* decFinalize -- adjust and store a final result                     */
+/*                                                                    */
+/*  df  is the decFloat format number which gets the final result     */
+/*  num is the descriptor of the number to be checked and encoded     */
+/*         [its values, including the coefficient, may be modified]   */
+/*  set is the context to use                                         */
+/*  returns df                                                        */
+/*                                                                    */
+/* The num descriptor may point to a bcd8 string of any length; this  */
+/* string may have leading insignificant zeros.  If it has more than  */
+/* DECPMAX digits then the final digit can be a round-for-reround     */
+/* digit (i.e., it may include a sticky bit residue).                 */
+/*                                                                    */
+/* The exponent (q) may be one of the codes for a special value and   */
+/* can be up to 999999999 for conversion from string.                 */
+/*                                                                    */
+/* No error is possible, but Inexact, Underflow, and/or Overflow may  */
+/* be set.                                                            */
+/* ------------------------------------------------------------------ */
+// Constant whose size varies with format; also the check for surprises
+static uByte allnines[DECPMAX]=
+#if SINGLE
+  {9, 9, 9, 9, 9, 9, 9};
+#elif DOUBLE
+  {9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+#elif QUAD
+  {9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+   9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+#endif
+
+static decFloat * decFinalize(decFloat *df, bcdnum *num,
+                              decContext *set) {
+  uByte *ub;                  // work
+  uInt   dpd;                 // ..
+  uInt   uiwork;              // for macros
+  uByte *umsd=num->msd;       // local copy
+  uByte *ulsd=num->lsd;       // ..
+  uInt   encode;              // encoding accumulator
+  Int    length;              // coefficient length
+
+  #if DECCHECK
+  Int clen=ulsd-umsd+1;
+  #if QUAD
+    #define COEXTRA 2                        // extra-long coefficent
+  #else
+    #define COEXTRA 0
+  #endif
+  if (clen<1 || clen>DECPMAX*3+2+COEXTRA)
+    printf("decFinalize: suspect coefficient [length=%ld]\n", (LI)clen);
+  if (num->sign!=0 && num->sign!=DECFLOAT_Sign)
+    printf("decFinalize: bad sign [%08lx]\n", (LI)num->sign);
+  if (!EXPISSPECIAL(num->exponent)
+      && (num->exponent>1999999999 || num->exponent<-1999999999))
+    printf("decFinalize: improbable exponent [%ld]\n", (LI)num->exponent);
+  // decShowNum(num, "final");
+  #endif
+
+  // A special will have an 'exponent' which is very positive and a
+  // coefficient < DECPMAX
+  length=(uInt)(ulsd-umsd+1);                // coefficient length
+
+  if (!NUMISSPECIAL(num)) {
+    Int   drop;                              // digits to be dropped
+    // skip leading insignificant zeros to calculate an exact length
+    // [this is quite expensive]
+    if (*umsd==0) {
+      for (; umsd+3<ulsd && UBTOUI(umsd)==0;) umsd+=4;
+      for (; *umsd==0 && umsd<ulsd;) umsd++;
+      length=ulsd-umsd+1;                    // recalculate
+      }
+    drop=MAXI(length-DECPMAX, DECQTINY-num->exponent);
+    // drop can now be > digits for bottom-clamp (subnormal) cases
+    if (drop>0) {                            // rounding needed
+      // (decFloatQuantize has very similar code to this, so any
+      // changes may need to be made there, too)
+      uByte *roundat;                        // -> re-round digit
+      uByte reround;                         // reround value
+      // printf("Rounding; drop=%ld\n", (LI)drop);
+
+      num->exponent+=drop;                   // always update exponent
+
+      // Three cases here:
+      //   1. new LSD is in coefficient (almost always)
+      //   2. new LSD is digit to left of coefficient (so MSD is
+      //      round-for-reround digit)
+      //   3. new LSD is to left of case 2 (whole coefficient is sticky)
+      // [duplicate check-stickies code to save a test]
+      // [by-digit check for stickies as runs of zeros are rare]
+      if (drop<length) {                     // NB lengths not addresses
+        roundat=umsd+length-drop;
+        reround=*roundat;
+        for (ub=roundat+1; ub<=ulsd; ub++) {
+          if (*ub!=0) {                      // non-zero to be discarded
+            reround=DECSTICKYTAB[reround];   // apply sticky bit
+            break;                           // [remainder don't-care]
+            }
+          } // check stickies
+        ulsd=roundat-1;                      // new LSD
+        }
+       else {                                // edge case
+        if (drop==length) {
+          roundat=umsd;
+          reround=*roundat;
+          }
+         else {
+          roundat=umsd-1;
+          reround=0;
+          }
+        for (ub=roundat+1; ub<=ulsd; ub++) {
+          if (*ub!=0) {                      // non-zero to be discarded
+            reround=DECSTICKYTAB[reround];   // apply sticky bit
+            break;                           // [remainder don't-care]
+            }
+          } // check stickies
+        *umsd=0;                             // coefficient is a 0
+        ulsd=umsd;                           // ..
+        }
+
+      if (reround!=0) {                      // discarding non-zero
+        uInt bump=0;
+        set->status|=DEC_Inexact;
+        // if adjusted exponent [exp+digits-1] is < EMIN then num is
+        // subnormal -- so raise Underflow
+        if (num->exponent<DECEMIN && (num->exponent+(ulsd-umsd+1)-1)<DECEMIN)
+          set->status|=DEC_Underflow;
+
+        // next decide whether increment of the coefficient is needed
+        if (set->round==DEC_ROUND_HALF_EVEN) {    // fastpath slowest case
+          if (reround>5) bump=1;                  // >0.5 goes up
+           else if (reround==5)                   // exactly 0.5000 ..
+            bump=*ulsd & 0x01;                    // .. up iff [new] lsd is odd
+          } // r-h-e
+         else switch (set->round) {
+          case DEC_ROUND_DOWN: {
+            // no change
+            break;} // r-d
+          case DEC_ROUND_HALF_DOWN: {
+            if (reround>5) bump=1;
+            break;} // r-h-d
+          case DEC_ROUND_HALF_UP: {
+            if (reround>=5) bump=1;
+            break;} // r-h-u
+          case DEC_ROUND_UP: {
+            if (reround>0) bump=1;
+            break;} // r-u
+          case DEC_ROUND_CEILING: {
+            // same as _UP for positive numbers, and as _DOWN for negatives
+            if (!num->sign && reround>0) bump=1;
+            break;} // r-c
+          case DEC_ROUND_FLOOR: {
+            // same as _UP for negative numbers, and as _DOWN for positive
+            // [negative reround cannot occur on 0]
+            if (num->sign && reround>0) bump=1;
+            break;} // r-f
+          case DEC_ROUND_05UP: {
+            if (reround>0) { // anything out there is 'sticky'
+              // bump iff lsd=0 or 5; this cannot carry so it could be
+              // effected immediately with no bump -- but the code
+              // is clearer if this is done the same way as the others
+              if (*ulsd==0 || *ulsd==5) bump=1;
+              }
+            break;} // r-r
+          default: {      // e.g., DEC_ROUND_MAX
+            set->status|=DEC_Invalid_context;
+            #if DECCHECK
+            printf("Unknown rounding mode: %ld\n", (LI)set->round);
+            #endif
+            break;}
+          } // switch (not r-h-e)
+        // printf("ReRound: %ld  bump: %ld\n", (LI)reround, (LI)bump);
+
+        if (bump!=0) {                       // need increment
+          // increment the coefficient; this might end up with 1000...
+          // (after the all nines case)
+          ub=ulsd;
+          for(; ub-3>=umsd && UBTOUI(ub-3)==0x09090909; ub-=4)  {
+            UBFROMUI(ub-3, 0);               // to 00000000
+            }
+          // [note ub could now be to left of msd, and it is not safe
+          // to write to the the left of the msd]
+          // now at most 3 digits left to non-9 (usually just the one)
+          for (; ub>=umsd; *ub=0, ub--) {
+            if (*ub==9) continue;            // carry
+            *ub+=1;
+            break;
+            }
+          if (ub<umsd) {                     // had all-nines
+            *umsd=1;                         // coefficient to 1000...
+            // usually the 1000... coefficient can be used as-is
+            if ((ulsd-umsd+1)==DECPMAX) {
+              num->exponent++;
+              }
+             else {
+              // if coefficient is shorter than Pmax then num is
+              // subnormal, so extend it; this is safe as drop>0
+              // (or, if the coefficient was supplied above, it could
+              // not be 9); this may make the result normal.
+              ulsd++;
+              *ulsd=0;
+              // [exponent unchanged]
+              #if DECCHECK
+              if (num->exponent!=DECQTINY) // sanity check
+                printf("decFinalize: bad all-nines extend [^%ld, %ld]\n",
+                       (LI)num->exponent, (LI)(ulsd-umsd+1));
+              #endif
+              } // subnormal extend
+            } // had all-nines
+          } // bump needed
+        } // inexact rounding
+
+      length=ulsd-umsd+1;               // recalculate (may be <DECPMAX)
+      } // need round (drop>0)
+
+    // The coefficient will now fit and has final length unless overflow
+    // decShowNum(num, "rounded");
+
+    // if exponent is >=emax may have to clamp, overflow, or fold-down
+    if (num->exponent>DECEMAX-(DECPMAX-1)) { // is edge case
+      // printf("overflow checks...\n");
+      if (*ulsd==0 && ulsd==umsd) {     // have zero
+        num->exponent=DECEMAX-(DECPMAX-1); // clamp to max
+        }
+       else if ((num->exponent+length-1)>DECEMAX) { // > Nmax
+        // Overflow -- these could go straight to encoding, here, but
+        // instead num is adjusted to keep the code cleaner
+        Flag needmax=0;                 // 1 for finite result
+        set->status|=(DEC_Overflow | DEC_Inexact);
+        switch (set->round) {
+          case DEC_ROUND_DOWN: {
+            needmax=1;                  // never Infinity
+            break;} // r-d
+          case DEC_ROUND_05UP: {
+            needmax=1;                  // never Infinity
+            break;} // r-05
+          case DEC_ROUND_CEILING: {
+            if (num->sign) needmax=1;   // Infinity iff non-negative
+            break;} // r-c
+          case DEC_ROUND_FLOOR: {
+            if (!num->sign) needmax=1;  // Infinity iff negative
+            break;} // r-f
+          default: break;               // Infinity in all other cases
+          }
+        if (!needmax) {                 // easy .. set Infinity
+          num->exponent=DECFLOAT_Inf;
+          *umsd=0;                      // be clean: coefficient to 0
+          ulsd=umsd;                    // ..
+          }
+         else {                         // return Nmax
+          umsd=allnines;                // use constant array
+          ulsd=allnines+DECPMAX-1;
+          num->exponent=DECEMAX-(DECPMAX-1);
+          }
+        }
+       else { // no overflow but non-zero and may have to fold-down
+        Int shift=num->exponent-(DECEMAX-(DECPMAX-1));
+        if (shift>0) {                  // fold-down needed
+          // fold down needed; must copy to buffer in order to pad
+          // with zeros safely; fortunately this is not the worst case
+          // path because cannot have had a round
+          uByte buffer[ROUNDUP(DECPMAX+3, 4)]; // [+3 allows uInt padding]
+          uByte *s=umsd;                // source
+          uByte *t=buffer;              // safe target
+          uByte *tlsd=buffer+(ulsd-umsd)+shift; // target LSD
+          // printf("folddown shift=%ld\n", (LI)shift);
+          for (; s<=ulsd; s+=4, t+=4) UBFROMUI(t, UBTOUI(s));
+          for (t=tlsd-shift+1; t<=tlsd; t+=4) UBFROMUI(t, 0);  // pad 0s
+          num->exponent-=shift;
+          umsd=buffer;
+          ulsd=tlsd;
+          }
+        } // fold-down?
+      length=ulsd-umsd+1;               // recalculate length
+      } // high-end edge case
+    } // finite number
+
+  /*------------------------------------------------------------------*/
+  /* At this point the result will properly fit the decFloat          */
+  /* encoding, and it can be encoded with no possibility of error     */
+  /*------------------------------------------------------------------*/
+  // Following code does not alter coefficient (could be allnines array)
+
+  // fast path possible when DECPMAX digits
+  if (length==DECPMAX) {
+    return decFloatFromBCD(df, num->exponent, umsd, num->sign);
+    } // full-length
+
+  // slower path when not a full-length number; must care about length
+  // [coefficient length here will be < DECPMAX]
+  if (!NUMISSPECIAL(num)) {             // is still finite
+    // encode the combination field and exponent continuation
+    uInt uexp=(uInt)(num->exponent+DECBIAS); // biased exponent
+    uInt code=(uexp>>DECECONL)<<4;      // top two bits of exp
+    // [msd==0]
+    // look up the combination field and make high word
+    encode=DECCOMBFROM[code];           // indexed by (0-2)*16+msd
+    encode|=(uexp<<(32-6-DECECONL)) & 0x03ffffff; // exponent continuation
+    }
+   else encode=num->exponent;           // special [already in word]
+  encode|=num->sign;                    // add sign
+
+  // private macro to extract a declet, n (where 0<=n<DECLETS and 0
+  // refers to the declet from the least significant three digits)
+  // and put the corresponding DPD code into dpd.  Access to umsd and
+  // ulsd (pointers to the most and least significant digit of the
+  // variable-length coefficient) is assumed, along with use of a
+  // working pointer, uInt *ub.
+  // As not full-length then chances are there are many leading zeros
+  // [and there may be a partial triad]
+  #define getDPDt(dpd, n) ub=ulsd-(3*(n))-2;                          \
+    if (ub<umsd-2) dpd=0;                                             \
+     else if (ub>=umsd) dpd=BCD2DPD[(*ub*256)+(*(ub+1)*16)+*(ub+2)];  \
+     else {dpd=*(ub+2); if (ub+1==umsd) dpd+=*(ub+1)*16; dpd=BCD2DPD[dpd];}
+
+  // place the declets in the encoding words and copy to result (df),
+  // according to endianness; in all cases complete the sign word
+  // first
+  #if DECPMAX==7
+    getDPDt(dpd, 1);
+    encode|=dpd<<10;
+    getDPDt(dpd, 0);
+    encode|=dpd;
+    DFWORD(df, 0)=encode;     // just the one word
+
+  #elif DECPMAX==16
+    getDPDt(dpd, 4); encode|=dpd<<8;
+    getDPDt(dpd, 3); encode|=dpd>>2;
+    DFWORD(df, 0)=encode;
+    encode=dpd<<30;
+    getDPDt(dpd, 2); encode|=dpd<<20;
+    getDPDt(dpd, 1); encode|=dpd<<10;
+    getDPDt(dpd, 0); encode|=dpd;
+    DFWORD(df, 1)=encode;
+
+  #elif DECPMAX==34
+    getDPDt(dpd,10); encode|=dpd<<4;
+    getDPDt(dpd, 9); encode|=dpd>>6;
+    DFWORD(df, 0)=encode;
+
+    encode=dpd<<26;
+    getDPDt(dpd, 8); encode|=dpd<<16;
+    getDPDt(dpd, 7); encode|=dpd<<6;
+    getDPDt(dpd, 6); encode|=dpd>>4;
+    DFWORD(df, 1)=encode;
+
+    encode=dpd<<28;
+    getDPDt(dpd, 5); encode|=dpd<<18;
+    getDPDt(dpd, 4); encode|=dpd<<8;
+    getDPDt(dpd, 3); encode|=dpd>>2;
+    DFWORD(df, 2)=encode;
+
+    encode=dpd<<30;
+    getDPDt(dpd, 2); encode|=dpd<<20;
+    getDPDt(dpd, 1); encode|=dpd<<10;
+    getDPDt(dpd, 0); encode|=dpd;
+    DFWORD(df, 3)=encode;
+  #endif
+
+  // printf("Status: %08lx\n", (LI)set->status);
+  // decFloatShow(df, "final2");
+  return df;
+  } // decFinalize
+
+/* ------------------------------------------------------------------ */
+/* decFloatFromBCD -- set decFloat from exponent, BCD8, and sign      */
+/*                                                                    */
+/*  df is the target decFloat                                         */
+/*  exp is the in-range unbiased exponent, q, or a special value in   */
+/*    the form returned by decFloatGetExponent                        */
+/*  bcdar holds DECPMAX digits to set the coefficient from, one       */
+/*    digit in each byte (BCD8 encoding); the first (MSD) is ignored  */
+/*    if df is a NaN; all are ignored if df is infinite.              */
+/*    All bytes must be in 0-9; results are undefined otherwise.      */
+/*  sig is DECFLOAT_Sign to set the sign bit, 0 otherwise             */
+/*  returns df, which will be canonical                               */
+/*                                                                    */
+/* No error is possible, and no status will be set.                   */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatFromBCD(decFloat *df, Int exp, const uByte *bcdar,
+                           Int sig) {
+  uInt encode, dpd;                     // work
+  const uByte *ub;                      // ..
+
+  if (EXPISSPECIAL(exp)) encode=exp|sig;// specials already encoded
+   else {                               // is finite
+    // encode the combination field and exponent continuation
+    uInt uexp=(uInt)(exp+DECBIAS);      // biased exponent
+    uInt code=(uexp>>DECECONL)<<4;      // top two bits of exp
+    code+=bcdar[0];                     // add msd
+    // look up the combination field and make high word
+    encode=DECCOMBFROM[code]|sig;       // indexed by (0-2)*16+msd
+    encode|=(uexp<<(32-6-DECECONL)) & 0x03ffffff; // exponent continuation
+    }
+
+  // private macro to extract a declet, n (where 0<=n<DECLETS and 0
+  // refers to the declet from the least significant three digits)
+  // and put the corresponding DPD code into dpd.
+  // Use of a working pointer, uInt *ub, is assumed.
+
+  #define getDPDb(dpd, n) ub=bcdar+DECPMAX-1-(3*(n))-2;     \
+    dpd=BCD2DPD[(*ub*256)+(*(ub+1)*16)+*(ub+2)];
+
+  // place the declets in the encoding words and copy to result (df),
+  // according to endianness; in all cases complete the sign word
+  // first
+  #if DECPMAX==7
+    getDPDb(dpd, 1);
+    encode|=dpd<<10;
+    getDPDb(dpd, 0);
+    encode|=dpd;
+    DFWORD(df, 0)=encode;     // just the one word
+
+  #elif DECPMAX==16
+    getDPDb(dpd, 4); encode|=dpd<<8;
+    getDPDb(dpd, 3); encode|=dpd>>2;
+    DFWORD(df, 0)=encode;
+    encode=dpd<<30;
+    getDPDb(dpd, 2); encode|=dpd<<20;
+    getDPDb(dpd, 1); encode|=dpd<<10;
+    getDPDb(dpd, 0); encode|=dpd;
+    DFWORD(df, 1)=encode;
+
+  #elif DECPMAX==34
+    getDPDb(dpd,10); encode|=dpd<<4;
+    getDPDb(dpd, 9); encode|=dpd>>6;
+    DFWORD(df, 0)=encode;
+
+    encode=dpd<<26;
+    getDPDb(dpd, 8); encode|=dpd<<16;
+    getDPDb(dpd, 7); encode|=dpd<<6;
+    getDPDb(dpd, 6); encode|=dpd>>4;
+    DFWORD(df, 1)=encode;
+
+    encode=dpd<<28;
+    getDPDb(dpd, 5); encode|=dpd<<18;
+    getDPDb(dpd, 4); encode|=dpd<<8;
+    getDPDb(dpd, 3); encode|=dpd>>2;
+    DFWORD(df, 2)=encode;
+
+    encode=dpd<<30;
+    getDPDb(dpd, 2); encode|=dpd<<20;
+    getDPDb(dpd, 1); encode|=dpd<<10;
+    getDPDb(dpd, 0); encode|=dpd;
+    DFWORD(df, 3)=encode;
+  #endif
+  // decFloatShow(df, "fromB");
+  return df;
+  } // decFloatFromBCD
+
+/* ------------------------------------------------------------------ */
+/* decFloatFromPacked -- set decFloat from exponent and packed BCD    */
+/*                                                                    */
+/*  df is the target decFloat                                         */
+/*  exp is the in-range unbiased exponent, q, or a special value in   */
+/*    the form returned by decFloatGetExponent                        */
+/*  packed holds DECPMAX packed decimal digits plus a sign nibble     */
+/*    (all 6 codes are OK); the first (MSD) is ignored if df is a NaN */
+/*    and all except sign are ignored if df is infinite.  For DOUBLE  */
+/*    and QUAD the first (pad) nibble is also ignored in all cases.   */
+/*    All coefficient nibbles must be in 0-9 and sign in A-F; results */
+/*    are undefined otherwise.                                        */
+/*  returns df, which will be canonical                               */
+/*                                                                    */
+/* No error is possible, and no status will be set.                   */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatFromPacked(decFloat *df, Int exp, const uByte *packed) {
+  uByte bcdar[DECPMAX+2];               // work [+1 for pad, +1 for sign]
+  const uByte *ip;                      // ..
+  uByte *op;                            // ..
+  Int   sig=0;                          // sign
+
+  // expand coefficient and sign to BCDAR
+  #if SINGLE
+  op=bcdar+1;                           // no pad digit
+  #else
+  op=bcdar;                             // first (pad) digit ignored
+  #endif
+  for (ip=packed; ip<packed+((DECPMAX+2)/2); ip++) {
+    *op++=*ip>>4;
+    *op++=(uByte)(*ip&0x0f);            // [final nibble is sign]
+    }
+  op--;                                 // -> sign byte
+  if (*op==DECPMINUS || *op==DECPMINUSALT) sig=DECFLOAT_Sign;
+
+  if (EXPISSPECIAL(exp)) {              // Infinity or NaN
+    if (!EXPISINF(exp)) bcdar[1]=0;     // a NaN: ignore MSD
+     else memset(bcdar+1, 0, DECPMAX);  // Infinite: coefficient to 0
+    }
+  return decFloatFromBCD(df, exp, bcdar+1, sig);
+  } // decFloatFromPacked
+
+/* ------------------------------------------------------------------ */
+/* decFloatFromPackedChecked -- set from exponent and packed; checked */
+/*                                                                    */
+/*  df is the target decFloat                                         */
+/*  exp is the in-range unbiased exponent, q, or a special value in   */
+/*    the form returned by decFloatGetExponent                        */
+/*  packed holds DECPMAX packed decimal digits plus a sign nibble     */
+/*    (all 6 codes are OK); the first (MSD) must be 0 if df is a NaN  */
+/*    and all digits must be 0 if df is infinite.  For DOUBLE and     */
+/*    QUAD the first (pad) nibble must be 0.                          */
+/*    All coefficient nibbles must be in 0-9 and sign in A-F.         */
+/*  returns df, which will be canonical or NULL if any of the         */
+/*    requirements are not met (if this case df is unchanged); that   */
+/*    is, the input data must be as returned by decFloatToPacked,     */
+/*    except that all six sign codes are acccepted.                   */
+/*                                                                    */
+/* No status will be set.                                             */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatFromPackedChecked(decFloat *df, Int exp,
+                                     const uByte *packed) {
+  uByte bcdar[DECPMAX+2];               // work [+1 for pad, +1 for sign]
+  const uByte *ip;                      // ..
+  uByte *op;                            // ..
+  Int   sig=0;                          // sign
+
+  // expand coefficient and sign to BCDAR
+  #if SINGLE
+  op=bcdar+1;                           // no pad digit
+  #else
+  op=bcdar;                             // first (pad) digit here
+  #endif
+  for (ip=packed; ip<packed+((DECPMAX+2)/2); ip++) {
+    *op=*ip>>4;
+    if (*op>9) return NULL;
+    op++;
+    *op=(uByte)(*ip&0x0f);              // [final nibble is sign]
+    if (*op>9 && ip<packed+((DECPMAX+2)/2)-1) return NULL;
+    op++;
+    }
+  op--;                                 // -> sign byte
+  if (*op<=9) return NULL;              // bad sign
+  if (*op==DECPMINUS || *op==DECPMINUSALT) sig=DECFLOAT_Sign;
+
+  #if !SINGLE
+  if (bcdar[0]!=0) return NULL;         // bad pad nibble
+  #endif
+
+  if (EXPISNAN(exp)) {                  // a NaN
+    if (bcdar[1]!=0) return NULL;       // bad msd
+    } // NaN
+   else if (EXPISINF(exp)) {            // is infinite
+    Int i;
+    for (i=0; i<DECPMAX; i++) {
+      if (bcdar[i+1]!=0) return NULL;   // should be all zeros
+      }
+    } // infinity
+   else {                               // finite
+    // check the exponent is in range
+    if (exp>DECEMAX-DECPMAX+1) return NULL;
+    if (exp<DECEMIN-DECPMAX+1) return NULL;
+    }
+  return decFloatFromBCD(df, exp, bcdar+1, sig);
+  } // decFloatFromPacked
+
+/* ------------------------------------------------------------------ */
+/* decFloatFromString -- conversion from numeric string               */
+/*                                                                    */
+/*  result  is the decFloat format number which gets the result of    */
+/*          the conversion                                            */
+/*  *string is the character string which should contain a valid      */
+/*          number (which may be a special value), \0-terminated      */
+/*          If there are too many significant digits in the           */
+/*          coefficient it will be rounded.                           */
+/*  set     is the context                                            */
+/*  returns result                                                    */
+/*                                                                    */
+/* The length of the coefficient and the size of the exponent are     */
+/* checked by this routine, so the correct error (Underflow or        */
+/* Overflow) can be reported or rounding applied, as necessary.       */
+/*                                                                    */
+/* There is no limit to the coefficient length for finite inputs;     */
+/* NaN payloads must be integers with no more than DECPMAX-1 digits.  */
+/* Exponents may have up to nine significant digits.                  */
+/*                                                                    */
+/* If bad syntax is detected, the result will be a quiet NaN.         */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatFromString(decFloat *result, const char *string,
+                              decContext *set) {
+  Int    digits;                   // count of digits in coefficient
+  const  char *dotchar=NULL;       // where dot was found [NULL if none]
+  const  char *cfirst=string;      // -> first character of decimal part
+  const  char *c;                  // work
+  uByte *ub;                       // ..
+  uInt   uiwork;                   // for macros
+  bcdnum num;                      // collects data for finishing
+  uInt   error=DEC_Conversion_syntax;      // assume the worst
+  uByte  buffer[ROUNDUP(DECSTRING+11, 8)]; // room for most coefficents,
+                                           // some common rounding, +3, & pad
+  #if DECTRACE
+  // printf("FromString %s ...\n", string);
+  #endif
+
+  for(;;) {                             // once-only 'loop'
+    num.sign=0;                         // assume non-negative
+    num.msd=buffer;                     // MSD is here always
+
+    // detect and validate the coefficient, including any leading,
+    // trailing, or embedded '.'
+    // [could test four-at-a-time here (saving 10% for decQuads),
+    // but that risks storage violation because the position of the
+    // terminator is unknown]
+    for (c=string;; c++) {              // -> input character
+      if (((unsigned)(*c-'0'))<=9) continue; // '0' through '9' is good
+      if (*c=='\0') break;              // most common non-digit
+      if (*c=='.') {
+        if (dotchar!=NULL) break;       // not first '.'
+        dotchar=c;                      // record offset into decimal part
+        continue;}
+      if (c==string) {                  // first in string...
+        if (*c=='-') {                  // valid - sign
+          cfirst++;
+          num.sign=DECFLOAT_Sign;
+          continue;}
+        if (*c=='+') {                  // valid + sign
+          cfirst++;
+          continue;}
+        }
+      // *c is not a digit, terminator, or a valid +, -, or '.'
+      break;
+      } // c loop
+
+    digits=(uInt)(c-cfirst);            // digits (+1 if a dot)
+
+    if (digits>0) {                     // had digits and/or dot
+      const char *clast=c-1;            // note last coefficient char position
+      Int exp=0;                        // exponent accumulator
+      if (*c!='\0') {                   // something follows the coefficient
+        uInt edig;                      // unsigned work
+        // had some digits and more to come; expect E[+|-]nnn now
+        const char *firstexp;           // exponent first non-zero
+        if (*c!='E' && *c!='e') break;
+        c++;                            // to (optional) sign
+        if (*c=='-' || *c=='+') c++;    // step over sign (c=clast+2)
+        if (*c=='\0') break;            // no digits!  (e.g., '1.2E')
+        for (; *c=='0';) c++;           // skip leading zeros [even last]
+        firstexp=c;                     // remember start [maybe '\0']
+        // gather exponent digits
+        edig=(uInt)*c-(uInt)'0';
+        if (edig<=9) {                  // [check not bad or terminator]
+          exp+=edig;                    // avoid initial X10
+          c++;
+          for (;; c++) {
+            edig=(uInt)*c-(uInt)'0';
+            if (edig>9) break;
+            exp=exp*10+edig;
+            }
+          }
+        // if not now on the '\0', *c must not be a digit
+        if (*c!='\0') break;
+
+        // (this next test must be after the syntax checks)
+        // if definitely more than the possible digits for format then
+        // the exponent may have wrapped, so simply set it to a certain
+        // over/underflow value
+        if (c>firstexp+DECEMAXD) exp=DECEMAX*2;
+        if (*(clast+2)=='-') exp=-exp;  // was negative
+        } // exponent part
+
+      if (dotchar!=NULL) {              // had a '.'
+        digits--;                       // remove from digits count
+        if (digits==0) break;           // was dot alone: bad syntax
+        exp-=(Int)(clast-dotchar);      // adjust exponent
+        // [the '.' can now be ignored]
+        }
+      num.exponent=exp;                 // exponent is good; store it
+
+      // Here when whole string has been inspected and syntax is good
+      // cfirst->first digit or dot, clast->last digit or dot
+      error=0;                          // no error possible now
+
+      // if the number of digits in the coefficient will fit in buffer
+      // then it can simply be converted to bcd8 and copied -- decFinalize
+      // will take care of leading zeros and rounding; the buffer is big
+      // enough for all canonical coefficients, including 0.00000nn...
+      ub=buffer;
+      if (digits<=(Int)(sizeof(buffer)-3)) { // [-3 allows by-4s copy]
+        c=cfirst;
+        if (dotchar!=NULL) {                 // a dot to worry about
+          if (*(c+1)=='.') {                 // common canonical case
+            *ub++=(uByte)(*c-'0');           // copy leading digit
+            c+=2;                            // prepare to handle rest
+            }
+           else for (; c<=clast;) {          // '.' could be anywhere
+            // as usual, go by fours when safe; NB it has been asserted
+            // that a '.' does not have the same mask as a digit
+            if (c<=clast-3                             // safe for four
+             && (UBTOUI(c)&0xf0f0f0f0)==CHARMASK) {    // test four
+              UBFROMUI(ub, UBTOUI(c)&0x0f0f0f0f);      // to BCD8
+              ub+=4;
+              c+=4;
+              continue;
+              }
+            if (*c=='.') {                   // found the dot
+              c++;                           // step over it ..
+              break;                         // .. and handle the rest
+              }
+            *ub++=(uByte)(*c++-'0');
+            }
+          } // had dot
+        // Now no dot; do this by fours (where safe)
+        for (; c<=clast-3; c+=4, ub+=4) UBFROMUI(ub, UBTOUI(c)&0x0f0f0f0f);
+        for (; c<=clast; c++, ub++) *ub=(uByte)(*c-'0');
+        num.lsd=buffer+digits-1;             // record new LSD
+        } // fits
+
+       else {                                // too long for buffer
+        // [This is a rare and unusual case; arbitrary-length input]
+        // strip leading zeros [but leave final 0 if all 0's]
+        if (*cfirst=='.') cfirst++;          // step past dot at start
+        if (*cfirst=='0') {                  // [cfirst always -> digit]
+          for (; cfirst<clast; cfirst++) {
+            if (*cfirst!='0') {              // non-zero found
+              if (*cfirst=='.') continue;    // [ignore]
+              break;                         // done
+              }
+            digits--;                        // 0 stripped
+            } // cfirst
+          } // at least one leading 0
+
+        // the coefficient is now as short as possible, but may still
+        // be too long; copy up to Pmax+1 digits to the buffer, then
+        // just record any non-zeros (set round-for-reround digit)
+        for (c=cfirst; c<=clast && ub<=buffer+DECPMAX; c++) {
+          // (see commentary just above)
+          if (c<=clast-3                          // safe for four
+           && (UBTOUI(c)&0xf0f0f0f0)==CHARMASK) { // four digits
+            UBFROMUI(ub, UBTOUI(c)&0x0f0f0f0f);   // to BCD8
+            ub+=4;
+            c+=3;                            // [will become 4]
+            continue;
+            }
+          if (*c=='.') continue;             // [ignore]
+          *ub++=(uByte)(*c-'0');
+          }
+        ub--;                                // -> LSD
+        for (; c<=clast; c++) {              // inspect remaining chars
+          if (*c!='0') {                     // sticky bit needed
+            if (*c=='.') continue;           // [ignore]
+            *ub=DECSTICKYTAB[*ub];           // update round-for-reround
+            break;                           // no need to look at more
+            }
+          }
+        num.lsd=ub;                          // record LSD
+        // adjust exponent for dropped digits
+        num.exponent+=digits-(Int)(ub-buffer+1);
+        } // too long for buffer
+      } // digits and/or dot
+
+     else {                             // no digits or dot were found
+      // only Infinities and NaNs are allowed, here
+      if (*c=='\0') break;              // nothing there is bad
+      buffer[0]=0;                      // default a coefficient of 0
+      num.lsd=buffer;                   // ..
+      if (decBiStr(c, "infinity", "INFINITY")
+       || decBiStr(c, "inf", "INF")) num.exponent=DECFLOAT_Inf;
+       else {                           // should be a NaN
+        num.exponent=DECFLOAT_qNaN;     // assume quiet NaN
+        if (*c=='s' || *c=='S') {       // probably an sNaN
+          num.exponent=DECFLOAT_sNaN;   // effect the 's'
+          c++;                          // and step over it
+          }
+        if (*c!='N' && *c!='n') break;  // check caseless "NaN"
+        c++;
+        if (*c!='a' && *c!='A') break;  // ..
+        c++;
+        if (*c!='N' && *c!='n') break;  // ..
+        c++;
+        // now either nothing, or nnnn payload (no dots), expected
+        // -> start of integer, and skip leading 0s [including plain 0]
+        for (cfirst=c; *cfirst=='0';) cfirst++;
+        if (*cfirst!='\0') {            // not empty or all-0, payload
+          // payload found; check all valid digits and copy to buffer as bcd8
+          ub=buffer;
+          for (c=cfirst;; c++, ub++) {
+            if ((unsigned)(*c-'0')>9) break; // quit if not 0-9
+            if (c-cfirst==DECPMAX-1) break;  // too many digits
+            *ub=(uByte)(*c-'0');        // good bcd8
+            }
+          if (*c!='\0') break;          // not all digits, or too many
+          num.lsd=ub-1;                 // record new LSD
+          }
+        } // NaN or sNaN
+      error=0;                          // syntax is OK
+      } // digits=0 (special expected)
+    break;                              // drop out
+    }                                   // [for(;;) once-loop]
+
+  // decShowNum(&num, "fromStr");
+
+  if (error!=0) {
+    set->status|=error;
+    num.exponent=DECFLOAT_qNaN;         // set up quiet NaN
+    num.sign=0;                         // .. with 0 sign
+    buffer[0]=0;                        // .. and coefficient
+    num.lsd=buffer;                     // ..
+    // decShowNum(&num, "oops");
+    }
+
+  // decShowNum(&num, "dffs");
+  decFinalize(result, &num, set);       // round, check, and lay out
+  // decFloatShow(result, "fromString");
+  return result;
+  } // decFloatFromString
+
+/* ------------------------------------------------------------------ */
+/* decFloatFromWider -- conversion from next-wider format             */
+/*                                                                    */
+/*  result  is the decFloat format number which gets the result of    */
+/*          the conversion                                            */
+/*  wider   is the decFloatWider format number which will be narrowed */
+/*  set     is the context                                            */
+/*  returns result                                                    */
+/*                                                                    */
+/* Narrowing can cause rounding, overflow, etc., but not Invalid      */
+/* operation (sNaNs are copied and do not signal).                    */
+/* ------------------------------------------------------------------ */
+// narrow-to is not possible for decQuad format numbers; simply omit
+#if !QUAD
+decFloat * decFloatFromWider(decFloat *result, const decFloatWider *wider,
+                             decContext *set) {
+  bcdnum num;                           // collects data for finishing
+  uByte  bcdar[DECWPMAX];               // room for wider coefficient
+  uInt   widerhi=DFWWORD(wider, 0);     // top word
+  Int    exp;
+
+  GETWCOEFF(wider, bcdar);
+
+  num.msd=bcdar;                        // MSD is here always
+  num.lsd=bcdar+DECWPMAX-1;             // LSD is here always
+  num.sign=widerhi&0x80000000;          // extract sign [DECFLOAT_Sign=Neg]
+
+  // decode the wider combination field to exponent
+  exp=DECCOMBWEXP[widerhi>>26];         // decode from wider combination field
+  // if it is a special there's nothing to do unless sNaN; if it's
+  // finite then add the (wider) exponent continuation and unbias
+  if (EXPISSPECIAL(exp)) exp=widerhi&0x7e000000; // include sNaN selector
+   else exp+=GETWECON(wider)-DECWBIAS;
+  num.exponent=exp;
+
+  // decShowNum(&num, "dffw");
+  return decFinalize(result, &num, set);// round, check, and lay out
+  } // decFloatFromWider
+#endif
+
+/* ------------------------------------------------------------------ */
+/* decFloatGetCoefficient -- get coefficient as BCD8                  */
+/*                                                                    */
+/*  df is the decFloat from which to extract the coefficient          */
+/*  bcdar is where DECPMAX bytes will be written, one BCD digit in    */
+/*    each byte (BCD8 encoding); if df is a NaN the first byte will   */
+/*    be zero, and if it is infinite they will all be zero            */
+/*  returns the sign of the coefficient (DECFLOAT_Sign if negative,   */
+/*    0 otherwise)                                                    */
+/*                                                                    */
+/* No error is possible, and no status will be set.  If df is a       */
+/* special value the array is set to zeros (for Infinity) or to the   */
+/* payload of a qNaN or sNaN.                                         */
+/* ------------------------------------------------------------------ */
+Int decFloatGetCoefficient(const decFloat *df, uByte *bcdar) {
+  if (DFISINF(df)) memset(bcdar, 0, DECPMAX);
+   else {
+    GETCOEFF(df, bcdar);           // use macro
+    if (DFISNAN(df)) bcdar[0]=0;   // MSD needs correcting
+    }
+  return GETSIGN(df);
+  } // decFloatGetCoefficient
+
+/* ------------------------------------------------------------------ */
+/* decFloatGetExponent -- get unbiased exponent                       */
+/*                                                                    */
+/*  df is the decFloat from which to extract the exponent             */
+/*  returns the exponent, q.                                          */
+/*                                                                    */
+/* No error is possible, and no status will be set.  If df is a       */
+/* special value the first seven bits of the decFloat are returned,   */
+/* left adjusted and with the first (sign) bit set to 0 (followed by  */
+/* 25 0 bits).  e.g., -sNaN would return 0x7e000000 (DECFLOAT_sNaN).  */
+/* ------------------------------------------------------------------ */
+Int decFloatGetExponent(const decFloat *df) {
+  if (DFISSPECIAL(df)) return DFWORD(df, 0)&0x7e000000;
+  return GETEXPUN(df);
+  } // decFloatGetExponent
+
+/* ------------------------------------------------------------------ */
+/* decFloatSetCoefficient -- set coefficient from BCD8                */
+/*                                                                    */
+/*  df is the target decFloat (and source of exponent/special value)  */
+/*  bcdar holds DECPMAX digits to set the coefficient from, one       */
+/*    digit in each byte (BCD8 encoding); the first (MSD) is ignored  */
+/*    if df is a NaN; all are ignored if df is infinite.              */
+/*  sig is DECFLOAT_Sign to set the sign bit, 0 otherwise             */
+/*  returns df, which will be canonical                               */
+/*                                                                    */
+/* No error is possible, and no status will be set.                   */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatSetCoefficient(decFloat *df, const uByte *bcdar,
+                                  Int sig) {
+  uInt exp;                        // for exponent
+  uByte bcdzero[DECPMAX];          // for infinities
+
+  // Exponent/special code is extracted from df
+  if (DFISSPECIAL(df)) {
+    exp=DFWORD(df, 0)&0x7e000000;
+    if (DFISINF(df)) {
+      memset(bcdzero, 0, DECPMAX);
+      return decFloatFromBCD(df, exp, bcdzero, sig);
+      }
+    }
+   else exp=GETEXPUN(df);
+  return decFloatFromBCD(df, exp, bcdar, sig);
+  } // decFloatSetCoefficient
+
+/* ------------------------------------------------------------------ */
+/* decFloatSetExponent -- set exponent or special value               */
+/*                                                                    */
+/*  df  is the target decFloat (and source of coefficient/payload)    */
+/*  set is the context for reporting status                           */
+/*  exp is the unbiased exponent, q, or a special value in the form   */
+/*    returned by decFloatGetExponent                                 */
+/*  returns df, which will be canonical                               */
+/*                                                                    */
+/* No error is possible, but Overflow or Underflow might occur.       */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatSetExponent(decFloat *df, decContext *set, Int exp) {
+  uByte  bcdcopy[DECPMAX];         // for coefficient
+  bcdnum num;                      // work
+  num.exponent=exp;
+  num.sign=decFloatGetCoefficient(df, bcdcopy); // extract coefficient
+  if (DFISSPECIAL(df)) {           // MSD or more needs correcting
+    if (DFISINF(df)) memset(bcdcopy, 0, DECPMAX);
+    bcdcopy[0]=0;
+    }
+  num.msd=bcdcopy;
+  num.lsd=bcdcopy+DECPMAX-1;
+  return decFinalize(df, &num, set);
+  } // decFloatSetExponent
+
+/* ------------------------------------------------------------------ */
+/* decFloatRadix -- returns the base (10)                             */
+/*                                                                    */
+/*   df is any decFloat of this format                                */
+/* ------------------------------------------------------------------ */
+uInt decFloatRadix(const decFloat *df) {
+  if (df) return 10;                         // to placate compiler
+  return 10;
+  } // decFloatRadix
+
+/* The following function is not available if DECPRINT=0              */
+#if DECPRINT
+/* ------------------------------------------------------------------ */
+/* decFloatShow -- printf a decFloat in hexadecimal and decimal       */
+/*   df  is the decFloat to show                                      */
+/*   tag is a tag string displayed with the number                    */
+/*                                                                    */
+/* This is a debug aid; the precise format of the string may change.  */
+/* ------------------------------------------------------------------ */
+void decFloatShow(const decFloat *df, const char *tag) {
+  char hexbuf[DECBYTES*2+DECBYTES/4+1]; // NB blank after every fourth
+  char buff[DECSTRING];                 // for value in decimal
+  Int i, j=0;
+
+  for (i=0; i<DECBYTES; i++) {
+    #if DECLITEND
+      sprintf(&hexbuf[j], "%02x", df->bytes[DECBYTES-1-i]);
+    #else
+      sprintf(&hexbuf[j], "%02x", df->bytes[i]);
+    #endif
+    j+=2;
+    // the next line adds blank (and terminator) after final pair, too
+    if ((i+1)%4==0) {strcpy(&hexbuf[j], " "); j++;}
+    }
+  decFloatToString(df, buff);
+  printf(">%s> %s [big-endian]  %s\n", tag, hexbuf, buff);
+  return;
+  } // decFloatShow
+#endif
+
+/* ------------------------------------------------------------------ */
+/* decFloatToBCD -- get sign, exponent, and BCD8 from a decFloat      */
+/*                                                                    */
+/*  df is the source decFloat                                         */
+/*  exp will be set to the unbiased exponent, q, or to a special      */
+/*    value in the form returned by decFloatGetExponent               */
+/*  bcdar is where DECPMAX bytes will be written, one BCD digit in    */
+/*    each byte (BCD8 encoding); if df is a NaN the first byte will   */
+/*    be zero, and if it is infinite they will all be zero            */
+/*  returns the sign of the coefficient (DECFLOAT_Sign if negative,   */
+/*    0 otherwise)                                                    */
+/*                                                                    */
+/* No error is possible, and no status will be set.                   */
+/* ------------------------------------------------------------------ */
+Int decFloatToBCD(const decFloat *df, Int *exp, uByte *bcdar) {
+  if (DFISINF(df)) {
+    memset(bcdar, 0, DECPMAX);
+    *exp=DFWORD(df, 0)&0x7e000000;
+    }
+   else {
+    GETCOEFF(df, bcdar);           // use macro
+    if (DFISNAN(df)) {
+      bcdar[0]=0;                  // MSD needs correcting
+      *exp=DFWORD(df, 0)&0x7e000000;
+      }
+     else {                        // finite
+      *exp=GETEXPUN(df);
+      }
+    }
+  return GETSIGN(df);
+  } // decFloatToBCD
+
+/* ------------------------------------------------------------------ */
+/* decFloatToEngString -- conversion to numeric string, engineering   */
+/*                                                                    */
+/*  df is the decFloat format number to convert                       */
+/*  string is the string where the result will be laid out            */
+/*                                                                    */
+/* string must be at least DECPMAX+9 characters (the worst case is    */
+/* "-0.00000nnn...nnn\0", which is as long as the exponent form when  */
+/* DECEMAXD<=4); this condition is asserted above                     */
+/*                                                                    */
+/* No error is possible, and no status will be set                    */
+/* ------------------------------------------------------------------ */
+char * decFloatToEngString(const decFloat *df, char *string){
+  uInt msd;                        // coefficient MSD
+  Int  exp;                        // exponent top two bits or full
+  uInt comb;                       // combination field
+  char *cstart;                    // coefficient start
+  char *c;                         // output pointer in string
+  char *s, *t;                     // .. (source, target)
+  Int  pre, e;                     // work
+  const uByte *u;                  // ..
+  uInt  uiwork;                    // for macros [one compiler needs
+                                   // volatile here to avoid bug, but
+                                   // that doubles execution time]
+
+  // Source words; macro handles endianness
+  uInt sourhi=DFWORD(df, 0);       // word with sign
+  #if DECPMAX==16
+  uInt sourlo=DFWORD(df, 1);
+  #elif DECPMAX==34
+  uInt sourmh=DFWORD(df, 1);
+  uInt sourml=DFWORD(df, 2);
+  uInt sourlo=DFWORD(df, 3);
+  #endif
+
+  c=string;                        // where result will go
+  if (((Int)sourhi)<0) *c++='-';   // handle sign
+  comb=sourhi>>26;                 // sign+combination field
+  msd=DECCOMBMSD[comb];            // decode the combination field
+  exp=DECCOMBEXP[comb];            // ..
+
+  if (EXPISSPECIAL(exp)) {         // special
+    if (exp==DECFLOAT_Inf) {       // infinity
+      strcpy(c,   "Inf");
+      strcpy(c+3, "inity");
+      return string;               // easy
+      }
+    if (sourhi&0x02000000) *c++='s'; // sNaN
+    strcpy(c, "NaN");              // complete word
+    c+=3;                          // step past
+    // quick exit if the payload is zero
+    #if DECPMAX==7
+    if ((sourhi&0x000fffff)==0) return string;
+    #elif DECPMAX==16
+    if (sourlo==0 && (sourhi&0x0003ffff)==0) return string;
+    #elif DECPMAX==34
+    if (sourlo==0 && sourml==0 && sourmh==0
+     && (sourhi&0x00003fff)==0) return string;
+    #endif
+    // otherwise drop through to add integer; set correct exp etc.
+    exp=0; msd=0;                  // setup for following code
+    }
+   else { // complete exponent; top two bits are in place
+    exp+=GETECON(df)-DECBIAS;      // .. + continuation and unbias
+    }
+
+  /* convert the digits of the significand to characters */
+  cstart=c;                        // save start of coefficient
+  if (msd) *c++=(char)('0'+(char)msd);  // non-zero most significant digit
+
+  // Decode the declets.  After extracting each declet, it is
+  // decoded to a 4-uByte sequence by table lookup; the four uBytes
+  // are the three encoded BCD8 digits followed by a 1-byte length
+  // (significant digits, except that 000 has length 0).  This allows
+  // us to left-align the first declet with non-zero content, then
+  // the remaining ones are full 3-char length.  Fixed-length copies
+  // are used because variable-length memcpy causes a subroutine call
+  // in at least two compilers.  (The copies are length 4 for speed
+  // and are safe because the last item in the array is of length
+  // three and has the length byte following.)
+  #define dpd2char(dpdin) u=&DPD2BCD8[((dpdin)&0x3ff)*4];        \
+         if (c!=cstart) {UBFROMUI(c, UBTOUI(u)|CHARMASK); c+=3;} \
+          else if (*(u+3)) {                                     \
+           UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); c+=*(u+3);}
+
+  #if DECPMAX==7
+  dpd2char(sourhi>>10);                 // declet 1
+  dpd2char(sourhi);                     // declet 2
+
+  #elif DECPMAX==16
+  dpd2char(sourhi>>8);                  // declet 1
+  dpd2char((sourhi<<2) | (sourlo>>30)); // declet 2
+  dpd2char(sourlo>>20);                 // declet 3
+  dpd2char(sourlo>>10);                 // declet 4
+  dpd2char(sourlo);                     // declet 5
+
+  #elif DECPMAX==34
+  dpd2char(sourhi>>4);                  // declet 1
+  dpd2char((sourhi<<6) | (sourmh>>26)); // declet 2
+  dpd2char(sourmh>>16);                 // declet 3
+  dpd2char(sourmh>>6);                  // declet 4
+  dpd2char((sourmh<<4) | (sourml>>28)); // declet 5
+  dpd2char(sourml>>18);                 // declet 6
+  dpd2char(sourml>>8);                  // declet 7
+  dpd2char((sourml<<2) | (sourlo>>30)); // declet 8
+  dpd2char(sourlo>>20);                 // declet 9
+  dpd2char(sourlo>>10);                 // declet 10
+  dpd2char(sourlo);                     // declet 11
+  #endif
+
+  if (c==cstart) *c++='0';         // all zeros, empty -- make "0"
+
+  if (exp==0) {                    // integer or NaN case -- easy
+    *c='\0';                       // terminate
+    return string;
+    }
+  /* non-0 exponent */
+
+  e=0;                             // assume no E
+  pre=(Int)(c-cstart)+exp;         // length+exp  [c->LSD+1]
+  // [here, pre-exp is the digits count (==1 for zero)]
+
+  if (exp>0 || pre<-5) {           // need exponential form
+    e=pre-1;                       // calculate E value
+    pre=1;                         // assume one digit before '.'
+    if (e!=0) {                    // engineering: may need to adjust
+      Int adj;                     // adjustment
+      // The C remainder operator is undefined for negative numbers, so
+      // a positive remainder calculation must be used here
+      if (e<0) {
+        adj=(-e)%3;
+        if (adj!=0) adj=3-adj;
+        }
+       else { // e>0
+        adj=e%3;
+        }
+      e=e-adj;
+      // if dealing with zero still produce an exponent which is a
+      // multiple of three, as expected, but there will only be the
+      // one zero before the E, still.  Otherwise note the padding.
+      if (!DFISZERO(df)) pre+=adj;
+       else {  // is zero
+        if (adj!=0) {              // 0.00Esnn needed
+          e=e+3;
+          pre=-(2-adj);
+          }
+        } // zero
+      } // engineering adjustment
+    } // exponential form
+  // printf("e=%ld pre=%ld exp=%ld\n", (LI)e, (LI)pre, (LI)exp);
+
+  /* modify the coefficient, adding 0s, '.', and E+nn as needed */
+  if (pre>0) {                     // ddd.ddd (plain), perhaps with E
+                                   // or dd00 padding for engineering
+    char *dotat=cstart+pre;
+    if (dotat<c) {                      // if embedded dot needed...
+      // move by fours; there must be space for junk at the end
+      // because there is still space for exponent
+      s=dotat+ROUNDDOWN4(c-dotat);      // source
+      t=s+1;                            // target
+      // open the gap [cannot use memcpy]
+      for (; s>=dotat; s-=4, t-=4) UBFROMUI(t, UBTOUI(s));
+      *dotat='.';
+      c++;                              // length increased by one
+      } // need dot?
+     else for (; c<dotat; c++) *c='0';  // pad for engineering
+    } // pre>0
+   else {
+    /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (may have
+       E, but only for 0.00E+3 kind of case -- with plenty of spare
+       space in this case */
+    pre=-pre+2;                         // gap width, including "0."
+    t=cstart+ROUNDDOWN4(c-cstart)+pre;  // preferred first target point
+    // backoff if too far to the right
+    if (t>string+DECSTRING-5) t=string+DECSTRING-5; // adjust to fit
+    // now shift the entire coefficient to the right, being careful not
+    // to access to the left of string [cannot use memcpy]
+    for (s=t-pre; s>=string; s-=4, t-=4) UBFROMUI(t, UBTOUI(s));
+    // for Quads and Singles there may be a character or two left...
+    s+=3;                               // where next would come from
+    for(; s>=cstart; s--, t--) *(t+3)=*(s);
+    // now have fill 0. through 0.00000; use overlaps to avoid tests
+    if (pre>=4) {
+      memcpy(cstart+pre-4, "0000", 4);
+      memcpy(cstart, "0.00", 4);
+      }
+     else { // 2 or 3
+      *(cstart+pre-1)='0';
+      memcpy(cstart, "0.", 2);
+      }
+    c+=pre;                             // to end
+    }
+
+  // finally add the E-part, if needed; it will never be 0, and has
+  // a maximum length of 3 or 4 digits (asserted above)
+  if (e!=0) {
+    memcpy(c, "E+", 2);                 // starts with E, assume +
+    c++;
+    if (e<0) {
+      *c='-';                           // oops, need '-'
+      e=-e;                             // uInt, please
+      }
+    c++;
+    // Three-character exponents are easy; 4-character a little trickier
+    #if DECEMAXD<=3
+      u=&BIN2BCD8[e*4];                 // -> 3 digits + length byte
+      // copy fixed 4 characters [is safe], starting at non-zero
+      // and with character mask to convert BCD to char
+      UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK);
+      c+=*(u+3);                        // bump pointer appropriately
+    #elif DECEMAXD==4
+      if (e<1000) {                     // 3 (or fewer) digits case
+        u=&BIN2BCD8[e*4];               // -> 3 digits + length byte
+        UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); // [as above]
+        c+=*(u+3);                      // bump pointer appropriately
+        }
+       else {                           // 4-digits
+        Int thou=((e>>3)*1049)>>17;     // e/1000
+        Int rem=e-(1000*thou);          // e%1000
+        *c++=(char)('0'+(char)thou);    // the thousands digit
+        u=&BIN2BCD8[rem*4];             // -> 3 digits + length byte
+        UBFROMUI(c, UBTOUI(u)|CHARMASK);// copy fixed 3+1 characters [is safe]
+        c+=3;                           // bump pointer, always 3 digits
+        }
+    #endif
+    }
+  *c='\0';                              // terminate
+  //printf("res %s\n", string);
+  return string;
+  } // decFloatToEngString
+
+/* ------------------------------------------------------------------ */
+/* decFloatToPacked -- convert decFloat to Packed decimal + exponent  */
+/*                                                                    */
+/*  df is the source decFloat                                         */
+/*  exp will be set to the unbiased exponent, q, or to a special      */
+/*    value in the form returned by decFloatGetExponent               */
+/*  packed is where DECPMAX nibbles will be written with the sign as  */
+/*    final nibble (0x0c for +, 0x0d for -); a NaN has a first nibble */
+/*    of zero, and an infinity is all zeros. decDouble and decQuad    */
+/*    have a additional leading zero nibble, leading to result        */
+/*    lengths of 4, 9, and 18 bytes.                                  */
+/*  returns the sign of the coefficient (DECFLOAT_Sign if negative,   */
+/*    0 otherwise)                                                    */
+/*                                                                    */
+/* No error is possible, and no status will be set.                   */
+/* ------------------------------------------------------------------ */
+Int decFloatToPacked(const decFloat *df, Int *exp, uByte *packed) {
+  uByte bcdar[DECPMAX+2];          // work buffer
+  uByte *ip=bcdar, *op=packed;     // work pointers
+  if (DFISINF(df)) {
+    memset(bcdar, 0, DECPMAX+2);
+    *exp=DECFLOAT_Inf;
+    }
+   else {
+    GETCOEFF(df, bcdar+1);         // use macro
+    if (DFISNAN(df)) {
+      bcdar[1]=0;                  // MSD needs clearing
+      *exp=DFWORD(df, 0)&0x7e000000;
+      }
+     else {                        // finite
+      *exp=GETEXPUN(df);
+      }
+    }
+  // now pack; coefficient currently at bcdar+1
+  #if SINGLE
+    ip++;                          // ignore first byte
+  #else
+    *ip=0;                         // need leading zero
+  #endif
+  // set final byte to Packed BCD sign value
+  bcdar[DECPMAX+1]=(DFISSIGNED(df) ? DECPMINUS : DECPPLUS);
+  // pack an even number of bytes...
+  for (; op<packed+((DECPMAX+2)/2); op++, ip+=2) {
+    *op=(uByte)((*ip<<4)+*(ip+1));
+    }
+  return (bcdar[DECPMAX+1]==DECPMINUS ? DECFLOAT_Sign : 0);
+  } // decFloatToPacked
+
+/* ------------------------------------------------------------------ */
+/* decFloatToString -- conversion to numeric string                   */
+/*                                                                    */
+/*  df is the decFloat format number to convert                       */
+/*  string is the string where the result will be laid out            */
+/*                                                                    */
+/* string must be at least DECPMAX+9 characters (the worst case is    */
+/* "-0.00000nnn...nnn\0", which is as long as the exponent form when  */
+/* DECEMAXD<=4); this condition is asserted above                     */
+/*                                                                    */
+/* No error is possible, and no status will be set                    */
+/* ------------------------------------------------------------------ */
+char * decFloatToString(const decFloat *df, char *string){
+  uInt msd;                        // coefficient MSD
+  Int  exp;                        // exponent top two bits or full
+  uInt comb;                       // combination field
+  char *cstart;                    // coefficient start
+  char *c;                         // output pointer in string
+  char *s, *t;                     // .. (source, target)
+  Int  pre, e;                     // work
+  const uByte *u;                  // ..
+  uInt  uiwork;                    // for macros [one compiler needs
+                                   // volatile here to avoid bug, but
+                                   // that doubles execution time]
+
+  // Source words; macro handles endianness
+  uInt sourhi=DFWORD(df, 0);       // word with sign
+  #if DECPMAX==16
+  uInt sourlo=DFWORD(df, 1);
+  #elif DECPMAX==34
+  uInt sourmh=DFWORD(df, 1);
+  uInt sourml=DFWORD(df, 2);
+  uInt sourlo=DFWORD(df, 3);
+  #endif
+
+  c=string;                        // where result will go
+  if (((Int)sourhi)<0) *c++='-';   // handle sign
+  comb=sourhi>>26;                 // sign+combination field
+  msd=DECCOMBMSD[comb];            // decode the combination field
+  exp=DECCOMBEXP[comb];            // ..
+
+  if (!EXPISSPECIAL(exp)) {        // finite
+    // complete exponent; top two bits are in place
+    exp+=GETECON(df)-DECBIAS;      // .. + continuation and unbias
+    }
+   else {                          // IS special
+    if (exp==DECFLOAT_Inf) {       // infinity
+      strcpy(c, "Infinity");
+      return string;               // easy
+      }
+    if (sourhi&0x02000000) *c++='s'; // sNaN
+    strcpy(c, "NaN");              // complete word
+    c+=3;                          // step past
+    // quick exit if the payload is zero
+    #if DECPMAX==7
+    if ((sourhi&0x000fffff)==0) return string;
+    #elif DECPMAX==16
+    if (sourlo==0 && (sourhi&0x0003ffff)==0) return string;
+    #elif DECPMAX==34
+    if (sourlo==0 && sourml==0 && sourmh==0
+     && (sourhi&0x00003fff)==0) return string;
+    #endif
+    // otherwise drop through to add integer; set correct exp etc.
+    exp=0; msd=0;                  // setup for following code
+    }
+
+  /* convert the digits of the significand to characters */
+  cstart=c;                        // save start of coefficient
+  if (msd) *c++=(char)('0'+(char)msd);  // non-zero most significant digit
+
+  // Decode the declets.  After extracting each declet, it is
+  // decoded to a 4-uByte sequence by table lookup; the four uBytes
+  // are the three encoded BCD8 digits followed by a 1-byte length
+  // (significant digits, except that 000 has length 0).  This allows
+  // us to left-align the first declet with non-zero content, then
+  // the remaining ones are full 3-char length.  Fixed-length copies
+  // are used because variable-length memcpy causes a subroutine call
+  // in at least two compilers.  (The copies are length 4 for speed
+  // and are safe because the last item in the array is of length
+  // three and has the length byte following.)
+  #define dpd2char(dpdin) u=&DPD2BCD8[((dpdin)&0x3ff)*4];        \
+         if (c!=cstart) {UBFROMUI(c, UBTOUI(u)|CHARMASK); c+=3;} \
+          else if (*(u+3)) {                                     \
+           UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); c+=*(u+3);}
+
+  #if DECPMAX==7
+  dpd2char(sourhi>>10);                 // declet 1
+  dpd2char(sourhi);                     // declet 2
+
+  #elif DECPMAX==16
+  dpd2char(sourhi>>8);                  // declet 1
+  dpd2char((sourhi<<2) | (sourlo>>30)); // declet 2
+  dpd2char(sourlo>>20);                 // declet 3
+  dpd2char(sourlo>>10);                 // declet 4
+  dpd2char(sourlo);                     // declet 5
+
+  #elif DECPMAX==34
+  dpd2char(sourhi>>4);                  // declet 1
+  dpd2char((sourhi<<6) | (sourmh>>26)); // declet 2
+  dpd2char(sourmh>>16);                 // declet 3
+  dpd2char(sourmh>>6);                  // declet 4
+  dpd2char((sourmh<<4) | (sourml>>28)); // declet 5
+  dpd2char(sourml>>18);                 // declet 6
+  dpd2char(sourml>>8);                  // declet 7
+  dpd2char((sourml<<2) | (sourlo>>30)); // declet 8
+  dpd2char(sourlo>>20);                 // declet 9
+  dpd2char(sourlo>>10);                 // declet 10
+  dpd2char(sourlo);                     // declet 11
+  #endif
+
+  if (c==cstart) *c++='0';         // all zeros, empty -- make "0"
+
+  //[This fast path is valid but adds 3-5 cycles to worst case length]
+  //if (exp==0) {                  // integer or NaN case -- easy
+  //  *c='\0';                     // terminate
+  //  return string;
+  //  }
+
+  e=0;                             // assume no E
+  pre=(Int)(c-cstart)+exp;         // length+exp  [c->LSD+1]
+  // [here, pre-exp is the digits count (==1 for zero)]
+
+  if (exp>0 || pre<-5) {           // need exponential form
+    e=pre-1;                       // calculate E value
+    pre=1;                         // assume one digit before '.'
+    } // exponential form
+
+  /* modify the coefficient, adding 0s, '.', and E+nn as needed */
+  if (pre>0) {                     // ddd.ddd (plain), perhaps with E
+    char *dotat=cstart+pre;
+    if (dotat<c) {                      // if embedded dot needed...
+      // [memmove is a disaster, here]
+      // move by fours; there must be space for junk at the end
+      // because exponent is still possible
+      s=dotat+ROUNDDOWN4(c-dotat);      // source
+      t=s+1;                            // target
+      // open the gap [cannot use memcpy]
+      for (; s>=dotat; s-=4, t-=4) UBFROMUI(t, UBTOUI(s));
+      *dotat='.';
+      c++;                              // length increased by one
+      } // need dot?
+
+    // finally add the E-part, if needed; it will never be 0, and has
+    // a maximum length of 3 or 4 digits (asserted above)
+    if (e!=0) {
+      memcpy(c, "E+", 2);               // starts with E, assume +
+      c++;
+      if (e<0) {
+        *c='-';                         // oops, need '-'
+        e=-e;                           // uInt, please
+        }
+      c++;
+      // Three-character exponents are easy; 4-character a little trickier
+      #if DECEMAXD<=3
+        u=&BIN2BCD8[e*4];               // -> 3 digits + length byte
+        // copy fixed 4 characters [is safe], starting at non-zero
+        // and with character mask to convert BCD to char
+        UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK);
+        c+=*(u+3);                      // bump pointer appropriately
+      #elif DECEMAXD==4
+        if (e<1000) {                   // 3 (or fewer) digits case
+          u=&BIN2BCD8[e*4];             // -> 3 digits + length byte
+          UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); // [as above]
+          c+=*(u+3);                    // bump pointer appropriately
+          }
+         else {                         // 4-digits
+          Int thou=((e>>3)*1049)>>17;   // e/1000
+          Int rem=e-(1000*thou);        // e%1000
+          *c++=(char)('0'+(char)thou);  // the thousands digit
+          u=&BIN2BCD8[rem*4];           // -> 3 digits + length byte
+          UBFROMUI(c, UBTOUI(u)|CHARMASK); // copy fixed 3+1 characters [is safe]
+          c+=3;                         // bump pointer, always 3 digits
+          }
+      #endif
+      }
+    *c='\0';                            // add terminator
+    //printf("res %s\n", string);
+    return string;
+    } // pre>0
+
+  /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
+  // Surprisingly, this is close to being the worst-case path, so the
+  // shift is done by fours; this is a little tricky because the
+  // rightmost character to be written must not be beyond where the
+  // rightmost terminator could be -- so backoff to not touch
+  // terminator position if need be (this can make exact alignments
+  // for full Doubles, but in some cases needs care not to access too
+  // far to the left)
+
+  pre=-pre+2;                           // gap width, including "0."
+  t=cstart+ROUNDDOWN4(c-cstart)+pre;    // preferred first target point
+  // backoff if too far to the right
+  if (t>string+DECSTRING-5) t=string+DECSTRING-5; // adjust to fit
+  // now shift the entire coefficient to the right, being careful not
+  // to access to the left of string [cannot use memcpy]
+  for (s=t-pre; s>=string; s-=4, t-=4) UBFROMUI(t, UBTOUI(s));
+  // for Quads and Singles there may be a character or two left...
+  s+=3;                                 // where next would come from
+  for(; s>=cstart; s--, t--) *(t+3)=*(s);
+  // now have fill 0. through 0.00000; use overlaps to avoid tests
+  if (pre>=4) {
+    memcpy(cstart+pre-4, "0000", 4);
+    memcpy(cstart, "0.00", 4);
+    }
+   else { // 2 or 3
+    *(cstart+pre-1)='0';
+    memcpy(cstart, "0.", 2);
+    }
+  *(c+pre)='\0';                        // terminate
+  return string;
+  } // decFloatToString
+
+/* ------------------------------------------------------------------ */
+/* decFloatToWider -- conversion to next-wider format                 */
+/*                                                                    */
+/*  source  is the decFloat format number which gets the result of    */
+/*          the conversion                                            */
+/*  wider   is the decFloatWider format number which will be narrowed */
+/*  returns wider                                                     */
+/*                                                                    */
+/* Widening is always exact; no status is set (sNaNs are copied and   */
+/* do not signal).  The result will be canonical if the source is,    */
+/* and may or may not be if the source is not.                        */
+/* ------------------------------------------------------------------ */
+// widening is not possible for decQuad format numbers; simply omit
+#if !QUAD
+decFloatWider * decFloatToWider(const decFloat *source, decFloatWider *wider) {
+  uInt msd;
+
+  /* Construct and copy the sign word */
+  if (DFISSPECIAL(source)) {
+    // copy sign, combination, and first bit of exponent (sNaN selector)
+    DFWWORD(wider, 0)=DFWORD(source, 0)&0xfe000000;
+    msd=0;
+    }
+   else { // is finite number
+    uInt exp=GETEXPUN(source)+DECWBIAS; // get unbiased exponent and rebias
+    uInt code=(exp>>DECWECONL)<<29;     // set two bits of exp [msd=0]
+    code|=(exp<<(32-6-DECWECONL)) & 0x03ffffff; // add exponent continuation
+    code|=DFWORD(source, 0)&0x80000000; // add sign
+    DFWWORD(wider, 0)=code;             // .. and place top word in wider
+    msd=GETMSD(source);                 // get source coefficient MSD [0-9]
+    }
+  /* Copy the coefficient and clear any 'unused' words to left */
+  #if SINGLE
+    DFWWORD(wider, 1)=(DFWORD(source, 0)&0x000fffff)|(msd<<20);
+  #elif DOUBLE
+    DFWWORD(wider, 2)=(DFWORD(source, 0)&0x0003ffff)|(msd<<18);
+    DFWWORD(wider, 3)=DFWORD(source, 1);
+    DFWWORD(wider, 1)=0;
+  #endif
+  return wider;
+  } // decFloatToWider
+#endif
+
+/* ------------------------------------------------------------------ */
+/* decFloatVersion -- return package version string                   */
+/*                                                                    */
+/*  returns a constant string describing this package                 */
+/* ------------------------------------------------------------------ */
+const char *decFloatVersion(void) {
+  return DECVERSION;
+  } // decFloatVersion
+
+/* ------------------------------------------------------------------ */
+/* decFloatZero -- set to canonical (integer) zero                    */
+/*                                                                    */
+/*  df is the decFloat format number to integer +0 (q=0, c=+0)        */
+/*  returns df                                                        */
+/*                                                                    */
+/* No error is possible, and no status can be set.                    */
+/* ------------------------------------------------------------------ */
+decFloat * decFloatZero(decFloat *df){
+  DFWORD(df, 0)=ZEROWORD;     // set appropriate top word
+  #if DOUBLE || QUAD
+    DFWORD(df, 1)=0;
+    #if QUAD
+      DFWORD(df, 2)=0;
+      DFWORD(df, 3)=0;
+    #endif
+  #endif
+  // decFloatShow(df, "zero");
+  return df;
+  } // decFloatZero
+
+/* ------------------------------------------------------------------ */
+/* Private generic function (not format-specific) for development use */
+/* ------------------------------------------------------------------ */
+// This is included once only, for all to use
+#if QUAD && (DECCHECK || DECTRACE)
+  /* ---------------------------------------------------------------- */
+  /* decShowNum -- display bcd8 number in debug form                  */
+  /*                                                                  */
+  /*   num is the bcdnum to display                                   */
+  /*   tag is a string to label the display                           */
+  /* ---------------------------------------------------------------- */
+  void decShowNum(const bcdnum *num, const char *tag) {
+    const char *csign="+";              // sign character
+    uByte *ub;                          // work
+    uInt  uiwork;                       // for macros
+    if (num->sign==DECFLOAT_Sign) csign="-";
+
+    printf(">%s> ", tag);
+    if (num->exponent==DECFLOAT_Inf) printf("%sInfinity", csign);
+    else if (num->exponent==DECFLOAT_qNaN) printf("%sqNaN", csign);
+    else if (num->exponent==DECFLOAT_sNaN) printf("%ssNaN", csign);
+    else {                              // finite
+     char qbuf[10];                     // for right-aligned q
+     char *c;                           // work
+     const uByte *u;                    // ..
+     Int e=num->exponent;               // .. exponent
+     strcpy(qbuf, "q=");
+     c=&qbuf[2];                        // where exponent will go
+     // lay out the exponent
+     if (e<0) {
+       *c++='-';                        // add '-'
+       e=-e;                            // uInt, please
+       }
+     #if DECEMAXD>4
+       #error Exponent form is too long for ShowNum to lay out
+     #endif
+     if (e==0) *c++='0';                // 0-length case
+      else if (e<1000) {                // 3 (or fewer) digits case
+       u=&BIN2BCD8[e*4];                // -> 3 digits + length byte
+       UBFROMUI(c, UBTOUI(u+3-*(u+3))|CHARMASK); // [as above]
+       c+=*(u+3);                       // bump pointer appropriately
+       }
+      else {                            // 4-digits
+       Int thou=((e>>3)*1049)>>17;      // e/1000
+       Int rem=e-(1000*thou);           // e%1000
+       *c++=(char)('0'+(char)thou);     // the thousands digit
+       u=&BIN2BCD8[rem*4];              // -> 3 digits + length byte
+       UBFROMUI(c, UBTOUI(u)|CHARMASK); // copy fixed 3+1 characters [is safe]
+       c+=3;                            // bump pointer, always 3 digits
+       }
+     *c='\0';                           // add terminator
+     printf("%7s c=%s", qbuf, csign);
+     }
+
+    if (!EXPISSPECIAL(num->exponent) || num->msd!=num->lsd || *num->lsd!=0) {
+      for (ub=num->msd; ub<=num->lsd; ub++) { // coefficient...
+        printf("%1x", *ub);
+        if ((num->lsd-ub)%3==0 && ub!=num->lsd) printf(" "); // 4-space
+        }
+      }
+    printf("\n");
+    } // decShowNum
+#endif
+
+#endif /* !defined(DECCOMMON) */
diff --git a/decNumber/decContext.c b/decNumber/decContext.c
index 408e3e65..9f997593 100644
--- a/decNumber/decContext.c
+++ b/decNumber/decContext.c
@@ -1,191 +1,437 @@
-/* ------------------------------------------------------------------ */
-/* Decimal Context module                                             */
-/* ------------------------------------------------------------------ */
-/* Copyright (c) IBM Corporation, 2000, 2005.  All rights reserved.   */
-/*                                                                    */
-/* This software is made available under the terms of the             */
-/* ICU License -- ICU 1.8.1 and later.                                */
-/*                                                                    */
-/* The description and User's Guide ("The decNumber C Library") for   */
-/* this software is called decNumber.pdf.  This document is           */
-/* available, together with arithmetic and format specifications,     */
-/* testcases, and Web links, at: http://www2.hursley.ibm.com/decimal  */
-/*                                                                    */
-/* Please send comments, suggestions, and corrections to the author:  */
-/*   mfc@uk.ibm.com                                                   */
-/*   Mike Cowlishaw, IBM Fellow                                       */
-/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
-/* ------------------------------------------------------------------ */
-/* This module comprises the routines for handling arithmetic         */
-/* context structures.                                                */
-/* ------------------------------------------------------------------ */
-
-#include <string.h>           // for strcmp
-#include "decContext.h"       // context and base types
-#include "decNumberLocal.h"   // decNumber local types, etc.
-
-/* ------------------------------------------------------------------ */
-/* decContextDefault -- initialize a context structure                */
-/*                                                                    */
-/*  context is the structure to be initialized                        */
-/*  kind selects the required set of default values, one of:          */
-/*      DEC_INIT_BASE       -- select ANSI X3-274 defaults            */
-/*      DEC_INIT_DECIMAL32  -- select IEEE 754r defaults, 32-bit      */
-/*      DEC_INIT_DECIMAL64  -- select IEEE 754r defaults, 64-bit      */
-/*      DEC_INIT_DECIMAL128 -- select IEEE 754r defaults, 128-bit     */
-/*      For any other value a valid context is returned, but with     */
-/*      Invalid_operation set in the status field.                    */
-/*  returns a context structure with the appropriate initial values.  */
-/* ------------------------------------------------------------------ */
-decContext * decContextDefault(decContext *context, Int kind) {
-  // set defaults...
-  context->digits=9;                         // 9 digits
-  context->emax=DEC_MAX_EMAX;                // 9-digit exponents
-  context->emin=DEC_MIN_EMIN;                // .. balanced
-  context->round=DEC_ROUND_HALF_UP;          // 0.5 rises
-  context->traps=DEC_Errors;                 // all but informational
-  context->status=0;                         // cleared
-  context->clamp=0;                          // no clamping
-  #if DECSUBSET
-  context->extended=0;                       // cleared
-  #endif
-  switch (kind) {
-    case DEC_INIT_BASE:
-      // [use defaults]
-      break;
-    case DEC_INIT_DECIMAL32:
-      context->digits=7;                     // digits
-      context->emax=96;                      // Emax
-      context->emin=-95;                     // Emin
-      context->round=DEC_ROUND_HALF_EVEN;    // 0.5 to nearest even
-      context->traps=0;                      // no traps set
-      context->clamp=1;                      // clamp exponents
-      #if DECSUBSET
-      context->extended=1;                   // set
-      #endif
-      break;
-    case DEC_INIT_DECIMAL64:
-      context->digits=16;                    // digits
-      context->emax=384;                     // Emax
-      context->emin=-383;                    // Emin
-      context->round=DEC_ROUND_HALF_EVEN;    // 0.5 to nearest even
-      context->traps=0;                      // no traps set
-      context->clamp=1;                      // clamp exponents
-      #if DECSUBSET
-      context->extended=1;                   // set
-      #endif
-      break;
-    case DEC_INIT_DECIMAL128:
-      context->digits=34;                    // digits
-      context->emax=6144;                    // Emax
-      context->emin=-6143;                   // Emin
-      context->round=DEC_ROUND_HALF_EVEN;    // 0.5 to nearest even
-      context->traps=0;                      // no traps set
-      context->clamp=1;                      // clamp exponents
-      #if DECSUBSET
-      context->extended=1;                   // set
-      #endif
-      break;
-
-    default:                                 // invalid Kind
-      // use defaults, and ..
-      decContextSetStatus(context, DEC_Invalid_operation); // trap
-    }
-  return context;} // decContextDefault
-
-/* ------------------------------------------------------------------ */
-/* decContextStatusToString -- convert status flags to a string       */
-/*                                                                    */
-/*  context is a context with valid status field                      */
-/*                                                                    */
-/*  returns a constant string describing the condition.  If multiple  */
-/*    (or no) flags are set, a generic constant message is returned.  */
-/* ------------------------------------------------------------------ */
-const char *decContextStatusToString(const decContext *context) {
-  Int status=context->status;
-  if (status==DEC_Conversion_syntax    ) return DEC_Condition_CS;
-  if (status==DEC_Division_by_zero     ) return DEC_Condition_DZ;
-  if (status==DEC_Division_impossible  ) return DEC_Condition_DI;
-  if (status==DEC_Division_undefined   ) return DEC_Condition_DU;
-  if (status==DEC_Inexact              ) return DEC_Condition_IE;
-  if (status==DEC_Insufficient_storage ) return DEC_Condition_IS;
-  if (status==DEC_Invalid_context      ) return DEC_Condition_IC;
-  if (status==DEC_Invalid_operation    ) return DEC_Condition_IO;
-  #if DECSUBSET
-  if (status==DEC_Lost_digits          ) return DEC_Condition_LD;
-  #endif
-  if (status==DEC_Overflow             ) return DEC_Condition_OV;
-  if (status==DEC_Clamped              ) return DEC_Condition_PA;
-  if (status==DEC_Rounded              ) return DEC_Condition_RO;
-  if (status==DEC_Subnormal            ) return DEC_Condition_SU;
-  if (status==DEC_Underflow            ) return DEC_Condition_UN;
-  if (status==0                        ) return DEC_Condition_ZE;
-  return DEC_Condition_MU;  // Multiple errors
-  } // decContextStatusToString
-
-/* ------------------------------------------------------------------ */
-/* decContextSetStatusFromString -- set status from a string          */
-/*                                                                    */
-/*  context is the controlling context                                */
-/*  string is a string exactly equal to one that might be returned    */
-/*            by decContextStatusToString                             */
-/*                                                                    */
-/*  The status bit corresponding to the string is set, and a trap     */
-/*  is raised if appropriate.                                         */
-/*                                                                    */
-/*  returns the context structure, unless the string is equal to      */
-/*    DEC_Condition_MU or is not recognized.  In these cases NULL is  */
-/*    returned.                                                       */
-/* ------------------------------------------------------------------ */
-decContext * decContextSetStatusFromString(decContext *context,
-                                           const char *string) {
-  if (strcmp(string, DEC_Condition_CS)==0)
-    return decContextSetStatus(context, DEC_Conversion_syntax);
-  if (strcmp(string, DEC_Condition_DZ)==0)
-    return decContextSetStatus(context, DEC_Division_by_zero);
-  if (strcmp(string, DEC_Condition_DI)==0)
-    return decContextSetStatus(context, DEC_Division_impossible);
-  if (strcmp(string, DEC_Condition_DU)==0)
-    return decContextSetStatus(context, DEC_Division_undefined);
-  if (strcmp(string, DEC_Condition_IE)==0)
-    return decContextSetStatus(context, DEC_Inexact);
-  if (strcmp(string, DEC_Condition_IS)==0)
-    return decContextSetStatus(context, DEC_Insufficient_storage);
-  if (strcmp(string, DEC_Condition_IC)==0)
-    return decContextSetStatus(context, DEC_Invalid_context);
-  if (strcmp(string, DEC_Condition_IO)==0)
-    return decContextSetStatus(context, DEC_Invalid_operation);
-  #if DECSUBSET
-  if (strcmp(string, DEC_Condition_LD)==0)
-    return decContextSetStatus(context, DEC_Lost_digits);
-  #endif
-  if (strcmp(string, DEC_Condition_OV)==0)
-    return decContextSetStatus(context, DEC_Overflow);
-  if (strcmp(string, DEC_Condition_PA)==0)
-    return decContextSetStatus(context, DEC_Clamped);
-  if (strcmp(string, DEC_Condition_RO)==0)
-    return decContextSetStatus(context, DEC_Rounded);
-  if (strcmp(string, DEC_Condition_SU)==0)
-    return decContextSetStatus(context, DEC_Subnormal);
-  if (strcmp(string, DEC_Condition_UN)==0)
-    return decContextSetStatus(context, DEC_Underflow);
-  if (strcmp(string, DEC_Condition_ZE)==0)
-    return context;
-  return NULL;  // Multiple status, or unknown
-  } // decContextSetStatusFromString
-
-/* ------------------------------------------------------------------ */
-/* decContextSetStatus -- set status and raise trap if appropriate    */
-/*                                                                    */
-/*  context is the controlling context                                */
-/*  status  is the DEC_ exception code                                */
-/*  returns the context structure                                     */
-/*                                                                    */
-/* Control may never return from this routine, if there is a signal   */
-/* handler and it takes a long jump.                                  */
-/* ------------------------------------------------------------------ */
-decContext * decContextSetStatus(decContext *context, uInt status) {
-  context->status|=status;
-  if (status & context->traps) raise(SIGFPE);
-  return context;} // decContextSetStatus
-
+/* ------------------------------------------------------------------ */
+/* Decimal Context module                                             */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2009.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is called decNumber.pdf.  This document is           */
+/* available, together with arithmetic and format specifications,     */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+/* This module comprises the routines for handling arithmetic         */
+/* context structures.                                                */
+/* ------------------------------------------------------------------ */
+
+#include <string.h>           // for strcmp
+#include <stdio.h>            // for printf if DECCHECK
+#include "decContext.h"       // context and base types
+#include "decNumberLocal.h"   // decNumber local types, etc.
+
+/* compile-time endian tester [assumes sizeof(Int)>1] */
+static  const  Int mfcone=1;                       // constant 1
+static  const  Flag *mfctop=(const Flag *)&mfcone; // -> top byte
+#define LITEND *mfctop        // named flag; 1=little-endian
+
+/* ------------------------------------------------------------------ */
+/* round-for-reround digits                                           */
+/* ------------------------------------------------------------------ */
+const uByte DECSTICKYTAB[10]={1,1,2,3,4,6,6,7,8,9}; /* used if sticky */
+
+/* ------------------------------------------------------------------ */
+/* Powers of ten (powers[n]==10**n, 0<=n<=9)                          */
+/* ------------------------------------------------------------------ */
+const uInt DECPOWERS[10]={1, 10, 100, 1000, 10000, 100000, 1000000,
+                          10000000, 100000000, 1000000000};
+
+/* ------------------------------------------------------------------ */
+/* decContextClearStatus -- clear bits in current status              */
+/*                                                                    */
+/*  context is the context structure to be queried                    */
+/*  mask indicates the bits to be cleared (the status bit that        */
+/*    corresponds to each 1 bit in the mask is cleared)               */
+/*  returns context                                                   */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+decContext *decContextClearStatus(decContext *context, uInt mask) {
+  context->status&=~mask;
+  return context;
+  } // decContextClearStatus
+
+/* ------------------------------------------------------------------ */
+/* decContextDefault -- initialize a context structure                */
+/*                                                                    */
+/*  context is the structure to be initialized                        */
+/*  kind selects the required set of default values, one of:          */
+/*      DEC_INIT_BASE       -- select ANSI X3-274 defaults            */
+/*      DEC_INIT_DECIMAL32  -- select IEEE 754 defaults, 32-bit       */
+/*      DEC_INIT_DECIMAL64  -- select IEEE 754 defaults, 64-bit       */
+/*      DEC_INIT_DECIMAL128 -- select IEEE 754 defaults, 128-bit      */
+/*      For any other value a valid context is returned, but with     */
+/*      Invalid_operation set in the status field.                    */
+/*  returns a context structure with the appropriate initial values.  */
+/* ------------------------------------------------------------------ */
+decContext * decContextDefault(decContext *context, Int kind) {
+  // set defaults...
+  context->digits=9;                         // 9 digits
+  context->emax=DEC_MAX_EMAX;                // 9-digit exponents
+  context->emin=DEC_MIN_EMIN;                // .. balanced
+  context->round=DEC_ROUND_HALF_UP;          // 0.5 rises
+  context->traps=DEC_Errors;                 // all but informational
+  context->status=0;                         // cleared
+  context->clamp=0;                          // no clamping
+  #if DECSUBSET
+  context->extended=0;                       // cleared
+  #endif
+  switch (kind) {
+    case DEC_INIT_BASE:
+      // [use defaults]
+      break;
+    case DEC_INIT_DECIMAL32:
+      context->digits=7;                     // digits
+      context->emax=96;                      // Emax
+      context->emin=-95;                     // Emin
+      context->round=DEC_ROUND_HALF_EVEN;    // 0.5 to nearest even
+      context->traps=0;                      // no traps set
+      context->clamp=1;                      // clamp exponents
+      #if DECSUBSET
+      context->extended=1;                   // set
+      #endif
+      break;
+    case DEC_INIT_DECIMAL64:
+      context->digits=16;                    // digits
+      context->emax=384;                     // Emax
+      context->emin=-383;                    // Emin
+      context->round=DEC_ROUND_HALF_EVEN;    // 0.5 to nearest even
+      context->traps=0;                      // no traps set
+      context->clamp=1;                      // clamp exponents
+      #if DECSUBSET
+      context->extended=1;                   // set
+      #endif
+      break;
+    case DEC_INIT_DECIMAL128:
+      context->digits=34;                    // digits
+      context->emax=6144;                    // Emax
+      context->emin=-6143;                   // Emin
+      context->round=DEC_ROUND_HALF_EVEN;    // 0.5 to nearest even
+      context->traps=0;                      // no traps set
+      context->clamp=1;                      // clamp exponents
+      #if DECSUBSET
+      context->extended=1;                   // set
+      #endif
+      break;
+
+    default:                                 // invalid Kind
+      // use defaults, and ..
+      decContextSetStatus(context, DEC_Invalid_operation); // trap
+    }
+
+  return context;} // decContextDefault
+
+/* ------------------------------------------------------------------ */
+/* decContextGetRounding -- return current rounding mode              */
+/*                                                                    */
+/*  context is the context structure to be queried                    */
+/*  returns the rounding mode                                         */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+enum rounding decContextGetRounding(decContext *context) {
+  return context->round;
+  } // decContextGetRounding
+
+/* ------------------------------------------------------------------ */
+/* decContextGetStatus -- return current status                       */
+/*                                                                    */
+/*  context is the context structure to be queried                    */
+/*  returns status                                                    */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+uInt decContextGetStatus(decContext *context) {
+  return context->status;
+  } // decContextGetStatus
+
+/* ------------------------------------------------------------------ */
+/* decContextRestoreStatus -- restore bits in current status          */
+/*                                                                    */
+/*  context is the context structure to be updated                    */
+/*  newstatus is the source for the bits to be restored               */
+/*  mask indicates the bits to be restored (the status bit that       */
+/*    corresponds to each 1 bit in the mask is set to the value of    */
+/*    the correspnding bit in newstatus)                              */
+/*  returns context                                                   */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+decContext *decContextRestoreStatus(decContext *context,
+                                    uInt newstatus, uInt mask) {
+  context->status&=~mask;               // clear the selected bits
+  context->status|=(mask&newstatus);    // or in the new bits
+  return context;
+  } // decContextRestoreStatus
+
+/* ------------------------------------------------------------------ */
+/* decContextSaveStatus -- save bits in current status                */
+/*                                                                    */
+/*  context is the context structure to be queried                    */
+/*  mask indicates the bits to be saved (the status bits that         */
+/*    correspond to each 1 bit in the mask are saved)                 */
+/*  returns the AND of the mask and the current status                */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+uInt decContextSaveStatus(decContext *context, uInt mask) {
+  return context->status&mask;
+  } // decContextSaveStatus
+
+/* ------------------------------------------------------------------ */
+/* decContextSetRounding -- set current rounding mode                 */
+/*                                                                    */
+/*  context is the context structure to be updated                    */
+/*  newround is the value which will replace the current mode         */
+/*  returns context                                                   */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+decContext *decContextSetRounding(decContext *context,
+                                  enum rounding newround) {
+  context->round=newround;
+  return context;
+  } // decContextSetRounding
+
+/* ------------------------------------------------------------------ */
+/* decContextSetStatus -- set status and raise trap if appropriate    */
+/*                                                                    */
+/*  context is the context structure to be updated                    */
+/*  status  is the DEC_ exception code                                */
+/*  returns the context structure                                     */
+/*                                                                    */
+/* Control may never return from this routine, if there is a signal   */
+/* handler and it takes a long jump.                                  */
+/* ------------------------------------------------------------------ */
+decContext * decContextSetStatus(decContext *context, uInt status) {
+  context->status|=status;
+  if (status & context->traps) raise(SIGFPE);
+  return context;} // decContextSetStatus
+
+/* ------------------------------------------------------------------ */
+/* decContextSetStatusFromString -- set status from a string + trap   */
+/*                                                                    */
+/*  context is the context structure to be updated                    */
+/*  string is a string exactly equal to one that might be returned    */
+/*            by decContextStatusToString                             */
+/*                                                                    */
+/*  The status bit corresponding to the string is set, and a trap     */
+/*  is raised if appropriate.                                         */
+/*                                                                    */
+/*  returns the context structure, unless the string is equal to      */
+/*    DEC_Condition_MU or is not recognized.  In these cases NULL is  */
+/*    returned.                                                       */
+/* ------------------------------------------------------------------ */
+decContext * decContextSetStatusFromString(decContext *context,
+                                           const char *string) {
+  if (strcmp(string, DEC_Condition_CS)==0)
+    return decContextSetStatus(context, DEC_Conversion_syntax);
+  if (strcmp(string, DEC_Condition_DZ)==0)
+    return decContextSetStatus(context, DEC_Division_by_zero);
+  if (strcmp(string, DEC_Condition_DI)==0)
+    return decContextSetStatus(context, DEC_Division_impossible);
+  if (strcmp(string, DEC_Condition_DU)==0)
+    return decContextSetStatus(context, DEC_Division_undefined);
+  if (strcmp(string, DEC_Condition_IE)==0)
+    return decContextSetStatus(context, DEC_Inexact);
+  if (strcmp(string, DEC_Condition_IS)==0)
+    return decContextSetStatus(context, DEC_Insufficient_storage);
+  if (strcmp(string, DEC_Condition_IC)==0)
+    return decContextSetStatus(context, DEC_Invalid_context);
+  if (strcmp(string, DEC_Condition_IO)==0)
+    return decContextSetStatus(context, DEC_Invalid_operation);
+  #if DECSUBSET
+  if (strcmp(string, DEC_Condition_LD)==0)
+    return decContextSetStatus(context, DEC_Lost_digits);
+  #endif
+  if (strcmp(string, DEC_Condition_OV)==0)
+    return decContextSetStatus(context, DEC_Overflow);
+  if (strcmp(string, DEC_Condition_PA)==0)
+    return decContextSetStatus(context, DEC_Clamped);
+  if (strcmp(string, DEC_Condition_RO)==0)
+    return decContextSetStatus(context, DEC_Rounded);
+  if (strcmp(string, DEC_Condition_SU)==0)
+    return decContextSetStatus(context, DEC_Subnormal);
+  if (strcmp(string, DEC_Condition_UN)==0)
+    return decContextSetStatus(context, DEC_Underflow);
+  if (strcmp(string, DEC_Condition_ZE)==0)
+    return context;
+  return NULL;  // Multiple status, or unknown
+  } // decContextSetStatusFromString
+
+/* ------------------------------------------------------------------ */
+/* decContextSetStatusFromStringQuiet -- set status from a string     */
+/*                                                                    */
+/*  context is the context structure to be updated                    */
+/*  string is a string exactly equal to one that might be returned    */
+/*            by decContextStatusToString                             */
+/*                                                                    */
+/*  The status bit corresponding to the string is set; no trap is     */
+/*  raised.                                                           */
+/*                                                                    */
+/*  returns the context structure, unless the string is equal to      */
+/*    DEC_Condition_MU or is not recognized.  In these cases NULL is  */
+/*    returned.                                                       */
+/* ------------------------------------------------------------------ */
+decContext * decContextSetStatusFromStringQuiet(decContext *context,
+                                                const char *string) {
+  if (strcmp(string, DEC_Condition_CS)==0)
+    return decContextSetStatusQuiet(context, DEC_Conversion_syntax);
+  if (strcmp(string, DEC_Condition_DZ)==0)
+    return decContextSetStatusQuiet(context, DEC_Division_by_zero);
+  if (strcmp(string, DEC_Condition_DI)==0)
+    return decContextSetStatusQuiet(context, DEC_Division_impossible);
+  if (strcmp(string, DEC_Condition_DU)==0)
+    return decContextSetStatusQuiet(context, DEC_Division_undefined);
+  if (strcmp(string, DEC_Condition_IE)==0)
+    return decContextSetStatusQuiet(context, DEC_Inexact);
+  if (strcmp(string, DEC_Condition_IS)==0)
+    return decContextSetStatusQuiet(context, DEC_Insufficient_storage);
+  if (strcmp(string, DEC_Condition_IC)==0)
+    return decContextSetStatusQuiet(context, DEC_Invalid_context);
+  if (strcmp(string, DEC_Condition_IO)==0)
+    return decContextSetStatusQuiet(context, DEC_Invalid_operation);
+  #if DECSUBSET
+  if (strcmp(string, DEC_Condition_LD)==0)
+    return decContextSetStatusQuiet(context, DEC_Lost_digits);
+  #endif
+  if (strcmp(string, DEC_Condition_OV)==0)
+    return decContextSetStatusQuiet(context, DEC_Overflow);
+  if (strcmp(string, DEC_Condition_PA)==0)
+    return decContextSetStatusQuiet(context, DEC_Clamped);
+  if (strcmp(string, DEC_Condition_RO)==0)
+    return decContextSetStatusQuiet(context, DEC_Rounded);
+  if (strcmp(string, DEC_Condition_SU)==0)
+    return decContextSetStatusQuiet(context, DEC_Subnormal);
+  if (strcmp(string, DEC_Condition_UN)==0)
+    return decContextSetStatusQuiet(context, DEC_Underflow);
+  if (strcmp(string, DEC_Condition_ZE)==0)
+    return context;
+  return NULL;  // Multiple status, or unknown
+  } // decContextSetStatusFromStringQuiet
+
+/* ------------------------------------------------------------------ */
+/* decContextSetStatusQuiet -- set status without trap                */
+/*                                                                    */
+/*  context is the context structure to be updated                    */
+/*  status  is the DEC_ exception code                                */
+/*  returns the context structure                                     */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+decContext * decContextSetStatusQuiet(decContext *context, uInt status) {
+  context->status|=status;
+  return context;} // decContextSetStatusQuiet
+
+/* ------------------------------------------------------------------ */
+/* decContextStatusToString -- convert status flags to a string       */
+/*                                                                    */
+/*  context is a context with valid status field                      */
+/*                                                                    */
+/*  returns a constant string describing the condition.  If multiple  */
+/*    (or no) flags are set, a generic constant message is returned.  */
+/* ------------------------------------------------------------------ */
+const char *decContextStatusToString(const decContext *context) {
+  Int status=context->status;
+
+  // test the five IEEE first, as some of the others are ambiguous when
+  // DECEXTFLAG=0
+  if (status==DEC_Invalid_operation    ) return DEC_Condition_IO;
+  if (status==DEC_Division_by_zero     ) return DEC_Condition_DZ;
+  if (status==DEC_Overflow             ) return DEC_Condition_OV;
+  if (status==DEC_Underflow            ) return DEC_Condition_UN;
+  if (status==DEC_Inexact              ) return DEC_Condition_IE;
+
+  if (status==DEC_Division_impossible  ) return DEC_Condition_DI;
+  if (status==DEC_Division_undefined   ) return DEC_Condition_DU;
+  if (status==DEC_Rounded              ) return DEC_Condition_RO;
+  if (status==DEC_Clamped              ) return DEC_Condition_PA;
+  if (status==DEC_Subnormal            ) return DEC_Condition_SU;
+  if (status==DEC_Conversion_syntax    ) return DEC_Condition_CS;
+  if (status==DEC_Insufficient_storage ) return DEC_Condition_IS;
+  if (status==DEC_Invalid_context      ) return DEC_Condition_IC;
+  #if DECSUBSET
+  if (status==DEC_Lost_digits          ) return DEC_Condition_LD;
+  #endif
+  if (status==0                        ) return DEC_Condition_ZE;
+  return DEC_Condition_MU;  // Multiple errors
+  } // decContextStatusToString
+
+/* ------------------------------------------------------------------ */
+/* decContextTestEndian -- test whether DECLITEND is set correctly    */
+/*                                                                    */
+/*  quiet is 1 to suppress message; 0 otherwise                       */
+/*  returns 0 if DECLITEND is correct                                 */
+/*          1 if DECLITEND is incorrect and should be 1               */
+/*         -1 if DECLITEND is incorrect and should be 0               */
+/*                                                                    */
+/* A message is displayed if the return value is not 0 and quiet==0.  */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+Int decContextTestEndian(Flag quiet) {
+  Int res=0;                  // optimist
+  uInt dle=(uInt)DECLITEND;   // unsign
+  if (dle>1) dle=1;           // ensure 0 or 1
+
+  if (LITEND!=DECLITEND) {
+    if (!quiet) {             // always refer to this
+      #if DECPRINT
+      const char *adj;
+      if (LITEND) adj="little";
+             else adj="big";
+      printf("Warning: DECLITEND is set to %d, but this computer appears to be %s-endian\n",
+             DECLITEND, adj);
+      #endif
+      }
+    res=(Int)LITEND-dle;
+    }
+  return res;
+  } // decContextTestEndian
+
+/* ------------------------------------------------------------------ */
+/* decContextTestSavedStatus -- test bits in saved status             */
+/*                                                                    */
+/*  oldstatus is the status word to be tested                         */
+/*  mask indicates the bits to be tested (the oldstatus bits that     */
+/*    correspond to each 1 bit in the mask are tested)                */
+/*  returns 1 if any of the tested bits are 1, or 0 otherwise         */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+uInt decContextTestSavedStatus(uInt oldstatus, uInt mask) {
+  return (oldstatus&mask)!=0;
+  } // decContextTestSavedStatus
+
+/* ------------------------------------------------------------------ */
+/* decContextTestStatus -- test bits in current status                */
+/*                                                                    */
+/*  context is the context structure to be updated                    */
+/*  mask indicates the bits to be tested (the status bits that        */
+/*    correspond to each 1 bit in the mask are tested)                */
+/*  returns 1 if any of the tested bits are 1, or 0 otherwise         */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+uInt decContextTestStatus(decContext *context, uInt mask) {
+  return (context->status&mask)!=0;
+  } // decContextTestStatus
+
+/* ------------------------------------------------------------------ */
+/* decContextZeroStatus -- clear all status bits                      */
+/*                                                                    */
+/*  context is the context structure to be updated                    */
+/*  returns context                                                   */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+decContext *decContextZeroStatus(decContext *context) {
+  context->status=0;
+  return context;
+  } // decContextZeroStatus
+
diff --git a/decNumber/decContext.h b/decNumber/decContext.h
index 21578638..82e4fcf2 100644
--- a/decNumber/decContext.h
+++ b/decNumber/decContext.h
@@ -1,168 +1,254 @@
-/* ------------------------------------------------------------------ */
-/* Decimal Context module header                                      */
-/* ------------------------------------------------------------------ */
-/* Copyright (c) IBM Corporation, 2000, 2005.  All rights reserved.   */
-/*                                                                    */
-/* This software is made available under the terms of the             */
-/* ICU License -- ICU 1.8.1 and later.                                */
-/*                                                                    */
-/* The description and User's Guide ("The decNumber C Library") for   */
-/* this software is called decNumber.pdf.  This document is           */
-/* available, together with arithmetic and format specifications,     */
-/* testcases, and Web links, at: http://www2.hursley.ibm.com/decimal  */
-/*                                                                    */
-/* Please send comments, suggestions, and corrections to the author:  */
-/*   mfc@uk.ibm.com                                                   */
-/*   Mike Cowlishaw, IBM Fellow                                       */
-/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
-/* ------------------------------------------------------------------ */
-/*                                                                    */
-/* Context must always be set correctly:                              */
-/*                                                                    */
-/*  digits   -- must be in the range 1 through 999999999              */
-/*  emax     -- must be in the range 0 through 999999999              */
-/*  emin     -- must be in the range 0 through -999999999             */
-/*  round    -- must be one of the enumerated rounding modes          */
-/*  traps    -- only defined bits may be set                          */
-/*  status   -- [any bits may be cleared, but not set, by user]       */
-/*  clamp    -- must be either 0 or 1                                 */
-/*  extended -- must be either 0 or 1 [present only if DECSUBSET]     */
-/*                                                                    */
-/* ------------------------------------------------------------------ */
-
-#if !defined(DECCONTEXT)
-  #define DECCONTEXT
-  #define DECCNAME     "decContext"                     /* Short name */
-  #define DECCFULLNAME "Decimal Context Descriptor"   /* Verbose name */
-  #define DECCAUTHOR   "Mike Cowlishaw"               /* Who to blame */
-
-  #if !defined(int32_t)
-    #include <hstdint.h>           // C99 standard integers
-  #endif
-  #include <signal.h>              // for traps
-
-  /* Conditional code flag -- set this to 0 for best performance */
-  #define DECSUBSET 0              // 1=enable subset arithmetic
-
-  /* Context for operations, with associated constants */
-  enum rounding {
-    DEC_ROUND_CEILING,             // round towards +infinity
-    DEC_ROUND_UP,                  // round away from 0
-    DEC_ROUND_HALF_UP,             // 0.5 rounds up
-    DEC_ROUND_HALF_EVEN,           // 0.5 rounds to nearest even
-    DEC_ROUND_HALF_DOWN,           // 0.5 rounds down
-    DEC_ROUND_DOWN,                // round towards 0 (truncate)
-    DEC_ROUND_FLOOR,               // round towards -infinity
-    DEC_ROUND_MAX                  // enum must be less than this
-    };
-
-  typedef struct {
-    int32_t  digits;               // working precision
-    int32_t  emax;                 // maximum positive exponent
-    int32_t  emin;                 // minimum negative exponent
-    enum     rounding round;       // rounding mode
-    uint32_t traps;                // trap-enabler flags
-    uint32_t status;               // status flags
-    uint8_t  clamp;                // flag: apply IEEE exponent clamp
-    #if DECSUBSET
-    uint8_t  extended;             // flag: special-values allowed
-    #endif
-    } decContext;
-
-  /* Maxima and Minima */
-  #define DEC_MAX_DIGITS 999999999
-  #define DEC_MIN_DIGITS         1
-  #define DEC_MAX_EMAX   999999999
-  #define DEC_MIN_EMAX           0
-  #define DEC_MAX_EMIN           0
-  #define DEC_MIN_EMIN  -999999999
-  #define DEC_MAX_MATH      999999 // max emax, etc., for math functions
-
-  /* Trap-enabler and Status flags (exceptional conditions), and their names */
-  // Top byte is reserved for internal use
-  #define DEC_Conversion_syntax    0x00000001
-  #define DEC_Division_by_zero     0x00000002
-  #define DEC_Division_impossible  0x00000004
-  #define DEC_Division_undefined   0x00000008
-  #define DEC_Insufficient_storage 0x00000010  // [used if malloc fails]
-  #define DEC_Inexact              0x00000020
-  #define DEC_Invalid_context      0x00000040
-  #define DEC_Invalid_operation    0x00000080
-  #if DECSUBSET
-  #define DEC_Lost_digits          0x00000100
-  #endif
-  #define DEC_Overflow             0x00000200
-  #define DEC_Clamped              0x00000400
-  #define DEC_Rounded              0x00000800
-  #define DEC_Subnormal            0x00001000
-  #define DEC_Underflow            0x00002000
-
-  /* IEEE 854 groupings for the flags */
-  // [DEC_Clamped, DEC_Lost_digits, DEC_Rounded, and DEC_Subnormal are
-  // not in IEEE 854]
-  #define DEC_IEEE_854_Division_by_zero  (DEC_Division_by_zero)
-  #if DECSUBSET
-  #define DEC_IEEE_854_Inexact           (DEC_Inexact | DEC_Lost_digits)
-  #else
-  #define DEC_IEEE_854_Inexact           (DEC_Inexact)
-  #endif
-  #define DEC_IEEE_854_Invalid_operation (DEC_Conversion_syntax |     \
-                                          DEC_Division_impossible |   \
-                                          DEC_Division_undefined |    \
-                                          DEC_Insufficient_storage |  \
-                                          DEC_Invalid_context |       \
-                                          DEC_Invalid_operation)
-  #define DEC_IEEE_854_Overflow          (DEC_Overflow)
-  #define DEC_IEEE_854_Underflow         (DEC_Underflow)
-
-  // flags which are normally errors (results are qNaN, infinite, or 0)
-  #define DEC_Errors (DEC_IEEE_854_Division_by_zero |                 \
-                      DEC_IEEE_854_Invalid_operation |                \
-                      DEC_IEEE_854_Overflow | DEC_IEEE_854_Underflow)
-  // flags which cause a result to become qNaN
-  #define DEC_NaNs    DEC_IEEE_854_Invalid_operation
-
-  // flags which are normally for information only (have finite results)
-  #if DECSUBSET
-  #define DEC_Information (DEC_Clamped | DEC_Rounded | DEC_Inexact     \
-                          | DEC_Lost_digits)
-  #else
-  #define DEC_Information (DEC_Clamped | DEC_Rounded | DEC_Inexact)
-  #endif
-
-  // name strings for the exceptional conditions
-
-  #define DEC_Condition_CS "Conversion syntax"
-  #define DEC_Condition_DZ "Division by zero"
-  #define DEC_Condition_DI "Division impossible"
-  #define DEC_Condition_DU "Division undefined"
-  #define DEC_Condition_IE "Inexact"
-  #define DEC_Condition_IS "Insufficient storage"
-  #define DEC_Condition_IC "Invalid context"
-  #define DEC_Condition_IO "Invalid operation"
-  #if DECSUBSET
-  #define DEC_Condition_LD "Lost digits"
-  #endif
-  #define DEC_Condition_OV "Overflow"
-  #define DEC_Condition_PA "Clamped"
-  #define DEC_Condition_RO "Rounded"
-  #define DEC_Condition_SU "Subnormal"
-  #define DEC_Condition_UN "Underflow"
-  #define DEC_Condition_ZE "No status"
-  #define DEC_Condition_MU "Multiple status"
-  #define DEC_Condition_Length 21  // length of the longest string,
-                                   // including terminator
-
-  /* Initialization descriptors, used by decContextDefault */
-  #define DEC_INIT_BASE         0
-  #define DEC_INIT_DECIMAL32   32
-  #define DEC_INIT_DECIMAL64   64
-  #define DEC_INIT_DECIMAL128 128
-
-  /* decContext routines */
-  decContext * decContextDefault(decContext *, int32_t);
-  decContext * decContextSetStatus(decContext *, uint32_t);
-  const char * decContextStatusToString(const decContext *);
-  decContext * decContextSetStatusFromString(decContext *, const char *);
-
-#endif
+/* ------------------------------------------------------------------ */
+/* Decimal Context module header                                      */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2010.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is called decNumber.pdf.  This document is           */
+/* available, together with arithmetic and format specifications,     */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+/*                                                                    */
+/* Context variables must always have valid values:                   */
+/*                                                                    */
+/*  status   -- [any bits may be cleared, but not set, by user]       */
+/*  round    -- must be one of the enumerated rounding modes          */
+/*                                                                    */
+/* The following variables are implied for fixed size formats (i.e.,  */
+/* they are ignored) but should still be set correctly in case used   */
+/* with decNumber functions:                                          */
+/*                                                                    */
+/*  clamp    -- must be either 0 or 1                                 */
+/*  digits   -- must be in the range 1 through 999999999              */
+/*  emax     -- must be in the range 0 through 999999999              */
+/*  emin     -- must be in the range 0 through -999999999             */
+/*  extended -- must be either 0 or 1 [present only if DECSUBSET]     */
+/*  traps    -- only defined bits may be set                          */
+/*                                                                    */
+/* ------------------------------------------------------------------ */
+
+#if !defined(DECCONTEXT)
+  #define DECCONTEXT
+  #define DECCNAME     "decContext"                     /* Short name */
+  #define DECCFULLNAME "Decimal Context Descriptor"   /* Verbose name */
+  #define DECCAUTHOR   "Mike Cowlishaw"               /* Who to blame */
+
+  #if !defined(int32_t)
+    #include <stdint.h>            /* C99 standard integers           */
+  #endif
+  #include <stdio.h>               /* for printf, etc.                */
+  #include <signal.h>              /* for traps                       */
+
+  /* Extended flags setting -- set this to 0 to use only IEEE flags   */
+  #if !defined(DECEXTFLAG)
+  #define DECEXTFLAG 1             /* 1=enable extended flags         */
+  #endif
+
+  /* Conditional code flag -- set this to 0 for best performance      */
+  #if !defined(DECSUBSET)
+  #define DECSUBSET  0             /* 1=enable subset arithmetic      */
+  #endif
+
+  /* Context for operations, with associated constants                */
+  enum rounding {
+    DEC_ROUND_CEILING,             /* round towards +infinity         */
+    DEC_ROUND_UP,                  /* round away from 0               */
+    DEC_ROUND_HALF_UP,             /* 0.5 rounds up                   */
+    DEC_ROUND_HALF_EVEN,           /* 0.5 rounds to nearest even      */
+    DEC_ROUND_HALF_DOWN,           /* 0.5 rounds down                 */
+    DEC_ROUND_DOWN,                /* round towards 0 (truncate)      */
+    DEC_ROUND_FLOOR,               /* round towards -infinity         */
+    DEC_ROUND_05UP,                /* round for reround               */
+    DEC_ROUND_MAX                  /* enum must be less than this     */
+    };
+  #define DEC_ROUND_DEFAULT DEC_ROUND_HALF_EVEN;
+
+  typedef struct {
+    int32_t  digits;               /* working precision               */
+    int32_t  emax;                 /* maximum positive exponent       */
+    int32_t  emin;                 /* minimum negative exponent       */
+    enum     rounding round;       /* rounding mode                   */
+    uint32_t traps;                /* trap-enabler flags              */
+    uint32_t status;               /* status flags                    */
+    uint8_t  clamp;                /* flag: apply IEEE exponent clamp */
+    #if DECSUBSET
+    uint8_t  extended;             /* flag: special-values allowed    */
+    #endif
+    } decContext;
+
+  /* Maxima and Minima for context settings                           */
+  #define DEC_MAX_DIGITS 999999999
+  #define DEC_MIN_DIGITS         1
+  #define DEC_MAX_EMAX   999999999
+  #define DEC_MIN_EMAX           0
+  #define DEC_MAX_EMIN           0
+  #define DEC_MIN_EMIN  -999999999
+  #define DEC_MAX_MATH      999999 /* max emax, etc., for math funcs. */
+
+  /* Classifications for decimal numbers, aligned with 754 (note that */
+  /* 'normal' and 'subnormal' are meaningful only with a decContext   */
+  /* or a fixed size format).                                         */
+  enum decClass {
+    DEC_CLASS_SNAN,
+    DEC_CLASS_QNAN,
+    DEC_CLASS_NEG_INF,
+    DEC_CLASS_NEG_NORMAL,
+    DEC_CLASS_NEG_SUBNORMAL,
+    DEC_CLASS_NEG_ZERO,
+    DEC_CLASS_POS_ZERO,
+    DEC_CLASS_POS_SUBNORMAL,
+    DEC_CLASS_POS_NORMAL,
+    DEC_CLASS_POS_INF
+    };
+  /* Strings for the decClasses */
+  #define DEC_ClassString_SN  "sNaN"
+  #define DEC_ClassString_QN  "NaN"
+  #define DEC_ClassString_NI  "-Infinity"
+  #define DEC_ClassString_NN  "-Normal"
+  #define DEC_ClassString_NS  "-Subnormal"
+  #define DEC_ClassString_NZ  "-Zero"
+  #define DEC_ClassString_PZ  "+Zero"
+  #define DEC_ClassString_PS  "+Subnormal"
+  #define DEC_ClassString_PN  "+Normal"
+  #define DEC_ClassString_PI  "+Infinity"
+  #define DEC_ClassString_UN  "Invalid"
+
+  /* Trap-enabler and Status flags (exceptional conditions), and      */
+  /* their names.  The top byte is reserved for internal use          */
+  #if DECEXTFLAG
+    /* Extended flags */
+    #define DEC_Conversion_syntax    0x00000001
+    #define DEC_Division_by_zero     0x00000002
+    #define DEC_Division_impossible  0x00000004
+    #define DEC_Division_undefined   0x00000008
+    #define DEC_Insufficient_storage 0x00000010 /* [when malloc fails]  */
+    #define DEC_Inexact              0x00000020
+    #define DEC_Invalid_context      0x00000040
+    #define DEC_Invalid_operation    0x00000080
+    #if DECSUBSET
+    #define DEC_Lost_digits          0x00000100
+    #endif
+    #define DEC_Overflow             0x00000200
+    #define DEC_Clamped              0x00000400
+    #define DEC_Rounded              0x00000800
+    #define DEC_Subnormal            0x00001000
+    #define DEC_Underflow            0x00002000
+  #else
+    /* IEEE flags only */
+    #define DEC_Conversion_syntax    0x00000010
+    #define DEC_Division_by_zero     0x00000002
+    #define DEC_Division_impossible  0x00000010
+    #define DEC_Division_undefined   0x00000010
+    #define DEC_Insufficient_storage 0x00000010 /* [when malloc fails]  */
+    #define DEC_Inexact              0x00000001
+    #define DEC_Invalid_context      0x00000010
+    #define DEC_Invalid_operation    0x00000010
+    #if DECSUBSET
+    #define DEC_Lost_digits          0x00000000
+    #endif
+    #define DEC_Overflow             0x00000008
+    #define DEC_Clamped              0x00000000
+    #define DEC_Rounded              0x00000000
+    #define DEC_Subnormal            0x00000000
+    #define DEC_Underflow            0x00000004
+  #endif
+
+  /* IEEE 754 groupings for the flags                                 */
+  /* [DEC_Clamped, DEC_Lost_digits, DEC_Rounded, and DEC_Subnormal    */
+  /* are not in IEEE 754]                                             */
+  #define DEC_IEEE_754_Division_by_zero  (DEC_Division_by_zero)
+  #if DECSUBSET
+  #define DEC_IEEE_754_Inexact           (DEC_Inexact | DEC_Lost_digits)
+  #else
+  #define DEC_IEEE_754_Inexact           (DEC_Inexact)
+  #endif
+  #define DEC_IEEE_754_Invalid_operation (DEC_Conversion_syntax |     \
+                                          DEC_Division_impossible |   \
+                                          DEC_Division_undefined |    \
+                                          DEC_Insufficient_storage |  \
+                                          DEC_Invalid_context |       \
+                                          DEC_Invalid_operation)
+  #define DEC_IEEE_754_Overflow          (DEC_Overflow)
+  #define DEC_IEEE_754_Underflow         (DEC_Underflow)
+
+  /* flags which are normally errors (result is qNaN, infinite, or 0) */
+  #define DEC_Errors (DEC_IEEE_754_Division_by_zero |                 \
+                      DEC_IEEE_754_Invalid_operation |                \
+                      DEC_IEEE_754_Overflow | DEC_IEEE_754_Underflow)
+  /* flags which cause a result to become qNaN                        */
+  #define DEC_NaNs    DEC_IEEE_754_Invalid_operation
+
+  /* flags which are normally for information only (finite results)   */
+  #if DECSUBSET
+  #define DEC_Information (DEC_Clamped | DEC_Rounded | DEC_Inexact    \
+                          | DEC_Lost_digits)
+  #else
+  #define DEC_Information (DEC_Clamped | DEC_Rounded | DEC_Inexact)
+  #endif
+
+  /* IEEE 854 names (for compatibility with older decNumber versions) */
+  #define DEC_IEEE_854_Division_by_zero  DEC_IEEE_754_Division_by_zero
+  #define DEC_IEEE_854_Inexact           DEC_IEEE_754_Inexact
+  #define DEC_IEEE_854_Invalid_operation DEC_IEEE_754_Invalid_operation
+  #define DEC_IEEE_854_Overflow          DEC_IEEE_754_Overflow
+  #define DEC_IEEE_854_Underflow         DEC_IEEE_754_Underflow
+
+  /* Name strings for the exceptional conditions                      */
+  #define DEC_Condition_CS "Conversion syntax"
+  #define DEC_Condition_DZ "Division by zero"
+  #define DEC_Condition_DI "Division impossible"
+  #define DEC_Condition_DU "Division undefined"
+  #define DEC_Condition_IE "Inexact"
+  #define DEC_Condition_IS "Insufficient storage"
+  #define DEC_Condition_IC "Invalid context"
+  #define DEC_Condition_IO "Invalid operation"
+  #if DECSUBSET
+  #define DEC_Condition_LD "Lost digits"
+  #endif
+  #define DEC_Condition_OV "Overflow"
+  #define DEC_Condition_PA "Clamped"
+  #define DEC_Condition_RO "Rounded"
+  #define DEC_Condition_SU "Subnormal"
+  #define DEC_Condition_UN "Underflow"
+  #define DEC_Condition_ZE "No status"
+  #define DEC_Condition_MU "Multiple status"
+  #define DEC_Condition_Length 21  /* length of the longest string,   */
+                                   /* including terminator            */
+
+  /* Initialization descriptors, used by decContextDefault            */
+  #define DEC_INIT_BASE         0
+  #define DEC_INIT_DECIMAL32   32
+  #define DEC_INIT_DECIMAL64   64
+  #define DEC_INIT_DECIMAL128 128
+  /* Synonyms */
+  #define DEC_INIT_DECSINGLE  DEC_INIT_DECIMAL32
+  #define DEC_INIT_DECDOUBLE  DEC_INIT_DECIMAL64
+  #define DEC_INIT_DECQUAD    DEC_INIT_DECIMAL128
+
+  /* decContext routines                                              */
+  extern decContext  * decContextClearStatus(decContext *, uint32_t);
+  extern decContext  * decContextDefault(decContext *, int32_t);
+  extern enum rounding decContextGetRounding(decContext *);
+  extern uint32_t      decContextGetStatus(decContext *);
+  extern decContext  * decContextRestoreStatus(decContext *, uint32_t, uint32_t);
+  extern uint32_t      decContextSaveStatus(decContext *, uint32_t);
+  extern decContext  * decContextSetRounding(decContext *, enum rounding);
+  extern decContext  * decContextSetStatus(decContext *, uint32_t);
+  extern decContext  * decContextSetStatusFromString(decContext *, const char *);
+  extern decContext  * decContextSetStatusFromStringQuiet(decContext *, const char *);
+  extern decContext  * decContextSetStatusQuiet(decContext *, uint32_t);
+  extern const char  * decContextStatusToString(const decContext *);
+  extern int32_t       decContextTestEndian(uint8_t);
+  extern uint32_t      decContextTestSavedStatus(uint32_t, uint32_t);
+  extern uint32_t      decContextTestStatus(decContext *, uint32_t);
+  extern decContext  * decContextZeroStatus(decContext *);
+
+#endif
diff --git a/decNumber/decDPD.h b/decNumber/decDPD.h
index 31295223..e6a80c0e 100644
--- a/decNumber/decDPD.h
+++ b/decNumber/decDPD.h
@@ -1,802 +1,1185 @@
-/* ------------------------------------------------------------------------ */
-/* Binary Coded Decimal <--> Densely Packed Decimal lookup tables           */
-/* [Automatically generated -- do not edit.  2006.11.09]                    */
-/* ------------------------------------------------------------------------ */
-/* Copyright (c) IBM Corporation, 2000, 2006. All rights reserved.          */
-/* ------------------------------------------------------------------------ */
-/* For details, see: http://www2.hursley.ibm.com/decimal/DPDecimal.html     */
-/*                                                                          */
-/* This include file defines conversion tables for DPD, as follows.         */
-/*                                                                          */
-/*   uint16_t BCD2DPD[2458];     // BCD -> DPD (0x999 => 2457)              */
-/*   uint16_t BIN2DPD[1000];     // BIN -> DPD (999 => 2457)                */
-/*   uint8_t  BIN2CHAR[4001];    // Bin -> CHAR (999 => '\3' '9' '9' '9')   */
-/*   uint16_t DPD2BCD[1024];     // DPD -> BCD (0x3FF => 0x999)             */
-/*   uint16_t DPD2BIN[1024];     // DPD -> BIN (0x3FF => 999)               */
-/*   uint8_t  DPD2BCD8[4096];    // DPD -> bytes (x3FF => 9 9 9 3)          */
-/*                                                                          */
-/* In all cases the result (10 bits or 12 bits, or binary) is right-aligned */
-/* in the table entry.  BIN2CHAR entries are a single byte length (0 for    */
-/* value 0) followed by three digit characters; a trailing terminator is    */
-/* included to allow 4-char moves always.  DPD2BCD8 entries are similar     */
-/* with the three BCD8 digits followed by a one-byte length.                */
-/*                                                                          */
-/* To use a table, its name, prefixed with DEC_, must be defined with a     */
-/* value of 1 before this header file is included.  For example:            */
-/*    #define DEC_BCD2DPD 1                                                 */
-/* ------------------------------------------------------------------------ */
- 
-#if DEC_BCD2DPD==1 && !defined(DECBCD2DPD)
-#define DECBCD2DPD
- 
-const uint16_t BCD2DPD[2458]={    0,    1,    2,    3,    4,    5,    6,    7, 
-    8,    9,    0,    0,    0,    0,    0,    0,   16,   17,   18,   19,   20, 
-   21,   22,   23,   24,   25,    0,    0,    0,    0,    0,    0,   32,   33, 
-   34,   35,   36,   37,   38,   39,   40,   41,    0,    0,    0,    0,    0, 
-    0,   48,   49,   50,   51,   52,   53,   54,   55,   56,   57,    0,    0, 
-    0,    0,    0,    0,   64,   65,   66,   67,   68,   69,   70,   71,   72, 
-   73,    0,    0,    0,    0,    0,    0,   80,   81,   82,   83,   84,   85, 
-   86,   87,   88,   89,    0,    0,    0,    0,    0,    0,   96,   97,   98, 
-   99,  100,  101,  102,  103,  104,  105,    0,    0,    0,    0,    0,    0, 
-  112,  113,  114,  115,  116,  117,  118,  119,  120,  121,    0,    0,    0, 
-    0,    0,    0,   10,   11,   42,   43,   74,   75,  106,  107,   78,   79, 
-    0,    0,    0,    0,    0,    0,   26,   27,   58,   59,   90,   91,  122, 
-  123,   94,   95,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,   10,   11,   42,   43,   74, 
-   75,  106,  107,   78,   79,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,  128,  129,  130,  131,  132,  133,  134,  135,  136,  137,    0,    0, 
-    0,    0,    0,    0,  144,  145,  146,  147,  148,  149,  150,  151,  152, 
-  153,    0,    0,    0,    0,    0,    0,  160,  161,  162,  163,  164,  165, 
-  166,  167,  168,  169,    0,    0,    0,    0,    0,    0,  176,  177,  178, 
-  179,  180,  181,  182,  183,  184,  185,    0,    0,    0,    0,    0,    0, 
-  192,  193,  194,  195,  196,  197,  198,  199,  200,  201,    0,    0,    0, 
-    0,    0,    0,  208,  209,  210,  211,  212,  213,  214,  215,  216,  217, 
-    0,    0,    0,    0,    0,    0,  224,  225,  226,  227,  228,  229,  230, 
-  231,  232,  233,    0,    0,    0,    0,    0,    0,  240,  241,  242,  243, 
-  244,  245,  246,  247,  248,  249,    0,    0,    0,    0,    0,    0,  138, 
-  139,  170,  171,  202,  203,  234,  235,  206,  207,    0,    0,    0,    0, 
-    0,    0,  154,  155,  186,  187,  218,  219,  250,  251,  222,  223,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,  138,  139,  170,  171,  202,  203,  234,  235,  206, 
-  207,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  256,  257,  258, 
-  259,  260,  261,  262,  263,  264,  265,    0,    0,    0,    0,    0,    0, 
-  272,  273,  274,  275,  276,  277,  278,  279,  280,  281,    0,    0,    0, 
-    0,    0,    0,  288,  289,  290,  291,  292,  293,  294,  295,  296,  297, 
-    0,    0,    0,    0,    0,    0,  304,  305,  306,  307,  308,  309,  310, 
-  311,  312,  313,    0,    0,    0,    0,    0,    0,  320,  321,  322,  323, 
-  324,  325,  326,  327,  328,  329,    0,    0,    0,    0,    0,    0,  336, 
-  337,  338,  339,  340,  341,  342,  343,  344,  345,    0,    0,    0,    0, 
-    0,    0,  352,  353,  354,  355,  356,  357,  358,  359,  360,  361,    0, 
-    0,    0,    0,    0,    0,  368,  369,  370,  371,  372,  373,  374,  375, 
-  376,  377,    0,    0,    0,    0,    0,    0,  266,  267,  298,  299,  330, 
-  331,  362,  363,  334,  335,    0,    0,    0,    0,    0,    0,  282,  283, 
-  314,  315,  346,  347,  378,  379,  350,  351,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-  266,  267,  298,  299,  330,  331,  362,  363,  334,  335,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,  384,  385,  386,  387,  388,  389,  390, 
-  391,  392,  393,    0,    0,    0,    0,    0,    0,  400,  401,  402,  403, 
-  404,  405,  406,  407,  408,  409,    0,    0,    0,    0,    0,    0,  416, 
-  417,  418,  419,  420,  421,  422,  423,  424,  425,    0,    0,    0,    0, 
-    0,    0,  432,  433,  434,  435,  436,  437,  438,  439,  440,  441,    0, 
-    0,    0,    0,    0,    0,  448,  449,  450,  451,  452,  453,  454,  455, 
-  456,  457,    0,    0,    0,    0,    0,    0,  464,  465,  466,  467,  468, 
-  469,  470,  471,  472,  473,    0,    0,    0,    0,    0,    0,  480,  481, 
-  482,  483,  484,  485,  486,  487,  488,  489,    0,    0,    0,    0,    0, 
-    0,  496,  497,  498,  499,  500,  501,  502,  503,  504,  505,    0,    0, 
-    0,    0,    0,    0,  394,  395,  426,  427,  458,  459,  490,  491,  462, 
-  463,    0,    0,    0,    0,    0,    0,  410,  411,  442,  443,  474,  475, 
-  506,  507,  478,  479,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,  394,  395,  426,  427, 
-  458,  459,  490,  491,  462,  463,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,  512,  513,  514,  515,  516,  517,  518,  519,  520,  521,    0, 
-    0,    0,    0,    0,    0,  528,  529,  530,  531,  532,  533,  534,  535, 
-  536,  537,    0,    0,    0,    0,    0,    0,  544,  545,  546,  547,  548, 
-  549,  550,  551,  552,  553,    0,    0,    0,    0,    0,    0,  560,  561, 
-  562,  563,  564,  565,  566,  567,  568,  569,    0,    0,    0,    0,    0, 
-    0,  576,  577,  578,  579,  580,  581,  582,  583,  584,  585,    0,    0, 
-    0,    0,    0,    0,  592,  593,  594,  595,  596,  597,  598,  599,  600, 
-  601,    0,    0,    0,    0,    0,    0,  608,  609,  610,  611,  612,  613, 
-  614,  615,  616,  617,    0,    0,    0,    0,    0,    0,  624,  625,  626, 
-  627,  628,  629,  630,  631,  632,  633,    0,    0,    0,    0,    0,    0, 
-  522,  523,  554,  555,  586,  587,  618,  619,  590,  591,    0,    0,    0, 
-    0,    0,    0,  538,  539,  570,  571,  602,  603,  634,  635,  606,  607, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,  522,  523,  554,  555,  586,  587,  618,  619, 
-  590,  591,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  640,  641, 
-  642,  643,  644,  645,  646,  647,  648,  649,    0,    0,    0,    0,    0, 
-    0,  656,  657,  658,  659,  660,  661,  662,  663,  664,  665,    0,    0, 
-    0,    0,    0,    0,  672,  673,  674,  675,  676,  677,  678,  679,  680, 
-  681,    0,    0,    0,    0,    0,    0,  688,  689,  690,  691,  692,  693, 
-  694,  695,  696,  697,    0,    0,    0,    0,    0,    0,  704,  705,  706, 
-  707,  708,  709,  710,  711,  712,  713,    0,    0,    0,    0,    0,    0, 
-  720,  721,  722,  723,  724,  725,  726,  727,  728,  729,    0,    0,    0, 
-    0,    0,    0,  736,  737,  738,  739,  740,  741,  742,  743,  744,  745, 
-    0,    0,    0,    0,    0,    0,  752,  753,  754,  755,  756,  757,  758, 
-  759,  760,  761,    0,    0,    0,    0,    0,    0,  650,  651,  682,  683, 
-  714,  715,  746,  747,  718,  719,    0,    0,    0,    0,    0,    0,  666, 
-  667,  698,  699,  730,  731,  762,  763,  734,  735,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,  650,  651,  682,  683,  714,  715,  746,  747,  718,  719,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,  768,  769,  770,  771,  772,  773, 
-  774,  775,  776,  777,    0,    0,    0,    0,    0,    0,  784,  785,  786, 
-  787,  788,  789,  790,  791,  792,  793,    0,    0,    0,    0,    0,    0, 
-  800,  801,  802,  803,  804,  805,  806,  807,  808,  809,    0,    0,    0, 
-    0,    0,    0,  816,  817,  818,  819,  820,  821,  822,  823,  824,  825, 
-    0,    0,    0,    0,    0,    0,  832,  833,  834,  835,  836,  837,  838, 
-  839,  840,  841,    0,    0,    0,    0,    0,    0,  848,  849,  850,  851, 
-  852,  853,  854,  855,  856,  857,    0,    0,    0,    0,    0,    0,  864, 
-  865,  866,  867,  868,  869,  870,  871,  872,  873,    0,    0,    0,    0, 
-    0,    0,  880,  881,  882,  883,  884,  885,  886,  887,  888,  889,    0, 
-    0,    0,    0,    0,    0,  778,  779,  810,  811,  842,  843,  874,  875, 
-  846,  847,    0,    0,    0,    0,    0,    0,  794,  795,  826,  827,  858, 
-  859,  890,  891,  862,  863,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  778,  779,  810, 
-  811,  842,  843,  874,  875,  846,  847,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,  896,  897,  898,  899,  900,  901,  902,  903,  904,  905, 
-    0,    0,    0,    0,    0,    0,  912,  913,  914,  915,  916,  917,  918, 
-  919,  920,  921,    0,    0,    0,    0,    0,    0,  928,  929,  930,  931, 
-  932,  933,  934,  935,  936,  937,    0,    0,    0,    0,    0,    0,  944, 
-  945,  946,  947,  948,  949,  950,  951,  952,  953,    0,    0,    0,    0, 
-    0,    0,  960,  961,  962,  963,  964,  965,  966,  967,  968,  969,    0, 
-    0,    0,    0,    0,    0,  976,  977,  978,  979,  980,  981,  982,  983, 
-  984,  985,    0,    0,    0,    0,    0,    0,  992,  993,  994,  995,  996, 
-  997,  998,  999, 1000, 1001,    0,    0,    0,    0,    0,    0, 1008, 1009, 
- 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017,    0,    0,    0,    0,    0, 
-    0,  906,  907,  938,  939,  970,  971, 1002, 1003,  974,  975,    0,    0, 
-    0,    0,    0,    0,  922,  923,  954,  955,  986,  987, 1018, 1019,  990, 
-  991,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,  906,  907,  938,  939,  970,  971, 1002, 
- 1003,  974,  975,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,   12, 
-   13,  268,  269,  524,  525,  780,  781,   46,   47,    0,    0,    0,    0, 
-    0,    0,   28,   29,  284,  285,  540,  541,  796,  797,   62,   63,    0, 
-    0,    0,    0,    0,    0,   44,   45,  300,  301,  556,  557,  812,  813, 
-  302,  303,    0,    0,    0,    0,    0,    0,   60,   61,  316,  317,  572, 
-  573,  828,  829,  318,  319,    0,    0,    0,    0,    0,    0,   76,   77, 
-  332,  333,  588,  589,  844,  845,  558,  559,    0,    0,    0,    0,    0, 
-    0,   92,   93,  348,  349,  604,  605,  860,  861,  574,  575,    0,    0, 
-    0,    0,    0,    0,  108,  109,  364,  365,  620,  621,  876,  877,  814, 
-  815,    0,    0,    0,    0,    0,    0,  124,  125,  380,  381,  636,  637, 
-  892,  893,  830,  831,    0,    0,    0,    0,    0,    0,   14,   15,  270, 
-  271,  526,  527,  782,  783,  110,  111,    0,    0,    0,    0,    0,    0, 
-   30,   31,  286,  287,  542,  543,  798,  799,  126,  127,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,   14,   15,  270,  271,  526,  527,  782,  783,  110,  111,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
-    0,    0,    0,    0,    0,    0,    0,    0,  140,  141,  396,  397,  652, 
-  653,  908,  909,  174,  175,    0,    0,    0,    0,    0,    0,  156,  157, 
-  412,  413,  668,  669,  924,  925,  190,  191,    0,    0,    0,    0,    0, 
-    0,  172,  173,  428,  429,  684,  685,  940,  941,  430,  431,    0,    0, 
-    0,    0,    0,    0,  188,  189,  444,  445,  700,  701,  956,  957,  446, 
-  447,    0,    0,    0,    0,    0,    0,  204,  205,  460,  461,  716,  717, 
-  972,  973,  686,  687,    0,    0,    0,    0,    0,    0,  220,  221,  476, 
-  477,  732,  733,  988,  989,  702,  703,    0,    0,    0,    0,    0,    0, 
-  236,  237,  492,  493,  748,  749, 1004, 1005,  942,  943,    0,    0,    0, 
-    0,    0,    0,  252,  253,  508,  509,  764,  765, 1020, 1021,  958,  959, 
-    0,    0,    0,    0,    0,    0,  142,  143,  398,  399,  654,  655,  910, 
-  911,  238,  239,    0,    0,    0,    0,    0,    0,  158,  159,  414,  415, 
-  670,  671,  926,  927,  254,  255};
-#endif
- 
-#if DEC_DPD2BCD==1 && !defined(DECDPD2BCD)
-#define DECDPD2BCD
- 
-const uint16_t DPD2BCD[1024]={    0,    1,    2,    3,    4,    5,    6,    7, 
-    8,    9,  128,  129, 2048, 2049, 2176, 2177,   16,   17,   18,   19,   20, 
-   21,   22,   23,   24,   25,  144,  145, 2064, 2065, 2192, 2193,   32,   33, 
-   34,   35,   36,   37,   38,   39,   40,   41,  130,  131, 2080, 2081, 2056, 
- 2057,   48,   49,   50,   51,   52,   53,   54,   55,   56,   57,  146,  147, 
- 2096, 2097, 2072, 2073,   64,   65,   66,   67,   68,   69,   70,   71,   72, 
-   73,  132,  133, 2112, 2113,  136,  137,   80,   81,   82,   83,   84,   85, 
-   86,   87,   88,   89,  148,  149, 2128, 2129,  152,  153,   96,   97,   98, 
-   99,  100,  101,  102,  103,  104,  105,  134,  135, 2144, 2145, 2184, 2185, 
-  112,  113,  114,  115,  116,  117,  118,  119,  120,  121,  150,  151, 2160, 
- 2161, 2200, 2201,  256,  257,  258,  259,  260,  261,  262,  263,  264,  265, 
-  384,  385, 2304, 2305, 2432, 2433,  272,  273,  274,  275,  276,  277,  278, 
-  279,  280,  281,  400,  401, 2320, 2321, 2448, 2449,  288,  289,  290,  291, 
-  292,  293,  294,  295,  296,  297,  386,  387, 2336, 2337, 2312, 2313,  304, 
-  305,  306,  307,  308,  309,  310,  311,  312,  313,  402,  403, 2352, 2353, 
- 2328, 2329,  320,  321,  322,  323,  324,  325,  326,  327,  328,  329,  388, 
-  389, 2368, 2369,  392,  393,  336,  337,  338,  339,  340,  341,  342,  343, 
-  344,  345,  404,  405, 2384, 2385,  408,  409,  352,  353,  354,  355,  356, 
-  357,  358,  359,  360,  361,  390,  391, 2400, 2401, 2440, 2441,  368,  369, 
-  370,  371,  372,  373,  374,  375,  376,  377,  406,  407, 2416, 2417, 2456, 
- 2457,  512,  513,  514,  515,  516,  517,  518,  519,  520,  521,  640,  641, 
- 2050, 2051, 2178, 2179,  528,  529,  530,  531,  532,  533,  534,  535,  536, 
-  537,  656,  657, 2066, 2067, 2194, 2195,  544,  545,  546,  547,  548,  549, 
-  550,  551,  552,  553,  642,  643, 2082, 2083, 2088, 2089,  560,  561,  562, 
-  563,  564,  565,  566,  567,  568,  569,  658,  659, 2098, 2099, 2104, 2105, 
-  576,  577,  578,  579,  580,  581,  582,  583,  584,  585,  644,  645, 2114, 
- 2115,  648,  649,  592,  593,  594,  595,  596,  597,  598,  599,  600,  601, 
-  660,  661, 2130, 2131,  664,  665,  608,  609,  610,  611,  612,  613,  614, 
-  615,  616,  617,  646,  647, 2146, 2147, 2184, 2185,  624,  625,  626,  627, 
-  628,  629,  630,  631,  632,  633,  662,  663, 2162, 2163, 2200, 2201,  768, 
-  769,  770,  771,  772,  773,  774,  775,  776,  777,  896,  897, 2306, 2307, 
- 2434, 2435,  784,  785,  786,  787,  788,  789,  790,  791,  792,  793,  912, 
-  913, 2322, 2323, 2450, 2451,  800,  801,  802,  803,  804,  805,  806,  807, 
-  808,  809,  898,  899, 2338, 2339, 2344, 2345,  816,  817,  818,  819,  820, 
-  821,  822,  823,  824,  825,  914,  915, 2354, 2355, 2360, 2361,  832,  833, 
-  834,  835,  836,  837,  838,  839,  840,  841,  900,  901, 2370, 2371,  904, 
-  905,  848,  849,  850,  851,  852,  853,  854,  855,  856,  857,  916,  917, 
- 2386, 2387,  920,  921,  864,  865,  866,  867,  868,  869,  870,  871,  872, 
-  873,  902,  903, 2402, 2403, 2440, 2441,  880,  881,  882,  883,  884,  885, 
-  886,  887,  888,  889,  918,  919, 2418, 2419, 2456, 2457, 1024, 1025, 1026, 
- 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1152, 1153, 2052, 2053, 2180, 2181, 
- 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1168, 1169, 2068, 
- 2069, 2196, 2197, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 
- 1154, 1155, 2084, 2085, 2120, 2121, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 
- 1079, 1080, 1081, 1170, 1171, 2100, 2101, 2136, 2137, 1088, 1089, 1090, 1091, 
- 1092, 1093, 1094, 1095, 1096, 1097, 1156, 1157, 2116, 2117, 1160, 1161, 1104, 
- 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1172, 1173, 2132, 2133, 
- 1176, 1177, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129, 1158, 
- 1159, 2148, 2149, 2184, 2185, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 
- 1144, 1145, 1174, 1175, 2164, 2165, 2200, 2201, 1280, 1281, 1282, 1283, 1284, 
- 1285, 1286, 1287, 1288, 1289, 1408, 1409, 2308, 2309, 2436, 2437, 1296, 1297, 
- 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1424, 1425, 2324, 2325, 2452, 
- 2453, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1410, 1411, 
- 2340, 2341, 2376, 2377, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 
- 1337, 1426, 1427, 2356, 2357, 2392, 2393, 1344, 1345, 1346, 1347, 1348, 1349, 
- 1350, 1351, 1352, 1353, 1412, 1413, 2372, 2373, 1416, 1417, 1360, 1361, 1362, 
- 1363, 1364, 1365, 1366, 1367, 1368, 1369, 1428, 1429, 2388, 2389, 1432, 1433, 
- 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1414, 1415, 2404, 
- 2405, 2440, 2441, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 
- 1430, 1431, 2420, 2421, 2456, 2457, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 
- 1543, 1544, 1545, 1664, 1665, 2054, 2055, 2182, 2183, 1552, 1553, 1554, 1555, 
- 1556, 1557, 1558, 1559, 1560, 1561, 1680, 1681, 2070, 2071, 2198, 2199, 1568, 
- 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1666, 1667, 2086, 2087, 
- 2152, 2153, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1682, 
- 1683, 2102, 2103, 2168, 2169, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 
- 1608, 1609, 1668, 1669, 2118, 2119, 1672, 1673, 1616, 1617, 1618, 1619, 1620, 
- 1621, 1622, 1623, 1624, 1625, 1684, 1685, 2134, 2135, 1688, 1689, 1632, 1633, 
- 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1670, 1671, 2150, 2151, 2184, 
- 2185, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, 1686, 1687, 
- 2166, 2167, 2200, 2201, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, 1800, 
- 1801, 1920, 1921, 2310, 2311, 2438, 2439, 1808, 1809, 1810, 1811, 1812, 1813, 
- 1814, 1815, 1816, 1817, 1936, 1937, 2326, 2327, 2454, 2455, 1824, 1825, 1826, 
- 1827, 1828, 1829, 1830, 1831, 1832, 1833, 1922, 1923, 2342, 2343, 2408, 2409, 
- 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849, 1938, 1939, 2358, 
- 2359, 2424, 2425, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865, 
- 1924, 1925, 2374, 2375, 1928, 1929, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 
- 1879, 1880, 1881, 1940, 1941, 2390, 2391, 1944, 1945, 1888, 1889, 1890, 1891, 
- 1892, 1893, 1894, 1895, 1896, 1897, 1926, 1927, 2406, 2407, 2440, 2441, 1904, 
- 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1942, 1943, 2422, 2423, 
- 2456, 2457};
-#endif
- 
-#if DEC_BIN2DPD==1 && !defined(DECBIN2DPD)
-#define DECBIN2DPD
- 
-const uint16_t BIN2DPD[1000]={    0,    1,    2,    3,    4,    5,    6,    7, 
-    8,    9,   16,   17,   18,   19,   20,   21,   22,   23,   24,   25,   32, 
-   33,   34,   35,   36,   37,   38,   39,   40,   41,   48,   49,   50,   51, 
-   52,   53,   54,   55,   56,   57,   64,   65,   66,   67,   68,   69,   70, 
-   71,   72,   73,   80,   81,   82,   83,   84,   85,   86,   87,   88,   89, 
-   96,   97,   98,   99,  100,  101,  102,  103,  104,  105,  112,  113,  114, 
-  115,  116,  117,  118,  119,  120,  121,   10,   11,   42,   43,   74,   75, 
-  106,  107,   78,   79,   26,   27,   58,   59,   90,   91,  122,  123,   94, 
-   95,  128,  129,  130,  131,  132,  133,  134,  135,  136,  137,  144,  145, 
-  146,  147,  148,  149,  150,  151,  152,  153,  160,  161,  162,  163,  164, 
-  165,  166,  167,  168,  169,  176,  177,  178,  179,  180,  181,  182,  183, 
-  184,  185,  192,  193,  194,  195,  196,  197,  198,  199,  200,  201,  208, 
-  209,  210,  211,  212,  213,  214,  215,  216,  217,  224,  225,  226,  227, 
-  228,  229,  230,  231,  232,  233,  240,  241,  242,  243,  244,  245,  246, 
-  247,  248,  249,  138,  139,  170,  171,  202,  203,  234,  235,  206,  207, 
-  154,  155,  186,  187,  218,  219,  250,  251,  222,  223,  256,  257,  258, 
-  259,  260,  261,  262,  263,  264,  265,  272,  273,  274,  275,  276,  277, 
-  278,  279,  280,  281,  288,  289,  290,  291,  292,  293,  294,  295,  296, 
-  297,  304,  305,  306,  307,  308,  309,  310,  311,  312,  313,  320,  321, 
-  322,  323,  324,  325,  326,  327,  328,  329,  336,  337,  338,  339,  340, 
-  341,  342,  343,  344,  345,  352,  353,  354,  355,  356,  357,  358,  359, 
-  360,  361,  368,  369,  370,  371,  372,  373,  374,  375,  376,  377,  266, 
-  267,  298,  299,  330,  331,  362,  363,  334,  335,  282,  283,  314,  315, 
-  346,  347,  378,  379,  350,  351,  384,  385,  386,  387,  388,  389,  390, 
-  391,  392,  393,  400,  401,  402,  403,  404,  405,  406,  407,  408,  409, 
-  416,  417,  418,  419,  420,  421,  422,  423,  424,  425,  432,  433,  434, 
-  435,  436,  437,  438,  439,  440,  441,  448,  449,  450,  451,  452,  453, 
-  454,  455,  456,  457,  464,  465,  466,  467,  468,  469,  470,  471,  472, 
-  473,  480,  481,  482,  483,  484,  485,  486,  487,  488,  489,  496,  497, 
-  498,  499,  500,  501,  502,  503,  504,  505,  394,  395,  426,  427,  458, 
-  459,  490,  491,  462,  463,  410,  411,  442,  443,  474,  475,  506,  507, 
-  478,  479,  512,  513,  514,  515,  516,  517,  518,  519,  520,  521,  528, 
-  529,  530,  531,  532,  533,  534,  535,  536,  537,  544,  545,  546,  547, 
-  548,  549,  550,  551,  552,  553,  560,  561,  562,  563,  564,  565,  566, 
-  567,  568,  569,  576,  577,  578,  579,  580,  581,  582,  583,  584,  585, 
-  592,  593,  594,  595,  596,  597,  598,  599,  600,  601,  608,  609,  610, 
-  611,  612,  613,  614,  615,  616,  617,  624,  625,  626,  627,  628,  629, 
-  630,  631,  632,  633,  522,  523,  554,  555,  586,  587,  618,  619,  590, 
-  591,  538,  539,  570,  571,  602,  603,  634,  635,  606,  607,  640,  641, 
-  642,  643,  644,  645,  646,  647,  648,  649,  656,  657,  658,  659,  660, 
-  661,  662,  663,  664,  665,  672,  673,  674,  675,  676,  677,  678,  679, 
-  680,  681,  688,  689,  690,  691,  692,  693,  694,  695,  696,  697,  704, 
-  705,  706,  707,  708,  709,  710,  711,  712,  713,  720,  721,  722,  723, 
-  724,  725,  726,  727,  728,  729,  736,  737,  738,  739,  740,  741,  742, 
-  743,  744,  745,  752,  753,  754,  755,  756,  757,  758,  759,  760,  761, 
-  650,  651,  682,  683,  714,  715,  746,  747,  718,  719,  666,  667,  698, 
-  699,  730,  731,  762,  763,  734,  735,  768,  769,  770,  771,  772,  773, 
-  774,  775,  776,  777,  784,  785,  786,  787,  788,  789,  790,  791,  792, 
-  793,  800,  801,  802,  803,  804,  805,  806,  807,  808,  809,  816,  817, 
-  818,  819,  820,  821,  822,  823,  824,  825,  832,  833,  834,  835,  836, 
-  837,  838,  839,  840,  841,  848,  849,  850,  851,  852,  853,  854,  855, 
-  856,  857,  864,  865,  866,  867,  868,  869,  870,  871,  872,  873,  880, 
-  881,  882,  883,  884,  885,  886,  887,  888,  889,  778,  779,  810,  811, 
-  842,  843,  874,  875,  846,  847,  794,  795,  826,  827,  858,  859,  890, 
-  891,  862,  863,  896,  897,  898,  899,  900,  901,  902,  903,  904,  905, 
-  912,  913,  914,  915,  916,  917,  918,  919,  920,  921,  928,  929,  930, 
-  931,  932,  933,  934,  935,  936,  937,  944,  945,  946,  947,  948,  949, 
-  950,  951,  952,  953,  960,  961,  962,  963,  964,  965,  966,  967,  968, 
-  969,  976,  977,  978,  979,  980,  981,  982,  983,  984,  985,  992,  993, 
-  994,  995,  996,  997,  998,  999, 1000, 1001, 1008, 1009, 1010, 1011, 1012, 
- 1013, 1014, 1015, 1016, 1017,  906,  907,  938,  939,  970,  971, 1002, 1003, 
-  974,  975,  922,  923,  954,  955,  986,  987, 1018, 1019,  990,  991,   12, 
-   13,  268,  269,  524,  525,  780,  781,   46,   47,   28,   29,  284,  285, 
-  540,  541,  796,  797,   62,   63,   44,   45,  300,  301,  556,  557,  812, 
-  813,  302,  303,   60,   61,  316,  317,  572,  573,  828,  829,  318,  319, 
-   76,   77,  332,  333,  588,  589,  844,  845,  558,  559,   92,   93,  348, 
-  349,  604,  605,  860,  861,  574,  575,  108,  109,  364,  365,  620,  621, 
-  876,  877,  814,  815,  124,  125,  380,  381,  636,  637,  892,  893,  830, 
-  831,   14,   15,  270,  271,  526,  527,  782,  783,  110,  111,   30,   31, 
-  286,  287,  542,  543,  798,  799,  126,  127,  140,  141,  396,  397,  652, 
-  653,  908,  909,  174,  175,  156,  157,  412,  413,  668,  669,  924,  925, 
-  190,  191,  172,  173,  428,  429,  684,  685,  940,  941,  430,  431,  188, 
-  189,  444,  445,  700,  701,  956,  957,  446,  447,  204,  205,  460,  461, 
-  716,  717,  972,  973,  686,  687,  220,  221,  476,  477,  732,  733,  988, 
-  989,  702,  703,  236,  237,  492,  493,  748,  749, 1004, 1005,  942,  943, 
-  252,  253,  508,  509,  764,  765, 1020, 1021,  958,  959,  142,  143,  398, 
-  399,  654,  655,  910,  911,  238,  239,  158,  159,  414,  415,  670,  671, 
-  926,  927,  254,  255};
-#endif 
- 
-#if DEC_DPD2BIN==1 && !defined(DECDPD2BIN)
-#define DECDPD2BIN
- 
-const uint16_t DPD2BIN[1024]={    0,    1,    2,    3,    4,    5,    6,    7, 
-    8,    9,   80,   81,  800,  801,  880,  881,   10,   11,   12,   13,   14, 
-   15,   16,   17,   18,   19,   90,   91,  810,  811,  890,  891,   20,   21, 
-   22,   23,   24,   25,   26,   27,   28,   29,   82,   83,  820,  821,  808, 
-  809,   30,   31,   32,   33,   34,   35,   36,   37,   38,   39,   92,   93, 
-  830,  831,  818,  819,   40,   41,   42,   43,   44,   45,   46,   47,   48, 
-   49,   84,   85,  840,  841,   88,   89,   50,   51,   52,   53,   54,   55, 
-   56,   57,   58,   59,   94,   95,  850,  851,   98,   99,   60,   61,   62, 
-   63,   64,   65,   66,   67,   68,   69,   86,   87,  860,  861,  888,  889, 
-   70,   71,   72,   73,   74,   75,   76,   77,   78,   79,   96,   97,  870, 
-  871,  898,  899,  100,  101,  102,  103,  104,  105,  106,  107,  108,  109, 
-  180,  181,  900,  901,  980,  981,  110,  111,  112,  113,  114,  115,  116, 
-  117,  118,  119,  190,  191,  910,  911,  990,  991,  120,  121,  122,  123, 
-  124,  125,  126,  127,  128,  129,  182,  183,  920,  921,  908,  909,  130, 
-  131,  132,  133,  134,  135,  136,  137,  138,  139,  192,  193,  930,  931, 
-  918,  919,  140,  141,  142,  143,  144,  145,  146,  147,  148,  149,  184, 
-  185,  940,  941,  188,  189,  150,  151,  152,  153,  154,  155,  156,  157, 
-  158,  159,  194,  195,  950,  951,  198,  199,  160,  161,  162,  163,  164, 
-  165,  166,  167,  168,  169,  186,  187,  960,  961,  988,  989,  170,  171, 
-  172,  173,  174,  175,  176,  177,  178,  179,  196,  197,  970,  971,  998, 
-  999,  200,  201,  202,  203,  204,  205,  206,  207,  208,  209,  280,  281, 
-  802,  803,  882,  883,  210,  211,  212,  213,  214,  215,  216,  217,  218, 
-  219,  290,  291,  812,  813,  892,  893,  220,  221,  222,  223,  224,  225, 
-  226,  227,  228,  229,  282,  283,  822,  823,  828,  829,  230,  231,  232, 
-  233,  234,  235,  236,  237,  238,  239,  292,  293,  832,  833,  838,  839, 
-  240,  241,  242,  243,  244,  245,  246,  247,  248,  249,  284,  285,  842, 
-  843,  288,  289,  250,  251,  252,  253,  254,  255,  256,  257,  258,  259, 
-  294,  295,  852,  853,  298,  299,  260,  261,  262,  263,  264,  265,  266, 
-  267,  268,  269,  286,  287,  862,  863,  888,  889,  270,  271,  272,  273, 
-  274,  275,  276,  277,  278,  279,  296,  297,  872,  873,  898,  899,  300, 
-  301,  302,  303,  304,  305,  306,  307,  308,  309,  380,  381,  902,  903, 
-  982,  983,  310,  311,  312,  313,  314,  315,  316,  317,  318,  319,  390, 
-  391,  912,  913,  992,  993,  320,  321,  322,  323,  324,  325,  326,  327, 
-  328,  329,  382,  383,  922,  923,  928,  929,  330,  331,  332,  333,  334, 
-  335,  336,  337,  338,  339,  392,  393,  932,  933,  938,  939,  340,  341, 
-  342,  343,  344,  345,  346,  347,  348,  349,  384,  385,  942,  943,  388, 
-  389,  350,  351,  352,  353,  354,  355,  356,  357,  358,  359,  394,  395, 
-  952,  953,  398,  399,  360,  361,  362,  363,  364,  365,  366,  367,  368, 
-  369,  386,  387,  962,  963,  988,  989,  370,  371,  372,  373,  374,  375, 
-  376,  377,  378,  379,  396,  397,  972,  973,  998,  999,  400,  401,  402, 
-  403,  404,  405,  406,  407,  408,  409,  480,  481,  804,  805,  884,  885, 
-  410,  411,  412,  413,  414,  415,  416,  417,  418,  419,  490,  491,  814, 
-  815,  894,  895,  420,  421,  422,  423,  424,  425,  426,  427,  428,  429, 
-  482,  483,  824,  825,  848,  849,  430,  431,  432,  433,  434,  435,  436, 
-  437,  438,  439,  492,  493,  834,  835,  858,  859,  440,  441,  442,  443, 
-  444,  445,  446,  447,  448,  449,  484,  485,  844,  845,  488,  489,  450, 
-  451,  452,  453,  454,  455,  456,  457,  458,  459,  494,  495,  854,  855, 
-  498,  499,  460,  461,  462,  463,  464,  465,  466,  467,  468,  469,  486, 
-  487,  864,  865,  888,  889,  470,  471,  472,  473,  474,  475,  476,  477, 
-  478,  479,  496,  497,  874,  875,  898,  899,  500,  501,  502,  503,  504, 
-  505,  506,  507,  508,  509,  580,  581,  904,  905,  984,  985,  510,  511, 
-  512,  513,  514,  515,  516,  517,  518,  519,  590,  591,  914,  915,  994, 
-  995,  520,  521,  522,  523,  524,  525,  526,  527,  528,  529,  582,  583, 
-  924,  925,  948,  949,  530,  531,  532,  533,  534,  535,  536,  537,  538, 
-  539,  592,  593,  934,  935,  958,  959,  540,  541,  542,  543,  544,  545, 
-  546,  547,  548,  549,  584,  585,  944,  945,  588,  589,  550,  551,  552, 
-  553,  554,  555,  556,  557,  558,  559,  594,  595,  954,  955,  598,  599, 
-  560,  561,  562,  563,  564,  565,  566,  567,  568,  569,  586,  587,  964, 
-  965,  988,  989,  570,  571,  572,  573,  574,  575,  576,  577,  578,  579, 
-  596,  597,  974,  975,  998,  999,  600,  601,  602,  603,  604,  605,  606, 
-  607,  608,  609,  680,  681,  806,  807,  886,  887,  610,  611,  612,  613, 
-  614,  615,  616,  617,  618,  619,  690,  691,  816,  817,  896,  897,  620, 
-  621,  622,  623,  624,  625,  626,  627,  628,  629,  682,  683,  826,  827, 
-  868,  869,  630,  631,  632,  633,  634,  635,  636,  637,  638,  639,  692, 
-  693,  836,  837,  878,  879,  640,  641,  642,  643,  644,  645,  646,  647, 
-  648,  649,  684,  685,  846,  847,  688,  689,  650,  651,  652,  653,  654, 
-  655,  656,  657,  658,  659,  694,  695,  856,  857,  698,  699,  660,  661, 
-  662,  663,  664,  665,  666,  667,  668,  669,  686,  687,  866,  867,  888, 
-  889,  670,  671,  672,  673,  674,  675,  676,  677,  678,  679,  696,  697, 
-  876,  877,  898,  899,  700,  701,  702,  703,  704,  705,  706,  707,  708, 
-  709,  780,  781,  906,  907,  986,  987,  710,  711,  712,  713,  714,  715, 
-  716,  717,  718,  719,  790,  791,  916,  917,  996,  997,  720,  721,  722, 
-  723,  724,  725,  726,  727,  728,  729,  782,  783,  926,  927,  968,  969, 
-  730,  731,  732,  733,  734,  735,  736,  737,  738,  739,  792,  793,  936, 
-  937,  978,  979,  740,  741,  742,  743,  744,  745,  746,  747,  748,  749, 
-  784,  785,  946,  947,  788,  789,  750,  751,  752,  753,  754,  755,  756, 
-  757,  758,  759,  794,  795,  956,  957,  798,  799,  760,  761,  762,  763, 
-  764,  765,  766,  767,  768,  769,  786,  787,  966,  967,  988,  989,  770, 
-  771,  772,  773,  774,  775,  776,  777,  778,  779,  796,  797,  976,  977, 
-  998,  999};
-#endif
- 
-#if DEC_BIN2CHAR==1 && !defined(DECBIN2CHAR)
-#define DECBIN2CHAR
- 
-const uint8_t BIN2CHAR[4001]={
- '\0','0','0','0', '\1','0','0','1', '\1','0','0','2', '\1','0','0','3', '\1','0','0','4', 
- '\1','0','0','5', '\1','0','0','6', '\1','0','0','7', '\1','0','0','8', '\1','0','0','9', 
- '\2','0','1','0', '\2','0','1','1', '\2','0','1','2', '\2','0','1','3', '\2','0','1','4', 
- '\2','0','1','5', '\2','0','1','6', '\2','0','1','7', '\2','0','1','8', '\2','0','1','9', 
- '\2','0','2','0', '\2','0','2','1', '\2','0','2','2', '\2','0','2','3', '\2','0','2','4', 
- '\2','0','2','5', '\2','0','2','6', '\2','0','2','7', '\2','0','2','8', '\2','0','2','9', 
- '\2','0','3','0', '\2','0','3','1', '\2','0','3','2', '\2','0','3','3', '\2','0','3','4', 
- '\2','0','3','5', '\2','0','3','6', '\2','0','3','7', '\2','0','3','8', '\2','0','3','9', 
- '\2','0','4','0', '\2','0','4','1', '\2','0','4','2', '\2','0','4','3', '\2','0','4','4', 
- '\2','0','4','5', '\2','0','4','6', '\2','0','4','7', '\2','0','4','8', '\2','0','4','9', 
- '\2','0','5','0', '\2','0','5','1', '\2','0','5','2', '\2','0','5','3', '\2','0','5','4', 
- '\2','0','5','5', '\2','0','5','6', '\2','0','5','7', '\2','0','5','8', '\2','0','5','9', 
- '\2','0','6','0', '\2','0','6','1', '\2','0','6','2', '\2','0','6','3', '\2','0','6','4', 
- '\2','0','6','5', '\2','0','6','6', '\2','0','6','7', '\2','0','6','8', '\2','0','6','9', 
- '\2','0','7','0', '\2','0','7','1', '\2','0','7','2', '\2','0','7','3', '\2','0','7','4', 
- '\2','0','7','5', '\2','0','7','6', '\2','0','7','7', '\2','0','7','8', '\2','0','7','9', 
- '\2','0','8','0', '\2','0','8','1', '\2','0','8','2', '\2','0','8','3', '\2','0','8','4', 
- '\2','0','8','5', '\2','0','8','6', '\2','0','8','7', '\2','0','8','8', '\2','0','8','9', 
- '\2','0','9','0', '\2','0','9','1', '\2','0','9','2', '\2','0','9','3', '\2','0','9','4', 
- '\2','0','9','5', '\2','0','9','6', '\2','0','9','7', '\2','0','9','8', '\2','0','9','9', 
- '\3','1','0','0', '\3','1','0','1', '\3','1','0','2', '\3','1','0','3', '\3','1','0','4', 
- '\3','1','0','5', '\3','1','0','6', '\3','1','0','7', '\3','1','0','8', '\3','1','0','9', 
- '\3','1','1','0', '\3','1','1','1', '\3','1','1','2', '\3','1','1','3', '\3','1','1','4', 
- '\3','1','1','5', '\3','1','1','6', '\3','1','1','7', '\3','1','1','8', '\3','1','1','9', 
- '\3','1','2','0', '\3','1','2','1', '\3','1','2','2', '\3','1','2','3', '\3','1','2','4', 
- '\3','1','2','5', '\3','1','2','6', '\3','1','2','7', '\3','1','2','8', '\3','1','2','9', 
- '\3','1','3','0', '\3','1','3','1', '\3','1','3','2', '\3','1','3','3', '\3','1','3','4', 
- '\3','1','3','5', '\3','1','3','6', '\3','1','3','7', '\3','1','3','8', '\3','1','3','9', 
- '\3','1','4','0', '\3','1','4','1', '\3','1','4','2', '\3','1','4','3', '\3','1','4','4', 
- '\3','1','4','5', '\3','1','4','6', '\3','1','4','7', '\3','1','4','8', '\3','1','4','9', 
- '\3','1','5','0', '\3','1','5','1', '\3','1','5','2', '\3','1','5','3', '\3','1','5','4', 
- '\3','1','5','5', '\3','1','5','6', '\3','1','5','7', '\3','1','5','8', '\3','1','5','9', 
- '\3','1','6','0', '\3','1','6','1', '\3','1','6','2', '\3','1','6','3', '\3','1','6','4', 
- '\3','1','6','5', '\3','1','6','6', '\3','1','6','7', '\3','1','6','8', '\3','1','6','9', 
- '\3','1','7','0', '\3','1','7','1', '\3','1','7','2', '\3','1','7','3', '\3','1','7','4', 
- '\3','1','7','5', '\3','1','7','6', '\3','1','7','7', '\3','1','7','8', '\3','1','7','9', 
- '\3','1','8','0', '\3','1','8','1', '\3','1','8','2', '\3','1','8','3', '\3','1','8','4', 
- '\3','1','8','5', '\3','1','8','6', '\3','1','8','7', '\3','1','8','8', '\3','1','8','9', 
- '\3','1','9','0', '\3','1','9','1', '\3','1','9','2', '\3','1','9','3', '\3','1','9','4', 
- '\3','1','9','5', '\3','1','9','6', '\3','1','9','7', '\3','1','9','8', '\3','1','9','9', 
- '\3','2','0','0', '\3','2','0','1', '\3','2','0','2', '\3','2','0','3', '\3','2','0','4', 
- '\3','2','0','5', '\3','2','0','6', '\3','2','0','7', '\3','2','0','8', '\3','2','0','9', 
- '\3','2','1','0', '\3','2','1','1', '\3','2','1','2', '\3','2','1','3', '\3','2','1','4', 
- '\3','2','1','5', '\3','2','1','6', '\3','2','1','7', '\3','2','1','8', '\3','2','1','9', 
- '\3','2','2','0', '\3','2','2','1', '\3','2','2','2', '\3','2','2','3', '\3','2','2','4', 
- '\3','2','2','5', '\3','2','2','6', '\3','2','2','7', '\3','2','2','8', '\3','2','2','9', 
- '\3','2','3','0', '\3','2','3','1', '\3','2','3','2', '\3','2','3','3', '\3','2','3','4', 
- '\3','2','3','5', '\3','2','3','6', '\3','2','3','7', '\3','2','3','8', '\3','2','3','9', 
- '\3','2','4','0', '\3','2','4','1', '\3','2','4','2', '\3','2','4','3', '\3','2','4','4', 
- '\3','2','4','5', '\3','2','4','6', '\3','2','4','7', '\3','2','4','8', '\3','2','4','9', 
- '\3','2','5','0', '\3','2','5','1', '\3','2','5','2', '\3','2','5','3', '\3','2','5','4', 
- '\3','2','5','5', '\3','2','5','6', '\3','2','5','7', '\3','2','5','8', '\3','2','5','9', 
- '\3','2','6','0', '\3','2','6','1', '\3','2','6','2', '\3','2','6','3', '\3','2','6','4', 
- '\3','2','6','5', '\3','2','6','6', '\3','2','6','7', '\3','2','6','8', '\3','2','6','9', 
- '\3','2','7','0', '\3','2','7','1', '\3','2','7','2', '\3','2','7','3', '\3','2','7','4', 
- '\3','2','7','5', '\3','2','7','6', '\3','2','7','7', '\3','2','7','8', '\3','2','7','9', 
- '\3','2','8','0', '\3','2','8','1', '\3','2','8','2', '\3','2','8','3', '\3','2','8','4', 
- '\3','2','8','5', '\3','2','8','6', '\3','2','8','7', '\3','2','8','8', '\3','2','8','9', 
- '\3','2','9','0', '\3','2','9','1', '\3','2','9','2', '\3','2','9','3', '\3','2','9','4', 
- '\3','2','9','5', '\3','2','9','6', '\3','2','9','7', '\3','2','9','8', '\3','2','9','9', 
- '\3','3','0','0', '\3','3','0','1', '\3','3','0','2', '\3','3','0','3', '\3','3','0','4', 
- '\3','3','0','5', '\3','3','0','6', '\3','3','0','7', '\3','3','0','8', '\3','3','0','9', 
- '\3','3','1','0', '\3','3','1','1', '\3','3','1','2', '\3','3','1','3', '\3','3','1','4', 
- '\3','3','1','5', '\3','3','1','6', '\3','3','1','7', '\3','3','1','8', '\3','3','1','9', 
- '\3','3','2','0', '\3','3','2','1', '\3','3','2','2', '\3','3','2','3', '\3','3','2','4', 
- '\3','3','2','5', '\3','3','2','6', '\3','3','2','7', '\3','3','2','8', '\3','3','2','9', 
- '\3','3','3','0', '\3','3','3','1', '\3','3','3','2', '\3','3','3','3', '\3','3','3','4', 
- '\3','3','3','5', '\3','3','3','6', '\3','3','3','7', '\3','3','3','8', '\3','3','3','9', 
- '\3','3','4','0', '\3','3','4','1', '\3','3','4','2', '\3','3','4','3', '\3','3','4','4', 
- '\3','3','4','5', '\3','3','4','6', '\3','3','4','7', '\3','3','4','8', '\3','3','4','9', 
- '\3','3','5','0', '\3','3','5','1', '\3','3','5','2', '\3','3','5','3', '\3','3','5','4', 
- '\3','3','5','5', '\3','3','5','6', '\3','3','5','7', '\3','3','5','8', '\3','3','5','9', 
- '\3','3','6','0', '\3','3','6','1', '\3','3','6','2', '\3','3','6','3', '\3','3','6','4', 
- '\3','3','6','5', '\3','3','6','6', '\3','3','6','7', '\3','3','6','8', '\3','3','6','9', 
- '\3','3','7','0', '\3','3','7','1', '\3','3','7','2', '\3','3','7','3', '\3','3','7','4', 
- '\3','3','7','5', '\3','3','7','6', '\3','3','7','7', '\3','3','7','8', '\3','3','7','9', 
- '\3','3','8','0', '\3','3','8','1', '\3','3','8','2', '\3','3','8','3', '\3','3','8','4', 
- '\3','3','8','5', '\3','3','8','6', '\3','3','8','7', '\3','3','8','8', '\3','3','8','9', 
- '\3','3','9','0', '\3','3','9','1', '\3','3','9','2', '\3','3','9','3', '\3','3','9','4', 
- '\3','3','9','5', '\3','3','9','6', '\3','3','9','7', '\3','3','9','8', '\3','3','9','9', 
- '\3','4','0','0', '\3','4','0','1', '\3','4','0','2', '\3','4','0','3', '\3','4','0','4', 
- '\3','4','0','5', '\3','4','0','6', '\3','4','0','7', '\3','4','0','8', '\3','4','0','9', 
- '\3','4','1','0', '\3','4','1','1', '\3','4','1','2', '\3','4','1','3', '\3','4','1','4', 
- '\3','4','1','5', '\3','4','1','6', '\3','4','1','7', '\3','4','1','8', '\3','4','1','9', 
- '\3','4','2','0', '\3','4','2','1', '\3','4','2','2', '\3','4','2','3', '\3','4','2','4', 
- '\3','4','2','5', '\3','4','2','6', '\3','4','2','7', '\3','4','2','8', '\3','4','2','9', 
- '\3','4','3','0', '\3','4','3','1', '\3','4','3','2', '\3','4','3','3', '\3','4','3','4', 
- '\3','4','3','5', '\3','4','3','6', '\3','4','3','7', '\3','4','3','8', '\3','4','3','9', 
- '\3','4','4','0', '\3','4','4','1', '\3','4','4','2', '\3','4','4','3', '\3','4','4','4', 
- '\3','4','4','5', '\3','4','4','6', '\3','4','4','7', '\3','4','4','8', '\3','4','4','9', 
- '\3','4','5','0', '\3','4','5','1', '\3','4','5','2', '\3','4','5','3', '\3','4','5','4', 
- '\3','4','5','5', '\3','4','5','6', '\3','4','5','7', '\3','4','5','8', '\3','4','5','9', 
- '\3','4','6','0', '\3','4','6','1', '\3','4','6','2', '\3','4','6','3', '\3','4','6','4', 
- '\3','4','6','5', '\3','4','6','6', '\3','4','6','7', '\3','4','6','8', '\3','4','6','9', 
- '\3','4','7','0', '\3','4','7','1', '\3','4','7','2', '\3','4','7','3', '\3','4','7','4', 
- '\3','4','7','5', '\3','4','7','6', '\3','4','7','7', '\3','4','7','8', '\3','4','7','9', 
- '\3','4','8','0', '\3','4','8','1', '\3','4','8','2', '\3','4','8','3', '\3','4','8','4', 
- '\3','4','8','5', '\3','4','8','6', '\3','4','8','7', '\3','4','8','8', '\3','4','8','9', 
- '\3','4','9','0', '\3','4','9','1', '\3','4','9','2', '\3','4','9','3', '\3','4','9','4', 
- '\3','4','9','5', '\3','4','9','6', '\3','4','9','7', '\3','4','9','8', '\3','4','9','9', 
- '\3','5','0','0', '\3','5','0','1', '\3','5','0','2', '\3','5','0','3', '\3','5','0','4', 
- '\3','5','0','5', '\3','5','0','6', '\3','5','0','7', '\3','5','0','8', '\3','5','0','9', 
- '\3','5','1','0', '\3','5','1','1', '\3','5','1','2', '\3','5','1','3', '\3','5','1','4', 
- '\3','5','1','5', '\3','5','1','6', '\3','5','1','7', '\3','5','1','8', '\3','5','1','9', 
- '\3','5','2','0', '\3','5','2','1', '\3','5','2','2', '\3','5','2','3', '\3','5','2','4', 
- '\3','5','2','5', '\3','5','2','6', '\3','5','2','7', '\3','5','2','8', '\3','5','2','9', 
- '\3','5','3','0', '\3','5','3','1', '\3','5','3','2', '\3','5','3','3', '\3','5','3','4', 
- '\3','5','3','5', '\3','5','3','6', '\3','5','3','7', '\3','5','3','8', '\3','5','3','9', 
- '\3','5','4','0', '\3','5','4','1', '\3','5','4','2', '\3','5','4','3', '\3','5','4','4', 
- '\3','5','4','5', '\3','5','4','6', '\3','5','4','7', '\3','5','4','8', '\3','5','4','9', 
- '\3','5','5','0', '\3','5','5','1', '\3','5','5','2', '\3','5','5','3', '\3','5','5','4', 
- '\3','5','5','5', '\3','5','5','6', '\3','5','5','7', '\3','5','5','8', '\3','5','5','9', 
- '\3','5','6','0', '\3','5','6','1', '\3','5','6','2', '\3','5','6','3', '\3','5','6','4', 
- '\3','5','6','5', '\3','5','6','6', '\3','5','6','7', '\3','5','6','8', '\3','5','6','9', 
- '\3','5','7','0', '\3','5','7','1', '\3','5','7','2', '\3','5','7','3', '\3','5','7','4', 
- '\3','5','7','5', '\3','5','7','6', '\3','5','7','7', '\3','5','7','8', '\3','5','7','9', 
- '\3','5','8','0', '\3','5','8','1', '\3','5','8','2', '\3','5','8','3', '\3','5','8','4', 
- '\3','5','8','5', '\3','5','8','6', '\3','5','8','7', '\3','5','8','8', '\3','5','8','9', 
- '\3','5','9','0', '\3','5','9','1', '\3','5','9','2', '\3','5','9','3', '\3','5','9','4', 
- '\3','5','9','5', '\3','5','9','6', '\3','5','9','7', '\3','5','9','8', '\3','5','9','9', 
- '\3','6','0','0', '\3','6','0','1', '\3','6','0','2', '\3','6','0','3', '\3','6','0','4', 
- '\3','6','0','5', '\3','6','0','6', '\3','6','0','7', '\3','6','0','8', '\3','6','0','9', 
- '\3','6','1','0', '\3','6','1','1', '\3','6','1','2', '\3','6','1','3', '\3','6','1','4', 
- '\3','6','1','5', '\3','6','1','6', '\3','6','1','7', '\3','6','1','8', '\3','6','1','9', 
- '\3','6','2','0', '\3','6','2','1', '\3','6','2','2', '\3','6','2','3', '\3','6','2','4', 
- '\3','6','2','5', '\3','6','2','6', '\3','6','2','7', '\3','6','2','8', '\3','6','2','9', 
- '\3','6','3','0', '\3','6','3','1', '\3','6','3','2', '\3','6','3','3', '\3','6','3','4', 
- '\3','6','3','5', '\3','6','3','6', '\3','6','3','7', '\3','6','3','8', '\3','6','3','9', 
- '\3','6','4','0', '\3','6','4','1', '\3','6','4','2', '\3','6','4','3', '\3','6','4','4', 
- '\3','6','4','5', '\3','6','4','6', '\3','6','4','7', '\3','6','4','8', '\3','6','4','9', 
- '\3','6','5','0', '\3','6','5','1', '\3','6','5','2', '\3','6','5','3', '\3','6','5','4', 
- '\3','6','5','5', '\3','6','5','6', '\3','6','5','7', '\3','6','5','8', '\3','6','5','9', 
- '\3','6','6','0', '\3','6','6','1', '\3','6','6','2', '\3','6','6','3', '\3','6','6','4', 
- '\3','6','6','5', '\3','6','6','6', '\3','6','6','7', '\3','6','6','8', '\3','6','6','9', 
- '\3','6','7','0', '\3','6','7','1', '\3','6','7','2', '\3','6','7','3', '\3','6','7','4', 
- '\3','6','7','5', '\3','6','7','6', '\3','6','7','7', '\3','6','7','8', '\3','6','7','9', 
- '\3','6','8','0', '\3','6','8','1', '\3','6','8','2', '\3','6','8','3', '\3','6','8','4', 
- '\3','6','8','5', '\3','6','8','6', '\3','6','8','7', '\3','6','8','8', '\3','6','8','9', 
- '\3','6','9','0', '\3','6','9','1', '\3','6','9','2', '\3','6','9','3', '\3','6','9','4', 
- '\3','6','9','5', '\3','6','9','6', '\3','6','9','7', '\3','6','9','8', '\3','6','9','9', 
- '\3','7','0','0', '\3','7','0','1', '\3','7','0','2', '\3','7','0','3', '\3','7','0','4', 
- '\3','7','0','5', '\3','7','0','6', '\3','7','0','7', '\3','7','0','8', '\3','7','0','9', 
- '\3','7','1','0', '\3','7','1','1', '\3','7','1','2', '\3','7','1','3', '\3','7','1','4', 
- '\3','7','1','5', '\3','7','1','6', '\3','7','1','7', '\3','7','1','8', '\3','7','1','9', 
- '\3','7','2','0', '\3','7','2','1', '\3','7','2','2', '\3','7','2','3', '\3','7','2','4', 
- '\3','7','2','5', '\3','7','2','6', '\3','7','2','7', '\3','7','2','8', '\3','7','2','9', 
- '\3','7','3','0', '\3','7','3','1', '\3','7','3','2', '\3','7','3','3', '\3','7','3','4', 
- '\3','7','3','5', '\3','7','3','6', '\3','7','3','7', '\3','7','3','8', '\3','7','3','9', 
- '\3','7','4','0', '\3','7','4','1', '\3','7','4','2', '\3','7','4','3', '\3','7','4','4', 
- '\3','7','4','5', '\3','7','4','6', '\3','7','4','7', '\3','7','4','8', '\3','7','4','9', 
- '\3','7','5','0', '\3','7','5','1', '\3','7','5','2', '\3','7','5','3', '\3','7','5','4', 
- '\3','7','5','5', '\3','7','5','6', '\3','7','5','7', '\3','7','5','8', '\3','7','5','9', 
- '\3','7','6','0', '\3','7','6','1', '\3','7','6','2', '\3','7','6','3', '\3','7','6','4', 
- '\3','7','6','5', '\3','7','6','6', '\3','7','6','7', '\3','7','6','8', '\3','7','6','9', 
- '\3','7','7','0', '\3','7','7','1', '\3','7','7','2', '\3','7','7','3', '\3','7','7','4', 
- '\3','7','7','5', '\3','7','7','6', '\3','7','7','7', '\3','7','7','8', '\3','7','7','9', 
- '\3','7','8','0', '\3','7','8','1', '\3','7','8','2', '\3','7','8','3', '\3','7','8','4', 
- '\3','7','8','5', '\3','7','8','6', '\3','7','8','7', '\3','7','8','8', '\3','7','8','9', 
- '\3','7','9','0', '\3','7','9','1', '\3','7','9','2', '\3','7','9','3', '\3','7','9','4', 
- '\3','7','9','5', '\3','7','9','6', '\3','7','9','7', '\3','7','9','8', '\3','7','9','9', 
- '\3','8','0','0', '\3','8','0','1', '\3','8','0','2', '\3','8','0','3', '\3','8','0','4', 
- '\3','8','0','5', '\3','8','0','6', '\3','8','0','7', '\3','8','0','8', '\3','8','0','9', 
- '\3','8','1','0', '\3','8','1','1', '\3','8','1','2', '\3','8','1','3', '\3','8','1','4', 
- '\3','8','1','5', '\3','8','1','6', '\3','8','1','7', '\3','8','1','8', '\3','8','1','9', 
- '\3','8','2','0', '\3','8','2','1', '\3','8','2','2', '\3','8','2','3', '\3','8','2','4', 
- '\3','8','2','5', '\3','8','2','6', '\3','8','2','7', '\3','8','2','8', '\3','8','2','9', 
- '\3','8','3','0', '\3','8','3','1', '\3','8','3','2', '\3','8','3','3', '\3','8','3','4', 
- '\3','8','3','5', '\3','8','3','6', '\3','8','3','7', '\3','8','3','8', '\3','8','3','9', 
- '\3','8','4','0', '\3','8','4','1', '\3','8','4','2', '\3','8','4','3', '\3','8','4','4', 
- '\3','8','4','5', '\3','8','4','6', '\3','8','4','7', '\3','8','4','8', '\3','8','4','9', 
- '\3','8','5','0', '\3','8','5','1', '\3','8','5','2', '\3','8','5','3', '\3','8','5','4', 
- '\3','8','5','5', '\3','8','5','6', '\3','8','5','7', '\3','8','5','8', '\3','8','5','9', 
- '\3','8','6','0', '\3','8','6','1', '\3','8','6','2', '\3','8','6','3', '\3','8','6','4', 
- '\3','8','6','5', '\3','8','6','6', '\3','8','6','7', '\3','8','6','8', '\3','8','6','9', 
- '\3','8','7','0', '\3','8','7','1', '\3','8','7','2', '\3','8','7','3', '\3','8','7','4', 
- '\3','8','7','5', '\3','8','7','6', '\3','8','7','7', '\3','8','7','8', '\3','8','7','9', 
- '\3','8','8','0', '\3','8','8','1', '\3','8','8','2', '\3','8','8','3', '\3','8','8','4', 
- '\3','8','8','5', '\3','8','8','6', '\3','8','8','7', '\3','8','8','8', '\3','8','8','9', 
- '\3','8','9','0', '\3','8','9','1', '\3','8','9','2', '\3','8','9','3', '\3','8','9','4', 
- '\3','8','9','5', '\3','8','9','6', '\3','8','9','7', '\3','8','9','8', '\3','8','9','9', 
- '\3','9','0','0', '\3','9','0','1', '\3','9','0','2', '\3','9','0','3', '\3','9','0','4', 
- '\3','9','0','5', '\3','9','0','6', '\3','9','0','7', '\3','9','0','8', '\3','9','0','9', 
- '\3','9','1','0', '\3','9','1','1', '\3','9','1','2', '\3','9','1','3', '\3','9','1','4', 
- '\3','9','1','5', '\3','9','1','6', '\3','9','1','7', '\3','9','1','8', '\3','9','1','9', 
- '\3','9','2','0', '\3','9','2','1', '\3','9','2','2', '\3','9','2','3', '\3','9','2','4', 
- '\3','9','2','5', '\3','9','2','6', '\3','9','2','7', '\3','9','2','8', '\3','9','2','9', 
- '\3','9','3','0', '\3','9','3','1', '\3','9','3','2', '\3','9','3','3', '\3','9','3','4', 
- '\3','9','3','5', '\3','9','3','6', '\3','9','3','7', '\3','9','3','8', '\3','9','3','9', 
- '\3','9','4','0', '\3','9','4','1', '\3','9','4','2', '\3','9','4','3', '\3','9','4','4', 
- '\3','9','4','5', '\3','9','4','6', '\3','9','4','7', '\3','9','4','8', '\3','9','4','9', 
- '\3','9','5','0', '\3','9','5','1', '\3','9','5','2', '\3','9','5','3', '\3','9','5','4', 
- '\3','9','5','5', '\3','9','5','6', '\3','9','5','7', '\3','9','5','8', '\3','9','5','9', 
- '\3','9','6','0', '\3','9','6','1', '\3','9','6','2', '\3','9','6','3', '\3','9','6','4', 
- '\3','9','6','5', '\3','9','6','6', '\3','9','6','7', '\3','9','6','8', '\3','9','6','9', 
- '\3','9','7','0', '\3','9','7','1', '\3','9','7','2', '\3','9','7','3', '\3','9','7','4', 
- '\3','9','7','5', '\3','9','7','6', '\3','9','7','7', '\3','9','7','8', '\3','9','7','9', 
- '\3','9','8','0', '\3','9','8','1', '\3','9','8','2', '\3','9','8','3', '\3','9','8','4', 
- '\3','9','8','5', '\3','9','8','6', '\3','9','8','7', '\3','9','8','8', '\3','9','8','9', 
- '\3','9','9','0', '\3','9','9','1', '\3','9','9','2', '\3','9','9','3', '\3','9','9','4', 
- '\3','9','9','5', '\3','9','9','6', '\3','9','9','7', '\3','9','9','8', '\3','9','9','9', '\0'};
-#endif
- 
-#if DEC_DPD2BCD8==1 && !defined(DECDPD2BCD8)
-#define DECDPD2BCD8
- 
-const uint8_t DPD2BCD8[4096]={
- 0,0,0,0, 0,0,1,1, 0,0,2,1, 0,0,3,1, 0,0,4,1, 0,0,5,1, 0,0,6,1, 0,0,7,1, 0,0,8,1, 
- 0,0,9,1, 0,8,0,2, 0,8,1,2, 8,0,0,3, 8,0,1,3, 8,8,0,3, 8,8,1,3, 0,1,0,2, 0,1,1,2, 
- 0,1,2,2, 0,1,3,2, 0,1,4,2, 0,1,5,2, 0,1,6,2, 0,1,7,2, 0,1,8,2, 0,1,9,2, 0,9,0,2, 
- 0,9,1,2, 8,1,0,3, 8,1,1,3, 8,9,0,3, 8,9,1,3, 0,2,0,2, 0,2,1,2, 0,2,2,2, 0,2,3,2, 
- 0,2,4,2, 0,2,5,2, 0,2,6,2, 0,2,7,2, 0,2,8,2, 0,2,9,2, 0,8,2,2, 0,8,3,2, 8,2,0,3, 
- 8,2,1,3, 8,0,8,3, 8,0,9,3, 0,3,0,2, 0,3,1,2, 0,3,2,2, 0,3,3,2, 0,3,4,2, 0,3,5,2, 
- 0,3,6,2, 0,3,7,2, 0,3,8,2, 0,3,9,2, 0,9,2,2, 0,9,3,2, 8,3,0,3, 8,3,1,3, 8,1,8,3, 
- 8,1,9,3, 0,4,0,2, 0,4,1,2, 0,4,2,2, 0,4,3,2, 0,4,4,2, 0,4,5,2, 0,4,6,2, 0,4,7,2, 
- 0,4,8,2, 0,4,9,2, 0,8,4,2, 0,8,5,2, 8,4,0,3, 8,4,1,3, 0,8,8,2, 0,8,9,2, 0,5,0,2, 
- 0,5,1,2, 0,5,2,2, 0,5,3,2, 0,5,4,2, 0,5,5,2, 0,5,6,2, 0,5,7,2, 0,5,8,2, 0,5,9,2, 
- 0,9,4,2, 0,9,5,2, 8,5,0,3, 8,5,1,3, 0,9,8,2, 0,9,9,2, 0,6,0,2, 0,6,1,2, 0,6,2,2, 
- 0,6,3,2, 0,6,4,2, 0,6,5,2, 0,6,6,2, 0,6,7,2, 0,6,8,2, 0,6,9,2, 0,8,6,2, 0,8,7,2, 
- 8,6,0,3, 8,6,1,3, 8,8,8,3, 8,8,9,3, 0,7,0,2, 0,7,1,2, 0,7,2,2, 0,7,3,2, 0,7,4,2, 
- 0,7,5,2, 0,7,6,2, 0,7,7,2, 0,7,8,2, 0,7,9,2, 0,9,6,2, 0,9,7,2, 8,7,0,3, 8,7,1,3, 
- 8,9,8,3, 8,9,9,3, 1,0,0,3, 1,0,1,3, 1,0,2,3, 1,0,3,3, 1,0,4,3, 1,0,5,3, 1,0,6,3, 
- 1,0,7,3, 1,0,8,3, 1,0,9,3, 1,8,0,3, 1,8,1,3, 9,0,0,3, 9,0,1,3, 9,8,0,3, 9,8,1,3, 
- 1,1,0,3, 1,1,1,3, 1,1,2,3, 1,1,3,3, 1,1,4,3, 1,1,5,3, 1,1,6,3, 1,1,7,3, 1,1,8,3, 
- 1,1,9,3, 1,9,0,3, 1,9,1,3, 9,1,0,3, 9,1,1,3, 9,9,0,3, 9,9,1,3, 1,2,0,3, 1,2,1,3, 
- 1,2,2,3, 1,2,3,3, 1,2,4,3, 1,2,5,3, 1,2,6,3, 1,2,7,3, 1,2,8,3, 1,2,9,3, 1,8,2,3, 
- 1,8,3,3, 9,2,0,3, 9,2,1,3, 9,0,8,3, 9,0,9,3, 1,3,0,3, 1,3,1,3, 1,3,2,3, 1,3,3,3, 
- 1,3,4,3, 1,3,5,3, 1,3,6,3, 1,3,7,3, 1,3,8,3, 1,3,9,3, 1,9,2,3, 1,9,3,3, 9,3,0,3, 
- 9,3,1,3, 9,1,8,3, 9,1,9,3, 1,4,0,3, 1,4,1,3, 1,4,2,3, 1,4,3,3, 1,4,4,3, 1,4,5,3, 
- 1,4,6,3, 1,4,7,3, 1,4,8,3, 1,4,9,3, 1,8,4,3, 1,8,5,3, 9,4,0,3, 9,4,1,3, 1,8,8,3, 
- 1,8,9,3, 1,5,0,3, 1,5,1,3, 1,5,2,3, 1,5,3,3, 1,5,4,3, 1,5,5,3, 1,5,6,3, 1,5,7,3, 
- 1,5,8,3, 1,5,9,3, 1,9,4,3, 1,9,5,3, 9,5,0,3, 9,5,1,3, 1,9,8,3, 1,9,9,3, 1,6,0,3, 
- 1,6,1,3, 1,6,2,3, 1,6,3,3, 1,6,4,3, 1,6,5,3, 1,6,6,3, 1,6,7,3, 1,6,8,3, 1,6,9,3, 
- 1,8,6,3, 1,8,7,3, 9,6,0,3, 9,6,1,3, 9,8,8,3, 9,8,9,3, 1,7,0,3, 1,7,1,3, 1,7,2,3, 
- 1,7,3,3, 1,7,4,3, 1,7,5,3, 1,7,6,3, 1,7,7,3, 1,7,8,3, 1,7,9,3, 1,9,6,3, 1,9,7,3, 
- 9,7,0,3, 9,7,1,3, 9,9,8,3, 9,9,9,3, 2,0,0,3, 2,0,1,3, 2,0,2,3, 2,0,3,3, 2,0,4,3, 
- 2,0,5,3, 2,0,6,3, 2,0,7,3, 2,0,8,3, 2,0,9,3, 2,8,0,3, 2,8,1,3, 8,0,2,3, 8,0,3,3, 
- 8,8,2,3, 8,8,3,3, 2,1,0,3, 2,1,1,3, 2,1,2,3, 2,1,3,3, 2,1,4,3, 2,1,5,3, 2,1,6,3, 
- 2,1,7,3, 2,1,8,3, 2,1,9,3, 2,9,0,3, 2,9,1,3, 8,1,2,3, 8,1,3,3, 8,9,2,3, 8,9,3,3, 
- 2,2,0,3, 2,2,1,3, 2,2,2,3, 2,2,3,3, 2,2,4,3, 2,2,5,3, 2,2,6,3, 2,2,7,3, 2,2,8,3, 
- 2,2,9,3, 2,8,2,3, 2,8,3,3, 8,2,2,3, 8,2,3,3, 8,2,8,3, 8,2,9,3, 2,3,0,3, 2,3,1,3, 
- 2,3,2,3, 2,3,3,3, 2,3,4,3, 2,3,5,3, 2,3,6,3, 2,3,7,3, 2,3,8,3, 2,3,9,3, 2,9,2,3, 
- 2,9,3,3, 8,3,2,3, 8,3,3,3, 8,3,8,3, 8,3,9,3, 2,4,0,3, 2,4,1,3, 2,4,2,3, 2,4,3,3, 
- 2,4,4,3, 2,4,5,3, 2,4,6,3, 2,4,7,3, 2,4,8,3, 2,4,9,3, 2,8,4,3, 2,8,5,3, 8,4,2,3, 
- 8,4,3,3, 2,8,8,3, 2,8,9,3, 2,5,0,3, 2,5,1,3, 2,5,2,3, 2,5,3,3, 2,5,4,3, 2,5,5,3, 
- 2,5,6,3, 2,5,7,3, 2,5,8,3, 2,5,9,3, 2,9,4,3, 2,9,5,3, 8,5,2,3, 8,5,3,3, 2,9,8,3, 
- 2,9,9,3, 2,6,0,3, 2,6,1,3, 2,6,2,3, 2,6,3,3, 2,6,4,3, 2,6,5,3, 2,6,6,3, 2,6,7,3, 
- 2,6,8,3, 2,6,9,3, 2,8,6,3, 2,8,7,3, 8,6,2,3, 8,6,3,3, 8,8,8,3, 8,8,9,3, 2,7,0,3, 
- 2,7,1,3, 2,7,2,3, 2,7,3,3, 2,7,4,3, 2,7,5,3, 2,7,6,3, 2,7,7,3, 2,7,8,3, 2,7,9,3, 
- 2,9,6,3, 2,9,7,3, 8,7,2,3, 8,7,3,3, 8,9,8,3, 8,9,9,3, 3,0,0,3, 3,0,1,3, 3,0,2,3, 
- 3,0,3,3, 3,0,4,3, 3,0,5,3, 3,0,6,3, 3,0,7,3, 3,0,8,3, 3,0,9,3, 3,8,0,3, 3,8,1,3, 
- 9,0,2,3, 9,0,3,3, 9,8,2,3, 9,8,3,3, 3,1,0,3, 3,1,1,3, 3,1,2,3, 3,1,3,3, 3,1,4,3, 
- 3,1,5,3, 3,1,6,3, 3,1,7,3, 3,1,8,3, 3,1,9,3, 3,9,0,3, 3,9,1,3, 9,1,2,3, 9,1,3,3, 
- 9,9,2,3, 9,9,3,3, 3,2,0,3, 3,2,1,3, 3,2,2,3, 3,2,3,3, 3,2,4,3, 3,2,5,3, 3,2,6,3, 
- 3,2,7,3, 3,2,8,3, 3,2,9,3, 3,8,2,3, 3,8,3,3, 9,2,2,3, 9,2,3,3, 9,2,8,3, 9,2,9,3, 
- 3,3,0,3, 3,3,1,3, 3,3,2,3, 3,3,3,3, 3,3,4,3, 3,3,5,3, 3,3,6,3, 3,3,7,3, 3,3,8,3, 
- 3,3,9,3, 3,9,2,3, 3,9,3,3, 9,3,2,3, 9,3,3,3, 9,3,8,3, 9,3,9,3, 3,4,0,3, 3,4,1,3, 
- 3,4,2,3, 3,4,3,3, 3,4,4,3, 3,4,5,3, 3,4,6,3, 3,4,7,3, 3,4,8,3, 3,4,9,3, 3,8,4,3, 
- 3,8,5,3, 9,4,2,3, 9,4,3,3, 3,8,8,3, 3,8,9,3, 3,5,0,3, 3,5,1,3, 3,5,2,3, 3,5,3,3, 
- 3,5,4,3, 3,5,5,3, 3,5,6,3, 3,5,7,3, 3,5,8,3, 3,5,9,3, 3,9,4,3, 3,9,5,3, 9,5,2,3, 
- 9,5,3,3, 3,9,8,3, 3,9,9,3, 3,6,0,3, 3,6,1,3, 3,6,2,3, 3,6,3,3, 3,6,4,3, 3,6,5,3, 
- 3,6,6,3, 3,6,7,3, 3,6,8,3, 3,6,9,3, 3,8,6,3, 3,8,7,3, 9,6,2,3, 9,6,3,3, 9,8,8,3, 
- 9,8,9,3, 3,7,0,3, 3,7,1,3, 3,7,2,3, 3,7,3,3, 3,7,4,3, 3,7,5,3, 3,7,6,3, 3,7,7,3, 
- 3,7,8,3, 3,7,9,3, 3,9,6,3, 3,9,7,3, 9,7,2,3, 9,7,3,3, 9,9,8,3, 9,9,9,3, 4,0,0,3, 
- 4,0,1,3, 4,0,2,3, 4,0,3,3, 4,0,4,3, 4,0,5,3, 4,0,6,3, 4,0,7,3, 4,0,8,3, 4,0,9,3, 
- 4,8,0,3, 4,8,1,3, 8,0,4,3, 8,0,5,3, 8,8,4,3, 8,8,5,3, 4,1,0,3, 4,1,1,3, 4,1,2,3, 
- 4,1,3,3, 4,1,4,3, 4,1,5,3, 4,1,6,3, 4,1,7,3, 4,1,8,3, 4,1,9,3, 4,9,0,3, 4,9,1,3, 
- 8,1,4,3, 8,1,5,3, 8,9,4,3, 8,9,5,3, 4,2,0,3, 4,2,1,3, 4,2,2,3, 4,2,3,3, 4,2,4,3, 
- 4,2,5,3, 4,2,6,3, 4,2,7,3, 4,2,8,3, 4,2,9,3, 4,8,2,3, 4,8,3,3, 8,2,4,3, 8,2,5,3, 
- 8,4,8,3, 8,4,9,3, 4,3,0,3, 4,3,1,3, 4,3,2,3, 4,3,3,3, 4,3,4,3, 4,3,5,3, 4,3,6,3, 
- 4,3,7,3, 4,3,8,3, 4,3,9,3, 4,9,2,3, 4,9,3,3, 8,3,4,3, 8,3,5,3, 8,5,8,3, 8,5,9,3, 
- 4,4,0,3, 4,4,1,3, 4,4,2,3, 4,4,3,3, 4,4,4,3, 4,4,5,3, 4,4,6,3, 4,4,7,3, 4,4,8,3, 
- 4,4,9,3, 4,8,4,3, 4,8,5,3, 8,4,4,3, 8,4,5,3, 4,8,8,3, 4,8,9,3, 4,5,0,3, 4,5,1,3, 
- 4,5,2,3, 4,5,3,3, 4,5,4,3, 4,5,5,3, 4,5,6,3, 4,5,7,3, 4,5,8,3, 4,5,9,3, 4,9,4,3, 
- 4,9,5,3, 8,5,4,3, 8,5,5,3, 4,9,8,3, 4,9,9,3, 4,6,0,3, 4,6,1,3, 4,6,2,3, 4,6,3,3, 
- 4,6,4,3, 4,6,5,3, 4,6,6,3, 4,6,7,3, 4,6,8,3, 4,6,9,3, 4,8,6,3, 4,8,7,3, 8,6,4,3, 
- 8,6,5,3, 8,8,8,3, 8,8,9,3, 4,7,0,3, 4,7,1,3, 4,7,2,3, 4,7,3,3, 4,7,4,3, 4,7,5,3, 
- 4,7,6,3, 4,7,7,3, 4,7,8,3, 4,7,9,3, 4,9,6,3, 4,9,7,3, 8,7,4,3, 8,7,5,3, 8,9,8,3, 
- 8,9,9,3, 5,0,0,3, 5,0,1,3, 5,0,2,3, 5,0,3,3, 5,0,4,3, 5,0,5,3, 5,0,6,3, 5,0,7,3, 
- 5,0,8,3, 5,0,9,3, 5,8,0,3, 5,8,1,3, 9,0,4,3, 9,0,5,3, 9,8,4,3, 9,8,5,3, 5,1,0,3, 
- 5,1,1,3, 5,1,2,3, 5,1,3,3, 5,1,4,3, 5,1,5,3, 5,1,6,3, 5,1,7,3, 5,1,8,3, 5,1,9,3, 
- 5,9,0,3, 5,9,1,3, 9,1,4,3, 9,1,5,3, 9,9,4,3, 9,9,5,3, 5,2,0,3, 5,2,1,3, 5,2,2,3, 
- 5,2,3,3, 5,2,4,3, 5,2,5,3, 5,2,6,3, 5,2,7,3, 5,2,8,3, 5,2,9,3, 5,8,2,3, 5,8,3,3, 
- 9,2,4,3, 9,2,5,3, 9,4,8,3, 9,4,9,3, 5,3,0,3, 5,3,1,3, 5,3,2,3, 5,3,3,3, 5,3,4,3, 
- 5,3,5,3, 5,3,6,3, 5,3,7,3, 5,3,8,3, 5,3,9,3, 5,9,2,3, 5,9,3,3, 9,3,4,3, 9,3,5,3, 
- 9,5,8,3, 9,5,9,3, 5,4,0,3, 5,4,1,3, 5,4,2,3, 5,4,3,3, 5,4,4,3, 5,4,5,3, 5,4,6,3, 
- 5,4,7,3, 5,4,8,3, 5,4,9,3, 5,8,4,3, 5,8,5,3, 9,4,4,3, 9,4,5,3, 5,8,8,3, 5,8,9,3, 
- 5,5,0,3, 5,5,1,3, 5,5,2,3, 5,5,3,3, 5,5,4,3, 5,5,5,3, 5,5,6,3, 5,5,7,3, 5,5,8,3, 
- 5,5,9,3, 5,9,4,3, 5,9,5,3, 9,5,4,3, 9,5,5,3, 5,9,8,3, 5,9,9,3, 5,6,0,3, 5,6,1,3, 
- 5,6,2,3, 5,6,3,3, 5,6,4,3, 5,6,5,3, 5,6,6,3, 5,6,7,3, 5,6,8,3, 5,6,9,3, 5,8,6,3, 
- 5,8,7,3, 9,6,4,3, 9,6,5,3, 9,8,8,3, 9,8,9,3, 5,7,0,3, 5,7,1,3, 5,7,2,3, 5,7,3,3, 
- 5,7,4,3, 5,7,5,3, 5,7,6,3, 5,7,7,3, 5,7,8,3, 5,7,9,3, 5,9,6,3, 5,9,7,3, 9,7,4,3, 
- 9,7,5,3, 9,9,8,3, 9,9,9,3, 6,0,0,3, 6,0,1,3, 6,0,2,3, 6,0,3,3, 6,0,4,3, 6,0,5,3, 
- 6,0,6,3, 6,0,7,3, 6,0,8,3, 6,0,9,3, 6,8,0,3, 6,8,1,3, 8,0,6,3, 8,0,7,3, 8,8,6,3, 
- 8,8,7,3, 6,1,0,3, 6,1,1,3, 6,1,2,3, 6,1,3,3, 6,1,4,3, 6,1,5,3, 6,1,6,3, 6,1,7,3, 
- 6,1,8,3, 6,1,9,3, 6,9,0,3, 6,9,1,3, 8,1,6,3, 8,1,7,3, 8,9,6,3, 8,9,7,3, 6,2,0,3, 
- 6,2,1,3, 6,2,2,3, 6,2,3,3, 6,2,4,3, 6,2,5,3, 6,2,6,3, 6,2,7,3, 6,2,8,3, 6,2,9,3, 
- 6,8,2,3, 6,8,3,3, 8,2,6,3, 8,2,7,3, 8,6,8,3, 8,6,9,3, 6,3,0,3, 6,3,1,3, 6,3,2,3, 
- 6,3,3,3, 6,3,4,3, 6,3,5,3, 6,3,6,3, 6,3,7,3, 6,3,8,3, 6,3,9,3, 6,9,2,3, 6,9,3,3, 
- 8,3,6,3, 8,3,7,3, 8,7,8,3, 8,7,9,3, 6,4,0,3, 6,4,1,3, 6,4,2,3, 6,4,3,3, 6,4,4,3, 
- 6,4,5,3, 6,4,6,3, 6,4,7,3, 6,4,8,3, 6,4,9,3, 6,8,4,3, 6,8,5,3, 8,4,6,3, 8,4,7,3, 
- 6,8,8,3, 6,8,9,3, 6,5,0,3, 6,5,1,3, 6,5,2,3, 6,5,3,3, 6,5,4,3, 6,5,5,3, 6,5,6,3, 
- 6,5,7,3, 6,5,8,3, 6,5,9,3, 6,9,4,3, 6,9,5,3, 8,5,6,3, 8,5,7,3, 6,9,8,3, 6,9,9,3, 
- 6,6,0,3, 6,6,1,3, 6,6,2,3, 6,6,3,3, 6,6,4,3, 6,6,5,3, 6,6,6,3, 6,6,7,3, 6,6,8,3, 
- 6,6,9,3, 6,8,6,3, 6,8,7,3, 8,6,6,3, 8,6,7,3, 8,8,8,3, 8,8,9,3, 6,7,0,3, 6,7,1,3, 
- 6,7,2,3, 6,7,3,3, 6,7,4,3, 6,7,5,3, 6,7,6,3, 6,7,7,3, 6,7,8,3, 6,7,9,3, 6,9,6,3, 
- 6,9,7,3, 8,7,6,3, 8,7,7,3, 8,9,8,3, 8,9,9,3, 7,0,0,3, 7,0,1,3, 7,0,2,3, 7,0,3,3, 
- 7,0,4,3, 7,0,5,3, 7,0,6,3, 7,0,7,3, 7,0,8,3, 7,0,9,3, 7,8,0,3, 7,8,1,3, 9,0,6,3, 
- 9,0,7,3, 9,8,6,3, 9,8,7,3, 7,1,0,3, 7,1,1,3, 7,1,2,3, 7,1,3,3, 7,1,4,3, 7,1,5,3, 
- 7,1,6,3, 7,1,7,3, 7,1,8,3, 7,1,9,3, 7,9,0,3, 7,9,1,3, 9,1,6,3, 9,1,7,3, 9,9,6,3, 
- 9,9,7,3, 7,2,0,3, 7,2,1,3, 7,2,2,3, 7,2,3,3, 7,2,4,3, 7,2,5,3, 7,2,6,3, 7,2,7,3, 
- 7,2,8,3, 7,2,9,3, 7,8,2,3, 7,8,3,3, 9,2,6,3, 9,2,7,3, 9,6,8,3, 9,6,9,3, 7,3,0,3, 
- 7,3,1,3, 7,3,2,3, 7,3,3,3, 7,3,4,3, 7,3,5,3, 7,3,6,3, 7,3,7,3, 7,3,8,3, 7,3,9,3, 
- 7,9,2,3, 7,9,3,3, 9,3,6,3, 9,3,7,3, 9,7,8,3, 9,7,9,3, 7,4,0,3, 7,4,1,3, 7,4,2,3, 
- 7,4,3,3, 7,4,4,3, 7,4,5,3, 7,4,6,3, 7,4,7,3, 7,4,8,3, 7,4,9,3, 7,8,4,3, 7,8,5,3, 
- 9,4,6,3, 9,4,7,3, 7,8,8,3, 7,8,9,3, 7,5,0,3, 7,5,1,3, 7,5,2,3, 7,5,3,3, 7,5,4,3, 
- 7,5,5,3, 7,5,6,3, 7,5,7,3, 7,5,8,3, 7,5,9,3, 7,9,4,3, 7,9,5,3, 9,5,6,3, 9,5,7,3, 
- 7,9,8,3, 7,9,9,3, 7,6,0,3, 7,6,1,3, 7,6,2,3, 7,6,3,3, 7,6,4,3, 7,6,5,3, 7,6,6,3, 
- 7,6,7,3, 7,6,8,3, 7,6,9,3, 7,8,6,3, 7,8,7,3, 9,6,6,3, 9,6,7,3, 9,8,8,3, 9,8,9,3, 
- 7,7,0,3, 7,7,1,3, 7,7,2,3, 7,7,3,3, 7,7,4,3, 7,7,5,3, 7,7,6,3, 7,7,7,3, 7,7,8,3, 
- 7,7,9,3, 7,9,6,3, 7,9,7,3, 9,7,6,3, 9,7,7,3, 9,9,8,3, 9,9,9,3};
-#endif
- 
+/* ------------------------------------------------------------------------ */
+/* Binary Coded Decimal and Densely Packed Decimal conversion lookup tables */
+/* [Automatically generated -- do not edit.  2008.06.21]                    */
+/* ------------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2008. All rights reserved.          */
+/* ------------------------------------------------------------------------ */
+/* For details, see DPDecimal.html on the General Decimal Arithmetic page.  */
+/*                                                                          */
+/* This include file defines several DPD and BCD conversion tables:         */
+/*                                                                          */
+/*   uint16_t BCD2DPD[2458];     -- BCD -> DPD (0x999 => 2457)              */
+/*   uint16_t BIN2DPD[1000];     -- Bin -> DPD (999 => 2457)                */
+/*   uint8_t  BIN2CHAR[4001];    -- Bin -> CHAR (999 => '\3' '9' '9' '9')   */
+/*   uint8_t  BIN2BCD8[4000];    -- Bin -> bytes (999 => 9 9 9 3)           */
+/*   uint16_t DPD2BCD[1024];     -- DPD -> BCD (0x3FF => 0x999)             */
+/*   uint16_t DPD2BIN[1024];     -- DPD -> BIN (0x3FF => 999)               */
+/*   uint32_t DPD2BINK[1024];    -- DPD -> BIN * 1000 (0x3FF => 999000)     */
+/*   uint32_t DPD2BINM[1024];    -- DPD -> BIN * 1E+6 (0x3FF => 999000000)  */
+/*   uint8_t  DPD2BCD8[4096];    -- DPD -> bytes (x3FF => 9 9 9 3)          */
+/*                                                                          */
+/* In all cases the result (10 bits or 12 bits, or binary) is right-aligned */
+/* in the table entry.  BIN2CHAR entries are a single byte length (0 for    */
+/* value 0) followed by three digit characters; a trailing terminator is    */
+/* included to allow 4-char moves always.  BIN2BCD8 and DPD2BCD8 entries    */
+/* are similar with the three BCD8 digits followed by a one-byte length     */
+/* (again, length=0 for value 0).                                           */
+/*                                                                          */
+/* To use a table, its name, prefixed with DEC_, must be defined with a     */
+/* value of 1 before this header file is included.  For example:            */
+/*    #define DEC_BCD2DPD 1                                                 */
+/* This mechanism allows software to only include tables that are needed.   */
+/* ------------------------------------------------------------------------ */
+ 
+#if defined(DEC_BCD2DPD) && DEC_BCD2DPD==1 && !defined(DECBCD2DPD)
+#define DECBCD2DPD
+ 
+const uint16_t BCD2DPD[2458]={    0,    1,    2,    3,    4,    5,    6,    7, 
+    8,    9,    0,    0,    0,    0,    0,    0,   16,   17,   18,   19,   20, 
+   21,   22,   23,   24,   25,    0,    0,    0,    0,    0,    0,   32,   33, 
+   34,   35,   36,   37,   38,   39,   40,   41,    0,    0,    0,    0,    0, 
+    0,   48,   49,   50,   51,   52,   53,   54,   55,   56,   57,    0,    0, 
+    0,    0,    0,    0,   64,   65,   66,   67,   68,   69,   70,   71,   72, 
+   73,    0,    0,    0,    0,    0,    0,   80,   81,   82,   83,   84,   85, 
+   86,   87,   88,   89,    0,    0,    0,    0,    0,    0,   96,   97,   98, 
+   99,  100,  101,  102,  103,  104,  105,    0,    0,    0,    0,    0,    0, 
+  112,  113,  114,  115,  116,  117,  118,  119,  120,  121,    0,    0,    0, 
+    0,    0,    0,   10,   11,   42,   43,   74,   75,  106,  107,   78,   79, 
+    0,    0,    0,    0,    0,    0,   26,   27,   58,   59,   90,   91,  122, 
+  123,   94,   95,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,  128,  129,  130,  131,  132,  133,  134,  135,  136,  137,    0,    0, 
+    0,    0,    0,    0,  144,  145,  146,  147,  148,  149,  150,  151,  152, 
+  153,    0,    0,    0,    0,    0,    0,  160,  161,  162,  163,  164,  165, 
+  166,  167,  168,  169,    0,    0,    0,    0,    0,    0,  176,  177,  178, 
+  179,  180,  181,  182,  183,  184,  185,    0,    0,    0,    0,    0,    0, 
+  192,  193,  194,  195,  196,  197,  198,  199,  200,  201,    0,    0,    0, 
+    0,    0,    0,  208,  209,  210,  211,  212,  213,  214,  215,  216,  217, 
+    0,    0,    0,    0,    0,    0,  224,  225,  226,  227,  228,  229,  230, 
+  231,  232,  233,    0,    0,    0,    0,    0,    0,  240,  241,  242,  243, 
+  244,  245,  246,  247,  248,  249,    0,    0,    0,    0,    0,    0,  138, 
+  139,  170,  171,  202,  203,  234,  235,  206,  207,    0,    0,    0,    0, 
+    0,    0,  154,  155,  186,  187,  218,  219,  250,  251,  222,  223,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  256,  257,  258, 
+  259,  260,  261,  262,  263,  264,  265,    0,    0,    0,    0,    0,    0, 
+  272,  273,  274,  275,  276,  277,  278,  279,  280,  281,    0,    0,    0, 
+    0,    0,    0,  288,  289,  290,  291,  292,  293,  294,  295,  296,  297, 
+    0,    0,    0,    0,    0,    0,  304,  305,  306,  307,  308,  309,  310, 
+  311,  312,  313,    0,    0,    0,    0,    0,    0,  320,  321,  322,  323, 
+  324,  325,  326,  327,  328,  329,    0,    0,    0,    0,    0,    0,  336, 
+  337,  338,  339,  340,  341,  342,  343,  344,  345,    0,    0,    0,    0, 
+    0,    0,  352,  353,  354,  355,  356,  357,  358,  359,  360,  361,    0, 
+    0,    0,    0,    0,    0,  368,  369,  370,  371,  372,  373,  374,  375, 
+  376,  377,    0,    0,    0,    0,    0,    0,  266,  267,  298,  299,  330, 
+  331,  362,  363,  334,  335,    0,    0,    0,    0,    0,    0,  282,  283, 
+  314,  315,  346,  347,  378,  379,  350,  351,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,  384,  385,  386,  387,  388,  389,  390, 
+  391,  392,  393,    0,    0,    0,    0,    0,    0,  400,  401,  402,  403, 
+  404,  405,  406,  407,  408,  409,    0,    0,    0,    0,    0,    0,  416, 
+  417,  418,  419,  420,  421,  422,  423,  424,  425,    0,    0,    0,    0, 
+    0,    0,  432,  433,  434,  435,  436,  437,  438,  439,  440,  441,    0, 
+    0,    0,    0,    0,    0,  448,  449,  450,  451,  452,  453,  454,  455, 
+  456,  457,    0,    0,    0,    0,    0,    0,  464,  465,  466,  467,  468, 
+  469,  470,  471,  472,  473,    0,    0,    0,    0,    0,    0,  480,  481, 
+  482,  483,  484,  485,  486,  487,  488,  489,    0,    0,    0,    0,    0, 
+    0,  496,  497,  498,  499,  500,  501,  502,  503,  504,  505,    0,    0, 
+    0,    0,    0,    0,  394,  395,  426,  427,  458,  459,  490,  491,  462, 
+  463,    0,    0,    0,    0,    0,    0,  410,  411,  442,  443,  474,  475, 
+  506,  507,  478,  479,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,  512,  513,  514,  515,  516,  517,  518,  519,  520,  521,    0, 
+    0,    0,    0,    0,    0,  528,  529,  530,  531,  532,  533,  534,  535, 
+  536,  537,    0,    0,    0,    0,    0,    0,  544,  545,  546,  547,  548, 
+  549,  550,  551,  552,  553,    0,    0,    0,    0,    0,    0,  560,  561, 
+  562,  563,  564,  565,  566,  567,  568,  569,    0,    0,    0,    0,    0, 
+    0,  576,  577,  578,  579,  580,  581,  582,  583,  584,  585,    0,    0, 
+    0,    0,    0,    0,  592,  593,  594,  595,  596,  597,  598,  599,  600, 
+  601,    0,    0,    0,    0,    0,    0,  608,  609,  610,  611,  612,  613, 
+  614,  615,  616,  617,    0,    0,    0,    0,    0,    0,  624,  625,  626, 
+  627,  628,  629,  630,  631,  632,  633,    0,    0,    0,    0,    0,    0, 
+  522,  523,  554,  555,  586,  587,  618,  619,  590,  591,    0,    0,    0, 
+    0,    0,    0,  538,  539,  570,  571,  602,  603,  634,  635,  606,  607, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,  640,  641, 
+  642,  643,  644,  645,  646,  647,  648,  649,    0,    0,    0,    0,    0, 
+    0,  656,  657,  658,  659,  660,  661,  662,  663,  664,  665,    0,    0, 
+    0,    0,    0,    0,  672,  673,  674,  675,  676,  677,  678,  679,  680, 
+  681,    0,    0,    0,    0,    0,    0,  688,  689,  690,  691,  692,  693, 
+  694,  695,  696,  697,    0,    0,    0,    0,    0,    0,  704,  705,  706, 
+  707,  708,  709,  710,  711,  712,  713,    0,    0,    0,    0,    0,    0, 
+  720,  721,  722,  723,  724,  725,  726,  727,  728,  729,    0,    0,    0, 
+    0,    0,    0,  736,  737,  738,  739,  740,  741,  742,  743,  744,  745, 
+    0,    0,    0,    0,    0,    0,  752,  753,  754,  755,  756,  757,  758, 
+  759,  760,  761,    0,    0,    0,    0,    0,    0,  650,  651,  682,  683, 
+  714,  715,  746,  747,  718,  719,    0,    0,    0,    0,    0,    0,  666, 
+  667,  698,  699,  730,  731,  762,  763,  734,  735,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,  768,  769,  770,  771,  772,  773, 
+  774,  775,  776,  777,    0,    0,    0,    0,    0,    0,  784,  785,  786, 
+  787,  788,  789,  790,  791,  792,  793,    0,    0,    0,    0,    0,    0, 
+  800,  801,  802,  803,  804,  805,  806,  807,  808,  809,    0,    0,    0, 
+    0,    0,    0,  816,  817,  818,  819,  820,  821,  822,  823,  824,  825, 
+    0,    0,    0,    0,    0,    0,  832,  833,  834,  835,  836,  837,  838, 
+  839,  840,  841,    0,    0,    0,    0,    0,    0,  848,  849,  850,  851, 
+  852,  853,  854,  855,  856,  857,    0,    0,    0,    0,    0,    0,  864, 
+  865,  866,  867,  868,  869,  870,  871,  872,  873,    0,    0,    0,    0, 
+    0,    0,  880,  881,  882,  883,  884,  885,  886,  887,  888,  889,    0, 
+    0,    0,    0,    0,    0,  778,  779,  810,  811,  842,  843,  874,  875, 
+  846,  847,    0,    0,    0,    0,    0,    0,  794,  795,  826,  827,  858, 
+  859,  890,  891,  862,  863,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,  896,  897,  898,  899,  900,  901,  902,  903,  904,  905, 
+    0,    0,    0,    0,    0,    0,  912,  913,  914,  915,  916,  917,  918, 
+  919,  920,  921,    0,    0,    0,    0,    0,    0,  928,  929,  930,  931, 
+  932,  933,  934,  935,  936,  937,    0,    0,    0,    0,    0,    0,  944, 
+  945,  946,  947,  948,  949,  950,  951,  952,  953,    0,    0,    0,    0, 
+    0,    0,  960,  961,  962,  963,  964,  965,  966,  967,  968,  969,    0, 
+    0,    0,    0,    0,    0,  976,  977,  978,  979,  980,  981,  982,  983, 
+  984,  985,    0,    0,    0,    0,    0,    0,  992,  993,  994,  995,  996, 
+  997,  998,  999, 1000, 1001,    0,    0,    0,    0,    0,    0, 1008, 1009, 
+ 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017,    0,    0,    0,    0,    0, 
+    0,  906,  907,  938,  939,  970,  971, 1002, 1003,  974,  975,    0,    0, 
+    0,    0,    0,    0,  922,  923,  954,  955,  986,  987, 1018, 1019,  990, 
+  991,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,   12, 
+   13,  268,  269,  524,  525,  780,  781,   46,   47,    0,    0,    0,    0, 
+    0,    0,   28,   29,  284,  285,  540,  541,  796,  797,   62,   63,    0, 
+    0,    0,    0,    0,    0,   44,   45,  300,  301,  556,  557,  812,  813, 
+  302,  303,    0,    0,    0,    0,    0,    0,   60,   61,  316,  317,  572, 
+  573,  828,  829,  318,  319,    0,    0,    0,    0,    0,    0,   76,   77, 
+  332,  333,  588,  589,  844,  845,  558,  559,    0,    0,    0,    0,    0, 
+    0,   92,   93,  348,  349,  604,  605,  860,  861,  574,  575,    0,    0, 
+    0,    0,    0,    0,  108,  109,  364,  365,  620,  621,  876,  877,  814, 
+  815,    0,    0,    0,    0,    0,    0,  124,  125,  380,  381,  636,  637, 
+  892,  893,  830,  831,    0,    0,    0,    0,    0,    0,   14,   15,  270, 
+  271,  526,  527,  782,  783,  110,  111,    0,    0,    0,    0,    0,    0, 
+   30,   31,  286,  287,  542,  543,  798,  799,  126,  127,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,    0, 
+    0,    0,    0,    0,    0,    0,    0,    0,  140,  141,  396,  397,  652, 
+  653,  908,  909,  174,  175,    0,    0,    0,    0,    0,    0,  156,  157, 
+  412,  413,  668,  669,  924,  925,  190,  191,    0,    0,    0,    0,    0, 
+    0,  172,  173,  428,  429,  684,  685,  940,  941,  430,  431,    0,    0, 
+    0,    0,    0,    0,  188,  189,  444,  445,  700,  701,  956,  957,  446, 
+  447,    0,    0,    0,    0,    0,    0,  204,  205,  460,  461,  716,  717, 
+  972,  973,  686,  687,    0,    0,    0,    0,    0,    0,  220,  221,  476, 
+  477,  732,  733,  988,  989,  702,  703,    0,    0,    0,    0,    0,    0, 
+  236,  237,  492,  493,  748,  749, 1004, 1005,  942,  943,    0,    0,    0, 
+    0,    0,    0,  252,  253,  508,  509,  764,  765, 1020, 1021,  958,  959, 
+    0,    0,    0,    0,    0,    0,  142,  143,  398,  399,  654,  655,  910, 
+  911,  238,  239,    0,    0,    0,    0,    0,    0,  158,  159,  414,  415, 
+  670,  671,  926,  927,  254,  255};
+#endif
+ 
+#if defined(DEC_DPD2BCD) && DEC_DPD2BCD==1 && !defined(DECDPD2BCD)
+#define DECDPD2BCD
+ 
+const uint16_t DPD2BCD[1024]={    0,    1,    2,    3,    4,    5,    6,    7, 
+    8,    9,  128,  129, 2048, 2049, 2176, 2177,   16,   17,   18,   19,   20, 
+   21,   22,   23,   24,   25,  144,  145, 2064, 2065, 2192, 2193,   32,   33, 
+   34,   35,   36,   37,   38,   39,   40,   41,  130,  131, 2080, 2081, 2056, 
+ 2057,   48,   49,   50,   51,   52,   53,   54,   55,   56,   57,  146,  147, 
+ 2096, 2097, 2072, 2073,   64,   65,   66,   67,   68,   69,   70,   71,   72, 
+   73,  132,  133, 2112, 2113,  136,  137,   80,   81,   82,   83,   84,   85, 
+   86,   87,   88,   89,  148,  149, 2128, 2129,  152,  153,   96,   97,   98, 
+   99,  100,  101,  102,  103,  104,  105,  134,  135, 2144, 2145, 2184, 2185, 
+  112,  113,  114,  115,  116,  117,  118,  119,  120,  121,  150,  151, 2160, 
+ 2161, 2200, 2201,  256,  257,  258,  259,  260,  261,  262,  263,  264,  265, 
+  384,  385, 2304, 2305, 2432, 2433,  272,  273,  274,  275,  276,  277,  278, 
+  279,  280,  281,  400,  401, 2320, 2321, 2448, 2449,  288,  289,  290,  291, 
+  292,  293,  294,  295,  296,  297,  386,  387, 2336, 2337, 2312, 2313,  304, 
+  305,  306,  307,  308,  309,  310,  311,  312,  313,  402,  403, 2352, 2353, 
+ 2328, 2329,  320,  321,  322,  323,  324,  325,  326,  327,  328,  329,  388, 
+  389, 2368, 2369,  392,  393,  336,  337,  338,  339,  340,  341,  342,  343, 
+  344,  345,  404,  405, 2384, 2385,  408,  409,  352,  353,  354,  355,  356, 
+  357,  358,  359,  360,  361,  390,  391, 2400, 2401, 2440, 2441,  368,  369, 
+  370,  371,  372,  373,  374,  375,  376,  377,  406,  407, 2416, 2417, 2456, 
+ 2457,  512,  513,  514,  515,  516,  517,  518,  519,  520,  521,  640,  641, 
+ 2050, 2051, 2178, 2179,  528,  529,  530,  531,  532,  533,  534,  535,  536, 
+  537,  656,  657, 2066, 2067, 2194, 2195,  544,  545,  546,  547,  548,  549, 
+  550,  551,  552,  553,  642,  643, 2082, 2083, 2088, 2089,  560,  561,  562, 
+  563,  564,  565,  566,  567,  568,  569,  658,  659, 2098, 2099, 2104, 2105, 
+  576,  577,  578,  579,  580,  581,  582,  583,  584,  585,  644,  645, 2114, 
+ 2115,  648,  649,  592,  593,  594,  595,  596,  597,  598,  599,  600,  601, 
+  660,  661, 2130, 2131,  664,  665,  608,  609,  610,  611,  612,  613,  614, 
+  615,  616,  617,  646,  647, 2146, 2147, 2184, 2185,  624,  625,  626,  627, 
+  628,  629,  630,  631,  632,  633,  662,  663, 2162, 2163, 2200, 2201,  768, 
+  769,  770,  771,  772,  773,  774,  775,  776,  777,  896,  897, 2306, 2307, 
+ 2434, 2435,  784,  785,  786,  787,  788,  789,  790,  791,  792,  793,  912, 
+  913, 2322, 2323, 2450, 2451,  800,  801,  802,  803,  804,  805,  806,  807, 
+  808,  809,  898,  899, 2338, 2339, 2344, 2345,  816,  817,  818,  819,  820, 
+  821,  822,  823,  824,  825,  914,  915, 2354, 2355, 2360, 2361,  832,  833, 
+  834,  835,  836,  837,  838,  839,  840,  841,  900,  901, 2370, 2371,  904, 
+  905,  848,  849,  850,  851,  852,  853,  854,  855,  856,  857,  916,  917, 
+ 2386, 2387,  920,  921,  864,  865,  866,  867,  868,  869,  870,  871,  872, 
+  873,  902,  903, 2402, 2403, 2440, 2441,  880,  881,  882,  883,  884,  885, 
+  886,  887,  888,  889,  918,  919, 2418, 2419, 2456, 2457, 1024, 1025, 1026, 
+ 1027, 1028, 1029, 1030, 1031, 1032, 1033, 1152, 1153, 2052, 2053, 2180, 2181, 
+ 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 1168, 1169, 2068, 
+ 2069, 2196, 2197, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065, 
+ 1154, 1155, 2084, 2085, 2120, 2121, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 
+ 1079, 1080, 1081, 1170, 1171, 2100, 2101, 2136, 2137, 1088, 1089, 1090, 1091, 
+ 1092, 1093, 1094, 1095, 1096, 1097, 1156, 1157, 2116, 2117, 1160, 1161, 1104, 
+ 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113, 1172, 1173, 2132, 2133, 
+ 1176, 1177, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129, 1158, 
+ 1159, 2148, 2149, 2184, 2185, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 
+ 1144, 1145, 1174, 1175, 2164, 2165, 2200, 2201, 1280, 1281, 1282, 1283, 1284, 
+ 1285, 1286, 1287, 1288, 1289, 1408, 1409, 2308, 2309, 2436, 2437, 1296, 1297, 
+ 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305, 1424, 1425, 2324, 2325, 2452, 
+ 2453, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321, 1410, 1411, 
+ 2340, 2341, 2376, 2377, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 
+ 1337, 1426, 1427, 2356, 2357, 2392, 2393, 1344, 1345, 1346, 1347, 1348, 1349, 
+ 1350, 1351, 1352, 1353, 1412, 1413, 2372, 2373, 1416, 1417, 1360, 1361, 1362, 
+ 1363, 1364, 1365, 1366, 1367, 1368, 1369, 1428, 1429, 2388, 2389, 1432, 1433, 
+ 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385, 1414, 1415, 2404, 
+ 2405, 2440, 2441, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401, 
+ 1430, 1431, 2420, 2421, 2456, 2457, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 
+ 1543, 1544, 1545, 1664, 1665, 2054, 2055, 2182, 2183, 1552, 1553, 1554, 1555, 
+ 1556, 1557, 1558, 1559, 1560, 1561, 1680, 1681, 2070, 2071, 2198, 2199, 1568, 
+ 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577, 1666, 1667, 2086, 2087, 
+ 2152, 2153, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593, 1682, 
+ 1683, 2102, 2103, 2168, 2169, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 
+ 1608, 1609, 1668, 1669, 2118, 2119, 1672, 1673, 1616, 1617, 1618, 1619, 1620, 
+ 1621, 1622, 1623, 1624, 1625, 1684, 1685, 2134, 2135, 1688, 1689, 1632, 1633, 
+ 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641, 1670, 1671, 2150, 2151, 2184, 
+ 2185, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657, 1686, 1687, 
+ 2166, 2167, 2200, 2201, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, 1800, 
+ 1801, 1920, 1921, 2310, 2311, 2438, 2439, 1808, 1809, 1810, 1811, 1812, 1813, 
+ 1814, 1815, 1816, 1817, 1936, 1937, 2326, 2327, 2454, 2455, 1824, 1825, 1826, 
+ 1827, 1828, 1829, 1830, 1831, 1832, 1833, 1922, 1923, 2342, 2343, 2408, 2409, 
+ 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849, 1938, 1939, 2358, 
+ 2359, 2424, 2425, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865, 
+ 1924, 1925, 2374, 2375, 1928, 1929, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 
+ 1879, 1880, 1881, 1940, 1941, 2390, 2391, 1944, 1945, 1888, 1889, 1890, 1891, 
+ 1892, 1893, 1894, 1895, 1896, 1897, 1926, 1927, 2406, 2407, 2440, 2441, 1904, 
+ 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 1942, 1943, 2422, 2423, 
+ 2456, 2457};
+#endif
+ 
+#if defined(DEC_BIN2DPD) && DEC_BIN2DPD==1 && !defined(DECBIN2DPD)
+#define DECBIN2DPD
+ 
+const uint16_t BIN2DPD[1000]={    0,    1,    2,    3,    4,    5,    6,    7, 
+    8,    9,   16,   17,   18,   19,   20,   21,   22,   23,   24,   25,   32, 
+   33,   34,   35,   36,   37,   38,   39,   40,   41,   48,   49,   50,   51, 
+   52,   53,   54,   55,   56,   57,   64,   65,   66,   67,   68,   69,   70, 
+   71,   72,   73,   80,   81,   82,   83,   84,   85,   86,   87,   88,   89, 
+   96,   97,   98,   99,  100,  101,  102,  103,  104,  105,  112,  113,  114, 
+  115,  116,  117,  118,  119,  120,  121,   10,   11,   42,   43,   74,   75, 
+  106,  107,   78,   79,   26,   27,   58,   59,   90,   91,  122,  123,   94, 
+   95,  128,  129,  130,  131,  132,  133,  134,  135,  136,  137,  144,  145, 
+  146,  147,  148,  149,  150,  151,  152,  153,  160,  161,  162,  163,  164, 
+  165,  166,  167,  168,  169,  176,  177,  178,  179,  180,  181,  182,  183, 
+  184,  185,  192,  193,  194,  195,  196,  197,  198,  199,  200,  201,  208, 
+  209,  210,  211,  212,  213,  214,  215,  216,  217,  224,  225,  226,  227, 
+  228,  229,  230,  231,  232,  233,  240,  241,  242,  243,  244,  245,  246, 
+  247,  248,  249,  138,  139,  170,  171,  202,  203,  234,  235,  206,  207, 
+  154,  155,  186,  187,  218,  219,  250,  251,  222,  223,  256,  257,  258, 
+  259,  260,  261,  262,  263,  264,  265,  272,  273,  274,  275,  276,  277, 
+  278,  279,  280,  281,  288,  289,  290,  291,  292,  293,  294,  295,  296, 
+  297,  304,  305,  306,  307,  308,  309,  310,  311,  312,  313,  320,  321, 
+  322,  323,  324,  325,  326,  327,  328,  329,  336,  337,  338,  339,  340, 
+  341,  342,  343,  344,  345,  352,  353,  354,  355,  356,  357,  358,  359, 
+  360,  361,  368,  369,  370,  371,  372,  373,  374,  375,  376,  377,  266, 
+  267,  298,  299,  330,  331,  362,  363,  334,  335,  282,  283,  314,  315, 
+  346,  347,  378,  379,  350,  351,  384,  385,  386,  387,  388,  389,  390, 
+  391,  392,  393,  400,  401,  402,  403,  404,  405,  406,  407,  408,  409, 
+  416,  417,  418,  419,  420,  421,  422,  423,  424,  425,  432,  433,  434, 
+  435,  436,  437,  438,  439,  440,  441,  448,  449,  450,  451,  452,  453, 
+  454,  455,  456,  457,  464,  465,  466,  467,  468,  469,  470,  471,  472, 
+  473,  480,  481,  482,  483,  484,  485,  486,  487,  488,  489,  496,  497, 
+  498,  499,  500,  501,  502,  503,  504,  505,  394,  395,  426,  427,  458, 
+  459,  490,  491,  462,  463,  410,  411,  442,  443,  474,  475,  506,  507, 
+  478,  479,  512,  513,  514,  515,  516,  517,  518,  519,  520,  521,  528, 
+  529,  530,  531,  532,  533,  534,  535,  536,  537,  544,  545,  546,  547, 
+  548,  549,  550,  551,  552,  553,  560,  561,  562,  563,  564,  565,  566, 
+  567,  568,  569,  576,  577,  578,  579,  580,  581,  582,  583,  584,  585, 
+  592,  593,  594,  595,  596,  597,  598,  599,  600,  601,  608,  609,  610, 
+  611,  612,  613,  614,  615,  616,  617,  624,  625,  626,  627,  628,  629, 
+  630,  631,  632,  633,  522,  523,  554,  555,  586,  587,  618,  619,  590, 
+  591,  538,  539,  570,  571,  602,  603,  634,  635,  606,  607,  640,  641, 
+  642,  643,  644,  645,  646,  647,  648,  649,  656,  657,  658,  659,  660, 
+  661,  662,  663,  664,  665,  672,  673,  674,  675,  676,  677,  678,  679, 
+  680,  681,  688,  689,  690,  691,  692,  693,  694,  695,  696,  697,  704, 
+  705,  706,  707,  708,  709,  710,  711,  712,  713,  720,  721,  722,  723, 
+  724,  725,  726,  727,  728,  729,  736,  737,  738,  739,  740,  741,  742, 
+  743,  744,  745,  752,  753,  754,  755,  756,  757,  758,  759,  760,  761, 
+  650,  651,  682,  683,  714,  715,  746,  747,  718,  719,  666,  667,  698, 
+  699,  730,  731,  762,  763,  734,  735,  768,  769,  770,  771,  772,  773, 
+  774,  775,  776,  777,  784,  785,  786,  787,  788,  789,  790,  791,  792, 
+  793,  800,  801,  802,  803,  804,  805,  806,  807,  808,  809,  816,  817, 
+  818,  819,  820,  821,  822,  823,  824,  825,  832,  833,  834,  835,  836, 
+  837,  838,  839,  840,  841,  848,  849,  850,  851,  852,  853,  854,  855, 
+  856,  857,  864,  865,  866,  867,  868,  869,  870,  871,  872,  873,  880, 
+  881,  882,  883,  884,  885,  886,  887,  888,  889,  778,  779,  810,  811, 
+  842,  843,  874,  875,  846,  847,  794,  795,  826,  827,  858,  859,  890, 
+  891,  862,  863,  896,  897,  898,  899,  900,  901,  902,  903,  904,  905, 
+  912,  913,  914,  915,  916,  917,  918,  919,  920,  921,  928,  929,  930, 
+  931,  932,  933,  934,  935,  936,  937,  944,  945,  946,  947,  948,  949, 
+  950,  951,  952,  953,  960,  961,  962,  963,  964,  965,  966,  967,  968, 
+  969,  976,  977,  978,  979,  980,  981,  982,  983,  984,  985,  992,  993, 
+  994,  995,  996,  997,  998,  999, 1000, 1001, 1008, 1009, 1010, 1011, 1012, 
+ 1013, 1014, 1015, 1016, 1017,  906,  907,  938,  939,  970,  971, 1002, 1003, 
+  974,  975,  922,  923,  954,  955,  986,  987, 1018, 1019,  990,  991,   12, 
+   13,  268,  269,  524,  525,  780,  781,   46,   47,   28,   29,  284,  285, 
+  540,  541,  796,  797,   62,   63,   44,   45,  300,  301,  556,  557,  812, 
+  813,  302,  303,   60,   61,  316,  317,  572,  573,  828,  829,  318,  319, 
+   76,   77,  332,  333,  588,  589,  844,  845,  558,  559,   92,   93,  348, 
+  349,  604,  605,  860,  861,  574,  575,  108,  109,  364,  365,  620,  621, 
+  876,  877,  814,  815,  124,  125,  380,  381,  636,  637,  892,  893,  830, 
+  831,   14,   15,  270,  271,  526,  527,  782,  783,  110,  111,   30,   31, 
+  286,  287,  542,  543,  798,  799,  126,  127,  140,  141,  396,  397,  652, 
+  653,  908,  909,  174,  175,  156,  157,  412,  413,  668,  669,  924,  925, 
+  190,  191,  172,  173,  428,  429,  684,  685,  940,  941,  430,  431,  188, 
+  189,  444,  445,  700,  701,  956,  957,  446,  447,  204,  205,  460,  461, 
+  716,  717,  972,  973,  686,  687,  220,  221,  476,  477,  732,  733,  988, 
+  989,  702,  703,  236,  237,  492,  493,  748,  749, 1004, 1005,  942,  943, 
+  252,  253,  508,  509,  764,  765, 1020, 1021,  958,  959,  142,  143,  398, 
+  399,  654,  655,  910,  911,  238,  239,  158,  159,  414,  415,  670,  671, 
+  926,  927,  254,  255};
+#endif 
+ 
+#if defined(DEC_DPD2BIN) && DEC_DPD2BIN==1 && !defined(DECDPD2BIN)
+#define DECDPD2BIN
+ 
+const uint16_t DPD2BIN[1024]={    0,    1,    2,    3,    4,    5,    6,    7, 
+    8,    9,   80,   81,  800,  801,  880,  881,   10,   11,   12,   13,   14, 
+   15,   16,   17,   18,   19,   90,   91,  810,  811,  890,  891,   20,   21, 
+   22,   23,   24,   25,   26,   27,   28,   29,   82,   83,  820,  821,  808, 
+  809,   30,   31,   32,   33,   34,   35,   36,   37,   38,   39,   92,   93, 
+  830,  831,  818,  819,   40,   41,   42,   43,   44,   45,   46,   47,   48, 
+   49,   84,   85,  840,  841,   88,   89,   50,   51,   52,   53,   54,   55, 
+   56,   57,   58,   59,   94,   95,  850,  851,   98,   99,   60,   61,   62, 
+   63,   64,   65,   66,   67,   68,   69,   86,   87,  860,  861,  888,  889, 
+   70,   71,   72,   73,   74,   75,   76,   77,   78,   79,   96,   97,  870, 
+  871,  898,  899,  100,  101,  102,  103,  104,  105,  106,  107,  108,  109, 
+  180,  181,  900,  901,  980,  981,  110,  111,  112,  113,  114,  115,  116, 
+  117,  118,  119,  190,  191,  910,  911,  990,  991,  120,  121,  122,  123, 
+  124,  125,  126,  127,  128,  129,  182,  183,  920,  921,  908,  909,  130, 
+  131,  132,  133,  134,  135,  136,  137,  138,  139,  192,  193,  930,  931, 
+  918,  919,  140,  141,  142,  143,  144,  145,  146,  147,  148,  149,  184, 
+  185,  940,  941,  188,  189,  150,  151,  152,  153,  154,  155,  156,  157, 
+  158,  159,  194,  195,  950,  951,  198,  199,  160,  161,  162,  163,  164, 
+  165,  166,  167,  168,  169,  186,  187,  960,  961,  988,  989,  170,  171, 
+  172,  173,  174,  175,  176,  177,  178,  179,  196,  197,  970,  971,  998, 
+  999,  200,  201,  202,  203,  204,  205,  206,  207,  208,  209,  280,  281, 
+  802,  803,  882,  883,  210,  211,  212,  213,  214,  215,  216,  217,  218, 
+  219,  290,  291,  812,  813,  892,  893,  220,  221,  222,  223,  224,  225, 
+  226,  227,  228,  229,  282,  283,  822,  823,  828,  829,  230,  231,  232, 
+  233,  234,  235,  236,  237,  238,  239,  292,  293,  832,  833,  838,  839, 
+  240,  241,  242,  243,  244,  245,  246,  247,  248,  249,  284,  285,  842, 
+  843,  288,  289,  250,  251,  252,  253,  254,  255,  256,  257,  258,  259, 
+  294,  295,  852,  853,  298,  299,  260,  261,  262,  263,  264,  265,  266, 
+  267,  268,  269,  286,  287,  862,  863,  888,  889,  270,  271,  272,  273, 
+  274,  275,  276,  277,  278,  279,  296,  297,  872,  873,  898,  899,  300, 
+  301,  302,  303,  304,  305,  306,  307,  308,  309,  380,  381,  902,  903, 
+  982,  983,  310,  311,  312,  313,  314,  315,  316,  317,  318,  319,  390, 
+  391,  912,  913,  992,  993,  320,  321,  322,  323,  324,  325,  326,  327, 
+  328,  329,  382,  383,  922,  923,  928,  929,  330,  331,  332,  333,  334, 
+  335,  336,  337,  338,  339,  392,  393,  932,  933,  938,  939,  340,  341, 
+  342,  343,  344,  345,  346,  347,  348,  349,  384,  385,  942,  943,  388, 
+  389,  350,  351,  352,  353,  354,  355,  356,  357,  358,  359,  394,  395, 
+  952,  953,  398,  399,  360,  361,  362,  363,  364,  365,  366,  367,  368, 
+  369,  386,  387,  962,  963,  988,  989,  370,  371,  372,  373,  374,  375, 
+  376,  377,  378,  379,  396,  397,  972,  973,  998,  999,  400,  401,  402, 
+  403,  404,  405,  406,  407,  408,  409,  480,  481,  804,  805,  884,  885, 
+  410,  411,  412,  413,  414,  415,  416,  417,  418,  419,  490,  491,  814, 
+  815,  894,  895,  420,  421,  422,  423,  424,  425,  426,  427,  428,  429, 
+  482,  483,  824,  825,  848,  849,  430,  431,  432,  433,  434,  435,  436, 
+  437,  438,  439,  492,  493,  834,  835,  858,  859,  440,  441,  442,  443, 
+  444,  445,  446,  447,  448,  449,  484,  485,  844,  845,  488,  489,  450, 
+  451,  452,  453,  454,  455,  456,  457,  458,  459,  494,  495,  854,  855, 
+  498,  499,  460,  461,  462,  463,  464,  465,  466,  467,  468,  469,  486, 
+  487,  864,  865,  888,  889,  470,  471,  472,  473,  474,  475,  476,  477, 
+  478,  479,  496,  497,  874,  875,  898,  899,  500,  501,  502,  503,  504, 
+  505,  506,  507,  508,  509,  580,  581,  904,  905,  984,  985,  510,  511, 
+  512,  513,  514,  515,  516,  517,  518,  519,  590,  591,  914,  915,  994, 
+  995,  520,  521,  522,  523,  524,  525,  526,  527,  528,  529,  582,  583, 
+  924,  925,  948,  949,  530,  531,  532,  533,  534,  535,  536,  537,  538, 
+  539,  592,  593,  934,  935,  958,  959,  540,  541,  542,  543,  544,  545, 
+  546,  547,  548,  549,  584,  585,  944,  945,  588,  589,  550,  551,  552, 
+  553,  554,  555,  556,  557,  558,  559,  594,  595,  954,  955,  598,  599, 
+  560,  561,  562,  563,  564,  565,  566,  567,  568,  569,  586,  587,  964, 
+  965,  988,  989,  570,  571,  572,  573,  574,  575,  576,  577,  578,  579, 
+  596,  597,  974,  975,  998,  999,  600,  601,  602,  603,  604,  605,  606, 
+  607,  608,  609,  680,  681,  806,  807,  886,  887,  610,  611,  612,  613, 
+  614,  615,  616,  617,  618,  619,  690,  691,  816,  817,  896,  897,  620, 
+  621,  622,  623,  624,  625,  626,  627,  628,  629,  682,  683,  826,  827, 
+  868,  869,  630,  631,  632,  633,  634,  635,  636,  637,  638,  639,  692, 
+  693,  836,  837,  878,  879,  640,  641,  642,  643,  644,  645,  646,  647, 
+  648,  649,  684,  685,  846,  847,  688,  689,  650,  651,  652,  653,  654, 
+  655,  656,  657,  658,  659,  694,  695,  856,  857,  698,  699,  660,  661, 
+  662,  663,  664,  665,  666,  667,  668,  669,  686,  687,  866,  867,  888, 
+  889,  670,  671,  672,  673,  674,  675,  676,  677,  678,  679,  696,  697, 
+  876,  877,  898,  899,  700,  701,  702,  703,  704,  705,  706,  707,  708, 
+  709,  780,  781,  906,  907,  986,  987,  710,  711,  712,  713,  714,  715, 
+  716,  717,  718,  719,  790,  791,  916,  917,  996,  997,  720,  721,  722, 
+  723,  724,  725,  726,  727,  728,  729,  782,  783,  926,  927,  968,  969, 
+  730,  731,  732,  733,  734,  735,  736,  737,  738,  739,  792,  793,  936, 
+  937,  978,  979,  740,  741,  742,  743,  744,  745,  746,  747,  748,  749, 
+  784,  785,  946,  947,  788,  789,  750,  751,  752,  753,  754,  755,  756, 
+  757,  758,  759,  794,  795,  956,  957,  798,  799,  760,  761,  762,  763, 
+  764,  765,  766,  767,  768,  769,  786,  787,  966,  967,  988,  989,  770, 
+  771,  772,  773,  774,  775,  776,  777,  778,  779,  796,  797,  976,  977, 
+  998,  999};
+#endif
+ 
+#if defined(DEC_DPD2BINK) && DEC_DPD2BINK==1 && !defined(DECDPD2BINK)
+#define DECDPD2BINK
+ 
+const uint32_t DPD2BINK[1024]={       0,   1000,   2000,   3000,   4000,   5000, 
+   6000,   7000,   8000,   9000,  80000,  81000, 800000, 801000, 880000, 881000, 
+  10000,  11000,  12000,  13000,  14000,  15000,  16000,  17000,  18000,  19000, 
+  90000,  91000, 810000, 811000, 890000, 891000,  20000,  21000,  22000,  23000, 
+  24000,  25000,  26000,  27000,  28000,  29000,  82000,  83000, 820000, 821000, 
+ 808000, 809000,  30000,  31000,  32000,  33000,  34000,  35000,  36000,  37000, 
+  38000,  39000,  92000,  93000, 830000, 831000, 818000, 819000,  40000,  41000, 
+  42000,  43000,  44000,  45000,  46000,  47000,  48000,  49000,  84000,  85000, 
+ 840000, 841000,  88000,  89000,  50000,  51000,  52000,  53000,  54000,  55000, 
+  56000,  57000,  58000,  59000,  94000,  95000, 850000, 851000,  98000,  99000, 
+  60000,  61000,  62000,  63000,  64000,  65000,  66000,  67000,  68000,  69000, 
+  86000,  87000, 860000, 861000, 888000, 889000,  70000,  71000,  72000,  73000, 
+  74000,  75000,  76000,  77000,  78000,  79000,  96000,  97000, 870000, 871000, 
+ 898000, 899000, 100000, 101000, 102000, 103000, 104000, 105000, 106000, 107000, 
+ 108000, 109000, 180000, 181000, 900000, 901000, 980000, 981000, 110000, 111000, 
+ 112000, 113000, 114000, 115000, 116000, 117000, 118000, 119000, 190000, 191000, 
+ 910000, 911000, 990000, 991000, 120000, 121000, 122000, 123000, 124000, 125000, 
+ 126000, 127000, 128000, 129000, 182000, 183000, 920000, 921000, 908000, 909000, 
+ 130000, 131000, 132000, 133000, 134000, 135000, 136000, 137000, 138000, 139000, 
+ 192000, 193000, 930000, 931000, 918000, 919000, 140000, 141000, 142000, 143000, 
+ 144000, 145000, 146000, 147000, 148000, 149000, 184000, 185000, 940000, 941000, 
+ 188000, 189000, 150000, 151000, 152000, 153000, 154000, 155000, 156000, 157000, 
+ 158000, 159000, 194000, 195000, 950000, 951000, 198000, 199000, 160000, 161000, 
+ 162000, 163000, 164000, 165000, 166000, 167000, 168000, 169000, 186000, 187000, 
+ 960000, 961000, 988000, 989000, 170000, 171000, 172000, 173000, 174000, 175000, 
+ 176000, 177000, 178000, 179000, 196000, 197000, 970000, 971000, 998000, 999000, 
+ 200000, 201000, 202000, 203000, 204000, 205000, 206000, 207000, 208000, 209000, 
+ 280000, 281000, 802000, 803000, 882000, 883000, 210000, 211000, 212000, 213000, 
+ 214000, 215000, 216000, 217000, 218000, 219000, 290000, 291000, 812000, 813000, 
+ 892000, 893000, 220000, 221000, 222000, 223000, 224000, 225000, 226000, 227000, 
+ 228000, 229000, 282000, 283000, 822000, 823000, 828000, 829000, 230000, 231000, 
+ 232000, 233000, 234000, 235000, 236000, 237000, 238000, 239000, 292000, 293000, 
+ 832000, 833000, 838000, 839000, 240000, 241000, 242000, 243000, 244000, 245000, 
+ 246000, 247000, 248000, 249000, 284000, 285000, 842000, 843000, 288000, 289000, 
+ 250000, 251000, 252000, 253000, 254000, 255000, 256000, 257000, 258000, 259000, 
+ 294000, 295000, 852000, 853000, 298000, 299000, 260000, 261000, 262000, 263000, 
+ 264000, 265000, 266000, 267000, 268000, 269000, 286000, 287000, 862000, 863000, 
+ 888000, 889000, 270000, 271000, 272000, 273000, 274000, 275000, 276000, 277000, 
+ 278000, 279000, 296000, 297000, 872000, 873000, 898000, 899000, 300000, 301000, 
+ 302000, 303000, 304000, 305000, 306000, 307000, 308000, 309000, 380000, 381000, 
+ 902000, 903000, 982000, 983000, 310000, 311000, 312000, 313000, 314000, 315000, 
+ 316000, 317000, 318000, 319000, 390000, 391000, 912000, 913000, 992000, 993000, 
+ 320000, 321000, 322000, 323000, 324000, 325000, 326000, 327000, 328000, 329000, 
+ 382000, 383000, 922000, 923000, 928000, 929000, 330000, 331000, 332000, 333000, 
+ 334000, 335000, 336000, 337000, 338000, 339000, 392000, 393000, 932000, 933000, 
+ 938000, 939000, 340000, 341000, 342000, 343000, 344000, 345000, 346000, 347000, 
+ 348000, 349000, 384000, 385000, 942000, 943000, 388000, 389000, 350000, 351000, 
+ 352000, 353000, 354000, 355000, 356000, 357000, 358000, 359000, 394000, 395000, 
+ 952000, 953000, 398000, 399000, 360000, 361000, 362000, 363000, 364000, 365000, 
+ 366000, 367000, 368000, 369000, 386000, 387000, 962000, 963000, 988000, 989000, 
+ 370000, 371000, 372000, 373000, 374000, 375000, 376000, 377000, 378000, 379000, 
+ 396000, 397000, 972000, 973000, 998000, 999000, 400000, 401000, 402000, 403000, 
+ 404000, 405000, 406000, 407000, 408000, 409000, 480000, 481000, 804000, 805000, 
+ 884000, 885000, 410000, 411000, 412000, 413000, 414000, 415000, 416000, 417000, 
+ 418000, 419000, 490000, 491000, 814000, 815000, 894000, 895000, 420000, 421000, 
+ 422000, 423000, 424000, 425000, 426000, 427000, 428000, 429000, 482000, 483000, 
+ 824000, 825000, 848000, 849000, 430000, 431000, 432000, 433000, 434000, 435000, 
+ 436000, 437000, 438000, 439000, 492000, 493000, 834000, 835000, 858000, 859000, 
+ 440000, 441000, 442000, 443000, 444000, 445000, 446000, 447000, 448000, 449000, 
+ 484000, 485000, 844000, 845000, 488000, 489000, 450000, 451000, 452000, 453000, 
+ 454000, 455000, 456000, 457000, 458000, 459000, 494000, 495000, 854000, 855000, 
+ 498000, 499000, 460000, 461000, 462000, 463000, 464000, 465000, 466000, 467000, 
+ 468000, 469000, 486000, 487000, 864000, 865000, 888000, 889000, 470000, 471000, 
+ 472000, 473000, 474000, 475000, 476000, 477000, 478000, 479000, 496000, 497000, 
+ 874000, 875000, 898000, 899000, 500000, 501000, 502000, 503000, 504000, 505000, 
+ 506000, 507000, 508000, 509000, 580000, 581000, 904000, 905000, 984000, 985000, 
+ 510000, 511000, 512000, 513000, 514000, 515000, 516000, 517000, 518000, 519000, 
+ 590000, 591000, 914000, 915000, 994000, 995000, 520000, 521000, 522000, 523000, 
+ 524000, 525000, 526000, 527000, 528000, 529000, 582000, 583000, 924000, 925000, 
+ 948000, 949000, 530000, 531000, 532000, 533000, 534000, 535000, 536000, 537000, 
+ 538000, 539000, 592000, 593000, 934000, 935000, 958000, 959000, 540000, 541000, 
+ 542000, 543000, 544000, 545000, 546000, 547000, 548000, 549000, 584000, 585000, 
+ 944000, 945000, 588000, 589000, 550000, 551000, 552000, 553000, 554000, 555000, 
+ 556000, 557000, 558000, 559000, 594000, 595000, 954000, 955000, 598000, 599000, 
+ 560000, 561000, 562000, 563000, 564000, 565000, 566000, 567000, 568000, 569000, 
+ 586000, 587000, 964000, 965000, 988000, 989000, 570000, 571000, 572000, 573000, 
+ 574000, 575000, 576000, 577000, 578000, 579000, 596000, 597000, 974000, 975000, 
+ 998000, 999000, 600000, 601000, 602000, 603000, 604000, 605000, 606000, 607000, 
+ 608000, 609000, 680000, 681000, 806000, 807000, 886000, 887000, 610000, 611000, 
+ 612000, 613000, 614000, 615000, 616000, 617000, 618000, 619000, 690000, 691000, 
+ 816000, 817000, 896000, 897000, 620000, 621000, 622000, 623000, 624000, 625000, 
+ 626000, 627000, 628000, 629000, 682000, 683000, 826000, 827000, 868000, 869000, 
+ 630000, 631000, 632000, 633000, 634000, 635000, 636000, 637000, 638000, 639000, 
+ 692000, 693000, 836000, 837000, 878000, 879000, 640000, 641000, 642000, 643000, 
+ 644000, 645000, 646000, 647000, 648000, 649000, 684000, 685000, 846000, 847000, 
+ 688000, 689000, 650000, 651000, 652000, 653000, 654000, 655000, 656000, 657000, 
+ 658000, 659000, 694000, 695000, 856000, 857000, 698000, 699000, 660000, 661000, 
+ 662000, 663000, 664000, 665000, 666000, 667000, 668000, 669000, 686000, 687000, 
+ 866000, 867000, 888000, 889000, 670000, 671000, 672000, 673000, 674000, 675000, 
+ 676000, 677000, 678000, 679000, 696000, 697000, 876000, 877000, 898000, 899000, 
+ 700000, 701000, 702000, 703000, 704000, 705000, 706000, 707000, 708000, 709000, 
+ 780000, 781000, 906000, 907000, 986000, 987000, 710000, 711000, 712000, 713000, 
+ 714000, 715000, 716000, 717000, 718000, 719000, 790000, 791000, 916000, 917000, 
+ 996000, 997000, 720000, 721000, 722000, 723000, 724000, 725000, 726000, 727000, 
+ 728000, 729000, 782000, 783000, 926000, 927000, 968000, 969000, 730000, 731000, 
+ 732000, 733000, 734000, 735000, 736000, 737000, 738000, 739000, 792000, 793000, 
+ 936000, 937000, 978000, 979000, 740000, 741000, 742000, 743000, 744000, 745000, 
+ 746000, 747000, 748000, 749000, 784000, 785000, 946000, 947000, 788000, 789000, 
+ 750000, 751000, 752000, 753000, 754000, 755000, 756000, 757000, 758000, 759000, 
+ 794000, 795000, 956000, 957000, 798000, 799000, 760000, 761000, 762000, 763000, 
+ 764000, 765000, 766000, 767000, 768000, 769000, 786000, 787000, 966000, 967000, 
+ 988000, 989000, 770000, 771000, 772000, 773000, 774000, 775000, 776000, 777000, 
+ 778000, 779000, 796000, 797000, 976000, 977000, 998000, 999000};
+#endif
+ 
+#if defined(DEC_DPD2BINM) && DEC_DPD2BINM==1 && !defined(DECDPD2BINM)
+#define DECDPD2BINM
+ 
+const uint32_t DPD2BINM[1024]={0,   1000000,   2000000,   3000000,   4000000, 
+   5000000,   6000000,   7000000,   8000000,   9000000,  80000000,  81000000, 
+ 800000000, 801000000, 880000000, 881000000,  10000000,  11000000,  12000000, 
+  13000000,  14000000,  15000000,  16000000,  17000000,  18000000,  19000000, 
+  90000000,  91000000, 810000000, 811000000, 890000000, 891000000,  20000000, 
+  21000000,  22000000,  23000000,  24000000,  25000000,  26000000,  27000000, 
+  28000000,  29000000,  82000000,  83000000, 820000000, 821000000, 808000000, 
+ 809000000,  30000000,  31000000,  32000000,  33000000,  34000000,  35000000, 
+  36000000,  37000000,  38000000,  39000000,  92000000,  93000000, 830000000, 
+ 831000000, 818000000, 819000000,  40000000,  41000000,  42000000,  43000000, 
+  44000000,  45000000,  46000000,  47000000,  48000000,  49000000,  84000000, 
+  85000000, 840000000, 841000000,  88000000,  89000000,  50000000,  51000000, 
+  52000000,  53000000,  54000000,  55000000,  56000000,  57000000,  58000000, 
+  59000000,  94000000,  95000000, 850000000, 851000000,  98000000,  99000000, 
+  60000000,  61000000,  62000000,  63000000,  64000000,  65000000,  66000000, 
+  67000000,  68000000,  69000000,  86000000,  87000000, 860000000, 861000000, 
+ 888000000, 889000000,  70000000,  71000000,  72000000,  73000000,  74000000, 
+  75000000,  76000000,  77000000,  78000000,  79000000,  96000000,  97000000, 
+ 870000000, 871000000, 898000000, 899000000, 100000000, 101000000, 102000000, 
+ 103000000, 104000000, 105000000, 106000000, 107000000, 108000000, 109000000, 
+ 180000000, 181000000, 900000000, 901000000, 980000000, 981000000, 110000000, 
+ 111000000, 112000000, 113000000, 114000000, 115000000, 116000000, 117000000, 
+ 118000000, 119000000, 190000000, 191000000, 910000000, 911000000, 990000000, 
+ 991000000, 120000000, 121000000, 122000000, 123000000, 124000000, 125000000, 
+ 126000000, 127000000, 128000000, 129000000, 182000000, 183000000, 920000000, 
+ 921000000, 908000000, 909000000, 130000000, 131000000, 132000000, 133000000, 
+ 134000000, 135000000, 136000000, 137000000, 138000000, 139000000, 192000000, 
+ 193000000, 930000000, 931000000, 918000000, 919000000, 140000000, 141000000, 
+ 142000000, 143000000, 144000000, 145000000, 146000000, 147000000, 148000000, 
+ 149000000, 184000000, 185000000, 940000000, 941000000, 188000000, 189000000, 
+ 150000000, 151000000, 152000000, 153000000, 154000000, 155000000, 156000000, 
+ 157000000, 158000000, 159000000, 194000000, 195000000, 950000000, 951000000, 
+ 198000000, 199000000, 160000000, 161000000, 162000000, 163000000, 164000000, 
+ 165000000, 166000000, 167000000, 168000000, 169000000, 186000000, 187000000, 
+ 960000000, 961000000, 988000000, 989000000, 170000000, 171000000, 172000000, 
+ 173000000, 174000000, 175000000, 176000000, 177000000, 178000000, 179000000, 
+ 196000000, 197000000, 970000000, 971000000, 998000000, 999000000, 200000000, 
+ 201000000, 202000000, 203000000, 204000000, 205000000, 206000000, 207000000, 
+ 208000000, 209000000, 280000000, 281000000, 802000000, 803000000, 882000000, 
+ 883000000, 210000000, 211000000, 212000000, 213000000, 214000000, 215000000, 
+ 216000000, 217000000, 218000000, 219000000, 290000000, 291000000, 812000000, 
+ 813000000, 892000000, 893000000, 220000000, 221000000, 222000000, 223000000, 
+ 224000000, 225000000, 226000000, 227000000, 228000000, 229000000, 282000000, 
+ 283000000, 822000000, 823000000, 828000000, 829000000, 230000000, 231000000, 
+ 232000000, 233000000, 234000000, 235000000, 236000000, 237000000, 238000000, 
+ 239000000, 292000000, 293000000, 832000000, 833000000, 838000000, 839000000, 
+ 240000000, 241000000, 242000000, 243000000, 244000000, 245000000, 246000000, 
+ 247000000, 248000000, 249000000, 284000000, 285000000, 842000000, 843000000, 
+ 288000000, 289000000, 250000000, 251000000, 252000000, 253000000, 254000000, 
+ 255000000, 256000000, 257000000, 258000000, 259000000, 294000000, 295000000, 
+ 852000000, 853000000, 298000000, 299000000, 260000000, 261000000, 262000000, 
+ 263000000, 264000000, 265000000, 266000000, 267000000, 268000000, 269000000, 
+ 286000000, 287000000, 862000000, 863000000, 888000000, 889000000, 270000000, 
+ 271000000, 272000000, 273000000, 274000000, 275000000, 276000000, 277000000, 
+ 278000000, 279000000, 296000000, 297000000, 872000000, 873000000, 898000000, 
+ 899000000, 300000000, 301000000, 302000000, 303000000, 304000000, 305000000, 
+ 306000000, 307000000, 308000000, 309000000, 380000000, 381000000, 902000000, 
+ 903000000, 982000000, 983000000, 310000000, 311000000, 312000000, 313000000, 
+ 314000000, 315000000, 316000000, 317000000, 318000000, 319000000, 390000000, 
+ 391000000, 912000000, 913000000, 992000000, 993000000, 320000000, 321000000, 
+ 322000000, 323000000, 324000000, 325000000, 326000000, 327000000, 328000000, 
+ 329000000, 382000000, 383000000, 922000000, 923000000, 928000000, 929000000, 
+ 330000000, 331000000, 332000000, 333000000, 334000000, 335000000, 336000000, 
+ 337000000, 338000000, 339000000, 392000000, 393000000, 932000000, 933000000, 
+ 938000000, 939000000, 340000000, 341000000, 342000000, 343000000, 344000000, 
+ 345000000, 346000000, 347000000, 348000000, 349000000, 384000000, 385000000, 
+ 942000000, 943000000, 388000000, 389000000, 350000000, 351000000, 352000000, 
+ 353000000, 354000000, 355000000, 356000000, 357000000, 358000000, 359000000, 
+ 394000000, 395000000, 952000000, 953000000, 398000000, 399000000, 360000000, 
+ 361000000, 362000000, 363000000, 364000000, 365000000, 366000000, 367000000, 
+ 368000000, 369000000, 386000000, 387000000, 962000000, 963000000, 988000000, 
+ 989000000, 370000000, 371000000, 372000000, 373000000, 374000000, 375000000, 
+ 376000000, 377000000, 378000000, 379000000, 396000000, 397000000, 972000000, 
+ 973000000, 998000000, 999000000, 400000000, 401000000, 402000000, 403000000, 
+ 404000000, 405000000, 406000000, 407000000, 408000000, 409000000, 480000000, 
+ 481000000, 804000000, 805000000, 884000000, 885000000, 410000000, 411000000, 
+ 412000000, 413000000, 414000000, 415000000, 416000000, 417000000, 418000000, 
+ 419000000, 490000000, 491000000, 814000000, 815000000, 894000000, 895000000, 
+ 420000000, 421000000, 422000000, 423000000, 424000000, 425000000, 426000000, 
+ 427000000, 428000000, 429000000, 482000000, 483000000, 824000000, 825000000, 
+ 848000000, 849000000, 430000000, 431000000, 432000000, 433000000, 434000000, 
+ 435000000, 436000000, 437000000, 438000000, 439000000, 492000000, 493000000, 
+ 834000000, 835000000, 858000000, 859000000, 440000000, 441000000, 442000000, 
+ 443000000, 444000000, 445000000, 446000000, 447000000, 448000000, 449000000, 
+ 484000000, 485000000, 844000000, 845000000, 488000000, 489000000, 450000000, 
+ 451000000, 452000000, 453000000, 454000000, 455000000, 456000000, 457000000, 
+ 458000000, 459000000, 494000000, 495000000, 854000000, 855000000, 498000000, 
+ 499000000, 460000000, 461000000, 462000000, 463000000, 464000000, 465000000, 
+ 466000000, 467000000, 468000000, 469000000, 486000000, 487000000, 864000000, 
+ 865000000, 888000000, 889000000, 470000000, 471000000, 472000000, 473000000, 
+ 474000000, 475000000, 476000000, 477000000, 478000000, 479000000, 496000000, 
+ 497000000, 874000000, 875000000, 898000000, 899000000, 500000000, 501000000, 
+ 502000000, 503000000, 504000000, 505000000, 506000000, 507000000, 508000000, 
+ 509000000, 580000000, 581000000, 904000000, 905000000, 984000000, 985000000, 
+ 510000000, 511000000, 512000000, 513000000, 514000000, 515000000, 516000000, 
+ 517000000, 518000000, 519000000, 590000000, 591000000, 914000000, 915000000, 
+ 994000000, 995000000, 520000000, 521000000, 522000000, 523000000, 524000000, 
+ 525000000, 526000000, 527000000, 528000000, 529000000, 582000000, 583000000, 
+ 924000000, 925000000, 948000000, 949000000, 530000000, 531000000, 532000000, 
+ 533000000, 534000000, 535000000, 536000000, 537000000, 538000000, 539000000, 
+ 592000000, 593000000, 934000000, 935000000, 958000000, 959000000, 540000000, 
+ 541000000, 542000000, 543000000, 544000000, 545000000, 546000000, 547000000, 
+ 548000000, 549000000, 584000000, 585000000, 944000000, 945000000, 588000000, 
+ 589000000, 550000000, 551000000, 552000000, 553000000, 554000000, 555000000, 
+ 556000000, 557000000, 558000000, 559000000, 594000000, 595000000, 954000000, 
+ 955000000, 598000000, 599000000, 560000000, 561000000, 562000000, 563000000, 
+ 564000000, 565000000, 566000000, 567000000, 568000000, 569000000, 586000000, 
+ 587000000, 964000000, 965000000, 988000000, 989000000, 570000000, 571000000, 
+ 572000000, 573000000, 574000000, 575000000, 576000000, 577000000, 578000000, 
+ 579000000, 596000000, 597000000, 974000000, 975000000, 998000000, 999000000, 
+ 600000000, 601000000, 602000000, 603000000, 604000000, 605000000, 606000000, 
+ 607000000, 608000000, 609000000, 680000000, 681000000, 806000000, 807000000, 
+ 886000000, 887000000, 610000000, 611000000, 612000000, 613000000, 614000000, 
+ 615000000, 616000000, 617000000, 618000000, 619000000, 690000000, 691000000, 
+ 816000000, 817000000, 896000000, 897000000, 620000000, 621000000, 622000000, 
+ 623000000, 624000000, 625000000, 626000000, 627000000, 628000000, 629000000, 
+ 682000000, 683000000, 826000000, 827000000, 868000000, 869000000, 630000000, 
+ 631000000, 632000000, 633000000, 634000000, 635000000, 636000000, 637000000, 
+ 638000000, 639000000, 692000000, 693000000, 836000000, 837000000, 878000000, 
+ 879000000, 640000000, 641000000, 642000000, 643000000, 644000000, 645000000, 
+ 646000000, 647000000, 648000000, 649000000, 684000000, 685000000, 846000000, 
+ 847000000, 688000000, 689000000, 650000000, 651000000, 652000000, 653000000, 
+ 654000000, 655000000, 656000000, 657000000, 658000000, 659000000, 694000000, 
+ 695000000, 856000000, 857000000, 698000000, 699000000, 660000000, 661000000, 
+ 662000000, 663000000, 664000000, 665000000, 666000000, 667000000, 668000000, 
+ 669000000, 686000000, 687000000, 866000000, 867000000, 888000000, 889000000, 
+ 670000000, 671000000, 672000000, 673000000, 674000000, 675000000, 676000000, 
+ 677000000, 678000000, 679000000, 696000000, 697000000, 876000000, 877000000, 
+ 898000000, 899000000, 700000000, 701000000, 702000000, 703000000, 704000000, 
+ 705000000, 706000000, 707000000, 708000000, 709000000, 780000000, 781000000, 
+ 906000000, 907000000, 986000000, 987000000, 710000000, 711000000, 712000000, 
+ 713000000, 714000000, 715000000, 716000000, 717000000, 718000000, 719000000, 
+ 790000000, 791000000, 916000000, 917000000, 996000000, 997000000, 720000000, 
+ 721000000, 722000000, 723000000, 724000000, 725000000, 726000000, 727000000, 
+ 728000000, 729000000, 782000000, 783000000, 926000000, 927000000, 968000000, 
+ 969000000, 730000000, 731000000, 732000000, 733000000, 734000000, 735000000, 
+ 736000000, 737000000, 738000000, 739000000, 792000000, 793000000, 936000000, 
+ 937000000, 978000000, 979000000, 740000000, 741000000, 742000000, 743000000, 
+ 744000000, 745000000, 746000000, 747000000, 748000000, 749000000, 784000000, 
+ 785000000, 946000000, 947000000, 788000000, 789000000, 750000000, 751000000, 
+ 752000000, 753000000, 754000000, 755000000, 756000000, 757000000, 758000000, 
+ 759000000, 794000000, 795000000, 956000000, 957000000, 798000000, 799000000, 
+ 760000000, 761000000, 762000000, 763000000, 764000000, 765000000, 766000000, 
+ 767000000, 768000000, 769000000, 786000000, 787000000, 966000000, 967000000, 
+ 988000000, 989000000, 770000000, 771000000, 772000000, 773000000, 774000000, 
+ 775000000, 776000000, 777000000, 778000000, 779000000, 796000000, 797000000, 
+ 976000000, 977000000, 998000000, 999000000};
+#endif
+ 
+#if defined(DEC_BIN2CHAR) && DEC_BIN2CHAR==1 && !defined(DECBIN2CHAR)
+#define DECBIN2CHAR
+ 
+const uint8_t BIN2CHAR[4001]={
+ '\0','0','0','0', '\1','0','0','1', '\1','0','0','2', '\1','0','0','3', '\1','0','0','4', 
+ '\1','0','0','5', '\1','0','0','6', '\1','0','0','7', '\1','0','0','8', '\1','0','0','9', 
+ '\2','0','1','0', '\2','0','1','1', '\2','0','1','2', '\2','0','1','3', '\2','0','1','4', 
+ '\2','0','1','5', '\2','0','1','6', '\2','0','1','7', '\2','0','1','8', '\2','0','1','9', 
+ '\2','0','2','0', '\2','0','2','1', '\2','0','2','2', '\2','0','2','3', '\2','0','2','4', 
+ '\2','0','2','5', '\2','0','2','6', '\2','0','2','7', '\2','0','2','8', '\2','0','2','9', 
+ '\2','0','3','0', '\2','0','3','1', '\2','0','3','2', '\2','0','3','3', '\2','0','3','4', 
+ '\2','0','3','5', '\2','0','3','6', '\2','0','3','7', '\2','0','3','8', '\2','0','3','9', 
+ '\2','0','4','0', '\2','0','4','1', '\2','0','4','2', '\2','0','4','3', '\2','0','4','4', 
+ '\2','0','4','5', '\2','0','4','6', '\2','0','4','7', '\2','0','4','8', '\2','0','4','9', 
+ '\2','0','5','0', '\2','0','5','1', '\2','0','5','2', '\2','0','5','3', '\2','0','5','4', 
+ '\2','0','5','5', '\2','0','5','6', '\2','0','5','7', '\2','0','5','8', '\2','0','5','9', 
+ '\2','0','6','0', '\2','0','6','1', '\2','0','6','2', '\2','0','6','3', '\2','0','6','4', 
+ '\2','0','6','5', '\2','0','6','6', '\2','0','6','7', '\2','0','6','8', '\2','0','6','9', 
+ '\2','0','7','0', '\2','0','7','1', '\2','0','7','2', '\2','0','7','3', '\2','0','7','4', 
+ '\2','0','7','5', '\2','0','7','6', '\2','0','7','7', '\2','0','7','8', '\2','0','7','9', 
+ '\2','0','8','0', '\2','0','8','1', '\2','0','8','2', '\2','0','8','3', '\2','0','8','4', 
+ '\2','0','8','5', '\2','0','8','6', '\2','0','8','7', '\2','0','8','8', '\2','0','8','9', 
+ '\2','0','9','0', '\2','0','9','1', '\2','0','9','2', '\2','0','9','3', '\2','0','9','4', 
+ '\2','0','9','5', '\2','0','9','6', '\2','0','9','7', '\2','0','9','8', '\2','0','9','9', 
+ '\3','1','0','0', '\3','1','0','1', '\3','1','0','2', '\3','1','0','3', '\3','1','0','4', 
+ '\3','1','0','5', '\3','1','0','6', '\3','1','0','7', '\3','1','0','8', '\3','1','0','9', 
+ '\3','1','1','0', '\3','1','1','1', '\3','1','1','2', '\3','1','1','3', '\3','1','1','4', 
+ '\3','1','1','5', '\3','1','1','6', '\3','1','1','7', '\3','1','1','8', '\3','1','1','9', 
+ '\3','1','2','0', '\3','1','2','1', '\3','1','2','2', '\3','1','2','3', '\3','1','2','4', 
+ '\3','1','2','5', '\3','1','2','6', '\3','1','2','7', '\3','1','2','8', '\3','1','2','9', 
+ '\3','1','3','0', '\3','1','3','1', '\3','1','3','2', '\3','1','3','3', '\3','1','3','4', 
+ '\3','1','3','5', '\3','1','3','6', '\3','1','3','7', '\3','1','3','8', '\3','1','3','9', 
+ '\3','1','4','0', '\3','1','4','1', '\3','1','4','2', '\3','1','4','3', '\3','1','4','4', 
+ '\3','1','4','5', '\3','1','4','6', '\3','1','4','7', '\3','1','4','8', '\3','1','4','9', 
+ '\3','1','5','0', '\3','1','5','1', '\3','1','5','2', '\3','1','5','3', '\3','1','5','4', 
+ '\3','1','5','5', '\3','1','5','6', '\3','1','5','7', '\3','1','5','8', '\3','1','5','9', 
+ '\3','1','6','0', '\3','1','6','1', '\3','1','6','2', '\3','1','6','3', '\3','1','6','4', 
+ '\3','1','6','5', '\3','1','6','6', '\3','1','6','7', '\3','1','6','8', '\3','1','6','9', 
+ '\3','1','7','0', '\3','1','7','1', '\3','1','7','2', '\3','1','7','3', '\3','1','7','4', 
+ '\3','1','7','5', '\3','1','7','6', '\3','1','7','7', '\3','1','7','8', '\3','1','7','9', 
+ '\3','1','8','0', '\3','1','8','1', '\3','1','8','2', '\3','1','8','3', '\3','1','8','4', 
+ '\3','1','8','5', '\3','1','8','6', '\3','1','8','7', '\3','1','8','8', '\3','1','8','9', 
+ '\3','1','9','0', '\3','1','9','1', '\3','1','9','2', '\3','1','9','3', '\3','1','9','4', 
+ '\3','1','9','5', '\3','1','9','6', '\3','1','9','7', '\3','1','9','8', '\3','1','9','9', 
+ '\3','2','0','0', '\3','2','0','1', '\3','2','0','2', '\3','2','0','3', '\3','2','0','4', 
+ '\3','2','0','5', '\3','2','0','6', '\3','2','0','7', '\3','2','0','8', '\3','2','0','9', 
+ '\3','2','1','0', '\3','2','1','1', '\3','2','1','2', '\3','2','1','3', '\3','2','1','4', 
+ '\3','2','1','5', '\3','2','1','6', '\3','2','1','7', '\3','2','1','8', '\3','2','1','9', 
+ '\3','2','2','0', '\3','2','2','1', '\3','2','2','2', '\3','2','2','3', '\3','2','2','4', 
+ '\3','2','2','5', '\3','2','2','6', '\3','2','2','7', '\3','2','2','8', '\3','2','2','9', 
+ '\3','2','3','0', '\3','2','3','1', '\3','2','3','2', '\3','2','3','3', '\3','2','3','4', 
+ '\3','2','3','5', '\3','2','3','6', '\3','2','3','7', '\3','2','3','8', '\3','2','3','9', 
+ '\3','2','4','0', '\3','2','4','1', '\3','2','4','2', '\3','2','4','3', '\3','2','4','4', 
+ '\3','2','4','5', '\3','2','4','6', '\3','2','4','7', '\3','2','4','8', '\3','2','4','9', 
+ '\3','2','5','0', '\3','2','5','1', '\3','2','5','2', '\3','2','5','3', '\3','2','5','4', 
+ '\3','2','5','5', '\3','2','5','6', '\3','2','5','7', '\3','2','5','8', '\3','2','5','9', 
+ '\3','2','6','0', '\3','2','6','1', '\3','2','6','2', '\3','2','6','3', '\3','2','6','4', 
+ '\3','2','6','5', '\3','2','6','6', '\3','2','6','7', '\3','2','6','8', '\3','2','6','9', 
+ '\3','2','7','0', '\3','2','7','1', '\3','2','7','2', '\3','2','7','3', '\3','2','7','4', 
+ '\3','2','7','5', '\3','2','7','6', '\3','2','7','7', '\3','2','7','8', '\3','2','7','9', 
+ '\3','2','8','0', '\3','2','8','1', '\3','2','8','2', '\3','2','8','3', '\3','2','8','4', 
+ '\3','2','8','5', '\3','2','8','6', '\3','2','8','7', '\3','2','8','8', '\3','2','8','9', 
+ '\3','2','9','0', '\3','2','9','1', '\3','2','9','2', '\3','2','9','3', '\3','2','9','4', 
+ '\3','2','9','5', '\3','2','9','6', '\3','2','9','7', '\3','2','9','8', '\3','2','9','9', 
+ '\3','3','0','0', '\3','3','0','1', '\3','3','0','2', '\3','3','0','3', '\3','3','0','4', 
+ '\3','3','0','5', '\3','3','0','6', '\3','3','0','7', '\3','3','0','8', '\3','3','0','9', 
+ '\3','3','1','0', '\3','3','1','1', '\3','3','1','2', '\3','3','1','3', '\3','3','1','4', 
+ '\3','3','1','5', '\3','3','1','6', '\3','3','1','7', '\3','3','1','8', '\3','3','1','9', 
+ '\3','3','2','0', '\3','3','2','1', '\3','3','2','2', '\3','3','2','3', '\3','3','2','4', 
+ '\3','3','2','5', '\3','3','2','6', '\3','3','2','7', '\3','3','2','8', '\3','3','2','9', 
+ '\3','3','3','0', '\3','3','3','1', '\3','3','3','2', '\3','3','3','3', '\3','3','3','4', 
+ '\3','3','3','5', '\3','3','3','6', '\3','3','3','7', '\3','3','3','8', '\3','3','3','9', 
+ '\3','3','4','0', '\3','3','4','1', '\3','3','4','2', '\3','3','4','3', '\3','3','4','4', 
+ '\3','3','4','5', '\3','3','4','6', '\3','3','4','7', '\3','3','4','8', '\3','3','4','9', 
+ '\3','3','5','0', '\3','3','5','1', '\3','3','5','2', '\3','3','5','3', '\3','3','5','4', 
+ '\3','3','5','5', '\3','3','5','6', '\3','3','5','7', '\3','3','5','8', '\3','3','5','9', 
+ '\3','3','6','0', '\3','3','6','1', '\3','3','6','2', '\3','3','6','3', '\3','3','6','4', 
+ '\3','3','6','5', '\3','3','6','6', '\3','3','6','7', '\3','3','6','8', '\3','3','6','9', 
+ '\3','3','7','0', '\3','3','7','1', '\3','3','7','2', '\3','3','7','3', '\3','3','7','4', 
+ '\3','3','7','5', '\3','3','7','6', '\3','3','7','7', '\3','3','7','8', '\3','3','7','9', 
+ '\3','3','8','0', '\3','3','8','1', '\3','3','8','2', '\3','3','8','3', '\3','3','8','4', 
+ '\3','3','8','5', '\3','3','8','6', '\3','3','8','7', '\3','3','8','8', '\3','3','8','9', 
+ '\3','3','9','0', '\3','3','9','1', '\3','3','9','2', '\3','3','9','3', '\3','3','9','4', 
+ '\3','3','9','5', '\3','3','9','6', '\3','3','9','7', '\3','3','9','8', '\3','3','9','9', 
+ '\3','4','0','0', '\3','4','0','1', '\3','4','0','2', '\3','4','0','3', '\3','4','0','4', 
+ '\3','4','0','5', '\3','4','0','6', '\3','4','0','7', '\3','4','0','8', '\3','4','0','9', 
+ '\3','4','1','0', '\3','4','1','1', '\3','4','1','2', '\3','4','1','3', '\3','4','1','4', 
+ '\3','4','1','5', '\3','4','1','6', '\3','4','1','7', '\3','4','1','8', '\3','4','1','9', 
+ '\3','4','2','0', '\3','4','2','1', '\3','4','2','2', '\3','4','2','3', '\3','4','2','4', 
+ '\3','4','2','5', '\3','4','2','6', '\3','4','2','7', '\3','4','2','8', '\3','4','2','9', 
+ '\3','4','3','0', '\3','4','3','1', '\3','4','3','2', '\3','4','3','3', '\3','4','3','4', 
+ '\3','4','3','5', '\3','4','3','6', '\3','4','3','7', '\3','4','3','8', '\3','4','3','9', 
+ '\3','4','4','0', '\3','4','4','1', '\3','4','4','2', '\3','4','4','3', '\3','4','4','4', 
+ '\3','4','4','5', '\3','4','4','6', '\3','4','4','7', '\3','4','4','8', '\3','4','4','9', 
+ '\3','4','5','0', '\3','4','5','1', '\3','4','5','2', '\3','4','5','3', '\3','4','5','4', 
+ '\3','4','5','5', '\3','4','5','6', '\3','4','5','7', '\3','4','5','8', '\3','4','5','9', 
+ '\3','4','6','0', '\3','4','6','1', '\3','4','6','2', '\3','4','6','3', '\3','4','6','4', 
+ '\3','4','6','5', '\3','4','6','6', '\3','4','6','7', '\3','4','6','8', '\3','4','6','9', 
+ '\3','4','7','0', '\3','4','7','1', '\3','4','7','2', '\3','4','7','3', '\3','4','7','4', 
+ '\3','4','7','5', '\3','4','7','6', '\3','4','7','7', '\3','4','7','8', '\3','4','7','9', 
+ '\3','4','8','0', '\3','4','8','1', '\3','4','8','2', '\3','4','8','3', '\3','4','8','4', 
+ '\3','4','8','5', '\3','4','8','6', '\3','4','8','7', '\3','4','8','8', '\3','4','8','9', 
+ '\3','4','9','0', '\3','4','9','1', '\3','4','9','2', '\3','4','9','3', '\3','4','9','4', 
+ '\3','4','9','5', '\3','4','9','6', '\3','4','9','7', '\3','4','9','8', '\3','4','9','9', 
+ '\3','5','0','0', '\3','5','0','1', '\3','5','0','2', '\3','5','0','3', '\3','5','0','4', 
+ '\3','5','0','5', '\3','5','0','6', '\3','5','0','7', '\3','5','0','8', '\3','5','0','9', 
+ '\3','5','1','0', '\3','5','1','1', '\3','5','1','2', '\3','5','1','3', '\3','5','1','4', 
+ '\3','5','1','5', '\3','5','1','6', '\3','5','1','7', '\3','5','1','8', '\3','5','1','9', 
+ '\3','5','2','0', '\3','5','2','1', '\3','5','2','2', '\3','5','2','3', '\3','5','2','4', 
+ '\3','5','2','5', '\3','5','2','6', '\3','5','2','7', '\3','5','2','8', '\3','5','2','9', 
+ '\3','5','3','0', '\3','5','3','1', '\3','5','3','2', '\3','5','3','3', '\3','5','3','4', 
+ '\3','5','3','5', '\3','5','3','6', '\3','5','3','7', '\3','5','3','8', '\3','5','3','9', 
+ '\3','5','4','0', '\3','5','4','1', '\3','5','4','2', '\3','5','4','3', '\3','5','4','4', 
+ '\3','5','4','5', '\3','5','4','6', '\3','5','4','7', '\3','5','4','8', '\3','5','4','9', 
+ '\3','5','5','0', '\3','5','5','1', '\3','5','5','2', '\3','5','5','3', '\3','5','5','4', 
+ '\3','5','5','5', '\3','5','5','6', '\3','5','5','7', '\3','5','5','8', '\3','5','5','9', 
+ '\3','5','6','0', '\3','5','6','1', '\3','5','6','2', '\3','5','6','3', '\3','5','6','4', 
+ '\3','5','6','5', '\3','5','6','6', '\3','5','6','7', '\3','5','6','8', '\3','5','6','9', 
+ '\3','5','7','0', '\3','5','7','1', '\3','5','7','2', '\3','5','7','3', '\3','5','7','4', 
+ '\3','5','7','5', '\3','5','7','6', '\3','5','7','7', '\3','5','7','8', '\3','5','7','9', 
+ '\3','5','8','0', '\3','5','8','1', '\3','5','8','2', '\3','5','8','3', '\3','5','8','4', 
+ '\3','5','8','5', '\3','5','8','6', '\3','5','8','7', '\3','5','8','8', '\3','5','8','9', 
+ '\3','5','9','0', '\3','5','9','1', '\3','5','9','2', '\3','5','9','3', '\3','5','9','4', 
+ '\3','5','9','5', '\3','5','9','6', '\3','5','9','7', '\3','5','9','8', '\3','5','9','9', 
+ '\3','6','0','0', '\3','6','0','1', '\3','6','0','2', '\3','6','0','3', '\3','6','0','4', 
+ '\3','6','0','5', '\3','6','0','6', '\3','6','0','7', '\3','6','0','8', '\3','6','0','9', 
+ '\3','6','1','0', '\3','6','1','1', '\3','6','1','2', '\3','6','1','3', '\3','6','1','4', 
+ '\3','6','1','5', '\3','6','1','6', '\3','6','1','7', '\3','6','1','8', '\3','6','1','9', 
+ '\3','6','2','0', '\3','6','2','1', '\3','6','2','2', '\3','6','2','3', '\3','6','2','4', 
+ '\3','6','2','5', '\3','6','2','6', '\3','6','2','7', '\3','6','2','8', '\3','6','2','9', 
+ '\3','6','3','0', '\3','6','3','1', '\3','6','3','2', '\3','6','3','3', '\3','6','3','4', 
+ '\3','6','3','5', '\3','6','3','6', '\3','6','3','7', '\3','6','3','8', '\3','6','3','9', 
+ '\3','6','4','0', '\3','6','4','1', '\3','6','4','2', '\3','6','4','3', '\3','6','4','4', 
+ '\3','6','4','5', '\3','6','4','6', '\3','6','4','7', '\3','6','4','8', '\3','6','4','9', 
+ '\3','6','5','0', '\3','6','5','1', '\3','6','5','2', '\3','6','5','3', '\3','6','5','4', 
+ '\3','6','5','5', '\3','6','5','6', '\3','6','5','7', '\3','6','5','8', '\3','6','5','9', 
+ '\3','6','6','0', '\3','6','6','1', '\3','6','6','2', '\3','6','6','3', '\3','6','6','4', 
+ '\3','6','6','5', '\3','6','6','6', '\3','6','6','7', '\3','6','6','8', '\3','6','6','9', 
+ '\3','6','7','0', '\3','6','7','1', '\3','6','7','2', '\3','6','7','3', '\3','6','7','4', 
+ '\3','6','7','5', '\3','6','7','6', '\3','6','7','7', '\3','6','7','8', '\3','6','7','9', 
+ '\3','6','8','0', '\3','6','8','1', '\3','6','8','2', '\3','6','8','3', '\3','6','8','4', 
+ '\3','6','8','5', '\3','6','8','6', '\3','6','8','7', '\3','6','8','8', '\3','6','8','9', 
+ '\3','6','9','0', '\3','6','9','1', '\3','6','9','2', '\3','6','9','3', '\3','6','9','4', 
+ '\3','6','9','5', '\3','6','9','6', '\3','6','9','7', '\3','6','9','8', '\3','6','9','9', 
+ '\3','7','0','0', '\3','7','0','1', '\3','7','0','2', '\3','7','0','3', '\3','7','0','4', 
+ '\3','7','0','5', '\3','7','0','6', '\3','7','0','7', '\3','7','0','8', '\3','7','0','9', 
+ '\3','7','1','0', '\3','7','1','1', '\3','7','1','2', '\3','7','1','3', '\3','7','1','4', 
+ '\3','7','1','5', '\3','7','1','6', '\3','7','1','7', '\3','7','1','8', '\3','7','1','9', 
+ '\3','7','2','0', '\3','7','2','1', '\3','7','2','2', '\3','7','2','3', '\3','7','2','4', 
+ '\3','7','2','5', '\3','7','2','6', '\3','7','2','7', '\3','7','2','8', '\3','7','2','9', 
+ '\3','7','3','0', '\3','7','3','1', '\3','7','3','2', '\3','7','3','3', '\3','7','3','4', 
+ '\3','7','3','5', '\3','7','3','6', '\3','7','3','7', '\3','7','3','8', '\3','7','3','9', 
+ '\3','7','4','0', '\3','7','4','1', '\3','7','4','2', '\3','7','4','3', '\3','7','4','4', 
+ '\3','7','4','5', '\3','7','4','6', '\3','7','4','7', '\3','7','4','8', '\3','7','4','9', 
+ '\3','7','5','0', '\3','7','5','1', '\3','7','5','2', '\3','7','5','3', '\3','7','5','4', 
+ '\3','7','5','5', '\3','7','5','6', '\3','7','5','7', '\3','7','5','8', '\3','7','5','9', 
+ '\3','7','6','0', '\3','7','6','1', '\3','7','6','2', '\3','7','6','3', '\3','7','6','4', 
+ '\3','7','6','5', '\3','7','6','6', '\3','7','6','7', '\3','7','6','8', '\3','7','6','9', 
+ '\3','7','7','0', '\3','7','7','1', '\3','7','7','2', '\3','7','7','3', '\3','7','7','4', 
+ '\3','7','7','5', '\3','7','7','6', '\3','7','7','7', '\3','7','7','8', '\3','7','7','9', 
+ '\3','7','8','0', '\3','7','8','1', '\3','7','8','2', '\3','7','8','3', '\3','7','8','4', 
+ '\3','7','8','5', '\3','7','8','6', '\3','7','8','7', '\3','7','8','8', '\3','7','8','9', 
+ '\3','7','9','0', '\3','7','9','1', '\3','7','9','2', '\3','7','9','3', '\3','7','9','4', 
+ '\3','7','9','5', '\3','7','9','6', '\3','7','9','7', '\3','7','9','8', '\3','7','9','9', 
+ '\3','8','0','0', '\3','8','0','1', '\3','8','0','2', '\3','8','0','3', '\3','8','0','4', 
+ '\3','8','0','5', '\3','8','0','6', '\3','8','0','7', '\3','8','0','8', '\3','8','0','9', 
+ '\3','8','1','0', '\3','8','1','1', '\3','8','1','2', '\3','8','1','3', '\3','8','1','4', 
+ '\3','8','1','5', '\3','8','1','6', '\3','8','1','7', '\3','8','1','8', '\3','8','1','9', 
+ '\3','8','2','0', '\3','8','2','1', '\3','8','2','2', '\3','8','2','3', '\3','8','2','4', 
+ '\3','8','2','5', '\3','8','2','6', '\3','8','2','7', '\3','8','2','8', '\3','8','2','9', 
+ '\3','8','3','0', '\3','8','3','1', '\3','8','3','2', '\3','8','3','3', '\3','8','3','4', 
+ '\3','8','3','5', '\3','8','3','6', '\3','8','3','7', '\3','8','3','8', '\3','8','3','9', 
+ '\3','8','4','0', '\3','8','4','1', '\3','8','4','2', '\3','8','4','3', '\3','8','4','4', 
+ '\3','8','4','5', '\3','8','4','6', '\3','8','4','7', '\3','8','4','8', '\3','8','4','9', 
+ '\3','8','5','0', '\3','8','5','1', '\3','8','5','2', '\3','8','5','3', '\3','8','5','4', 
+ '\3','8','5','5', '\3','8','5','6', '\3','8','5','7', '\3','8','5','8', '\3','8','5','9', 
+ '\3','8','6','0', '\3','8','6','1', '\3','8','6','2', '\3','8','6','3', '\3','8','6','4', 
+ '\3','8','6','5', '\3','8','6','6', '\3','8','6','7', '\3','8','6','8', '\3','8','6','9', 
+ '\3','8','7','0', '\3','8','7','1', '\3','8','7','2', '\3','8','7','3', '\3','8','7','4', 
+ '\3','8','7','5', '\3','8','7','6', '\3','8','7','7', '\3','8','7','8', '\3','8','7','9', 
+ '\3','8','8','0', '\3','8','8','1', '\3','8','8','2', '\3','8','8','3', '\3','8','8','4', 
+ '\3','8','8','5', '\3','8','8','6', '\3','8','8','7', '\3','8','8','8', '\3','8','8','9', 
+ '\3','8','9','0', '\3','8','9','1', '\3','8','9','2', '\3','8','9','3', '\3','8','9','4', 
+ '\3','8','9','5', '\3','8','9','6', '\3','8','9','7', '\3','8','9','8', '\3','8','9','9', 
+ '\3','9','0','0', '\3','9','0','1', '\3','9','0','2', '\3','9','0','3', '\3','9','0','4', 
+ '\3','9','0','5', '\3','9','0','6', '\3','9','0','7', '\3','9','0','8', '\3','9','0','9', 
+ '\3','9','1','0', '\3','9','1','1', '\3','9','1','2', '\3','9','1','3', '\3','9','1','4', 
+ '\3','9','1','5', '\3','9','1','6', '\3','9','1','7', '\3','9','1','8', '\3','9','1','9', 
+ '\3','9','2','0', '\3','9','2','1', '\3','9','2','2', '\3','9','2','3', '\3','9','2','4', 
+ '\3','9','2','5', '\3','9','2','6', '\3','9','2','7', '\3','9','2','8', '\3','9','2','9', 
+ '\3','9','3','0', '\3','9','3','1', '\3','9','3','2', '\3','9','3','3', '\3','9','3','4', 
+ '\3','9','3','5', '\3','9','3','6', '\3','9','3','7', '\3','9','3','8', '\3','9','3','9', 
+ '\3','9','4','0', '\3','9','4','1', '\3','9','4','2', '\3','9','4','3', '\3','9','4','4', 
+ '\3','9','4','5', '\3','9','4','6', '\3','9','4','7', '\3','9','4','8', '\3','9','4','9', 
+ '\3','9','5','0', '\3','9','5','1', '\3','9','5','2', '\3','9','5','3', '\3','9','5','4', 
+ '\3','9','5','5', '\3','9','5','6', '\3','9','5','7', '\3','9','5','8', '\3','9','5','9', 
+ '\3','9','6','0', '\3','9','6','1', '\3','9','6','2', '\3','9','6','3', '\3','9','6','4', 
+ '\3','9','6','5', '\3','9','6','6', '\3','9','6','7', '\3','9','6','8', '\3','9','6','9', 
+ '\3','9','7','0', '\3','9','7','1', '\3','9','7','2', '\3','9','7','3', '\3','9','7','4', 
+ '\3','9','7','5', '\3','9','7','6', '\3','9','7','7', '\3','9','7','8', '\3','9','7','9', 
+ '\3','9','8','0', '\3','9','8','1', '\3','9','8','2', '\3','9','8','3', '\3','9','8','4', 
+ '\3','9','8','5', '\3','9','8','6', '\3','9','8','7', '\3','9','8','8', '\3','9','8','9', 
+ '\3','9','9','0', '\3','9','9','1', '\3','9','9','2', '\3','9','9','3', '\3','9','9','4', 
+ '\3','9','9','5', '\3','9','9','6', '\3','9','9','7', '\3','9','9','8', '\3','9','9','9', '\0'};
+#endif
+ 
+#if defined(DEC_DPD2BCD8) && DEC_DPD2BCD8==1 && !defined(DECDPD2BCD8)
+#define DECDPD2BCD8
+ 
+const uint8_t DPD2BCD8[4096]={
+ 0,0,0,0, 0,0,1,1, 0,0,2,1, 0,0,3,1, 0,0,4,1, 0,0,5,1, 0,0,6,1, 0,0,7,1, 0,0,8,1, 
+ 0,0,9,1, 0,8,0,2, 0,8,1,2, 8,0,0,3, 8,0,1,3, 8,8,0,3, 8,8,1,3, 0,1,0,2, 0,1,1,2, 
+ 0,1,2,2, 0,1,3,2, 0,1,4,2, 0,1,5,2, 0,1,6,2, 0,1,7,2, 0,1,8,2, 0,1,9,2, 0,9,0,2, 
+ 0,9,1,2, 8,1,0,3, 8,1,1,3, 8,9,0,3, 8,9,1,3, 0,2,0,2, 0,2,1,2, 0,2,2,2, 0,2,3,2, 
+ 0,2,4,2, 0,2,5,2, 0,2,6,2, 0,2,7,2, 0,2,8,2, 0,2,9,2, 0,8,2,2, 0,8,3,2, 8,2,0,3, 
+ 8,2,1,3, 8,0,8,3, 8,0,9,3, 0,3,0,2, 0,3,1,2, 0,3,2,2, 0,3,3,2, 0,3,4,2, 0,3,5,2, 
+ 0,3,6,2, 0,3,7,2, 0,3,8,2, 0,3,9,2, 0,9,2,2, 0,9,3,2, 8,3,0,3, 8,3,1,3, 8,1,8,3, 
+ 8,1,9,3, 0,4,0,2, 0,4,1,2, 0,4,2,2, 0,4,3,2, 0,4,4,2, 0,4,5,2, 0,4,6,2, 0,4,7,2, 
+ 0,4,8,2, 0,4,9,2, 0,8,4,2, 0,8,5,2, 8,4,0,3, 8,4,1,3, 0,8,8,2, 0,8,9,2, 0,5,0,2, 
+ 0,5,1,2, 0,5,2,2, 0,5,3,2, 0,5,4,2, 0,5,5,2, 0,5,6,2, 0,5,7,2, 0,5,8,2, 0,5,9,2, 
+ 0,9,4,2, 0,9,5,2, 8,5,0,3, 8,5,1,3, 0,9,8,2, 0,9,9,2, 0,6,0,2, 0,6,1,2, 0,6,2,2, 
+ 0,6,3,2, 0,6,4,2, 0,6,5,2, 0,6,6,2, 0,6,7,2, 0,6,8,2, 0,6,9,2, 0,8,6,2, 0,8,7,2, 
+ 8,6,0,3, 8,6,1,3, 8,8,8,3, 8,8,9,3, 0,7,0,2, 0,7,1,2, 0,7,2,2, 0,7,3,2, 0,7,4,2, 
+ 0,7,5,2, 0,7,6,2, 0,7,7,2, 0,7,8,2, 0,7,9,2, 0,9,6,2, 0,9,7,2, 8,7,0,3, 8,7,1,3, 
+ 8,9,8,3, 8,9,9,3, 1,0,0,3, 1,0,1,3, 1,0,2,3, 1,0,3,3, 1,0,4,3, 1,0,5,3, 1,0,6,3, 
+ 1,0,7,3, 1,0,8,3, 1,0,9,3, 1,8,0,3, 1,8,1,3, 9,0,0,3, 9,0,1,3, 9,8,0,3, 9,8,1,3, 
+ 1,1,0,3, 1,1,1,3, 1,1,2,3, 1,1,3,3, 1,1,4,3, 1,1,5,3, 1,1,6,3, 1,1,7,3, 1,1,8,3, 
+ 1,1,9,3, 1,9,0,3, 1,9,1,3, 9,1,0,3, 9,1,1,3, 9,9,0,3, 9,9,1,3, 1,2,0,3, 1,2,1,3, 
+ 1,2,2,3, 1,2,3,3, 1,2,4,3, 1,2,5,3, 1,2,6,3, 1,2,7,3, 1,2,8,3, 1,2,9,3, 1,8,2,3, 
+ 1,8,3,3, 9,2,0,3, 9,2,1,3, 9,0,8,3, 9,0,9,3, 1,3,0,3, 1,3,1,3, 1,3,2,3, 1,3,3,3, 
+ 1,3,4,3, 1,3,5,3, 1,3,6,3, 1,3,7,3, 1,3,8,3, 1,3,9,3, 1,9,2,3, 1,9,3,3, 9,3,0,3, 
+ 9,3,1,3, 9,1,8,3, 9,1,9,3, 1,4,0,3, 1,4,1,3, 1,4,2,3, 1,4,3,3, 1,4,4,3, 1,4,5,3, 
+ 1,4,6,3, 1,4,7,3, 1,4,8,3, 1,4,9,3, 1,8,4,3, 1,8,5,3, 9,4,0,3, 9,4,1,3, 1,8,8,3, 
+ 1,8,9,3, 1,5,0,3, 1,5,1,3, 1,5,2,3, 1,5,3,3, 1,5,4,3, 1,5,5,3, 1,5,6,3, 1,5,7,3, 
+ 1,5,8,3, 1,5,9,3, 1,9,4,3, 1,9,5,3, 9,5,0,3, 9,5,1,3, 1,9,8,3, 1,9,9,3, 1,6,0,3, 
+ 1,6,1,3, 1,6,2,3, 1,6,3,3, 1,6,4,3, 1,6,5,3, 1,6,6,3, 1,6,7,3, 1,6,8,3, 1,6,9,3, 
+ 1,8,6,3, 1,8,7,3, 9,6,0,3, 9,6,1,3, 9,8,8,3, 9,8,9,3, 1,7,0,3, 1,7,1,3, 1,7,2,3, 
+ 1,7,3,3, 1,7,4,3, 1,7,5,3, 1,7,6,3, 1,7,7,3, 1,7,8,3, 1,7,9,3, 1,9,6,3, 1,9,7,3, 
+ 9,7,0,3, 9,7,1,3, 9,9,8,3, 9,9,9,3, 2,0,0,3, 2,0,1,3, 2,0,2,3, 2,0,3,3, 2,0,4,3, 
+ 2,0,5,3, 2,0,6,3, 2,0,7,3, 2,0,8,3, 2,0,9,3, 2,8,0,3, 2,8,1,3, 8,0,2,3, 8,0,3,3, 
+ 8,8,2,3, 8,8,3,3, 2,1,0,3, 2,1,1,3, 2,1,2,3, 2,1,3,3, 2,1,4,3, 2,1,5,3, 2,1,6,3, 
+ 2,1,7,3, 2,1,8,3, 2,1,9,3, 2,9,0,3, 2,9,1,3, 8,1,2,3, 8,1,3,3, 8,9,2,3, 8,9,3,3, 
+ 2,2,0,3, 2,2,1,3, 2,2,2,3, 2,2,3,3, 2,2,4,3, 2,2,5,3, 2,2,6,3, 2,2,7,3, 2,2,8,3, 
+ 2,2,9,3, 2,8,2,3, 2,8,3,3, 8,2,2,3, 8,2,3,3, 8,2,8,3, 8,2,9,3, 2,3,0,3, 2,3,1,3, 
+ 2,3,2,3, 2,3,3,3, 2,3,4,3, 2,3,5,3, 2,3,6,3, 2,3,7,3, 2,3,8,3, 2,3,9,3, 2,9,2,3, 
+ 2,9,3,3, 8,3,2,3, 8,3,3,3, 8,3,8,3, 8,3,9,3, 2,4,0,3, 2,4,1,3, 2,4,2,3, 2,4,3,3, 
+ 2,4,4,3, 2,4,5,3, 2,4,6,3, 2,4,7,3, 2,4,8,3, 2,4,9,3, 2,8,4,3, 2,8,5,3, 8,4,2,3, 
+ 8,4,3,3, 2,8,8,3, 2,8,9,3, 2,5,0,3, 2,5,1,3, 2,5,2,3, 2,5,3,3, 2,5,4,3, 2,5,5,3, 
+ 2,5,6,3, 2,5,7,3, 2,5,8,3, 2,5,9,3, 2,9,4,3, 2,9,5,3, 8,5,2,3, 8,5,3,3, 2,9,8,3, 
+ 2,9,9,3, 2,6,0,3, 2,6,1,3, 2,6,2,3, 2,6,3,3, 2,6,4,3, 2,6,5,3, 2,6,6,3, 2,6,7,3, 
+ 2,6,8,3, 2,6,9,3, 2,8,6,3, 2,8,7,3, 8,6,2,3, 8,6,3,3, 8,8,8,3, 8,8,9,3, 2,7,0,3, 
+ 2,7,1,3, 2,7,2,3, 2,7,3,3, 2,7,4,3, 2,7,5,3, 2,7,6,3, 2,7,7,3, 2,7,8,3, 2,7,9,3, 
+ 2,9,6,3, 2,9,7,3, 8,7,2,3, 8,7,3,3, 8,9,8,3, 8,9,9,3, 3,0,0,3, 3,0,1,3, 3,0,2,3, 
+ 3,0,3,3, 3,0,4,3, 3,0,5,3, 3,0,6,3, 3,0,7,3, 3,0,8,3, 3,0,9,3, 3,8,0,3, 3,8,1,3, 
+ 9,0,2,3, 9,0,3,3, 9,8,2,3, 9,8,3,3, 3,1,0,3, 3,1,1,3, 3,1,2,3, 3,1,3,3, 3,1,4,3, 
+ 3,1,5,3, 3,1,6,3, 3,1,7,3, 3,1,8,3, 3,1,9,3, 3,9,0,3, 3,9,1,3, 9,1,2,3, 9,1,3,3, 
+ 9,9,2,3, 9,9,3,3, 3,2,0,3, 3,2,1,3, 3,2,2,3, 3,2,3,3, 3,2,4,3, 3,2,5,3, 3,2,6,3, 
+ 3,2,7,3, 3,2,8,3, 3,2,9,3, 3,8,2,3, 3,8,3,3, 9,2,2,3, 9,2,3,3, 9,2,8,3, 9,2,9,3, 
+ 3,3,0,3, 3,3,1,3, 3,3,2,3, 3,3,3,3, 3,3,4,3, 3,3,5,3, 3,3,6,3, 3,3,7,3, 3,3,8,3, 
+ 3,3,9,3, 3,9,2,3, 3,9,3,3, 9,3,2,3, 9,3,3,3, 9,3,8,3, 9,3,9,3, 3,4,0,3, 3,4,1,3, 
+ 3,4,2,3, 3,4,3,3, 3,4,4,3, 3,4,5,3, 3,4,6,3, 3,4,7,3, 3,4,8,3, 3,4,9,3, 3,8,4,3, 
+ 3,8,5,3, 9,4,2,3, 9,4,3,3, 3,8,8,3, 3,8,9,3, 3,5,0,3, 3,5,1,3, 3,5,2,3, 3,5,3,3, 
+ 3,5,4,3, 3,5,5,3, 3,5,6,3, 3,5,7,3, 3,5,8,3, 3,5,9,3, 3,9,4,3, 3,9,5,3, 9,5,2,3, 
+ 9,5,3,3, 3,9,8,3, 3,9,9,3, 3,6,0,3, 3,6,1,3, 3,6,2,3, 3,6,3,3, 3,6,4,3, 3,6,5,3, 
+ 3,6,6,3, 3,6,7,3, 3,6,8,3, 3,6,9,3, 3,8,6,3, 3,8,7,3, 9,6,2,3, 9,6,3,3, 9,8,8,3, 
+ 9,8,9,3, 3,7,0,3, 3,7,1,3, 3,7,2,3, 3,7,3,3, 3,7,4,3, 3,7,5,3, 3,7,6,3, 3,7,7,3, 
+ 3,7,8,3, 3,7,9,3, 3,9,6,3, 3,9,7,3, 9,7,2,3, 9,7,3,3, 9,9,8,3, 9,9,9,3, 4,0,0,3, 
+ 4,0,1,3, 4,0,2,3, 4,0,3,3, 4,0,4,3, 4,0,5,3, 4,0,6,3, 4,0,7,3, 4,0,8,3, 4,0,9,3, 
+ 4,8,0,3, 4,8,1,3, 8,0,4,3, 8,0,5,3, 8,8,4,3, 8,8,5,3, 4,1,0,3, 4,1,1,3, 4,1,2,3, 
+ 4,1,3,3, 4,1,4,3, 4,1,5,3, 4,1,6,3, 4,1,7,3, 4,1,8,3, 4,1,9,3, 4,9,0,3, 4,9,1,3, 
+ 8,1,4,3, 8,1,5,3, 8,9,4,3, 8,9,5,3, 4,2,0,3, 4,2,1,3, 4,2,2,3, 4,2,3,3, 4,2,4,3, 
+ 4,2,5,3, 4,2,6,3, 4,2,7,3, 4,2,8,3, 4,2,9,3, 4,8,2,3, 4,8,3,3, 8,2,4,3, 8,2,5,3, 
+ 8,4,8,3, 8,4,9,3, 4,3,0,3, 4,3,1,3, 4,3,2,3, 4,3,3,3, 4,3,4,3, 4,3,5,3, 4,3,6,3, 
+ 4,3,7,3, 4,3,8,3, 4,3,9,3, 4,9,2,3, 4,9,3,3, 8,3,4,3, 8,3,5,3, 8,5,8,3, 8,5,9,3, 
+ 4,4,0,3, 4,4,1,3, 4,4,2,3, 4,4,3,3, 4,4,4,3, 4,4,5,3, 4,4,6,3, 4,4,7,3, 4,4,8,3, 
+ 4,4,9,3, 4,8,4,3, 4,8,5,3, 8,4,4,3, 8,4,5,3, 4,8,8,3, 4,8,9,3, 4,5,0,3, 4,5,1,3, 
+ 4,5,2,3, 4,5,3,3, 4,5,4,3, 4,5,5,3, 4,5,6,3, 4,5,7,3, 4,5,8,3, 4,5,9,3, 4,9,4,3, 
+ 4,9,5,3, 8,5,4,3, 8,5,5,3, 4,9,8,3, 4,9,9,3, 4,6,0,3, 4,6,1,3, 4,6,2,3, 4,6,3,3, 
+ 4,6,4,3, 4,6,5,3, 4,6,6,3, 4,6,7,3, 4,6,8,3, 4,6,9,3, 4,8,6,3, 4,8,7,3, 8,6,4,3, 
+ 8,6,5,3, 8,8,8,3, 8,8,9,3, 4,7,0,3, 4,7,1,3, 4,7,2,3, 4,7,3,3, 4,7,4,3, 4,7,5,3, 
+ 4,7,6,3, 4,7,7,3, 4,7,8,3, 4,7,9,3, 4,9,6,3, 4,9,7,3, 8,7,4,3, 8,7,5,3, 8,9,8,3, 
+ 8,9,9,3, 5,0,0,3, 5,0,1,3, 5,0,2,3, 5,0,3,3, 5,0,4,3, 5,0,5,3, 5,0,6,3, 5,0,7,3, 
+ 5,0,8,3, 5,0,9,3, 5,8,0,3, 5,8,1,3, 9,0,4,3, 9,0,5,3, 9,8,4,3, 9,8,5,3, 5,1,0,3, 
+ 5,1,1,3, 5,1,2,3, 5,1,3,3, 5,1,4,3, 5,1,5,3, 5,1,6,3, 5,1,7,3, 5,1,8,3, 5,1,9,3, 
+ 5,9,0,3, 5,9,1,3, 9,1,4,3, 9,1,5,3, 9,9,4,3, 9,9,5,3, 5,2,0,3, 5,2,1,3, 5,2,2,3, 
+ 5,2,3,3, 5,2,4,3, 5,2,5,3, 5,2,6,3, 5,2,7,3, 5,2,8,3, 5,2,9,3, 5,8,2,3, 5,8,3,3, 
+ 9,2,4,3, 9,2,5,3, 9,4,8,3, 9,4,9,3, 5,3,0,3, 5,3,1,3, 5,3,2,3, 5,3,3,3, 5,3,4,3, 
+ 5,3,5,3, 5,3,6,3, 5,3,7,3, 5,3,8,3, 5,3,9,3, 5,9,2,3, 5,9,3,3, 9,3,4,3, 9,3,5,3, 
+ 9,5,8,3, 9,5,9,3, 5,4,0,3, 5,4,1,3, 5,4,2,3, 5,4,3,3, 5,4,4,3, 5,4,5,3, 5,4,6,3, 
+ 5,4,7,3, 5,4,8,3, 5,4,9,3, 5,8,4,3, 5,8,5,3, 9,4,4,3, 9,4,5,3, 5,8,8,3, 5,8,9,3, 
+ 5,5,0,3, 5,5,1,3, 5,5,2,3, 5,5,3,3, 5,5,4,3, 5,5,5,3, 5,5,6,3, 5,5,7,3, 5,5,8,3, 
+ 5,5,9,3, 5,9,4,3, 5,9,5,3, 9,5,4,3, 9,5,5,3, 5,9,8,3, 5,9,9,3, 5,6,0,3, 5,6,1,3, 
+ 5,6,2,3, 5,6,3,3, 5,6,4,3, 5,6,5,3, 5,6,6,3, 5,6,7,3, 5,6,8,3, 5,6,9,3, 5,8,6,3, 
+ 5,8,7,3, 9,6,4,3, 9,6,5,3, 9,8,8,3, 9,8,9,3, 5,7,0,3, 5,7,1,3, 5,7,2,3, 5,7,3,3, 
+ 5,7,4,3, 5,7,5,3, 5,7,6,3, 5,7,7,3, 5,7,8,3, 5,7,9,3, 5,9,6,3, 5,9,7,3, 9,7,4,3, 
+ 9,7,5,3, 9,9,8,3, 9,9,9,3, 6,0,0,3, 6,0,1,3, 6,0,2,3, 6,0,3,3, 6,0,4,3, 6,0,5,3, 
+ 6,0,6,3, 6,0,7,3, 6,0,8,3, 6,0,9,3, 6,8,0,3, 6,8,1,3, 8,0,6,3, 8,0,7,3, 8,8,6,3, 
+ 8,8,7,3, 6,1,0,3, 6,1,1,3, 6,1,2,3, 6,1,3,3, 6,1,4,3, 6,1,5,3, 6,1,6,3, 6,1,7,3, 
+ 6,1,8,3, 6,1,9,3, 6,9,0,3, 6,9,1,3, 8,1,6,3, 8,1,7,3, 8,9,6,3, 8,9,7,3, 6,2,0,3, 
+ 6,2,1,3, 6,2,2,3, 6,2,3,3, 6,2,4,3, 6,2,5,3, 6,2,6,3, 6,2,7,3, 6,2,8,3, 6,2,9,3, 
+ 6,8,2,3, 6,8,3,3, 8,2,6,3, 8,2,7,3, 8,6,8,3, 8,6,9,3, 6,3,0,3, 6,3,1,3, 6,3,2,3, 
+ 6,3,3,3, 6,3,4,3, 6,3,5,3, 6,3,6,3, 6,3,7,3, 6,3,8,3, 6,3,9,3, 6,9,2,3, 6,9,3,3, 
+ 8,3,6,3, 8,3,7,3, 8,7,8,3, 8,7,9,3, 6,4,0,3, 6,4,1,3, 6,4,2,3, 6,4,3,3, 6,4,4,3, 
+ 6,4,5,3, 6,4,6,3, 6,4,7,3, 6,4,8,3, 6,4,9,3, 6,8,4,3, 6,8,5,3, 8,4,6,3, 8,4,7,3, 
+ 6,8,8,3, 6,8,9,3, 6,5,0,3, 6,5,1,3, 6,5,2,3, 6,5,3,3, 6,5,4,3, 6,5,5,3, 6,5,6,3, 
+ 6,5,7,3, 6,5,8,3, 6,5,9,3, 6,9,4,3, 6,9,5,3, 8,5,6,3, 8,5,7,3, 6,9,8,3, 6,9,9,3, 
+ 6,6,0,3, 6,6,1,3, 6,6,2,3, 6,6,3,3, 6,6,4,3, 6,6,5,3, 6,6,6,3, 6,6,7,3, 6,6,8,3, 
+ 6,6,9,3, 6,8,6,3, 6,8,7,3, 8,6,6,3, 8,6,7,3, 8,8,8,3, 8,8,9,3, 6,7,0,3, 6,7,1,3, 
+ 6,7,2,3, 6,7,3,3, 6,7,4,3, 6,7,5,3, 6,7,6,3, 6,7,7,3, 6,7,8,3, 6,7,9,3, 6,9,6,3, 
+ 6,9,7,3, 8,7,6,3, 8,7,7,3, 8,9,8,3, 8,9,9,3, 7,0,0,3, 7,0,1,3, 7,0,2,3, 7,0,3,3, 
+ 7,0,4,3, 7,0,5,3, 7,0,6,3, 7,0,7,3, 7,0,8,3, 7,0,9,3, 7,8,0,3, 7,8,1,3, 9,0,6,3, 
+ 9,0,7,3, 9,8,6,3, 9,8,7,3, 7,1,0,3, 7,1,1,3, 7,1,2,3, 7,1,3,3, 7,1,4,3, 7,1,5,3, 
+ 7,1,6,3, 7,1,7,3, 7,1,8,3, 7,1,9,3, 7,9,0,3, 7,9,1,3, 9,1,6,3, 9,1,7,3, 9,9,6,3, 
+ 9,9,7,3, 7,2,0,3, 7,2,1,3, 7,2,2,3, 7,2,3,3, 7,2,4,3, 7,2,5,3, 7,2,6,3, 7,2,7,3, 
+ 7,2,8,3, 7,2,9,3, 7,8,2,3, 7,8,3,3, 9,2,6,3, 9,2,7,3, 9,6,8,3, 9,6,9,3, 7,3,0,3, 
+ 7,3,1,3, 7,3,2,3, 7,3,3,3, 7,3,4,3, 7,3,5,3, 7,3,6,3, 7,3,7,3, 7,3,8,3, 7,3,9,3, 
+ 7,9,2,3, 7,9,3,3, 9,3,6,3, 9,3,7,3, 9,7,8,3, 9,7,9,3, 7,4,0,3, 7,4,1,3, 7,4,2,3, 
+ 7,4,3,3, 7,4,4,3, 7,4,5,3, 7,4,6,3, 7,4,7,3, 7,4,8,3, 7,4,9,3, 7,8,4,3, 7,8,5,3, 
+ 9,4,6,3, 9,4,7,3, 7,8,8,3, 7,8,9,3, 7,5,0,3, 7,5,1,3, 7,5,2,3, 7,5,3,3, 7,5,4,3, 
+ 7,5,5,3, 7,5,6,3, 7,5,7,3, 7,5,8,3, 7,5,9,3, 7,9,4,3, 7,9,5,3, 9,5,6,3, 9,5,7,3, 
+ 7,9,8,3, 7,9,9,3, 7,6,0,3, 7,6,1,3, 7,6,2,3, 7,6,3,3, 7,6,4,3, 7,6,5,3, 7,6,6,3, 
+ 7,6,7,3, 7,6,8,3, 7,6,9,3, 7,8,6,3, 7,8,7,3, 9,6,6,3, 9,6,7,3, 9,8,8,3, 9,8,9,3, 
+ 7,7,0,3, 7,7,1,3, 7,7,2,3, 7,7,3,3, 7,7,4,3, 7,7,5,3, 7,7,6,3, 7,7,7,3, 7,7,8,3, 
+ 7,7,9,3, 7,9,6,3, 7,9,7,3, 9,7,6,3, 9,7,7,3, 9,9,8,3, 9,9,9,3};
+#endif
+ 
+#if defined(DEC_BIN2BCD8) && DEC_BIN2BCD8==1 && !defined(DECBIN2BCD8)
+#define DECBIN2BCD8
+ 
+const uint8_t BIN2BCD8[4000]={
+ 0,0,0,0, 0,0,1,1, 0,0,2,1, 0,0,3,1, 0,0,4,1, 0,0,5,1, 0,0,6,1, 0,0,7,1, 0,0,8,1, 
+ 0,0,9,1, 0,1,0,2, 0,1,1,2, 0,1,2,2, 0,1,3,2, 0,1,4,2, 0,1,5,2, 0,1,6,2, 0,1,7,2, 
+ 0,1,8,2, 0,1,9,2, 0,2,0,2, 0,2,1,2, 0,2,2,2, 0,2,3,2, 0,2,4,2, 0,2,5,2, 0,2,6,2, 
+ 0,2,7,2, 0,2,8,2, 0,2,9,2, 0,3,0,2, 0,3,1,2, 0,3,2,2, 0,3,3,2, 0,3,4,2, 0,3,5,2, 
+ 0,3,6,2, 0,3,7,2, 0,3,8,2, 0,3,9,2, 0,4,0,2, 0,4,1,2, 0,4,2,2, 0,4,3,2, 0,4,4,2, 
+ 0,4,5,2, 0,4,6,2, 0,4,7,2, 0,4,8,2, 0,4,9,2, 0,5,0,2, 0,5,1,2, 0,5,2,2, 0,5,3,2, 
+ 0,5,4,2, 0,5,5,2, 0,5,6,2, 0,5,7,2, 0,5,8,2, 0,5,9,2, 0,6,0,2, 0,6,1,2, 0,6,2,2, 
+ 0,6,3,2, 0,6,4,2, 0,6,5,2, 0,6,6,2, 0,6,7,2, 0,6,8,2, 0,6,9,2, 0,7,0,2, 0,7,1,2, 
+ 0,7,2,2, 0,7,3,2, 0,7,4,2, 0,7,5,2, 0,7,6,2, 0,7,7,2, 0,7,8,2, 0,7,9,2, 0,8,0,2, 
+ 0,8,1,2, 0,8,2,2, 0,8,3,2, 0,8,4,2, 0,8,5,2, 0,8,6,2, 0,8,7,2, 0,8,8,2, 0,8,9,2, 
+ 0,9,0,2, 0,9,1,2, 0,9,2,2, 0,9,3,2, 0,9,4,2, 0,9,5,2, 0,9,6,2, 0,9,7,2, 0,9,8,2, 
+ 0,9,9,2, 1,0,0,3, 1,0,1,3, 1,0,2,3, 1,0,3,3, 1,0,4,3, 1,0,5,3, 1,0,6,3, 1,0,7,3, 
+ 1,0,8,3, 1,0,9,3, 1,1,0,3, 1,1,1,3, 1,1,2,3, 1,1,3,3, 1,1,4,3, 1,1,5,3, 1,1,6,3, 
+ 1,1,7,3, 1,1,8,3, 1,1,9,3, 1,2,0,3, 1,2,1,3, 1,2,2,3, 1,2,3,3, 1,2,4,3, 1,2,5,3, 
+ 1,2,6,3, 1,2,7,3, 1,2,8,3, 1,2,9,3, 1,3,0,3, 1,3,1,3, 1,3,2,3, 1,3,3,3, 1,3,4,3, 
+ 1,3,5,3, 1,3,6,3, 1,3,7,3, 1,3,8,3, 1,3,9,3, 1,4,0,3, 1,4,1,3, 1,4,2,3, 1,4,3,3, 
+ 1,4,4,3, 1,4,5,3, 1,4,6,3, 1,4,7,3, 1,4,8,3, 1,4,9,3, 1,5,0,3, 1,5,1,3, 1,5,2,3, 
+ 1,5,3,3, 1,5,4,3, 1,5,5,3, 1,5,6,3, 1,5,7,3, 1,5,8,3, 1,5,9,3, 1,6,0,3, 1,6,1,3, 
+ 1,6,2,3, 1,6,3,3, 1,6,4,3, 1,6,5,3, 1,6,6,3, 1,6,7,3, 1,6,8,3, 1,6,9,3, 1,7,0,3, 
+ 1,7,1,3, 1,7,2,3, 1,7,3,3, 1,7,4,3, 1,7,5,3, 1,7,6,3, 1,7,7,3, 1,7,8,3, 1,7,9,3, 
+ 1,8,0,3, 1,8,1,3, 1,8,2,3, 1,8,3,3, 1,8,4,3, 1,8,5,3, 1,8,6,3, 1,8,7,3, 1,8,8,3, 
+ 1,8,9,3, 1,9,0,3, 1,9,1,3, 1,9,2,3, 1,9,3,3, 1,9,4,3, 1,9,5,3, 1,9,6,3, 1,9,7,3, 
+ 1,9,8,3, 1,9,9,3, 2,0,0,3, 2,0,1,3, 2,0,2,3, 2,0,3,3, 2,0,4,3, 2,0,5,3, 2,0,6,3, 
+ 2,0,7,3, 2,0,8,3, 2,0,9,3, 2,1,0,3, 2,1,1,3, 2,1,2,3, 2,1,3,3, 2,1,4,3, 2,1,5,3, 
+ 2,1,6,3, 2,1,7,3, 2,1,8,3, 2,1,9,3, 2,2,0,3, 2,2,1,3, 2,2,2,3, 2,2,3,3, 2,2,4,3, 
+ 2,2,5,3, 2,2,6,3, 2,2,7,3, 2,2,8,3, 2,2,9,3, 2,3,0,3, 2,3,1,3, 2,3,2,3, 2,3,3,3, 
+ 2,3,4,3, 2,3,5,3, 2,3,6,3, 2,3,7,3, 2,3,8,3, 2,3,9,3, 2,4,0,3, 2,4,1,3, 2,4,2,3, 
+ 2,4,3,3, 2,4,4,3, 2,4,5,3, 2,4,6,3, 2,4,7,3, 2,4,8,3, 2,4,9,3, 2,5,0,3, 2,5,1,3, 
+ 2,5,2,3, 2,5,3,3, 2,5,4,3, 2,5,5,3, 2,5,6,3, 2,5,7,3, 2,5,8,3, 2,5,9,3, 2,6,0,3, 
+ 2,6,1,3, 2,6,2,3, 2,6,3,3, 2,6,4,3, 2,6,5,3, 2,6,6,3, 2,6,7,3, 2,6,8,3, 2,6,9,3, 
+ 2,7,0,3, 2,7,1,3, 2,7,2,3, 2,7,3,3, 2,7,4,3, 2,7,5,3, 2,7,6,3, 2,7,7,3, 2,7,8,3, 
+ 2,7,9,3, 2,8,0,3, 2,8,1,3, 2,8,2,3, 2,8,3,3, 2,8,4,3, 2,8,5,3, 2,8,6,3, 2,8,7,3, 
+ 2,8,8,3, 2,8,9,3, 2,9,0,3, 2,9,1,3, 2,9,2,3, 2,9,3,3, 2,9,4,3, 2,9,5,3, 2,9,6,3, 
+ 2,9,7,3, 2,9,8,3, 2,9,9,3, 3,0,0,3, 3,0,1,3, 3,0,2,3, 3,0,3,3, 3,0,4,3, 3,0,5,3, 
+ 3,0,6,3, 3,0,7,3, 3,0,8,3, 3,0,9,3, 3,1,0,3, 3,1,1,3, 3,1,2,3, 3,1,3,3, 3,1,4,3, 
+ 3,1,5,3, 3,1,6,3, 3,1,7,3, 3,1,8,3, 3,1,9,3, 3,2,0,3, 3,2,1,3, 3,2,2,3, 3,2,3,3, 
+ 3,2,4,3, 3,2,5,3, 3,2,6,3, 3,2,7,3, 3,2,8,3, 3,2,9,3, 3,3,0,3, 3,3,1,3, 3,3,2,3, 
+ 3,3,3,3, 3,3,4,3, 3,3,5,3, 3,3,6,3, 3,3,7,3, 3,3,8,3, 3,3,9,3, 3,4,0,3, 3,4,1,3, 
+ 3,4,2,3, 3,4,3,3, 3,4,4,3, 3,4,5,3, 3,4,6,3, 3,4,7,3, 3,4,8,3, 3,4,9,3, 3,5,0,3, 
+ 3,5,1,3, 3,5,2,3, 3,5,3,3, 3,5,4,3, 3,5,5,3, 3,5,6,3, 3,5,7,3, 3,5,8,3, 3,5,9,3, 
+ 3,6,0,3, 3,6,1,3, 3,6,2,3, 3,6,3,3, 3,6,4,3, 3,6,5,3, 3,6,6,3, 3,6,7,3, 3,6,8,3, 
+ 3,6,9,3, 3,7,0,3, 3,7,1,3, 3,7,2,3, 3,7,3,3, 3,7,4,3, 3,7,5,3, 3,7,6,3, 3,7,7,3, 
+ 3,7,8,3, 3,7,9,3, 3,8,0,3, 3,8,1,3, 3,8,2,3, 3,8,3,3, 3,8,4,3, 3,8,5,3, 3,8,6,3, 
+ 3,8,7,3, 3,8,8,3, 3,8,9,3, 3,9,0,3, 3,9,1,3, 3,9,2,3, 3,9,3,3, 3,9,4,3, 3,9,5,3, 
+ 3,9,6,3, 3,9,7,3, 3,9,8,3, 3,9,9,3, 4,0,0,3, 4,0,1,3, 4,0,2,3, 4,0,3,3, 4,0,4,3, 
+ 4,0,5,3, 4,0,6,3, 4,0,7,3, 4,0,8,3, 4,0,9,3, 4,1,0,3, 4,1,1,3, 4,1,2,3, 4,1,3,3, 
+ 4,1,4,3, 4,1,5,3, 4,1,6,3, 4,1,7,3, 4,1,8,3, 4,1,9,3, 4,2,0,3, 4,2,1,3, 4,2,2,3, 
+ 4,2,3,3, 4,2,4,3, 4,2,5,3, 4,2,6,3, 4,2,7,3, 4,2,8,3, 4,2,9,3, 4,3,0,3, 4,3,1,3, 
+ 4,3,2,3, 4,3,3,3, 4,3,4,3, 4,3,5,3, 4,3,6,3, 4,3,7,3, 4,3,8,3, 4,3,9,3, 4,4,0,3, 
+ 4,4,1,3, 4,4,2,3, 4,4,3,3, 4,4,4,3, 4,4,5,3, 4,4,6,3, 4,4,7,3, 4,4,8,3, 4,4,9,3, 
+ 4,5,0,3, 4,5,1,3, 4,5,2,3, 4,5,3,3, 4,5,4,3, 4,5,5,3, 4,5,6,3, 4,5,7,3, 4,5,8,3, 
+ 4,5,9,3, 4,6,0,3, 4,6,1,3, 4,6,2,3, 4,6,3,3, 4,6,4,3, 4,6,5,3, 4,6,6,3, 4,6,7,3, 
+ 4,6,8,3, 4,6,9,3, 4,7,0,3, 4,7,1,3, 4,7,2,3, 4,7,3,3, 4,7,4,3, 4,7,5,3, 4,7,6,3, 
+ 4,7,7,3, 4,7,8,3, 4,7,9,3, 4,8,0,3, 4,8,1,3, 4,8,2,3, 4,8,3,3, 4,8,4,3, 4,8,5,3, 
+ 4,8,6,3, 4,8,7,3, 4,8,8,3, 4,8,9,3, 4,9,0,3, 4,9,1,3, 4,9,2,3, 4,9,3,3, 4,9,4,3, 
+ 4,9,5,3, 4,9,6,3, 4,9,7,3, 4,9,8,3, 4,9,9,3, 5,0,0,3, 5,0,1,3, 5,0,2,3, 5,0,3,3, 
+ 5,0,4,3, 5,0,5,3, 5,0,6,3, 5,0,7,3, 5,0,8,3, 5,0,9,3, 5,1,0,3, 5,1,1,3, 5,1,2,3, 
+ 5,1,3,3, 5,1,4,3, 5,1,5,3, 5,1,6,3, 5,1,7,3, 5,1,8,3, 5,1,9,3, 5,2,0,3, 5,2,1,3, 
+ 5,2,2,3, 5,2,3,3, 5,2,4,3, 5,2,5,3, 5,2,6,3, 5,2,7,3, 5,2,8,3, 5,2,9,3, 5,3,0,3, 
+ 5,3,1,3, 5,3,2,3, 5,3,3,3, 5,3,4,3, 5,3,5,3, 5,3,6,3, 5,3,7,3, 5,3,8,3, 5,3,9,3, 
+ 5,4,0,3, 5,4,1,3, 5,4,2,3, 5,4,3,3, 5,4,4,3, 5,4,5,3, 5,4,6,3, 5,4,7,3, 5,4,8,3, 
+ 5,4,9,3, 5,5,0,3, 5,5,1,3, 5,5,2,3, 5,5,3,3, 5,5,4,3, 5,5,5,3, 5,5,6,3, 5,5,7,3, 
+ 5,5,8,3, 5,5,9,3, 5,6,0,3, 5,6,1,3, 5,6,2,3, 5,6,3,3, 5,6,4,3, 5,6,5,3, 5,6,6,3, 
+ 5,6,7,3, 5,6,8,3, 5,6,9,3, 5,7,0,3, 5,7,1,3, 5,7,2,3, 5,7,3,3, 5,7,4,3, 5,7,5,3, 
+ 5,7,6,3, 5,7,7,3, 5,7,8,3, 5,7,9,3, 5,8,0,3, 5,8,1,3, 5,8,2,3, 5,8,3,3, 5,8,4,3, 
+ 5,8,5,3, 5,8,6,3, 5,8,7,3, 5,8,8,3, 5,8,9,3, 5,9,0,3, 5,9,1,3, 5,9,2,3, 5,9,3,3, 
+ 5,9,4,3, 5,9,5,3, 5,9,6,3, 5,9,7,3, 5,9,8,3, 5,9,9,3, 6,0,0,3, 6,0,1,3, 6,0,2,3, 
+ 6,0,3,3, 6,0,4,3, 6,0,5,3, 6,0,6,3, 6,0,7,3, 6,0,8,3, 6,0,9,3, 6,1,0,3, 6,1,1,3, 
+ 6,1,2,3, 6,1,3,3, 6,1,4,3, 6,1,5,3, 6,1,6,3, 6,1,7,3, 6,1,8,3, 6,1,9,3, 6,2,0,3, 
+ 6,2,1,3, 6,2,2,3, 6,2,3,3, 6,2,4,3, 6,2,5,3, 6,2,6,3, 6,2,7,3, 6,2,8,3, 6,2,9,3, 
+ 6,3,0,3, 6,3,1,3, 6,3,2,3, 6,3,3,3, 6,3,4,3, 6,3,5,3, 6,3,6,3, 6,3,7,3, 6,3,8,3, 
+ 6,3,9,3, 6,4,0,3, 6,4,1,3, 6,4,2,3, 6,4,3,3, 6,4,4,3, 6,4,5,3, 6,4,6,3, 6,4,7,3, 
+ 6,4,8,3, 6,4,9,3, 6,5,0,3, 6,5,1,3, 6,5,2,3, 6,5,3,3, 6,5,4,3, 6,5,5,3, 6,5,6,3, 
+ 6,5,7,3, 6,5,8,3, 6,5,9,3, 6,6,0,3, 6,6,1,3, 6,6,2,3, 6,6,3,3, 6,6,4,3, 6,6,5,3, 
+ 6,6,6,3, 6,6,7,3, 6,6,8,3, 6,6,9,3, 6,7,0,3, 6,7,1,3, 6,7,2,3, 6,7,3,3, 6,7,4,3, 
+ 6,7,5,3, 6,7,6,3, 6,7,7,3, 6,7,8,3, 6,7,9,3, 6,8,0,3, 6,8,1,3, 6,8,2,3, 6,8,3,3, 
+ 6,8,4,3, 6,8,5,3, 6,8,6,3, 6,8,7,3, 6,8,8,3, 6,8,9,3, 6,9,0,3, 6,9,1,3, 6,9,2,3, 
+ 6,9,3,3, 6,9,4,3, 6,9,5,3, 6,9,6,3, 6,9,7,3, 6,9,8,3, 6,9,9,3, 7,0,0,3, 7,0,1,3, 
+ 7,0,2,3, 7,0,3,3, 7,0,4,3, 7,0,5,3, 7,0,6,3, 7,0,7,3, 7,0,8,3, 7,0,9,3, 7,1,0,3, 
+ 7,1,1,3, 7,1,2,3, 7,1,3,3, 7,1,4,3, 7,1,5,3, 7,1,6,3, 7,1,7,3, 7,1,8,3, 7,1,9,3, 
+ 7,2,0,3, 7,2,1,3, 7,2,2,3, 7,2,3,3, 7,2,4,3, 7,2,5,3, 7,2,6,3, 7,2,7,3, 7,2,8,3, 
+ 7,2,9,3, 7,3,0,3, 7,3,1,3, 7,3,2,3, 7,3,3,3, 7,3,4,3, 7,3,5,3, 7,3,6,3, 7,3,7,3, 
+ 7,3,8,3, 7,3,9,3, 7,4,0,3, 7,4,1,3, 7,4,2,3, 7,4,3,3, 7,4,4,3, 7,4,5,3, 7,4,6,3, 
+ 7,4,7,3, 7,4,8,3, 7,4,9,3, 7,5,0,3, 7,5,1,3, 7,5,2,3, 7,5,3,3, 7,5,4,3, 7,5,5,3, 
+ 7,5,6,3, 7,5,7,3, 7,5,8,3, 7,5,9,3, 7,6,0,3, 7,6,1,3, 7,6,2,3, 7,6,3,3, 7,6,4,3, 
+ 7,6,5,3, 7,6,6,3, 7,6,7,3, 7,6,8,3, 7,6,9,3, 7,7,0,3, 7,7,1,3, 7,7,2,3, 7,7,3,3, 
+ 7,7,4,3, 7,7,5,3, 7,7,6,3, 7,7,7,3, 7,7,8,3, 7,7,9,3, 7,8,0,3, 7,8,1,3, 7,8,2,3, 
+ 7,8,3,3, 7,8,4,3, 7,8,5,3, 7,8,6,3, 7,8,7,3, 7,8,8,3, 7,8,9,3, 7,9,0,3, 7,9,1,3, 
+ 7,9,2,3, 7,9,3,3, 7,9,4,3, 7,9,5,3, 7,9,6,3, 7,9,7,3, 7,9,8,3, 7,9,9,3, 8,0,0,3, 
+ 8,0,1,3, 8,0,2,3, 8,0,3,3, 8,0,4,3, 8,0,5,3, 8,0,6,3, 8,0,7,3, 8,0,8,3, 8,0,9,3, 
+ 8,1,0,3, 8,1,1,3, 8,1,2,3, 8,1,3,3, 8,1,4,3, 8,1,5,3, 8,1,6,3, 8,1,7,3, 8,1,8,3, 
+ 8,1,9,3, 8,2,0,3, 8,2,1,3, 8,2,2,3, 8,2,3,3, 8,2,4,3, 8,2,5,3, 8,2,6,3, 8,2,7,3, 
+ 8,2,8,3, 8,2,9,3, 8,3,0,3, 8,3,1,3, 8,3,2,3, 8,3,3,3, 8,3,4,3, 8,3,5,3, 8,3,6,3, 
+ 8,3,7,3, 8,3,8,3, 8,3,9,3, 8,4,0,3, 8,4,1,3, 8,4,2,3, 8,4,3,3, 8,4,4,3, 8,4,5,3, 
+ 8,4,6,3, 8,4,7,3, 8,4,8,3, 8,4,9,3, 8,5,0,3, 8,5,1,3, 8,5,2,3, 8,5,3,3, 8,5,4,3, 
+ 8,5,5,3, 8,5,6,3, 8,5,7,3, 8,5,8,3, 8,5,9,3, 8,6,0,3, 8,6,1,3, 8,6,2,3, 8,6,3,3, 
+ 8,6,4,3, 8,6,5,3, 8,6,6,3, 8,6,7,3, 8,6,8,3, 8,6,9,3, 8,7,0,3, 8,7,1,3, 8,7,2,3, 
+ 8,7,3,3, 8,7,4,3, 8,7,5,3, 8,7,6,3, 8,7,7,3, 8,7,8,3, 8,7,9,3, 8,8,0,3, 8,8,1,3, 
+ 8,8,2,3, 8,8,3,3, 8,8,4,3, 8,8,5,3, 8,8,6,3, 8,8,7,3, 8,8,8,3, 8,8,9,3, 8,9,0,3, 
+ 8,9,1,3, 8,9,2,3, 8,9,3,3, 8,9,4,3, 8,9,5,3, 8,9,6,3, 8,9,7,3, 8,9,8,3, 8,9,9,3, 
+ 9,0,0,3, 9,0,1,3, 9,0,2,3, 9,0,3,3, 9,0,4,3, 9,0,5,3, 9,0,6,3, 9,0,7,3, 9,0,8,3, 
+ 9,0,9,3, 9,1,0,3, 9,1,1,3, 9,1,2,3, 9,1,3,3, 9,1,4,3, 9,1,5,3, 9,1,6,3, 9,1,7,3, 
+ 9,1,8,3, 9,1,9,3, 9,2,0,3, 9,2,1,3, 9,2,2,3, 9,2,3,3, 9,2,4,3, 9,2,5,3, 9,2,6,3, 
+ 9,2,7,3, 9,2,8,3, 9,2,9,3, 9,3,0,3, 9,3,1,3, 9,3,2,3, 9,3,3,3, 9,3,4,3, 9,3,5,3, 
+ 9,3,6,3, 9,3,7,3, 9,3,8,3, 9,3,9,3, 9,4,0,3, 9,4,1,3, 9,4,2,3, 9,4,3,3, 9,4,4,3, 
+ 9,4,5,3, 9,4,6,3, 9,4,7,3, 9,4,8,3, 9,4,9,3, 9,5,0,3, 9,5,1,3, 9,5,2,3, 9,5,3,3, 
+ 9,5,4,3, 9,5,5,3, 9,5,6,3, 9,5,7,3, 9,5,8,3, 9,5,9,3, 9,6,0,3, 9,6,1,3, 9,6,2,3, 
+ 9,6,3,3, 9,6,4,3, 9,6,5,3, 9,6,6,3, 9,6,7,3, 9,6,8,3, 9,6,9,3, 9,7,0,3, 9,7,1,3, 
+ 9,7,2,3, 9,7,3,3, 9,7,4,3, 9,7,5,3, 9,7,6,3, 9,7,7,3, 9,7,8,3, 9,7,9,3, 9,8,0,3, 
+ 9,8,1,3, 9,8,2,3, 9,8,3,3, 9,8,4,3, 9,8,5,3, 9,8,6,3, 9,8,7,3, 9,8,8,3, 9,8,9,3, 
+ 9,9,0,3, 9,9,1,3, 9,9,2,3, 9,9,3,3, 9,9,4,3, 9,9,5,3, 9,9,6,3, 9,9,7,3, 9,9,8,3, 
+ 9,9,9,3};
+#endif
+ 
diff --git a/decNumber/decDouble.c b/decNumber/decDouble.c
new file mode 100644
index 00000000..cb51f5bf
--- /dev/null
+++ b/decNumber/decDouble.c
@@ -0,0 +1,140 @@
+/* ------------------------------------------------------------------ */
+/* decDouble.c -- decDouble operations module                         */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2010.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is included in the package as decNumber.pdf.  This   */
+/* document is also available in HTML, together with specifications,  */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+/* This module comprises decDouble operations (including conversions) */
+/* ------------------------------------------------------------------ */
+
+#include "decContext.h"       // public includes
+#include "decDouble.h"        // ..
+
+/* Constant mappings for shared code */
+#define DECPMAX     DECDOUBLE_Pmax
+#define DECEMIN     DECDOUBLE_Emin
+#define DECEMAX     DECDOUBLE_Emax
+#define DECEMAXD    DECDOUBLE_EmaxD
+#define DECBYTES    DECDOUBLE_Bytes
+#define DECSTRING   DECDOUBLE_String
+#define DECECONL    DECDOUBLE_EconL
+#define DECBIAS     DECDOUBLE_Bias
+#define DECLETS     DECDOUBLE_Declets
+#define DECQTINY    (-DECDOUBLE_Bias)
+// parameters of next-wider format
+#define DECWBYTES   DECQUAD_Bytes
+#define DECWPMAX    DECQUAD_Pmax
+#define DECWECONL   DECQUAD_EconL
+#define DECWBIAS    DECQUAD_Bias
+
+/* Type and function mappings for shared code */
+#define decFloat                   decDouble      // Type name
+#define decFloatWider              decQuad        // Type name
+
+// Utilities and conversions (binary results, extractors, etc.)
+#define decFloatFromBCD            decDoubleFromBCD
+#define decFloatFromInt32          decDoubleFromInt32
+#define decFloatFromPacked         decDoubleFromPacked
+#define decFloatFromPackedChecked  decDoubleFromPackedChecked
+#define decFloatFromString         decDoubleFromString
+#define decFloatFromUInt32         decDoubleFromUInt32
+#define decFloatFromWider          decDoubleFromWider
+#define decFloatGetCoefficient     decDoubleGetCoefficient
+#define decFloatGetExponent        decDoubleGetExponent
+#define decFloatSetCoefficient     decDoubleSetCoefficient
+#define decFloatSetExponent        decDoubleSetExponent
+#define decFloatShow               decDoubleShow
+#define decFloatToBCD              decDoubleToBCD
+#define decFloatToEngString        decDoubleToEngString
+#define decFloatToInt32            decDoubleToInt32
+#define decFloatToInt32Exact       decDoubleToInt32Exact
+#define decFloatToPacked           decDoubleToPacked
+#define decFloatToString           decDoubleToString
+#define decFloatToUInt32           decDoubleToUInt32
+#define decFloatToUInt32Exact      decDoubleToUInt32Exact
+#define decFloatToWider            decDoubleToWider
+#define decFloatZero               decDoubleZero
+
+// Computational (result is a decFloat)
+#define decFloatAbs                decDoubleAbs
+#define decFloatAdd                decDoubleAdd
+#define decFloatAnd                decDoubleAnd
+#define decFloatDivide             decDoubleDivide
+#define decFloatDivideInteger      decDoubleDivideInteger
+#define decFloatFMA                decDoubleFMA
+#define decFloatInvert             decDoubleInvert
+#define decFloatLogB               decDoubleLogB
+#define decFloatMax                decDoubleMax
+#define decFloatMaxMag             decDoubleMaxMag
+#define decFloatMin                decDoubleMin
+#define decFloatMinMag             decDoubleMinMag
+#define decFloatMinus              decDoubleMinus
+#define decFloatMultiply           decDoubleMultiply
+#define decFloatNextMinus          decDoubleNextMinus
+#define decFloatNextPlus           decDoubleNextPlus
+#define decFloatNextToward         decDoubleNextToward
+#define decFloatOr                 decDoubleOr
+#define decFloatPlus               decDoublePlus
+#define decFloatQuantize           decDoubleQuantize
+#define decFloatReduce             decDoubleReduce
+#define decFloatRemainder          decDoubleRemainder
+#define decFloatRemainderNear      decDoubleRemainderNear
+#define decFloatRotate             decDoubleRotate
+#define decFloatScaleB             decDoubleScaleB
+#define decFloatShift              decDoubleShift
+#define decFloatSubtract           decDoubleSubtract
+#define decFloatToIntegralValue    decDoubleToIntegralValue
+#define decFloatToIntegralExact    decDoubleToIntegralExact
+#define decFloatXor                decDoubleXor
+
+// Comparisons
+#define decFloatCompare            decDoubleCompare
+#define decFloatCompareSignal      decDoubleCompareSignal
+#define decFloatCompareTotal       decDoubleCompareTotal
+#define decFloatCompareTotalMag    decDoubleCompareTotalMag
+
+// Copies
+#define decFloatCanonical          decDoubleCanonical
+#define decFloatCopy               decDoubleCopy
+#define decFloatCopyAbs            decDoubleCopyAbs
+#define decFloatCopyNegate         decDoubleCopyNegate
+#define decFloatCopySign           decDoubleCopySign
+
+// Non-computational
+#define decFloatClass              decDoubleClass
+#define decFloatClassString        decDoubleClassString
+#define decFloatDigits             decDoubleDigits
+#define decFloatIsCanonical        decDoubleIsCanonical
+#define decFloatIsFinite           decDoubleIsFinite
+#define decFloatIsInfinite         decDoubleIsInfinite
+#define decFloatIsInteger          decDoubleIsInteger
+#define decFloatIsLogical          decDoubleIsLogical
+#define decFloatIsNaN              decDoubleIsNaN
+#define decFloatIsNegative         decDoubleIsNegative
+#define decFloatIsNormal           decDoubleIsNormal
+#define decFloatIsPositive         decDoubleIsPositive
+#define decFloatIsSignaling        decDoubleIsSignaling
+#define decFloatIsSignalling       decDoubleIsSignalling
+#define decFloatIsSigned           decDoubleIsSigned
+#define decFloatIsSubnormal        decDoubleIsSubnormal
+#define decFloatIsZero             decDoubleIsZero
+#define decFloatRadix              decDoubleRadix
+#define decFloatSameQuantum        decDoubleSameQuantum
+#define decFloatVersion            decDoubleVersion
+
+#include "decNumberLocal.h"   // local includes (need DECPMAX)
+#include "decCommon.h"        // non-arithmetic decFloat routines
+#include "decBasic.h"         // basic formats routines
+
diff --git a/decNumber/decDouble.h b/decNumber/decDouble.h
new file mode 100644
index 00000000..fe9c26dc
--- /dev/null
+++ b/decNumber/decDouble.h
@@ -0,0 +1,155 @@
+/* ------------------------------------------------------------------ */
+/* decDouble.h -- Decimal 64-bit format module header                 */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2010.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is included in the package as decNumber.pdf.  This   */
+/* document is also available in HTML, together with specifications,  */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+
+#if !defined(DECDOUBLE)
+  #define DECDOUBLE
+
+  #define DECDOUBLENAME       "decimalDouble"         /* Short name   */
+  #define DECDOUBLETITLE      "Decimal 64-bit datum"  /* Verbose name */
+  #define DECDOUBLEAUTHOR     "Mike Cowlishaw"        /* Who to blame */
+
+  /* parameters for decDoubles */
+  #define DECDOUBLE_Bytes   8      /* length                          */
+  #define DECDOUBLE_Pmax    16     /* maximum precision (digits)      */
+  #define DECDOUBLE_Emin   -383    /* minimum adjusted exponent       */
+  #define DECDOUBLE_Emax    384    /* maximum adjusted exponent       */
+  #define DECDOUBLE_EmaxD   3      /* maximum exponent digits         */
+  #define DECDOUBLE_Bias    398    /* bias for the exponent           */
+  #define DECDOUBLE_String  25     /* maximum string length, +1       */
+  #define DECDOUBLE_EconL   8      /* exponent continuation length    */
+  #define DECDOUBLE_Declets 5      /* count of declets                */
+  /* highest biased exponent (Elimit-1) */
+  #define DECDOUBLE_Ehigh (DECDOUBLE_Emax + DECDOUBLE_Bias - (DECDOUBLE_Pmax-1))
+
+  /* Required includes                                                */
+  #include "decContext.h"
+  #include "decQuad.h"
+
+  /* The decDouble decimal 64-bit type, accessible by all sizes */
+  typedef union {
+    uint8_t   bytes[DECDOUBLE_Bytes];   /* fields: 1, 5, 8, 50 bits */
+    uint16_t shorts[DECDOUBLE_Bytes/2];
+    uint32_t  words[DECDOUBLE_Bytes/4];
+    #if DECUSE64
+    uint64_t  longs[DECDOUBLE_Bytes/8];
+    #endif
+    } decDouble;
+
+  /* ---------------------------------------------------------------- */
+  /* Routines -- implemented as decFloat routines in common files     */
+  /* ---------------------------------------------------------------- */
+
+  /* Utilities and conversions, extractors, etc.) */
+  extern decDouble * decDoubleFromBCD(decDouble *, int32_t, const uint8_t *, int32_t);
+  extern decDouble * decDoubleFromInt32(decDouble *, int32_t);
+  extern decDouble * decDoubleFromPacked(decDouble *, int32_t, const uint8_t *);
+  extern decDouble * decDoubleFromPackedChecked(decDouble *, int32_t, const uint8_t *);
+  extern decDouble * decDoubleFromString(decDouble *, const char *, decContext *);
+  extern decDouble * decDoubleFromUInt32(decDouble *, uint32_t);
+  extern decDouble * decDoubleFromWider(decDouble *, const decQuad *, decContext *);
+  extern int32_t     decDoubleGetCoefficient(const decDouble *, uint8_t *);
+  extern int32_t     decDoubleGetExponent(const decDouble *);
+  extern decDouble * decDoubleSetCoefficient(decDouble *, const uint8_t *, int32_t);
+  extern decDouble * decDoubleSetExponent(decDouble *, decContext *, int32_t);
+  extern void        decDoubleShow(const decDouble *, const char *);
+  extern int32_t     decDoubleToBCD(const decDouble *, int32_t *, uint8_t *);
+  extern char      * decDoubleToEngString(const decDouble *, char *);
+  extern int32_t     decDoubleToInt32(const decDouble *, decContext *, enum rounding);
+  extern int32_t     decDoubleToInt32Exact(const decDouble *, decContext *, enum rounding);
+  extern int32_t     decDoubleToPacked(const decDouble *, int32_t *, uint8_t *);
+  extern char      * decDoubleToString(const decDouble *, char *);
+  extern uint32_t    decDoubleToUInt32(const decDouble *, decContext *, enum rounding);
+  extern uint32_t    decDoubleToUInt32Exact(const decDouble *, decContext *, enum rounding);
+  extern decQuad   * decDoubleToWider(const decDouble *, decQuad *);
+  extern decDouble * decDoubleZero(decDouble *);
+
+  /* Computational (result is a decDouble) */
+  extern decDouble * decDoubleAbs(decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleAdd(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleAnd(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleDivide(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleDivideInteger(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleFMA(decDouble *, const decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleInvert(decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleLogB(decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleMax(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleMaxMag(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleMin(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleMinMag(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleMinus(decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleMultiply(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleNextMinus(decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleNextPlus(decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleNextToward(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleOr(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoublePlus(decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleQuantize(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleReduce(decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleRemainder(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleRemainderNear(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleRotate(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleScaleB(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleShift(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleSubtract(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleToIntegralValue(decDouble *, const decDouble *, decContext *, enum rounding);
+  extern decDouble * decDoubleToIntegralExact(decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleXor(decDouble *, const decDouble *, const decDouble *, decContext *);
+
+  /* Comparisons */
+  extern decDouble * decDoubleCompare(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleCompareSignal(decDouble *, const decDouble *, const decDouble *, decContext *);
+  extern decDouble * decDoubleCompareTotal(decDouble *, const decDouble *, const decDouble *);
+  extern decDouble * decDoubleCompareTotalMag(decDouble *, const decDouble *, const decDouble *);
+
+  /* Copies */
+  extern decDouble * decDoubleCanonical(decDouble *, const decDouble *);
+  extern decDouble * decDoubleCopy(decDouble *, const decDouble *);
+  extern decDouble * decDoubleCopyAbs(decDouble *, const decDouble *);
+  extern decDouble * decDoubleCopyNegate(decDouble *, const decDouble *);
+  extern decDouble * decDoubleCopySign(decDouble *, const decDouble *, const decDouble *);
+
+  /* Non-computational */
+  extern enum decClass decDoubleClass(const decDouble *);
+  extern const char *  decDoubleClassString(const decDouble *);
+  extern uint32_t      decDoubleDigits(const decDouble *);
+  extern uint32_t      decDoubleIsCanonical(const decDouble *);
+  extern uint32_t      decDoubleIsFinite(const decDouble *);
+  extern uint32_t      decDoubleIsInfinite(const decDouble *);
+  extern uint32_t      decDoubleIsInteger(const decDouble *);
+  extern uint32_t      decDoubleIsLogical(const decDouble *);
+  extern uint32_t      decDoubleIsNaN(const decDouble *);
+  extern uint32_t      decDoubleIsNegative(const decDouble *);
+  extern uint32_t      decDoubleIsNormal(const decDouble *);
+  extern uint32_t      decDoubleIsPositive(const decDouble *);
+  extern uint32_t      decDoubleIsSignaling(const decDouble *);
+  extern uint32_t      decDoubleIsSignalling(const decDouble *);
+  extern uint32_t      decDoubleIsSigned(const decDouble *);
+  extern uint32_t      decDoubleIsSubnormal(const decDouble *);
+  extern uint32_t      decDoubleIsZero(const decDouble *);
+  extern uint32_t      decDoubleRadix(const decDouble *);
+  extern uint32_t      decDoubleSameQuantum(const decDouble *, const decDouble *);
+  extern const char *  decDoubleVersion(void);
+
+  /* decNumber conversions; these are implemented as macros so as not  */
+  /* to force a dependency on decimal64 and decNumber in decDouble.    */
+  /* decDoubleFromNumber returns a decimal64 * to avoid warnings.      */
+  #define decDoubleToNumber(dq, dn) decimal64ToNumber((decimal64 *)(dq), dn)
+  #define decDoubleFromNumber(dq, dn, set) decimal64FromNumber((decimal64 *)(dq), dn, set)
+
+#endif
diff --git a/decNumber/decNumber.c b/decNumber/decNumber.c
index 42548767..19230b89 100644
--- a/decNumber/decNumber.c
+++ b/decNumber/decNumber.c
@@ -1,6646 +1,8141 @@
-/* ------------------------------------------------------------------ */
-/* Decimal Number arithmetic module                                   */
-/* ------------------------------------------------------------------ */
-/* Copyright (c) IBM Corporation, 2000, 2006.  All rights reserved.   */
-/*                                                                    */
-/* This software is made available under the terms of the             */
-/* ICU License -- ICU 1.8.1 and later.                                */
-/*                                                                    */
-/* The description and User's Guide ("The decNumber C Library") for   */
-/* this software is called decNumber.pdf.  This document is           */
-/* available, together with arithmetic and format specifications,     */
-/* testcases, and Web links, at: http://www2.hursley.ibm.com/decimal  */
-/*                                                                    */
-/* Please send comments, suggestions, and corrections to the author:  */
-/*   mfc@uk.ibm.com                                                   */
-/*   Mike Cowlishaw, IBM Fellow                                       */
-/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
-/* ------------------------------------------------------------------ */
-/* This module comprises the routines for General Decimal Arithmetic  */
-/* as defined in the specification which may be found on the          */
-/* http://www2.hursley.ibm.com/decimal web pages.  It implements both */
-/* the full ('extended') arithmetic and the simpler ('subset')        */
-/* arithmetic.                                                        */
-/*                                                                    */
-/* Usage notes:                                                       */
-/*                                                                    */
-/* 1. This code is ANSI C89 except:                                   */
-/*                                                                    */
-/*    a) C99 line comments (double forward slash) are used.  (Most C  */
-/*       compilers accept these.  If yours does not, a simple script  */
-/*       can be used to convert them to ANSI C comments.)             */
-/*                                                                    */
-/*    b) Types from C99 stdint.h are used.  If you do not have this   */
-/*       header file, see the User's Guide section of the decNumber   */
-/*       documentation; this lists the necessary definitions.         */
-/*                                                                    */
-/*    c) If DECDPUN>4 or DECUSE64=1, the C99 64-bit int64_t and       */
-/*       uint64_t types may be used.  To avoid these, set DECUSE64=0  */
-/*       and DECDPUN<=4 (see documentation).                          */
-/*                                                                    */
-/* 2. The decNumber format which this library uses is optimized for   */
-/*    efficient processing of relatively short numbers; in particular */
-/*    it allows the use of fixed sized structures and minimizes copy  */
-/*    and move operations.  It does, however, support arbitrary       */
-/*    precision (up to 999,999,999 digits) and arbitrary exponent     */
-/*    range (Emax in the range 0 through 999,999,999 and Emin in the  */
-/*    range -999,999,999 through 0).  Mathematical functions (for     */
-/*    example decNumberExp) as identified below are restricted more   */
-/*    tightly: digits, emax, and -emin in the context must be <=      */
-/*    DEC_MAX_MATH (999999), and their operand(s) must be within      */
-/*    these bounds.                                                   */
-/*                                                                    */
-/* 3. Operands to operator functions are never modified unless they   */
-/*    are also specified to be the result number (which is always     */
-/*    permitted).  Other than that case, operands must not overlap.   */
-/*                                                                    */
-/* 4. Error handling: the type of the error is ORed into the status   */
-/*    flags in the current context (decContext structure).  The       */
-/*    SIGFPE signal is then raised if the corresponding trap-enabler  */
-/*    flag in the decContext is set (is 1).                           */
-/*                                                                    */
-/*    It is the responsibility of the caller to clear the status      */
-/*    flags as required.                                              */
-/*                                                                    */
-/*    The result of any routine which returns a number will always    */
-/*    be a valid number (which may be a special value, such as an     */
-/*    Infinity or NaN).                                               */
-/*                                                                    */
-/* 5. The decNumber format is not an exchangeable concrete            */
-/*    representation as it comprises fields which may be machine-     */
-/*    dependent (packed or unpacked, or special length, for example). */
-/*    Canonical conversions to and from strings are provided; other   */
-/*    conversions are available in separate modules.                  */
-/*                                                                    */
-/* 6. Normally, input operands are assumed to be valid.  Set DECCHECK */
-/*    to 1 for extended operand checking (including NULL operands).   */
-/*    Results are undefined if a badly-formed structure (or a NULL    */
-/*    pointer to a structure) is provided, though with DECCHECK       */
-/*    enabled the operator routines are protected against exceptions. */
-/*    (Except if the result pointer is NULL, which is unrecoverable.) */
-/*                                                                    */
-/*    However, the routines will never cause exceptions if they are   */
-/*    given well-formed operands, even if the value of the operands   */
-/*    is inappropriate for the operation and DECCHECK is not set.     */
-/*    (Except for SIGFPE, as and where documented.)                   */
-/*                                                                    */
-/* 7. Subset arithmetic is available only if DECSUBSET is set to 1.   */
-/* ------------------------------------------------------------------ */
-/* Implementation notes for maintenance of this module:               */
-/*                                                                    */
-/* 1. Storage leak protection:  Routines which use malloc are not     */
-/*    permitted to use return for fastpath or error exits (i.e.,      */
-/*    they follow strict structured programming conventions).         */
-/*    Instead they have a do{}while(0); construct surrounding the     */
-/*    code which is protected -- break may be used to exit this.      */
-/*    Other routines can safely use the return statement inline.      */
-/*                                                                    */
-/*    Storage leak accounting can be enabled using DECALLOC.          */
-/*                                                                    */
-/* 2. All loops use the for(;;) construct.  Any do construct does     */
-/*    not loop; it is for allocation protection as just described.    */
-/*                                                                    */
-/* 3. Setting status in the context must always be the very last      */
-/*    action in a routine, as non-0 status may raise a trap and hence */
-/*    the call to set status may not return (if the handler uses long */
-/*    jump).  Therefore all cleanup must be done first.  In general,  */
-/*    to achieve this status is accumulated and is only applied just  */
-/*    before return by calling decContextSetStatus (via decStatus).   */
-/*                                                                    */
-/*    Routines which allocate storage cannot, in general, use the     */
-/*    'top level' routines which could cause a non-returning          */
-/*    transfer of control.  The decXxxxOp routines are safe (do not   */
-/*    call decStatus even if traps are set in the context) and should */
-/*    be used instead (they are also a little faster).                */
-/*                                                                    */
-/* 4. Exponent checking is minimized by allowing the exponent to      */
-/*    grow outside its limits during calculations, provided that      */
-/*    the decFinalize function is called later.  Multiplication and   */
-/*    division, and intermediate calculations in exponentiation,      */
-/*    require more careful checks because of the risk of 31-bit       */
-/*    overflow (the most negative valid exponent is -1999999997, for  */
-/*    a 999999999-digit number with adjusted exponent of -999999999). */
-/*                                                                    */
-/* 5. Rounding is deferred until finalization of results, with any    */
-/*    'off to the right' data being represented as a single digit     */
-/*    residue (in the range -1 through 9).  This avoids any double-   */
-/*    rounding when more than one shortening takes place (for         */
-/*    example, when a result is subnormal).                           */
-/*                                                                    */
-/* 6. The digits count is allowed to rise to a multiple of DECDPUN    */
-/*    during many operations, so whole Units are handled and exact    */
-/*    accounting of digits is not needed.  The correct digits value   */
-/*    is found by decGetDigits, which accounts for leading zeros.     */
-/*    This must be called before any rounding if the number of digits */
-/*    is not known exactly.                                           */
-/*                                                                    */
-/* 7. The multiply-by-reciprocal 'trick' is used for partitioning     */
-/*    numbers up to four digits, using appropriate constants.  This   */
-/*    is not useful for longer numbers because overflow of 32 bits    */
-/*    would lead to 4 multiplies, which is almost as expensive as     */
-/*    a divide (unless a floating-point or 64-bit multiply is         */
-/*    assumed to be available).                                       */
-/*                                                                    */
-/* 8. Unusual abbreviations that may be used in the commentary:       */
-/*      lhs -- left hand side (operand, of an operation)              */
-/*      lsd -- least significant digit (of coefficient)               */
-/*      lsu -- least significant Unit (of coefficient)                */
-/*      msd -- most significant digit (of coefficient)                */
-/*      msi -- most significant item (in an array)                    */
-/*      msu -- most significant Unit (of coefficient)                 */
-/*      rhs -- right hand side (operand, of an operation)             */
-/*      +ve -- positive                                               */
-/*      -ve -- negative                                               */
-/*      **  -- raise to the power                                     */
-/* ------------------------------------------------------------------ */
-
-#include <stdlib.h>                // for malloc, free, etc.
-#include <stdio.h>                 // for printf [if needed]
-#include <string.h>                // for strcpy
-#include <ctype.h>                 // for lower
-#if defined(_MSVC_)
-#pragma warning( disable: 4244 )   // (floating-point only?) "conversion from 'x' to 'y', possible loss of data"
-#endif /*defined(_MSVC_)*/
-#include "decNumber.h"             // base number library
-#include "decNumberLocal.h"        // decNumber local types, etc.
-
-/* Constants */
-// Public constant array: powers of ten (powers[n]==10**n, 0<=n<=9)
-const uInt powers[10]={1, 10, 100, 1000, 10000, 100000, 1000000,
-                       10000000, 100000000, 1000000000};
-// Public lookup table used by the D2U macro
-const uByte d2utable[DECMAXD2U+1]=D2UTABLE;
-
-// Local constants
-#define DIVIDE    0x80             // Divide operators
-#define REMAINDER 0x40             // ..
-#define DIVIDEINT 0x20             // ..
-#define REMNEAR   0x10             // ..
-#define COMPARE   0x01             // Compare operators
-#define COMPMAX   0x02             // ..
-#define COMPMIN   0x03             // ..
-#define COMPTOTAL 0x04             // ..
-#define COMPNAN   0x05             // .. [NaN processing]
-
-#define DEC_sNaN     0x40000000    // local status: sNaN signal
-#define BADINT  (Int)0x80000000    // most-negative Int; error indicator
-// Next two indicate an integer >= 10**6, and its parity (bottom bit)
-#define BIGEVEN (Int)0x80000002
-#define BIGODD  (Int)0x80000003
-
-static Unit uarrone[1]={1};   // Unit array of 1, used for incrementing
-
-/* Granularity-dependent code */
-#if DECDPUN<=4
-  #define eInt  Int           // extended integer
-  #define ueInt uInt          // unsigned extended integer
-  // Constant multipliers for divide-by-power-of five using reciprocal
-  // multiply, after removing powers of 2 by shifting, and final shift
-  // of 17 [we only need up to **4]
-  static const uInt multies[]={131073, 26215, 5243, 1049, 210};
-  // QUOT10 -- macro to return the quotient of unit u divided by 10**n
-  #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17)
-#else
-  // For DECDPUN>4 non-ANSI-89 64-bit types are needed.
-  #if !DECUSE64
-    #error decNumber.c: DECUSE64 must be 1 when DECDPUN>4
-  #endif
-  #define eInt  Long          // extended integer
-  #define ueInt uLong         // unsigned extended integer
-#endif
-
-/* Local routines */
-static decNumber * decAddOp(decNumber *, const decNumber *, const decNumber *,
-                              decContext *, uByte, uInt *);
-static Flag        decBiStr(const char *, const char *, const char *);
-static uInt        decCheckMath(const decNumber *, decContext *, uInt *);
-static void        decApplyRound(decNumber *, decContext *, Int, uInt *);
-static Int         decCompare(const decNumber *lhs, const decNumber *rhs, Flag);
-static decNumber * decCompareOp(decNumber *, const decNumber *,
-                              const decNumber *, decContext *,
-                              Flag, uInt *);
-static void        decCopyFit(decNumber *, const decNumber *, decContext *,
-                              Int *, uInt *);
-static decNumber * decDivideOp(decNumber *, const decNumber *,
-                              const decNumber *, decContext *, Flag, uInt *);
-static decNumber * decExpOp(decNumber *, const decNumber *,
-                              decContext *, uInt *);
-static void        decFinalize(decNumber *, decContext *, Int *, uInt *);
-static Int         decGetDigits(Unit *, Int);
-static Int         decGetInt(const decNumber *);
-static decNumber * decLnOp(decNumber *, const decNumber *,
-                              decContext *, uInt *);
-static decNumber * decMultiplyOp(decNumber *, const decNumber *,
-                              const decNumber *, decContext *,
-                              uInt *);
-static decNumber * decNaNs(decNumber *, const decNumber *,
-                              const decNumber *, uInt *);
-static decNumber * decPutInt(decNumber *, Int);
-static decNumber * decQuantizeOp(decNumber *, const decNumber *,
-                              const decNumber *, decContext *, Flag,
-                              uInt *);
-static void        decSetCoeff(decNumber *, decContext *, const Unit *,
-                              Int, Int *, uInt *);
-static void        decSetOverflow(decNumber *, decContext *, uInt *);
-static void        decSetSubnormal(decNumber *, decContext *, Int *, uInt *);
-static Int         decShiftToLeast(Unit *, Int, Int);
-static Int         decShiftToMost(Unit *, Int, Int);
-static void        decStatus(decNumber *, uInt, decContext *);
-static void        decToString(const decNumber *, char[], Flag);
-static decNumber * decTrim(decNumber *, Flag, Int *);
-static Int         decUnitAddSub(const Unit *, Int, const Unit *, Int, Int,
-                              Unit *, Int);
-static Int         decUnitCompare(const Unit *, Int, const Unit *, Int, Int);
-
-#if !DECSUBSET
-/* decFinish == decFinalize when no subset arithmetic needed */
-#define decFinish(a,b,c,d) decFinalize(a,b,c,d)
-#else
-static void        decFinish(decNumber *, decContext *, Int *, uInt *);
-static decNumber * decRoundOperand(const decNumber *, decContext *, uInt *);
-#endif
-
-/* Local macros */
-// masked special-values bits
-#define SPECIALARG  (rhs->bits & DECSPECIAL)
-#define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL)
-
-/* Diagnostic macros, etc. */
-#if DECALLOC
-// Handle malloc/free accounting.  If enabled, our accountable routines
-// are used; otherwise the code just goes straight to the system malloc
-// and free routines.
-#define malloc(a) decMalloc(a)
-#define free(a) decFree(a)
-#define DECFENCE 0x5a              // corruption detector
-// 'Our' malloc and free:
-static void *decMalloc(size_t);
-static void  decFree(void *);
-uInt decAllocBytes=0;              // count of bytes allocated
-// Note that DECALLOC code only checks for storage buffer overflow.
-// To check for memory leaks, the decAllocBytes variable must be
-// checked to be 0 at appropriate times (e.g., after the test
-// harness completes a set of tests).  This checking may be unreliable
-// if the testing is done in a multi-thread environment.
-#endif
-
-#if DECCHECK
-// Optional checking routines.  Enabling these means that decNumber
-// and decContext operands to operator routines are checked for
-// correctness.  This roughly doubles the execution time of the
-// fastest routines (and adds 600+ bytes), so should not normally be
-// used in 'production'.
-// decCheckInexact is used to check that inexact results have a full
-// complement of digits (where appropriate -- this is not the case
-// for Quantize, for example)
-#define DECUNUSED (void *)(0xffffffff)
-static Flag decCheckOperands(decNumber *, const decNumber *,
-                             const decNumber *, decContext *);
-static Flag decCheckNumber(const decNumber *, decContext *);
-static void decCheckInexact(const decNumber *, decContext *);
-#endif
-
-#if DECTRACE || DECCHECK
-// Optional trace/debugging routines (may or may not be used)
-void decNumberShow(const decNumber *);  // displays the components of a number
-static void decDumpAr(char, const Unit *, Int);
-#endif
-
-/* ================================================================== */
-/* Conversions                                                        */
-/* ================================================================== */
-
-/* ------------------------------------------------------------------ */
-/* to-scientific-string -- conversion to numeric string               */
-/* to-engineering-string -- conversion to numeric string              */
-/*                                                                    */
-/*   decNumberToString(dn, string);                                   */
-/*   decNumberToEngString(dn, string);                                */
-/*                                                                    */
-/*  dn is the decNumber to convert                                    */
-/*  string is the string where the result will be laid out            */
-/*                                                                    */
-/*  string must be at least dn->digits+14 characters long             */
-/*                                                                    */
-/*  No error is possible, and no status can be set.                   */
-/* ------------------------------------------------------------------ */
-char * decNumberToString(const decNumber *dn, char *string){
-  decToString(dn, string, 0);
-  return string;
-  } // DecNumberToString
-
-char * decNumberToEngString(const decNumber *dn, char *string){
-  decToString(dn, string, 1);
-  return string;
-  } // DecNumberToEngString
-
-/* ------------------------------------------------------------------ */
-/* to-number -- conversion from numeric string                        */
-/*                                                                    */
-/* decNumberFromString -- convert string to decNumber                 */
-/*   dn        -- the number structure to fill                        */
-/*   chars[]   -- the string to convert ('\0' terminated)             */
-/*   set       -- the context used for processing any error,          */
-/*                determining the maximum precision available         */
-/*                (set.digits), determining the maximum and minimum   */
-/*                exponent (set.emax and set.emin), determining if    */
-/*                extended values are allowed, and checking the       */
-/*                rounding mode if overflow occurs or rounding is     */
-/*                needed.                                             */
-/*                                                                    */
-/* The length of the coefficient and the size of the exponent are     */
-/* checked by this routine, so the correct error (Underflow or        */
-/* Overflow) can be reported or rounding applied, as necessary.       */
-/*                                                                    */
-/* If bad syntax is detected, the result will be a quiet NaN.         */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberFromString(decNumber *dn, const char chars[],
-                                decContext *set) {
-  Int   exponent=0;                // working exponent [assume 0]
-  uByte bits=0;                    // working flags [assume +ve]
-  Unit  *res;                      // where result will be built
-  Unit  resbuff[SD2U(DECBUFFER+1)];// local buffer in case need temporary
-  Unit  *allocres=NULL;            // -> allocated result, iff allocated
-  Int   d=0;                       // count of digits found in decimal part
-  const char *dotchar=NULL;        // where dot was found
-  const char *cfirst=chars;        // -> first character of decimal part
-  const char *last=NULL;           // -> last digit of decimal part
-  const char *c;                   // work
-  Unit  *up;                       // ..
-  #if DECDPUN>1
-  Int   cut, out;                  // ..
-  #endif
-  Int   residue;                   // rounding residue
-  uInt  status=0;                  // error code
-
-  #if DECCHECK
-  if (decCheckOperands(DECUNUSED, DECUNUSED, DECUNUSED, set))
-    return decNumberZero(dn);
-  #endif
-
-  do {                             // status & malloc protection
-    for (c=chars;; c++) {          // -> input character
-      if (*c>='0' && *c<='9') {    // test for Arabic digit
-        last=c;
-        d++;                       // count of real digits
-        continue;                  // still in decimal part
-        }
-      if (*c=='.' && dotchar==NULL) { // first '.'
-        dotchar=c;                 // record offset into decimal part
-        if (c==cfirst) cfirst++;   // first digit must follow
-        continue;}
-      if (c==chars) {              // first in string...
-        if (*c=='-') {             // valid - sign
-          cfirst++;
-          bits=DECNEG;
-          continue;}
-        if (*c=='+') {             // valid + sign
-          cfirst++;
-          continue;}
-        }
-      // *c is not a digit, or a valid +, -, or '.'
-      break;
-      } // c
-
-    if (last==NULL) {              // no digits yet
-      status=DEC_Conversion_syntax;// assume the worst
-      if (*c=='\0') break;         // and no more to come...
-      #if DECSUBSET
-      // if subset then infinities and NaNs are not allowed
-      if (!set->extended) break;   // hopeless
-      #endif
-      // Infinities and NaNs are possible, here
-      if (dotchar!=NULL) break;    // .. unless had a dot
-      decNumberZero(dn);           // be optimistic
-      if (decBiStr(c, "infinity", "INFINITY")
-       || decBiStr(c, "inf", "INF")) {
-        dn->bits=bits | DECINF;
-        status=0;                  // is OK
-        break; // all done
-        }
-      // a NaN expected
-      // 2003.09.10 NaNs are now permitted to have a sign
-      dn->bits=bits | DECNAN;      // assume simple NaN
-      if (*c=='s' || *c=='S') {    // looks like an sNaN
-        c++;
-        dn->bits=bits | DECSNAN;
-        }
-      if (*c!='n' && *c!='N') break;    // check caseless "NaN"
-      c++;
-      if (*c!='a' && *c!='A') break;    // ..
-      c++;
-      if (*c!='n' && *c!='N') break;    // ..
-      c++;
-      // now either nothing, or nnnn payload, expected
-      // -> start of integer and skip leading 0s [including plain 0]
-      for (cfirst=c; *cfirst=='0';) cfirst++;
-      if (*cfirst=='\0') {         // "NaN" or "sNaN", maybe with all 0s
-        status=0;                  // it's good
-        break;                     // ..
-        }
-      // something other than 0s; setup last and d as usual [no dots]
-      for (c=cfirst;; c++, d++) {
-        if (*c<'0' || *c>'9') break; // test for Arabic digit
-        last=c;
-        }
-      if (*c!='\0') break;         // not all digits
-      if (d>set->digits-1) {
-        // [NB: payload in a decNumber can be full length unless
-        // clamped, in which case can only be digits-1]
-        if (set->clamp) break;
-        if (d>set->digits) break;
-        } // too many digits?
-      // good; drop through to convert the integer to coefficient
-      status=0;                    // syntax is OK
-      bits=dn->bits;               // for copy-back
-      } // last==NULL
-
-     else if (*c!='\0') {          // more to process...
-      // had some digits; exponent is only valid sequence now
-      Flag nege;                   // 1=negative exponent
-      const char *firstexp;        // -> first significant exponent digit
-      status=DEC_Conversion_syntax;// assume the worst
-      if (*c!='e' && *c!='E') break;
-      /* Found 'e' or 'E' -- now process explicit exponent */
-      // 1998.07.11: sign no longer required
-      nege=0;
-      c++;                         // to (possible) sign
-      if (*c=='-') {nege=1; c++;}
-       else if (*c=='+') c++;
-      if (*c=='\0') break;
-
-      for (; *c=='0' && *(c+1)!='\0';) c++;  // strip insignificant zeros
-      firstexp=c;                            // save exponent digit place
-      for (; ;c++) {
-        if (*c<'0' || *c>'9') break;         // not a digit
-        exponent=X10(exponent)+(Int)*c-(Int)'0';
-        } // c
-      // if not now on a '\0', *c must not be a digit
-      if (*c!='\0') break;
-
-      // (this next test must be after the syntax checks)
-      // if it was too long the exponent may have wrapped, so check
-      // carefully and set it to a certain overflow if wrap possible
-      if (c>=firstexp+9+1) {
-        if (c>firstexp+9+1 || *firstexp>'1') exponent=DECNUMMAXE*2;
-        // [up to 1999999999 is OK, for example 1E-1000000998]
-        }
-      if (nege) exponent=-exponent;     // was negative
-      status=0;                         // is OK
-      } // stuff after digits
-
-    // Here when whole string has been inspected; syntax is good
-    // cfirst->first digit (never dot), last->last digit (ditto)
-
-    // strip leading zeros/dot [leave final 0 if all 0's]
-    if (*cfirst=='0') {                 // [cfirst has stepped over .]
-      for (c=cfirst; c<last; c++, cfirst++) {
-        if (*c=='.') continue;          // ignore dots
-        if (*c!='0') break;             // non-zero found
-        d--;                            // 0 stripped
-        } // c
-      #if DECSUBSET
-      // make a rapid exit for easy zeros if !extended
-      if (*cfirst=='0' && !set->extended) {
-        decNumberZero(dn);              // clean result
-        break;                          // [could be return]
-        }
-      #endif
-      } // at least one leading 0
-
-    // Handle decimal point...
-    if (dotchar!=NULL && dotchar<last)  // non-trailing '.' found?
-      exponent-=(last-dotchar);         // adjust exponent
-    // [we can now ignore the .]
-
-    // OK, the digits string is good.  Assemble in the decNumber, or in
-    // a temporary units array if rounding is needed
-    if (d<=set->digits) res=dn->lsu;    // fits into supplied decNumber
-     else {                             // rounding needed
-      Int needbytes=D2U(d)*sizeof(Unit);// bytes needed
-      res=resbuff;                      // assume use local buffer
-      if (needbytes>(Int)sizeof(resbuff)) { // too big for local
-        allocres=(Unit *)malloc(needbytes);
-        if (allocres==NULL) {status|=DEC_Insufficient_storage; break;}
-        res=allocres;
-        }
-      }
-    // res now -> number lsu, buffer, or allocated storage for Unit array
-
-    // Place the coefficient into the selected Unit array
-    // [this is often 70% of the cost of this function when DECDPUN>1]
-    #if DECDPUN>1
-    out=0;                         // accumulator
-    up=res+D2U(d)-1;               // -> msu
-    cut=d-(up-res)*DECDPUN;        // digits in top unit
-    for (c=cfirst;; c++) {         // along the digits
-      if (*c=='.') continue;       // ignore '.' [don't decrement cut]
-      out=X10(out)+(Int)*c-(Int)'0';
-      if (c==last) break;          // done [never get to trailing '.']
-      cut--;
-      if (cut>0) continue;         // more for this unit
-      *up=(Unit)out;               // write unit
-      up--;                        // prepare for unit below..
-      cut=DECDPUN;                 // ..
-      out=0;                       // ..
-      } // c
-    *up=(Unit)out;                 // write lsu
-
-    #else
-    // DECDPUN==1
-    up=res;                        // -> lsu
-    for (c=last; c>=cfirst; c--) { // over each character, from least
-      if (*c=='.') continue;       // ignore . [don't step up]
-      *up=(Unit)((Int)*c-(Int)'0');
-      up++;
-      } // c
-    #endif
-
-    dn->bits=bits;
-    dn->exponent=exponent;
-    dn->digits=d;
-
-    // if not in number (too long) shorten into the number
-    if (d>set->digits) {
-      residue=0;
-      decSetCoeff(dn, set, res, d, &residue, &status);
-      // always check for overflow or subnormal and round as needed
-      decFinalize(dn, set, &residue, &status);
-      }
-     else { // no rounding, but may still have overflow or subnormal
-      // [these tests are just for performance; finalize repeats them]
-      if ((dn->exponent-1<set->emin-dn->digits)
-       || (dn->exponent-1>set->emax-set->digits)) {
-        residue=0;
-        decFinalize(dn, set, &residue, &status);
-        }
-      }
-    // decNumberShow(dn);
-    } while(0);                         // [for break]
-
-  if (allocres!=NULL) free(allocres);   // drop any storage used
-  if (status!=0) decStatus(dn, status, set);
-  return dn;
-  } /* decNumberFromString */
-
-/* ================================================================== */
-/* Operators                                                          */
-/* ================================================================== */
-
-/* ------------------------------------------------------------------ */
-/* decNumberAbs -- absolute value operator                            */
-/*                                                                    */
-/*   This computes C = abs(A)                                         */
-/*                                                                    */
-/*   res is C, the result.  C may be A                                */
-/*   rhs is A                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-/* This has the same effect as decNumberPlus unless A is negative,    */
-/* in which case it has the same effect as decNumberMinus.            */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberAbs(decNumber *res, const decNumber *rhs,
-                         decContext *set) {
-  decNumber dzero;                      // for 0
-  uInt status=0;                        // accumulator
-
-  #if DECCHECK
-  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
-  #endif
-
-  decNumberZero(&dzero);                // set 0
-  dzero.exponent=rhs->exponent;         // [no coefficient expansion]
-  decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status);
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberAbs
-
-/* ------------------------------------------------------------------ */
-/* decNumberAdd -- add two Numbers                                    */
-/*                                                                    */
-/*   This computes C = A + B                                          */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X+X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-/* This just calls the routine shared with Subtract                   */
-decNumber * decNumberAdd(decNumber *res, const decNumber *lhs,
-                         const decNumber *rhs, decContext *set) {
-  uInt status=0;                        // accumulator
-  decAddOp(res, lhs, rhs, set, 0, &status);
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberAdd
-
-/* ------------------------------------------------------------------ */
-/* decNumberCompare -- compare two Numbers                            */
-/*                                                                    */
-/*   This computes C = A ? B                                          */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for one digit (or NaN).                          */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberCompare(decNumber *res, const decNumber *lhs,
-                             const decNumber *rhs, decContext *set) {
-  uInt status=0;                        // accumulator
-  decCompareOp(res, lhs, rhs, set, COMPARE, &status);
-  if (status!=0) decStatus(res, status, set);
-  return res;
-  } // decNumberCompare
-
-/* ------------------------------------------------------------------ */
-/* decNumberCompareTotal -- compare two Numbers, using total ordering */
-/*                                                                    */
-/*   This computes C = A ? B, under total ordering                    */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for one digit; the result will always be one of  */
-/* -1, 0, or 1.                                                       */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberCompareTotal(decNumber *res, const decNumber *lhs,
-                             const decNumber *rhs, decContext *set) {
-  uInt status=0;                        // accumulator
-  decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
-  if (status!=0) decStatus(res, status, set);
-  return res;
-  } // decNumberCompareTotal
-
-/* ------------------------------------------------------------------ */
-/* decNumberDivide -- divide one number by another                    */
-/*                                                                    */
-/*   This computes C = A / B                                          */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X/X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberDivide(decNumber *res, const decNumber *lhs,
-                            const decNumber *rhs, decContext *set) {
-  uInt status=0;                        // accumulator
-  decDivideOp(res, lhs, rhs, set, DIVIDE, &status);
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberDivide
-
-/* ------------------------------------------------------------------ */
-/* decNumberDivideInteger -- divide and return integer quotient       */
-/*                                                                    */
-/*   This computes C = A # B, where # is the integer divide operator  */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X#X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberDivideInteger(decNumber *res, const decNumber *lhs,
-                                   const decNumber *rhs, decContext *set) {
-  uInt status=0;                        // accumulator
-  decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status);
-  if (status!=0) decStatus(res, status, set);
-  return res;
-  } // decNumberDivideInteger
-
-/* ------------------------------------------------------------------ */
-/* decNumberExp -- exponentiation                                     */
-/*                                                                    */
-/*   This computes C = exp(A)                                         */
-/*                                                                    */
-/*   res is C, the result.  C may be A                                */
-/*   rhs is A                                                         */
-/*   set is the context; note that rounding mode has no effect        */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/*                                                                    */
-/* Mathematical function restrictions apply (see above); a NaN is     */
-/* returned with Invalid_operation if a restriction is violated.      */
-/*                                                                    */
-/* Finite results will always be full precision and Inexact, except   */
-/* when A is a zero or -Infinity (giving 1 or 0 respectively).        */
-/*                                                                    */
-/* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
-/* almost always be correctly rounded, but may be up to 1 ulp in      */
-/* error in rare cases.                                               */
-/* ------------------------------------------------------------------ */
-/* This is a wrapper for decExpOp which can handle the slightly wider */
-/* (double) range needed by Ln (which has to be able to calculate     */
-/* exp(-a) where a can be the tiniest number (Ntiny).                 */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberExp(decNumber *res, const decNumber *rhs,
-                         decContext *set) {
-  uInt status=0;                        // accumulator
-  #if DECSUBSET
-  decNumber *allocrhs=NULL;        // non-NULL if rounded rhs allocated
-  #endif
-
-  #if DECCHECK
-  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
-  #endif
-
-  // Check restrictions; these restrictions ensure that if h=8 (see
-  // decExpOp) then the result will either overflow or underflow to 0.
-  // Other math functions restrict the input range, too, for inverses.
-  // If not violated then carry out the operation.
-  if (!decCheckMath(rhs, set, &status)) do { // protect allocation
-    #if DECSUBSET
-    if (!set->extended) {
-      // reduce operand and set lostDigits status, as needed
-      if (rhs->digits>set->digits) {
-        allocrhs=decRoundOperand(rhs, set, &status);
-        if (allocrhs==NULL) break;
-        rhs=allocrhs;
-        }
-      }
-    #endif
-    decExpOp(res, rhs, set, &status);
-    } while(0);                         // end protected
-
-  #if DECSUBSET
-  if (allocrhs !=NULL) free(allocrhs);  // drop any storage used
-  #endif
-  // apply significant status
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberExp
-
-/* ------------------------------------------------------------------ */
-/* decNumberLn -- natural logarithm                                   */
-/*                                                                    */
-/*   This computes C = ln(A)                                          */
-/*                                                                    */
-/*   res is C, the result.  C may be A                                */
-/*   rhs is A                                                         */
-/*   set is the context; note that rounding mode has no effect        */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/*                                                                    */
-/* Notable cases:                                                     */
-/*   A<0 -> Invalid                                                   */
-/*   A=0 -> -Infinity (Exact)                                         */
-/*   A=+Infinity -> +Infinity (Exact)                                 */
-/*   A=1 exactly -> 0 (Exact)                                         */
-/*                                                                    */
-/* Mathematical function restrictions apply (see above); a NaN is     */
-/* returned with Invalid_operation if a restriction is violated.      */
-/*                                                                    */
-/* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
-/* almost always be correctly rounded, but may be up to 1 ulp in      */
-/* error in rare cases.                                               */
-/* ------------------------------------------------------------------ */
-/* This is a wrapper for decLnOp which can handle the slightly wider  */
-/* (+11) range needed by Ln, Log10, etc. (which may have to be able   */
-/* to calculate at p+e+2).                                            */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberLn(decNumber *res, const decNumber *rhs,
-                        decContext *set) {
-  uInt status=0;                   // accumulator
-  #if DECSUBSET
-  decNumber *allocrhs=NULL;        // non-NULL if rounded rhs allocated
-  #endif
-
-  #if DECCHECK
-  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
-  #endif
-
-  // Check restrictions; this is a math function; if not violated
-  // then carry out the operation.
-  if (!decCheckMath(rhs, set, &status)) do { // protect allocation
-    #if DECSUBSET
-    if (!set->extended) {
-      // reduce operand and set lostDigits status, as needed
-      if (rhs->digits>set->digits) {
-        allocrhs=decRoundOperand(rhs, set, &status);
-        if (allocrhs==NULL) break;
-        rhs=allocrhs;
-        }
-      // special check in subset for rhs=0
-      if (ISZERO(rhs)) {                // +/- zeros -> error
-        status|=DEC_Invalid_operation;
-        break;}
-      } // extended=0
-    #endif
-    decLnOp(res, rhs, set, &status);
-    } while(0);                         // end protected
-
-  #if DECSUBSET
-  if (allocrhs !=NULL) free(allocrhs);  // drop any storage used
-  #endif
-  // apply significant status
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberLn
-
-/* ------------------------------------------------------------------ */
-/* decNumberLog10 -- logarithm in base 10                             */
-/*                                                                    */
-/*   This computes C = log10(A)                                       */
-/*                                                                    */
-/*   res is C, the result.  C may be A                                */
-/*   rhs is A                                                         */
-/*   set is the context; note that rounding mode has no effect        */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/*                                                                    */
-/* Notable cases:                                                     */
-/*   A<0 -> Invalid                                                   */
-/*   A=0 -> -Infinity (Exact)                                         */
-/*   A=+Infinity -> +Infinity (Exact)                                 */
-/*   A=10**n (if n is an integer) -> n (Exact)                        */
-/*                                                                    */
-/* Mathematical function restrictions apply (see above); a NaN is     */
-/* returned with Invalid_operation if a restriction is violated.      */
-/*                                                                    */
-/* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
-/* almost always be correctly rounded, but may be up to 1 ulp in      */
-/* error in rare cases.                                               */
-/* ------------------------------------------------------------------ */
-/* This calculates ln(A)/ln(10) using appropriate precision.  For     */
-/* ln(A) this is the max(p, rhs->digits + t) + 3, where p is the      */
-/* requested digits and t is the number of digits in the exponent     */
-/* (maximum 6).  For ln(10) it is p + 3; this is often handled by the */
-/* fastpath in decLnOp.  The final division is done to the requested  */
-/* precision.                                                         */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberLog10(decNumber *res, const decNumber *rhs,
-                          decContext *set) {
-  uInt status=0, ignore=0;         // status accumulators
-  uInt needbytes;                  // for space calculations
-  Int p;                           // working precision
-  Int t;                           // digits in exponent of A
-
-  // buffers for a and b working decimals
-  // (adjustment calculator, same size)
-  decNumber bufa[D2N(DECBUFFER+2)];
-  decNumber *allocbufa=NULL;       // -> allocated bufa, iff allocated
-  decNumber *a=bufa;               // temporary a
-  decNumber bufb[D2N(DECBUFFER+2)];
-  decNumber *allocbufb=NULL;       // -> allocated bufa, iff allocated
-  decNumber *b=bufb;               // temporary b
-  decNumber bufw[D2N(10)];         // working 2-10 digit number
-  decNumber *w=bufw;               // ..
-  #if DECSUBSET
-  decNumber *allocrhs=NULL;        // non-NULL if rounded rhs allocated
-  #endif
-
-  decContext aset;                 // working context
-
-  #if DECCHECK
-  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
-  #endif
-
-  // Check restrictions; this is a math function; if not violated
-  // then carry out the operation.
-  if (!decCheckMath(rhs, set, &status)) do { // protect malloc
-    #if DECSUBSET
-    if (!set->extended) {
-      // reduce operand and set lostDigits status, as needed
-      if (rhs->digits>set->digits) {
-        allocrhs=decRoundOperand(rhs, set, &status);
-        if (allocrhs==NULL) break;
-        rhs=allocrhs;
-        }
-      // special check in subset for rhs=0
-      if (ISZERO(rhs)) {                // +/- zeros -> error
-        status|=DEC_Invalid_operation;
-        break;}
-      } // extended=0
-    #endif
-
-    decContextDefault(&aset, DEC_INIT_DECIMAL64); // clean context
-
-    // handle exact powers of 10; only check if +ve finite
-    if (!(rhs->bits&(DECNEG|DECSPECIAL)) && !ISZERO(rhs)) {
-      Int residue=0;               // (no residue)
-      uInt copystat=0;             // clean status
-
-      // round to a single digit...
-      aset.digits=1;
-      decCopyFit(w, rhs, &aset, &residue, &copystat); // copy & shorten
-      // if exact and the digit is 1, rhs is a power of 10
-      if (!(copystat&DEC_Inexact) && w->lsu[0]==1) {
-        // the exponent, conveniently, is the power of 10; making
-        // this the result needs a little care as it might not fit,
-        // so first convert it into the working number, and then move
-        // to res
-        decPutInt(w, w->exponent);
-        residue=0;
-        decCopyFit(res, w, set, &residue, &status); // copy & round
-        decFinish(res, set, &residue, &status);     // cleanup/set flags
-        break;
-        } // not a power of 10
-      } // not a candidate for exact
-
-    // simplify the information-content calculation to use 'total
-    // number of digits in a, including exponent' as compared to the
-    // requested digits, as increasing this will only rarely cost an
-    // iteration in ln(a) anyway
-    t=6;                                // it can never be >6
-
-    // allocate space when needed...
-    p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3;
-    needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
-    if (needbytes>sizeof(bufa)) {       // need malloc space
-      allocbufa=(decNumber *)malloc(needbytes);
-      if (allocbufa==NULL) {            // hopeless -- abandon
-        status|=DEC_Insufficient_storage;
-        break;}
-      a=allocbufa;                      // use the allocated space
-      }
-    aset.digits=p;                      // as calculated
-    aset.emax=DEC_MAX_MATH;             // usual bounds
-    aset.emin=-DEC_MAX_MATH;            // ..
-    aset.clamp=0;                       // and no concrete format
-    decLnOp(a, rhs, &aset, &status);    // a=ln(rhs)
-
-    // skip the division if the result so far is infinite, NaN, or
-    // zero, or there was an error; note NaN from sNaN needs copy
-    if (status&DEC_NaNs && !(status&DEC_sNaN)) break;
-    if (a->bits&DECSPECIAL || ISZERO(a)) {
-      decNumberCopy(res, a);            // [will fit]
-      break;}
-
-    // for ln(10) an extra 3 digits of precision are needed
-    p=set->digits+3;
-    needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
-    if (needbytes>sizeof(bufb)) {       // need malloc space
-      allocbufb=(decNumber *)malloc(needbytes);
-      if (allocbufb==NULL) {            // hopeless -- abandon
-        status|=DEC_Insufficient_storage;
-        break;}
-      b=allocbufb;                      // use the allocated space
-      }
-    decNumberZero(w);                   // set up 10...
-    #if DECDPUN==1
-    w->lsu[1]=1; w->lsu[0]=0;           // ..
-    #else
-    w->lsu[0]=10;                       // ..
-    #endif
-    w->digits=2;                        // ..
-
-    aset.digits=p;
-    decLnOp(b, w, &aset, &ignore);      // b=ln(10)
-
-    aset.digits=set->digits;            // for final divide
-    decDivideOp(res, a, b, &aset, DIVIDE, &status); // into result
-    } while(0);                         // [for break]
-
-  if (allocbufa!=NULL) free(allocbufa); // drop any storage used
-  if (allocbufb!=NULL) free(allocbufb); // ..
-  #if DECSUBSET
-  if (allocrhs !=NULL) free(allocrhs);  // ..
-  #endif
-  // apply significant status
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberLog10
-
-/* ------------------------------------------------------------------ */
-/* decNumberMax -- compare two Numbers and return the maximum         */
-/*                                                                    */
-/*   This computes C = A ? B, returning the maximum or A if equal     */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberMax(decNumber *res, const decNumber *lhs,
-                         const decNumber *rhs, decContext *set) {
-  uInt status=0;                        // accumulator
-  decCompareOp(res, lhs, rhs, set, COMPMAX, &status);
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberMax
-
-/* ------------------------------------------------------------------ */
-/* decNumberMin -- compare two Numbers and return the minimum         */
-/*                                                                    */
-/*   This computes C = A ? B, returning the minimum or A if equal     */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberMin(decNumber *res, const decNumber *lhs,
-                         const decNumber *rhs, decContext *set) {
-  uInt status=0;                        // accumulator
-  decCompareOp(res, lhs, rhs, set, COMPMIN, &status);
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberMin
-
-/* ------------------------------------------------------------------ */
-/* decNumberMinus -- prefix minus operator                            */
-/*                                                                    */
-/*   This computes C = 0 - A                                          */
-/*                                                                    */
-/*   res is C, the result.  C may be A                                */
-/*   rhs is A                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-/* Simply use AddOp for the subtract, which will do the necessary.    */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberMinus(decNumber *res, const decNumber *rhs,
-                           decContext *set) {
-  decNumber dzero;
-  uInt status=0;                        // accumulator
-
-  #if DECCHECK
-  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
-  #endif
-
-  decNumberZero(&dzero);                // make 0
-  dzero.exponent=rhs->exponent;         // [no coefficient expansion]
-  decAddOp(res, &dzero, rhs, set, DECNEG, &status);
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberMinus
-
-/* ------------------------------------------------------------------ */
-/* decNumberPlus -- prefix plus operator                              */
-/*                                                                    */
-/*   This computes C = 0 + A                                          */
-/*                                                                    */
-/*   res is C, the result.  C may be A                                */
-/*   rhs is A                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-/* This simply uses AddOp; Add will take fast path after preparing A. */
-/* Performance is a concern here, as this routine is often used to    */
-/* check operands and apply rounding and overflow/underflow testing.  */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberPlus(decNumber *res, const decNumber *rhs,
-                          decContext *set) {
-  decNumber dzero;
-  uInt status=0;                        // accumulator
-
-  #if DECCHECK
-  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
-  #endif
-
-  decNumberZero(&dzero);                // make 0
-  dzero.exponent=rhs->exponent;         // [no coefficient expansion]
-  decAddOp(res, &dzero, rhs, set, 0, &status);
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberPlus
-
-/* ------------------------------------------------------------------ */
-/* decNumberMultiply -- multiply two Numbers                          */
-/*                                                                    */
-/*   This computes C = A x B                                          */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X+X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberMultiply(decNumber *res, const decNumber *lhs,
-                              const decNumber *rhs, decContext *set) {
-  uInt status=0;                   // accumulator
-  decMultiplyOp(res, lhs, rhs, set, &status);
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberMultiply
-
-/* ------------------------------------------------------------------ */
-/* decNumberNormalize -- remove trailing zeros                        */
-/*                                                                    */
-/*   This computes C = 0 + A, and normalizes the result               */
-/*                                                                    */
-/*   res is C, the result.  C may be A                                */
-/*   rhs is A                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberNormalize(decNumber *res, const decNumber *rhs,
-                               decContext *set) {
-  #if DECSUBSET
-  decNumber *allocrhs=NULL;        // non-NULL if rounded rhs allocated
-  #endif
-  uInt status=0;                   // as usual
-  Int  residue=0;                  // as usual
-  Int  dropped;                    // work
-
-  #if DECCHECK
-  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
-  #endif
-
-  do {                             // protect allocated storage
-    #if DECSUBSET
-    if (!set->extended) {
-      // reduce operand and set lostDigits status, as needed
-      if (rhs->digits>set->digits) {
-        allocrhs=decRoundOperand(rhs, set, &status);
-        if (allocrhs==NULL) break;
-        rhs=allocrhs;
-        }
-      }
-    #endif
-    // [following code does not require input rounding]
-
-    // specials copy through, except NaNs need care
-    if (decNumberIsNaN(rhs)) {
-      decNaNs(res, rhs, NULL, &status);
-      break;
-      }
-
-    // reduce result to the requested length and copy to result
-    decCopyFit(res, rhs, set, &residue, &status); // copy & round
-    decFinish(res, set, &residue, &status);       // cleanup/set flags
-    decTrim(res, 1, &dropped);               // normalize in place
-    } while(0);                              // end protected
-
-  #if DECSUBSET
-  if (allocrhs !=NULL) free(allocrhs);       // ..
-  #endif
-  if (status!=0) decStatus(res, status, set);// then report status
-  return res;
-  } // decNumberNormalize
-
-/* ------------------------------------------------------------------ */
-/* decNumberPower -- raise a number to a power                        */
-/*                                                                    */
-/*   This computes C = A ** B                                         */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X**X)        */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/*                                                                    */
-/* Mathematical function restrictions apply (see above); a NaN is     */
-/* returned with Invalid_operation if a restriction is violated.      */
-/*                                                                    */
-/* However, if 1999999997<=B<=999999999 and B is an integer then the  */
-/* restrictions on A and the context are relaxed to the usual bounds, */
-/* for compatibility with the earlier (integer power only) version    */
-/* of this function.                                                  */
-/*                                                                    */
-/* When B is an integer, the result may be exact, even if rounded.    */
-/*                                                                    */
-/* The final result is rounded according to the context; it will      */
-/* almost always be correctly rounded, but may be up to 1 ulp in      */
-/* error in rare cases.                                               */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberPower(decNumber *res, const decNumber *lhs,
-                           const decNumber *rhs, decContext *set) {
-  #if DECSUBSET
-  decNumber *alloclhs=NULL;        // non-NULL if rounded lhs allocated
-  decNumber *allocrhs=NULL;        // .., rhs
-  #endif
-  decNumber *allocdac=NULL;        // -> allocated acc buffer, iff used
-  decNumber *allocinv=NULL;        // -> allocated 1/x buffer, iff used
-  Int   reqdigits=set->digits;     // requested DIGITS
-  Int   n;                         // rhs in binary
-  Flag  rhsint=0;                  // 1 if rhs is an integer
-  Flag  useint=0;                  // 1 if can use integer calculation
-  Flag  isoddint=0;                // 1 if rhs is an integer and odd
-  Int   i;                         // work
-  #if DECSUBSET
-  Int   dropped;                   // ..
-  #endif
-  uInt  needbytes;                 // buffer size needed
-  Flag  seenbit;                   // seen a bit while powering
-  Int   residue=0;                 // rounding residue
-  uInt  status=0;                  // accumulators
-  uByte bits=0;                    // result sign if errors
-  decContext aset;                 // working context
-  decNumber dnOne;                 // work value 1...
-  // local accumulator buffer [a decNumber, with digits+elength+1 digits]
-  decNumber dacbuff[D2N(DECBUFFER+9)];
-  decNumber *dac=dacbuff;          // -> result accumulator
-  // same again for possible 1/lhs calculation
-  decNumber invbuff[D2N(DECBUFFER+9)];
-
-  #if DECCHECK
-  if (decCheckOperands(res, lhs, rhs, set)) return res;
-  #endif
-
-  do {                             // protect allocated storage
-    #if DECSUBSET
-    if (!set->extended) { // reduce operands and set status, as needed
-      if (lhs->digits>reqdigits) {
-        alloclhs=decRoundOperand(lhs, set, &status);
-        if (alloclhs==NULL) break;
-        lhs=alloclhs;
-        }
-      if (rhs->digits>reqdigits) {
-        allocrhs=decRoundOperand(rhs, set, &status);
-        if (allocrhs==NULL) break;
-        rhs=allocrhs;
-        }
-      }
-    #endif
-    // [following code does not require input rounding]
-
-    // handle NaNs and rhs Infinity (lhs infinity is harder)
-    if (SPECIALARGS) {
-      if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { // NaNs
-        decNaNs(res, lhs, rhs, &status);
-        break;}
-      if (decNumberIsInfinite(rhs)) {   // rhs Infinity
-        Flag rhsneg=rhs->bits&DECNEG;   // save rhs sign
-        if (decNumberIsNegative(lhs)    // lhs<0
-         && !decNumberIsZero(lhs))      // ..
-          status|=DEC_Invalid_operation;
-         else {                         // lhs >=0
-          decNumberZero(&dnOne);        // set up 1
-          dnOne.lsu[0]=1;
-          decNumberCompare(dac, lhs, &dnOne, set); // lhs ? 1
-          decNumberZero(res);           // prepare for 0/1/Infinity
-          if (decNumberIsNegative(dac)) {    // lhs<1
-            if (rhsneg) res->bits|=DECINF;   // +Infinity [else is +0]
-            }
-           else if (dac->lsu[0]==0) {        // lhs=1
-            // 1**Infinity is inexact, so return fully-padded 1.0000
-            Int shift=set->digits-1;
-            *res->lsu=1;                     // was 0, make int 1
-            res->digits=decShiftToMost(res->lsu, 1, shift);
-            res->exponent=-shift;            // make 1.0000...
-            status|=DEC_Inexact|DEC_Rounded; // deemed inexact
-            }
-           else {                            // lhs>1
-            if (!rhsneg) res->bits|=DECINF;  // +Infinity [else is +0]
-            }
-          } // lhs>=0
-        break;}
-      // [lhs infinity drops through]
-      } // specials
-
-    // Original rhs may be an integer that fits and is in range
-    n=decGetInt(rhs);
-    if (n!=BADINT) {                    // it is an integer
-      rhsint=1;                         // record the fact for 1**n
-      isoddint=(Flag)n&1;               // [works even if big]
-      if (n!=BIGEVEN && n!=BIGODD)      // can use integer path?
-        useint=1;                       // looks good
-      }
-
-    if (decNumberIsNegative(lhs)        // -x ..
-      && isoddint) bits=DECNEG;         // .. to an odd power
-
-    // handle LHS infinity
-    if (decNumberIsInfinite(lhs)) {     // [NaNs already handled]
-      uByte rbits=rhs->bits;            // save
-      decNumberZero(res);               // prepare
-      if (n==0) *res->lsu=1;            // [-]Inf**0 => 1
-       else {
-        // -Inf**nonint -> error
-        if (!rhsint && decNumberIsNegative(lhs)) {
-          status|=DEC_Invalid_operation;     // -Inf**nonint is error
-          break;}
-        if (!(rbits & DECNEG)) bits|=DECINF; // was not a **-n
-        // [otherwise will be 0 or -0]
-        res->bits=bits;
-        }
-      break;}
-
-    // similarly handle LHS zero
-    if (decNumberIsZero(lhs)) {
-      if (n==0) {                            // 0**0 => Error
-        #if DECSUBSET
-        if (!set->extended) {                // [unless subset]
-          decNumberZero(res);
-          *res->lsu=1;                       // return 1
-          break;}
-        #endif
-        status|=DEC_Invalid_operation;
-        }
-       else {                                // 0**x
-        uByte rbits=rhs->bits;               // save
-        if (rbits & DECNEG) {                // was a 0**(-n)
-          #if DECSUBSET
-          if (!set->extended) {              // [bad if subset]
-            status|=DEC_Invalid_operation;
-            break;}
-          #endif
-          bits|=DECINF;
-          }
-        decNumberZero(res);                  // prepare
-        // [otherwise will be 0 or -0]
-        res->bits=bits;
-        }
-      break;}
-
-    // here both lhs and rhs are finite; rhs==0 is handled in the
-    // integer path.  Next handle the non-integer cases
-    if (!useint) {                      // non-integral rhs
-      // any -ve lhs is bad, as is either operand or context out of
-      // bounds
-      if (decNumberIsNegative(lhs)) {
-        status|=DEC_Invalid_operation;
-        break;}
-      if (decCheckMath(lhs, set, &status)
-       || decCheckMath(rhs, set, &status)) break; // variable status
-
-      decContextDefault(&aset, DEC_INIT_DECIMAL64); // clean context
-      aset.emax=DEC_MAX_MATH;           // usual bounds
-      aset.emin=-DEC_MAX_MATH;          // ..
-      aset.clamp=0;                     // and no concrete format
-
-      // calculate the result using exp(ln(lhs)*rhs), which can
-      // all be done into the accumulator, dac.  The precision needed
-      // is enough to contain the full information in the lhs (which
-      // is the total digits, including exponent), or the requested
-      // precision, if larger, + 4; 6 is used for the exponent
-      // maximum length, and this is also used when it is shorter
-      // than the requested digits as it greatly reduces the >0.5 ulp
-      // cases at little cost (because Ln doubles digits each
-      // iteration so a few extra digits rarely causes an extra
-      // iteration)
-      aset.digits=MAX(lhs->digits, set->digits)+6+4;
-      } // non-integer rhs
-
-     else { // rhs is in-range integer
-      if (n==0) {                       // x**0 = 1
-        // (0**0 was handled above)
-        decNumberZero(res);             // result=1
-        *res->lsu=1;                    // ..
-        break;}
-      // rhs is a non-zero integer
-      if (n<0) n=-n;                    // use abs(n)
-
-      aset=*set;                        // clone the context
-      aset.round=DEC_ROUND_HALF_EVEN;   // internally use balanced
-      // calculate the working DIGITS
-      aset.digits=reqdigits+(rhs->digits+rhs->exponent)+2;
-      #if DECSUBSET
-      if (!set->extended) aset.digits--;     // use classic precision
-      #endif
-      // it's an error if this is more than can be handled
-      if (aset.digits>DECNUMMAXP) {status|=DEC_Invalid_operation; break;}
-      } // integer path
-
-    // aset.digits is the count of digits for the accumulator needed
-    // if accumulator is too long for local storage, then allocate
-    needbytes=sizeof(decNumber)+(D2U(aset.digits)-1)*sizeof(Unit);
-    // [needbytes also used below if 1/lhs needed]
-    if (needbytes>sizeof(dacbuff)) {
-      allocdac=(decNumber *)malloc(needbytes);
-      if (allocdac==NULL) {   // hopeless -- abandon
-        status|=DEC_Insufficient_storage;
-        break;}
-      dac=allocdac;           // use the allocated space
-      }
-    // here, aset is set up and accumulator is ready for use
-
-    if (!useint) {                           // non-integral rhs
-      // x ** y; special-case x=1 here as it will otherwise always
-      // reduce to integer 1; decLnOp has a fastpath which detects
-      // the case of x=1
-      decLnOp(dac, lhs, &aset, &status);     // dac=ln(lhs)
-      // [no error possible, as lhs 0 already handled]
-      if (ISZERO(dac)) {                     // x==1, 1.0, etc.
-        // need to return fully-padded 1.0000 etc., but rhsint->1
-        *dac->lsu=1;                         // was 0, make int 1
-        if (!rhsint) {                       // add padding
-          Int shift=set->digits-1;
-          dac->digits=decShiftToMost(dac->lsu, 1, shift);
-          dac->exponent=-shift;              // make 1.0000...
-          status|=DEC_Inexact|DEC_Rounded;   // deemed inexact
-          }
-        }
-       else {
-        decMultiplyOp(dac, dac, rhs, &aset, &status);  // dac=dac*rhs
-        decExpOp(dac, dac, &aset, &status);            // dac=exp(dac)
-        }
-      // and drop through for final rounding
-      } // non-integer rhs
-
-     else {                             // carry on with integer
-      decNumberZero(dac);               // acc=1
-      *dac->lsu=1;                      // ..
-
-      // if a negative power the constant 1 is needed, and if not subset
-      // invert the lhs now rather than inverting the result later
-      if (decNumberIsNegative(rhs)) {   // was a **-n [hence digits>0]
-        decNumber *inv=invbuff;         // asssume use fixed buffer
-        decNumberCopy(&dnOne, dac);     // dnOne=1;  [needed now or later]
-        #if DECSUBSET
-        if (set->extended) {            // need to calculate 1/lhs
-        #endif
-          // divide lhs into 1, putting result in dac [dac=1/dac]
-          decDivideOp(dac, &dnOne, lhs, &aset, DIVIDE, &status);
-          // now locate or allocate space for the inverted lhs
-          if (needbytes>sizeof(invbuff)) {
-            allocinv=(decNumber *)malloc(needbytes);
-            if (allocinv==NULL) {       // hopeless -- abandon
-              status|=DEC_Insufficient_storage;
-              break;}
-            inv=allocinv;               // use the allocated space
-            }
-          // [inv now points to big-enough buffer or allocated storage]
-          decNumberCopy(inv, dac);      // copy the 1/lhs
-          decNumberCopy(dac, &dnOne);   // restore acc=1
-          lhs=inv;                      // .. and go forward with new lhs
-        #if DECSUBSET
-          }
-        #endif
-        }
-
-      // Raise-to-the-power loop...
-      seenbit=0;                   // set once a 1-bit is encountered
-      for (i=1;;i++){              // for each bit [top bit ignored]
-        // abandon if had overflow or terminal underflow
-        if (status & (DEC_Overflow|DEC_Underflow)) { // interesting?
-          if (status&DEC_Overflow || ISZERO(dac)) break;
-          }
-        // [the following two lines revealed an optimizer bug in a C++
-        // compiler, with symptom: 5**3 -> 25, when n=n+n was used]
-        n=n<<1;                    // move next bit to testable position
-        if (n<0) {                 // top bit is set
-          seenbit=1;               // OK, significant bit seen
-          decMultiplyOp(dac, dac, lhs, &aset, &status); // dac=dac*x
-          }
-        if (i==31) break;          // that was the last bit
-        if (!seenbit) continue;    // no need to square 1
-        decMultiplyOp(dac, dac, dac, &aset, &status); // dac=dac*dac [square]
-        } /*i*/ // 32 bits
-
-      // complete internal overflow or underflow processing
-      if (status & (DEC_Overflow|DEC_Subnormal)) {
-        #if DECSUBSET
-        // If subset, and power was negative, reverse the kind of -erflow
-        // [1/x not yet done]
-        if (!set->extended && decNumberIsNegative(rhs)) {
-          if (status & DEC_Overflow)
-            status^=DEC_Overflow | DEC_Underflow | DEC_Subnormal;
-           else { // trickier -- Underflow may or may not be set
-            status&=~(DEC_Underflow | DEC_Subnormal); // [one or both]
-            status|=DEC_Overflow;
-            }
-          }
-        #endif
-        dac->bits=(dac->bits & ~DECNEG) | bits; // force correct sign
-        // round subnormals [to set.digits rather than aset.digits]
-        // or set overflow result similarly as required
-        decFinalize(dac, set, &residue, &status);
-        decNumberCopy(res, dac);   // copy to result (is now OK length)
-        break;
-        }
-
-      #if DECSUBSET
-      if (!set->extended &&                  // subset math
-          decNumberIsNegative(rhs)) {        // was a **-n [hence digits>0]
-        // so divide result into 1 [dac=1/dac]
-        decDivideOp(dac, &dnOne, dac, &aset, DIVIDE, &status);
-        }
-      #endif
-      } // rhs integer path
-
-    // reduce result to the requested length and copy to result
-    decCopyFit(res, dac, set, &residue, &status);
-    decFinish(res, set, &residue, &status);  // final cleanup
-    #if DECSUBSET
-    if (!set->extended) decTrim(res, 0, &dropped); // trailing zeros
-    #endif
-    } while(0);                         // end protected
-
-  if (allocdac!=NULL) free(allocdac);   // drop any storage used
-  if (allocinv!=NULL) free(allocinv);   // ..
-  #if DECSUBSET
-  if (alloclhs!=NULL) free(alloclhs);   // ..
-  if (allocrhs!=NULL) free(allocrhs);   // ..
-  #endif
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberPower
-
-/* ------------------------------------------------------------------ */
-/* decNumberQuantize -- force exponent to requested value             */
-/*                                                                    */
-/*   This computes C = op(A, B), where op adjusts the coefficient     */
-/*   of C (by rounding or shifting) such that the exponent (-scale)   */
-/*   of C has exponent of B.  The numerical value of C will equal A,  */
-/*   except for the effects of any rounding that occurred.            */
-/*                                                                    */
-/*   res is C, the result.  C may be A or B                           */
-/*   lhs is A, the number to adjust                                   */
-/*   rhs is B, the number with exponent to match                      */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/*                                                                    */
-/* Unless there is an error or the result is infinite, the exponent   */
-/* after the operation is guaranteed to be equal to that of B.        */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberQuantize(decNumber *res, const decNumber *lhs,
-                              const decNumber *rhs, decContext *set) {
-  uInt status=0;                        // accumulator
-  decQuantizeOp(res, lhs, rhs, set, 1, &status);
-  if (status!=0) decStatus(res, status, set);
-  return res;
-  } // decNumberQuantize
-
-/* ------------------------------------------------------------------ */
-/* decNumberRescale -- force exponent to requested value              */
-/*                                                                    */
-/*   This computes C = op(A, B), where op adjusts the coefficient     */
-/*   of C (by rounding or shifting) such that the exponent (-scale)   */
-/*   of C has the value B.  The numerical value of C will equal A,    */
-/*   except for the effects of any rounding that occurred.            */
-/*                                                                    */
-/*   res is C, the result.  C may be A or B                           */
-/*   lhs is A, the number to adjust                                   */
-/*   rhs is B, the requested exponent                                 */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/*                                                                    */
-/* Unless there is an error or the result is infinite, the exponent   */
-/* after the operation is guaranteed to be equal to B.                */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberRescale(decNumber *res, const decNumber *lhs,
-                             const decNumber *rhs, decContext *set) {
-  uInt status=0;                        // accumulator
-  decQuantizeOp(res, lhs, rhs, set, 0, &status);
-  if (status!=0) decStatus(res, status, set);
-  return res;
-  } // decNumberRescale
-
-/* ------------------------------------------------------------------ */
-/* decNumberRemainder -- divide and return remainder                  */
-/*                                                                    */
-/*   This computes C = A % B                                          */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X%X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberRemainder(decNumber *res, const decNumber *lhs,
-                               const decNumber *rhs, decContext *set) {
-  uInt status=0;                        // accumulator
-  decDivideOp(res, lhs, rhs, set, REMAINDER, &status);
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberRemainder
-
-/* ------------------------------------------------------------------ */
-/* decNumberRemainderNear -- divide and return remainder from nearest */
-/*                                                                    */
-/*   This computes C = A % B, where % is the IEEE remainder operator  */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X%X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberRemainderNear(decNumber *res, const decNumber *lhs,
-                                   const decNumber *rhs, decContext *set) {
-  uInt status=0;                        // accumulator
-  decDivideOp(res, lhs, rhs, set, REMNEAR, &status);
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberRemainderNear
-
-/* ------------------------------------------------------------------ */
-/* decNumberSameQuantum -- test for equal exponents                   */
-/*                                                                    */
-/*   res is the result number, which will contain either 0 or 1       */
-/*   lhs is a number to test                                          */
-/*   rhs is the second (usually a pattern)                            */
-/*                                                                    */
-/* No errors are possible and no context is needed.                   */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberSameQuantum(decNumber *res, const decNumber *lhs,
-                                 const decNumber *rhs) {
-  Unit ret=0;                      // return value
-
-  #if DECCHECK
-  if (decCheckOperands(res, lhs, rhs, DECUNUSED)) return res;
-  #endif
-
-  if (SPECIALARGS) {
-    if (decNumberIsNaN(lhs) && decNumberIsNaN(rhs)) ret=1;
-     else if (decNumberIsInfinite(lhs) && decNumberIsInfinite(rhs)) ret=1;
-     // [anything else with a special gives 0]
-    }
-   else if (lhs->exponent==rhs->exponent) ret=1;
-
-  decNumberZero(res);              // OK to overwrite an operand now
-  *res->lsu=ret;
-  return res;
-  } // decNumberSameQuantum
-
-/* ------------------------------------------------------------------ */
-/* decNumberSquareRoot -- square root operator                        */
-/*                                                                    */
-/*   This computes C = squareroot(A)                                  */
-/*                                                                    */
-/*   res is C, the result.  C may be A                                */
-/*   rhs is A                                                         */
-/*   set is the context; note that rounding mode has no effect        */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-/* This uses the following varying-precision algorithm in:            */
-/*                                                                    */
-/*   Properly Rounded Variable Precision Square Root, T. E. Hull and  */
-/*   A. Abrham, ACM Transactions on Mathematical Software, Vol 11 #3, */
-/*   pp229-237, ACM, September 1985.                                  */
-/*                                                                    */
-/* The square-root is calculated using Newton's method, after which   */
-/* a check is made to ensure the result is correctly rounded.         */
-/*                                                                    */
-/* % [Reformatted original Numerical Turing source code follows.]     */
-/* function sqrt(x : real) : real                                     */
-/* % sqrt(x) returns the properly rounded approximation to the square */
-/* % root of x, in the precision of the calling environment, or it    */
-/* % fails if x < 0.                                                  */
-/* % t e hull and a abrham, august, 1984                              */
-/* if x <= 0 then                                                     */
-/*   if x < 0 then                                                    */
-/*     assert false                                                   */
-/*   else                                                             */
-/*     result 0                                                       */
-/*   end if                                                           */
-/* end if                                                             */
-/* var f := setexp(x, 0)  % fraction part of x   [0.1 <= x < 1]       */
-/* var e := getexp(x)     % exponent part of x                        */
-/* var approx : real                                                  */
-/* if e mod 2 = 0  then                                               */
-/*   approx := .259 + .819 * f   % approx to root of f                */
-/* else                                                               */
-/*   f := f/l0                   % adjustments                        */
-/*   e := e + 1                  %   for odd                          */
-/*   approx := .0819 + 2.59 * f  %   exponent                         */
-/* end if                                                             */
-/*                                                                    */
-/* var p:= 3                                                          */
-/* const maxp := currentprecision + 2                                 */
-/* loop                                                               */
-/*   p := min(2*p - 2, maxp)     % p = 4,6,10, . . . , maxp           */
-/*   precision p                                                      */
-/*   approx := .5 * (approx + f/approx)                               */
-/*   exit when p = maxp                                               */
-/* end loop                                                           */
-/*                                                                    */
-/* % approx is now within 1 ulp of the properly rounded square root   */
-/* % of f; to ensure proper rounding, compare squares of (approx -    */
-/* % l/2 ulp) and (approx + l/2 ulp) with f.                          */
-/* p := currentprecision                                              */
-/* begin                                                              */
-/*   precision p + 2                                                  */
-/*   const approxsubhalf := approx - setexp(.5, -p)                   */
-/*   if mulru(approxsubhalf, approxsubhalf) > f then                  */
-/*     approx := approx - setexp(.l, -p + 1)                          */
-/*   else                                                             */
-/*     const approxaddhalf := approx + setexp(.5, -p)                 */
-/*     if mulrd(approxaddhalf, approxaddhalf) < f then                */
-/*       approx := approx + setexp(.l, -p + 1)                        */
-/*     end if                                                         */
-/*   end if                                                           */
-/* end                                                                */
-/* result setexp(approx, e div 2)  % fix exponent                     */
-/* end sqrt                                                           */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberSquareRoot(decNumber *res, const decNumber *rhs,
-                                decContext *set) {
-  decContext workset, approxset;   // work contexts
-  decNumber dzero;                 // used for constant zero
-  Int  maxp=set->digits+2;         // largest working precision
-  Int  residue=0;                  // rounding residue
-  uInt status=0, ignore=0;         // status accumulators
-  Int  exp;                        // working exponent
-  Int  ideal;                      // ideal (preferred) exponent
-  Int  needbytes;                  // work
-  Int  dropped;                    // ..
-
-  #if DECSUBSET
-  decNumber *allocrhs=NULL;        // non-NULL if rounded rhs allocated
-  #endif
-  // buffer for f [needs +1 in case DECBUFFER 0]
-  decNumber buff[D2N(DECBUFFER+1)];
-  // buffer for a [needs +2 to match maxp]
-  decNumber bufa[D2N(DECBUFFER+2)];
-  // buffer for temporary, b [must be same size as a]
-  decNumber bufb[D2N(DECBUFFER+2)];
-  decNumber *allocbuff=NULL;       // -> allocated buff, iff allocated
-  decNumber *allocbufa=NULL;       // -> allocated bufa, iff allocated
-  decNumber *allocbufb=NULL;       // -> allocated bufb, iff allocated
-  decNumber *f=buff;               // reduced fraction
-  decNumber *a=bufa;               // approximation to result
-  decNumber *b=bufb;               // intermediate result
-  // buffer for temporary variable, up to 3 digits
-  decNumber buft[D2N(3)];
-  decNumber *t=buft;               // up-to-3-digit constant or work
-
-  #if DECCHECK
-  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
-  #endif
-
-  do {                             // protect allocated storage
-    #if DECSUBSET
-    if (!set->extended) {
-      // reduce operand and set lostDigits status, as needed
-      if (rhs->digits>set->digits) {
-        allocrhs=decRoundOperand(rhs, set, &status);
-        if (allocrhs==NULL) break;
-        // [Note: 'f' allocation below could reuse this buffer if
-        // used, but as this is rare they are kept separate for clarity.]
-        rhs=allocrhs;
-        }
-      }
-    #endif
-    // [following code does not require input rounding]
-
-    // handle infinities and NaNs
-    if (SPECIALARG) {
-      if (decNumberIsInfinite(rhs)) {         // an infinity
-        if (decNumberIsNegative(rhs)) status|=DEC_Invalid_operation;
-         else decNumberCopy(res, rhs);        // +Infinity
-        }
-       else decNaNs(res, rhs, NULL, &status); // a NaN
-      break;
-      }
-
-    // calculate the ideal (preferred) exponent [floor(exp/2)]
-    // [We would like to write: ideal=rhs->exponent>>1, but this
-    // generates a compiler warning.  Generated code is the same.]
-    ideal=(rhs->exponent&~1)/2;         // target
-
-    // handle zeros
-    if (ISZERO(rhs)) {
-      decNumberCopy(res, rhs);          // could be 0 or -0
-      res->exponent=ideal;              // use the ideal [safe]
-      break;
-      }
-
-    // any other -x is an oops
-    if (decNumberIsNegative(rhs)) {
-      status|=DEC_Invalid_operation;
-      break;
-      }
-
-    // space is needed for three working variables
-    //   f -- the same precision as the RHS, reduced to 0.01->0.99...
-    //   a -- Hull's approximation -- precision, when assigned, is
-    //        currentprecision (we allow +2 for use as temporary)
-    //   b -- intermediate temporary result
-    // if any is too long for local storage, then allocate
-    needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
-    if (needbytes>(Int)sizeof(buff)) {
-      allocbuff=(decNumber *)malloc(needbytes);
-      if (allocbuff==NULL) {  // hopeless -- abandon
-        status|=DEC_Insufficient_storage;
-        break;}
-      f=allocbuff;            // use the allocated space
-      }
-    // a and b both need to be able to hold a maxp-length number
-    needbytes=sizeof(decNumber)+(D2U(maxp)-1)*sizeof(Unit);
-    if (needbytes>(Int)sizeof(bufa)) {            // [same applies to b]
-      allocbufa=(decNumber *)malloc(needbytes);
-      allocbufb=(decNumber *)malloc(needbytes);
-      if (allocbufa==NULL || allocbufb==NULL) {   // hopeless
-        status|=DEC_Insufficient_storage;
-        break;}
-      a=allocbufa;            // use the allocated space
-      b=allocbufb;            // ..
-      }
-
-    // copy rhs -> f, save exponent, and reduce so 0.1 <= f < 1
-    decNumberCopy(f, rhs);
-    exp=f->exponent+f->digits;               // adjusted to Hull rules
-    f->exponent=-(f->digits);                // to range
-
-    // set up working contexts (the second is used for Numerical
-    // Turing assignment)
-    decContextDefault(&workset, DEC_INIT_DECIMAL64);
-    decContextDefault(&approxset, DEC_INIT_DECIMAL64);
-    approxset.digits=set->digits;                   // approx's length
-
-    // [Until further notice, no error is possible and status bits
-    // (Rounded, etc.) should be ignored, not accumulated.]
-
-    // Calculate initial approximation, and allow for odd exponent
-    workset.digits=set->digits;              // p for initial calculation
-    t->bits=0; t->digits=3;
-    a->bits=0; a->digits=3;
-    if ((exp & 1)==0) {                      // even exponent
-      // Set t=0.259, a=0.819
-      t->exponent=-3;
-      a->exponent=-3;
-      #if DECDPUN>=3
-        t->lsu[0]=259;
-        a->lsu[0]=819;
-      #elif DECDPUN==2
-        t->lsu[0]=59; t->lsu[1]=2;
-        a->lsu[0]=19; a->lsu[1]=8;
-      #else
-        t->lsu[0]=9; t->lsu[1]=5; t->lsu[2]=2;
-        a->lsu[0]=9; a->lsu[1]=1; a->lsu[2]=8;
-      #endif
-      }
-     else {                                  // odd exponent
-      // Set t=0.0819, a=2.59
-      f->exponent--;                         // f=f/10
-      exp++;                                 // e=e+1
-      t->exponent=-4;
-      a->exponent=-2;
-      #if DECDPUN>=3
-        t->lsu[0]=819;
-        a->lsu[0]=259;
-      #elif DECDPUN==2
-        t->lsu[0]=19; t->lsu[1]=8;
-        a->lsu[0]=59; a->lsu[1]=2;
-      #else
-        t->lsu[0]=9; t->lsu[1]=1; t->lsu[2]=8;
-        a->lsu[0]=9; a->lsu[1]=5; a->lsu[2]=2;
-      #endif
-      }
-    decMultiplyOp(a, a, f, &workset, &ignore);    // a=a*f
-    decAddOp(a, a, t, &workset, 0, &ignore);      // ..+t
-    // [a is now the initial approximation for sqrt(f), calculated with
-    // currentprecision, which is also a's precision.]
-
-    // the main calculation loop
-    decNumberZero(&dzero);                        // make 0
-    decNumberZero(t);                             // set t = 0.5
-    t->lsu[0]=5;                                  // ..
-    t->exponent=-1;                               // ..
-    workset.digits=3;                             // initial p
-    for (;;) {
-      // set p to min(2*p - 2, maxp)  [hence 3; or: 4, 6, 10, ... , maxp]
-      workset.digits=workset.digits*2-2;
-      if (workset.digits>maxp) workset.digits=maxp;
-      // a = 0.5 * (a + f/a)
-      // [calculated at p then rounded to currentprecision]
-      decDivideOp(b, f, a, &workset, DIVIDE, &ignore); // b=f/a
-      decAddOp(b, b, a, &workset, 0, &ignore);    // b=b+a
-      decMultiplyOp(a, b, t, &workset, &ignore);  // a=b*0.5
-      // assign to approx [round to length]
-      decAddOp(a, &dzero, a, &approxset, 0, &ignore);
-      if (workset.digits==maxp) break;            // just did final
-      } // loop
-
-    // a is now at currentprecision and within 1 ulp of the properly
-    // rounded square root of f; to ensure proper rounding, compare
-    // squares of (a - l/2 ulp) and (a + l/2 ulp) with f.
-    // Here workset.digits=maxp and t=0.5
-    workset.digits--;                             // maxp-1 is OK now
-    t->exponent=-set->digits-1;                   // make 0.5 ulp
-    decNumberCopy(b, a);
-    decAddOp(b, b, t, &workset, DECNEG, &ignore); // b = a - 0.5 ulp
-    workset.round=DEC_ROUND_UP;
-    decMultiplyOp(b, b, b, &workset, &ignore);    // b = mulru(b, b)
-    decCompareOp(b, f, b, &workset, COMPARE, &ignore); // b ? f, reversed
-    if (decNumberIsNegative(b)) {                 // f < b [i.e., b > f]
-      // this is the more common adjustment, though both are rare
-      t->exponent++;                              // make 1.0 ulp
-      t->lsu[0]=1;                                // ..
-      decAddOp(a, a, t, &workset, DECNEG, &ignore); // a = a - 1 ulp
-      // assign to approx [round to length]
-      decAddOp(a, &dzero, a, &approxset, 0, &ignore);
-      }
-     else {
-      decNumberCopy(b, a);
-      decAddOp(b, b, t, &workset, 0, &ignore);    // b = a + 0.5 ulp
-      workset.round=DEC_ROUND_DOWN;
-      decMultiplyOp(b, b, b, &workset, &ignore);  // b = mulrd(b, b)
-      decCompareOp(b, b, f, &workset, COMPARE, &ignore);   // b ? f
-      if (decNumberIsNegative(b)) {               // b < f
-        t->exponent++;                            // make 1.0 ulp
-        t->lsu[0]=1;                              // ..
-        decAddOp(a, a, t, &workset, 0, &ignore);  // a = a + 1 ulp
-        // assign to approx [round to length]
-        decAddOp(a, &dzero, a, &approxset, 0, &ignore);
-        }
-      }
-    // [no errors are possible in the above, and rounding/inexact during
-    // estimation are irrelevant, so status was not accumulated]
-
-    // Here, 0.1 <= a < 1  [Hull]
-    a->exponent+=exp/2;                      // set correct exponent
-
-    // Process Subnormals
-    decFinalize(a, set, &residue, &status);
-
-    // count droppable zeros [after any subnormal rounding] by
-    // trimming a copy
-    decNumberCopy(b, a);
-    decTrim(b, 1, &dropped);                 // [drops trailing zeros]
-
-    // Finally set Inexact and Rounded.  The answer can only be exact if
-    // it is short enough so that squaring it could fit in set->digits,
-    // so this is the only (relatively rare) time a careful check is
-    // needed
-    if (b->digits*2-1 > set->digits) {       // cannot fit
-      status|=DEC_Inexact|DEC_Rounded;
-      }
-     else {                                  // could be exact/unrounded
-      uInt mstatus=0;                        // local status
-      decMultiplyOp(b, b, b, &workset, &mstatus); // try the multiply
-      if (mstatus!=0) {                      // result won't fit
-        status|=DEC_Inexact|DEC_Rounded;
-        }
-       else {                                // plausible
-        decCompareOp(t, b, rhs, &workset, COMPARE, &mstatus); // b ? rhs
-        if (!ISZERO(t)) {
-          status|=DEC_Inexact|DEC_Rounded;
-          }
-         else {                              // is Exact
-          Int todrop;                        // work
-          // here, dropped is the count of trailing zeros in 'a'
-          // use closest exponent to ideal...
-          todrop=ideal-a->exponent;          // most that can be dropped
-          if (todrop<0) {                    // ideally would add 0s
-            status|=DEC_Rounded;
-            }
-           else {                            // unrounded
-            if (dropped<todrop) todrop=dropped; // clamp to those available
-            if (todrop>0) {                  // OK, some to drop
-              decShiftToLeast(a->lsu, D2U(a->digits), todrop);
-              a->exponent+=todrop;           // maintain numerical value
-              a->digits-=todrop;             // new length
-              }
-            }
-          }
-        }
-      }
-
-    // make sure there is a full complement of digits for normal
-    // inexact results
-    if ((status & (DEC_Inexact|DEC_Subnormal))==DEC_Inexact) {
-      Int shift=set->digits-a->digits;
-      if (shift>0) {
-        a->digits=decShiftToMost(a->lsu, a->digits, shift);
-        a->exponent-=shift;                  // adjust the exponent.
-        }
-      }
-    decNumberCopy(res, a);                   // a is now the result
-    } while(0);                              // end protected
-
-  if (allocbuff!=NULL) free(allocbuff);      // drop any storage used
-  if (allocbufa!=NULL) free(allocbufa);      // ..
-  if (allocbufb!=NULL) free(allocbufb);      // ..
-  #if DECSUBSET
-  if (allocrhs !=NULL) free(allocrhs);       // ..
-  #endif
-  if (status!=0) decStatus(res, status, set);// then report status
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberSquareRoot
-
-/* ------------------------------------------------------------------ */
-/* decNumberSubtract -- subtract two Numbers                          */
-/*                                                                    */
-/*   This computes C = A - B                                          */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X-X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberSubtract(decNumber *res, const decNumber *lhs,
-                              const decNumber *rhs, decContext *set) {
-  uInt status=0;                        // accumulator
-
-  decAddOp(res, lhs, rhs, set, DECNEG, &status);
-  if (status!=0) decStatus(res, status, set);
-  #if DECCHECK
-  decCheckInexact(res, set);
-  #endif
-  return res;
-  } // decNumberSubtract
-
-/* ------------------------------------------------------------------ */
-/* decNumberToIntegralValue -- round-to-integral-value                */
-/*                                                                    */
-/*   res is the result                                                */
-/*   rhs is input number                                              */
-/*   set is the context                                               */
-/*                                                                    */
-/* res must have space for any value of rhs.                          */
-/*                                                                    */
-/* This implements the IEEE special operator and therefore treats     */
-/* special values as valid, and also never sets Inexact.  For finite  */
-/* numbers it returns rescale(rhs, 0) if rhs->exponent is <0.         */
-/* Otherwise the result is rhs (so no error is possible).             */
-/*                                                                    */
-/* The context is used for rounding mode and status after sNaN, but   */
-/* the digits setting is ignored.                                     */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberToIntegralValue(decNumber *res, const decNumber *rhs,
-                                     decContext *set) {
-  decNumber dn;
-  decContext workset;              // working context
-
-  #if DECCHECK
-  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
-  #endif
-
-  // handle infinities and NaNs
-  if (SPECIALARG) {
-    uInt status=0;
-    if (decNumberIsInfinite(rhs)) decNumberCopy(res, rhs); // an Infinity
-     else decNaNs(res, rhs, NULL, &status); // a NaN
-    if (status!=0) decStatus(res, status, set);
-    return res;
-    }
-
-  // have a finite number; no error possible (res must be big enough)
-  if (rhs->exponent>=0) return decNumberCopy(res, rhs);
-  // that was easy, but if negative exponent there is work to do...
-  workset=*set;                    // clone rounding, etc.
-  workset.digits=rhs->digits;      // no length rounding
-  workset.traps=0;                 // no traps
-  decNumberZero(&dn);              // make a number with exponent 0
-  return decNumberQuantize(res, rhs, &dn, &workset);
-  } // decNumberToIntegralValue
-
-/* ================================================================== */
-/* Utility routines                                                   */
-/* ================================================================== */
-
-/* ------------------------------------------------------------------ */
-/* decNumberCopy -- copy a number                                     */
-/*                                                                    */
-/*   dest is the target decNumber                                     */
-/*   src  is the source decNumber                                     */
-/*   returns dest                                                     */
-/*                                                                    */
-/* (dest==src is allowed and is a no-op)                              */
-/* All fields are updated as required.  This is a utility operation,  */
-/* so special values are unchanged and no error is possible.          */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberCopy(decNumber *dest, const decNumber *src) {
-
-  #if DECCHECK
-  if (src==NULL) return decNumberZero(dest);
-  #endif
-
-  if (dest==src) return dest;                // no copy required
-
-  // Use explicit assignments here as structure assignment could copy
-  // more than just the lsu (for small DECDPUN).  This would not affect
-  // the value of the results, but could disturb test harness spill
-  // checking.
-  dest->bits=src->bits;
-  dest->exponent=src->exponent;
-  dest->digits=src->digits;
-  dest->lsu[0]=src->lsu[0];
-  if (src->digits>DECDPUN) {                 // more Units to come
-    const Unit *smsup, *s;                   // work
-    Unit  *d;                                // ..
-    // memcpy for the remaining Units would be safe as they cannot
-    // overlap.  However, this explicit loop is faster in short cases.
-    d=dest->lsu+1;                           // -> first destination
-    smsup=src->lsu+D2U(src->digits);         // -> source msu+1
-    for (s=src->lsu+1; s<smsup; s++, d++) *d=*s;
-    }
-  return dest;
-  } // decNumberCopy
-
-/* ------------------------------------------------------------------ */
-/* decNumberTrim -- remove insignificant zeros                        */
-/*                                                                    */
-/*   dn is the number to trim                                         */
-/*   returns dn                                                       */
-/*                                                                    */
-/* All fields are updated as required.  This is a utility operation,  */
-/* so special values are unchanged and no error is possible.          */
-/* ------------------------------------------------------------------ */
-decNumber * decNumberTrim(decNumber *dn) {
-  Int  dropped;                    // work
-  return decTrim(dn, 0, &dropped);
-  } // decNumberTrim
-
-/* ------------------------------------------------------------------ */
-/* decNumberVersion -- return the name and version of this module     */
-/*                                                                    */
-/* No error is possible.                                              */
-/* ------------------------------------------------------------------ */
-const char * decNumberVersion(void) {
-  return DECVERSION;
-  } // decNumberVersion
-
-/* ------------------------------------------------------------------ */
-/* decNumberZero -- set a number to 0                                 */
-/*                                                                    */
-/*   dn is the number to set, with space for one digit                */
-/*   returns dn                                                       */
-/*                                                                    */
-/* No error is possible.                                              */
-/* ------------------------------------------------------------------ */
-// Memset is not used as it is much slower in some environments.
-decNumber * decNumberZero(decNumber *dn) {
-
-  #if DECCHECK
-  if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNUSED)) return dn;
-  #endif
-
-  dn->bits=0;
-  dn->exponent=0;
-  dn->digits=1;
-  dn->lsu[0]=0;
-  return dn;
-  } // decNumberZero
-
-/* ================================================================== */
-/* Local routines                                                     */
-/* ================================================================== */
-
-/* ------------------------------------------------------------------ */
-/* decToString -- lay out a number into a string                      */
-/*                                                                    */
-/*   dn     is the number to lay out                                  */
-/*   string is where to lay out the number                            */
-/*   eng    is 1 if Engineering, 0 if Scientific                      */
-/*                                                                    */
-/* string must be at least dn->digits+14 characters long              */
-/* No error is possible.                                              */
-/*                                                                    */
-/* Note that this routine can generate a -0 or 0.000.  These are      */
-/* never generated in subset to-number or arithmetic, but can occur   */
-/* in non-subset arithmetic (e.g., -1*0 or 1.234-1.234).              */
-/* ------------------------------------------------------------------ */
-// If DECCHECK is enabled the string "?" is returned if a number is
-// invalid.
-static void decToString(const decNumber *dn, char *string, Flag eng) {
-  Int exp=dn->exponent;       // local copy
-  Int e;                      // E-part value
-  Int pre;                    // digits before the '.'
-  Int cut;                    // for counting digits in a Unit
-  char *c=string;             // work [output pointer]
-  const Unit *up=dn->lsu+D2U(dn->digits)-1; // -> msu [input pointer]
-  uInt u, pow;                // work
-
-  #if DECCHECK
-  if (decCheckOperands(DECUNUSED, dn, DECUNUSED, DECUNUSED)) {
-    strcpy(string, "?");
-    return;}
-  #endif
-
-  if (decNumberIsNegative(dn)) {   // Negatives get a minus
-    *c='-';
-    c++;
-    }
-  if (dn->bits&DECSPECIAL) {       // Is a special value
-    if (decNumberIsInfinite(dn)) {
-      strcpy(c, "Infinity");
-      return;}
-    // a NaN
-    if (dn->bits&DECSNAN) {        // signalling NaN
-      *c='s';
-      c++;
-      }
-    strcpy(c, "NaN");
-    c+=3;                          // step past
-    // if not a clean non-zero coefficient, that's all there is in a
-    // NaN string
-    if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return;
-    // [drop through to add integer]
-    }
-
-  // calculate how many digits in msu, and hence first cut
-  cut=MSUDIGITS(dn->digits);       // [faster than remainder]
-  cut--;                           // power of ten for digit
-
-  if (exp==0) {                    // simple integer [common fastpath]
-    for (;up>=dn->lsu; up--) {     // each Unit from msu
-      u=*up;                       // contains DECDPUN digits to lay out
-      for (; cut>=0; c++, cut--) TODIGIT(u, cut, c, pow);
-      cut=DECDPUN-1;               // next Unit has all digits
-      }
-    *c='\0';                       // terminate the string
-    return;}
-
-  /* non-0 exponent -- assume plain form */
-  pre=dn->digits+exp;              // digits before '.'
-  e=0;                             // no E
-  if ((exp>0) || (pre<-5)) {       // need exponential form
-    e=exp+dn->digits-1;            // calculate E value
-    pre=1;                         // assume one digit before '.'
-    if (eng && (e!=0)) {           // engineering: may need to adjust
-      Int adj;                     // adjustment
-      // The C remainder operator is undefined for negative numbers, so
-      // a positive remainder calculation must be used here
-      if (e<0) {
-        adj=(-e)%3;
-        if (adj!=0) adj=3-adj;
-        }
-       else { // e>0
-        adj=e%3;
-        }
-      e=e-adj;
-      // if dealing with zero still produce an exponent which is a
-      // multiple of three, as expected, but there will only be the
-      // one zero before the E, still.  Otherwise note the padding.
-      if (!ISZERO(dn)) pre+=adj;
-       else {  // is zero
-        if (adj!=0) {              // 0.00Esnn needed
-          e=e+3;
-          pre=-(2-adj);
-          }
-        } // zero
-      } // eng
-    } // need exponent
-
-  /* lay out the digits of the coefficient, adding 0s and . as needed */
-  u=*up;
-  if (pre>0) {                     // xxx.xxx or xx00 (engineering) form
-    Int n=pre;
-    for (; pre>0; pre--, c++, cut--) {
-      if (cut<0) {                 // need new Unit
-        if (up==dn->lsu) break;    // out of input digits (pre>digits)
-        up--;
-        cut=DECDPUN-1;
-        u=*up;
-        }
-      TODIGIT(u, cut, c, pow);
-      }
-    if (n<dn->digits) {            // more to come, after '.'
-      *c='.'; c++;
-      for (;; c++, cut--) {
-        if (cut<0) {               // need new Unit
-          if (up==dn->lsu) break;  // out of input digits
-          up--;
-          cut=DECDPUN-1;
-          u=*up;
-          }
-        TODIGIT(u, cut, c, pow);
-        }
-      }
-     else for (; pre>0; pre--, c++) *c='0'; // 0 padding (for engineering) needed
-    }
-   else {                          // 0.xxx or 0.000xxx form
-    *c='0'; c++;
-    *c='.'; c++;
-    for (; pre<0; pre++, c++) *c='0';   // add any 0's after '.'
-    for (; ; c++, cut--) {
-      if (cut<0) {                 // need new Unit
-        if (up==dn->lsu) break;    // out of input digits
-        up--;
-        cut=DECDPUN-1;
-        u=*up;
-        }
-      TODIGIT(u, cut, c, pow);
-      }
-    }
-
-  /* Finally add the E-part, if needed.  It will never be 0, has a
-     base maximum and minimum of +999999999 through -999999999, but
-     could range down to -1999999998 for anormal numbers */
-  if (e!=0) {
-    Flag had=0;               // 1=had non-zero
-    *c='E'; c++;
-    *c='+'; c++;              // assume positive
-    u=e;                      // ..
-    if (e<0) {
-      *(c-1)='-';             // oops, need -
-      u=-e;                   // uInt, please
-      }
-    // layout the exponent [_itoa or equivalent is not ANSI C]
-    for (cut=9; cut>=0; cut--) {
-      TODIGIT(u, cut, c, pow);
-      if (*c=='0' && !had) continue;    // skip leading zeros
-      had=1;                            // had non-0
-      c++;                              // step for next
-      } // cut
-    }
-  *c='\0';          // terminate the string (all paths)
-  return;
-  } // decToString
-
-/* ------------------------------------------------------------------ */
-/* decAddOp -- add/subtract operation                                 */
-/*                                                                    */
-/*   This computes C = A + B                                          */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X+X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*   negate is DECNEG if rhs should be negated, or 0 otherwise        */
-/*   status accumulates status for the caller                         */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/* ------------------------------------------------------------------ */
-/* If possible, the coefficient is calculated directly into C.        */
-/* However, if:                                                       */
-/*   -- a digits+1 calculation is needed because the numbers are      */
-/*      unaligned and span more than set->digits digits               */
-/*   -- a carry to digits+1 digits looks possible                     */
-/*   -- C is the same as A or B, and the result would destructively   */
-/*      overlap the A or B coefficient                                */
-/* then the result must be calculated into a temporary buffer.  In    */
-/* this case a local (stack) buffer is used if possible, and only if  */
-/* too long for that does malloc become the last resort.              */
-/*                                                                    */
-/* Misalignment is handled as follows:                                */
-/*   Apad: (AExp>BExp) Swap operands and proceed as for BExp>AExp.    */
-/*   BPad: Apply the padding by a combination of shifting (whole      */
-/*         units) and multiplication (part units).                    */
-/*                                                                    */
-/* Addition, especially x=x+1, is speed-critical.                     */
-/* ------------------------------------------------------------------ */
-static decNumber * decAddOp(decNumber *res, const decNumber *lhs,
-                            const decNumber *rhs, decContext *set,
-                            uByte negate, uInt *status) {
-  #if DECSUBSET
-  decNumber *alloclhs=NULL;        // non-NULL if rounded lhs allocated
-  decNumber *allocrhs=NULL;        // .., rhs
-  #endif
-  Int   rhsshift;                  // working shift (in Units)
-  Int   maxdigits;                 // longest logical length
-  Int   mult;                      // multiplier
-  Int   residue;                   // rounding accumulator
-  uByte bits;                      // result bits
-  Flag  diffsign;                  // non-0 if arguments have different sign
-  Unit  *acc;                      // accumulator for result
-  Unit  accbuff[SD2U(DECBUFFER+20)]; // local buffer [+20 reduces many
-                                   // allocations when called from
-                                   // other operations]
-  Unit  *allocacc=NULL;            // -> allocated acc buffer, iff allocated
-  Int   reqdigits=set->digits;     // local copy; requested DIGITS
-  Int   padding;                   // work
-
-  #if DECCHECK
-  if (decCheckOperands(res, lhs, rhs, set)) return res;
-  #endif
-
-  do {                             // protect allocated storage
-    #if DECSUBSET
-    if (!set->extended) {
-      // reduce operands and set lostDigits status, as needed
-      if (lhs->digits>reqdigits) {
-        alloclhs=decRoundOperand(lhs, set, status);
-        if (alloclhs==NULL) break;
-        lhs=alloclhs;
-        }
-      if (rhs->digits>reqdigits) {
-        allocrhs=decRoundOperand(rhs, set, status);
-        if (allocrhs==NULL) break;
-        rhs=allocrhs;
-        }
-      }
-    #endif
-    // [following code does not require input rounding]
-
-    // note whether signs differ [used all paths]
-    diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG);
-
-    // handle infinities and NaNs
-    if (SPECIALARGS) {                  // a special bit set
-      if (SPECIALARGS & (DECSNAN | DECNAN))  // a NaN
-        decNaNs(res, lhs, rhs, status);
-       else { // one or two infinities
-        if (decNumberIsInfinite(lhs)) { // LHS is infinity
-          // two infinities with different signs is invalid
-          if (decNumberIsInfinite(rhs) && diffsign) {
-            *status|=DEC_Invalid_operation;
-            break;
-            }
-          bits=lhs->bits & DECNEG;      // get sign from LHS
-          }
-         else bits=(rhs->bits^negate) & DECNEG;// RHS must be Infinity
-        bits|=DECINF;
-        decNumberZero(res);
-        res->bits=bits;                 // set +/- infinity
-        } // an infinity
-      break;
-      }
-
-    // Quick exit for add 0s; return the non-0, modified as need be
-    if (ISZERO(lhs)) {
-      Int adjust;                       // work
-      Int lexp=lhs->exponent;           // save in case LHS==RES
-      bits=lhs->bits;                   // ..
-      residue=0;                        // clear accumulator
-      decCopyFit(res, rhs, set, &residue, status); // copy (as needed)
-      res->bits^=negate;                // flip if rhs was negated
-      #if DECSUBSET
-      if (set->extended) {              // exponents on zeros count
-      #endif
-        // exponent will be the lower of the two
-        adjust=lexp-res->exponent;      // adjustment needed [if -ve]
-        if (ISZERO(res)) {              // both 0: special IEEE 854 rules
-          if (adjust<0) res->exponent=lexp;  // set exponent
-          // 0-0 gives +0 unless rounding to -infinity, and -0-0 gives -0
-          if (diffsign) {
-            if (set->round!=DEC_ROUND_FLOOR) res->bits=0;
-             else res->bits=DECNEG;     // preserve 0 sign
-            }
-          }
-         else { // non-0 res
-          if (adjust<0) {     // 0-padding needed
-            if ((res->digits-adjust)>set->digits) {
-              adjust=res->digits-set->digits;     // to fit exactly
-              *status|=DEC_Rounded;               // [but exact]
-              }
-            res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
-            res->exponent+=adjust;                // set the exponent.
-            }
-          } // non-0 res
-      #if DECSUBSET
-        } // extended
-      #endif
-      decFinish(res, set, &residue, status);      // clean and finalize
-      break;}
-
-    if (ISZERO(rhs)) {                  // [lhs is non-zero]
-      Int adjust;                       // work
-      Int rexp=rhs->exponent;           // save in case RHS==RES
-      bits=rhs->bits;                   // be clean
-      residue=0;                        // clear accumulator
-      decCopyFit(res, lhs, set, &residue, status); // copy (as needed)
-      #if DECSUBSET
-      if (set->extended) {              // exponents on zeros count
-      #endif
-        // exponent will be the lower of the two
-        // [0-0 case handled above]
-        adjust=rexp-res->exponent;      // adjustment needed [if -ve]
-        if (adjust<0) {     // 0-padding needed
-          if ((res->digits-adjust)>set->digits) {
-            adjust=res->digits-set->digits;     // to fit exactly
-            *status|=DEC_Rounded;               // [but exact]
-            }
-          res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
-          res->exponent+=adjust;                // set the exponent.
-          }
-      #if DECSUBSET
-        } // extended
-      #endif
-      decFinish(res, set, &residue, status);      // clean and finalize
-      break;}
-    // [NB: both fastpath and mainpath code below assume these cases
-    // (notably 0-0) have already been handled]
-
-    // calculate the padding needed to align the operands
-    padding=rhs->exponent-lhs->exponent;
-
-    // Fastpath cases where the numbers are aligned and normal, the RHS
-    // is all in one unit, no operand rounding is needed, and no carry,
-    // lengthening, or borrow is needed
-    if (padding==0
-        && rhs->digits<=DECDPUN
-        && rhs->exponent>=set->emin     // [some normals drop through]
-        && rhs->digits<=reqdigits
-        && lhs->digits<=reqdigits) {
-      Int partial=*lhs->lsu;
-      if (!diffsign) {                  // adding
-        partial+=*rhs->lsu;
-        if ((partial<=DECDPUNMAX)       // result fits in unit
-         && (lhs->digits>=DECDPUN ||    // .. and no digits-count change
-             partial<(Int)powers[lhs->digits])) { // ..
-          if (res!=lhs) decNumberCopy(res, lhs);  // not in place
-          *res->lsu=(Unit)partial;      // [copy could have overwritten RHS]
-          break;
-          }
-        // else drop out for careful add
-        }
-       else {                           // signs differ
-        partial-=*rhs->lsu;
-        if (partial>0) { // no borrow needed, and non-0 result
-          if (res!=lhs) decNumberCopy(res, lhs);  // not in place
-          *res->lsu=(Unit)partial;
-          // this could have reduced digits [but result>0]
-          res->digits=decGetDigits(res->lsu, D2U(res->digits));
-          break;
-          }
-        // else drop out for careful subtract
-        }
-      }
-
-    // Now align (pad) the lhs or rhs so they can be added or
-    // subtracted, as necessary.  If one number is much larger than
-    // the other (that is, if in plain form there is a least one
-    // digit between the lowest digit of one and the highest of the
-    // other) padding with up to DIGITS-1 trailing zeros may be
-    // needed; then apply rounding (as exotic rounding modes may be
-    // affected by the residue).
-    rhsshift=0;               // rhs shift to left (padding) in Units
-    bits=lhs->bits;           // assume sign is that of LHS
-    mult=1;                   // likely multiplier
-
-    // if padding==0 the operands are aligned; no padding needed
-    if (padding!=0) {
-      // some padding needed; always pad the RHS, as any required
-      // padding can then be effected by a simple combination of
-      // shifts and a multiply
-      Flag swapped=0;
-      if (padding<0) {                  // LHS needs the padding
-        const decNumber *t;
-        padding=-padding;               // will be +ve
-        bits=(uByte)(rhs->bits^negate); // assumed sign is now that of RHS
-        t=lhs; lhs=rhs; rhs=t;
-        swapped=1;
-        }
-
-      // If, after pad, rhs would be longer than lhs by digits+1 or
-      // more then lhs cannot affect the answer, except as a residue,
-      // so only need to pad up to a length of DIGITS+1.
-      if (rhs->digits+padding > lhs->digits+reqdigits+1) {
-        // The RHS is sufficient
-        // for residue use the relative sign indication...
-        Int shift=reqdigits-rhs->digits;     // left shift needed
-        residue=1;                           // residue for rounding
-        if (diffsign) residue=-residue;      // signs differ
-        // copy, shortening if necessary
-        decCopyFit(res, rhs, set, &residue, status);
-        // if it was already shorter, then need to pad with zeros
-        if (shift>0) {
-          res->digits=decShiftToMost(res->lsu, res->digits, shift);
-          res->exponent-=shift;              // adjust the exponent.
-          }
-        // flip the result sign if unswapped and rhs was negated
-        if (!swapped) res->bits^=negate;
-        decFinish(res, set, &residue, status);    // done
-        break;}
-
-      // LHS digits may affect result
-      rhsshift=D2U(padding+1)-1;        // this much by Unit shift ..
-      mult=powers[padding-(rhsshift*DECDPUN)]; // .. this by multiplication
-      } // padding needed
-
-    if (diffsign) mult=-mult;           // signs differ
-
-    // determine the longer operand
-    maxdigits=rhs->digits+padding;      // virtual length of RHS
-    if (lhs->digits>maxdigits) maxdigits=lhs->digits;
-
-    // Decide on the result buffer to use; if possible place directly
-    // into result.
-    acc=res->lsu;                       // assume add direct to result
-    // If destructive overlap, or the number is too long, or a carry or
-    // borrow to DIGITS+1 might be possible, a buffer must be used.
-    // [Might be worth more sophisticated tests when maxdigits==reqdigits]
-    if ((maxdigits>=reqdigits)          // is, or could be, too large
-     || (res==rhs && rhsshift>0)) {     // destructive overlap
-      // buffer needed, choose it; units for maxdigits digits will be
-      // needed, +1 Unit for carry or borrow
-      Int need=D2U(maxdigits)+1;
-      acc=accbuff;                      // assume use local buffer
-      if (need*sizeof(Unit)>sizeof(accbuff)) {
-        allocacc=(Unit *)malloc(need*sizeof(Unit));
-        if (allocacc==NULL) {           // hopeless -- abandon
-          *status|=DEC_Insufficient_storage;
-          break;}
-        acc=allocacc;
-        }
-      }
-
-    res->bits=(uByte)(bits&DECNEG);     // it's now safe to overwrite..
-    res->exponent=lhs->exponent;        // .. operands (even if aliased)
-
-    #if DECTRACE
-      decDumpAr('A', lhs->lsu, D2U(lhs->digits));
-      decDumpAr('B', rhs->lsu, D2U(rhs->digits));
-      printf("  :h: %d %d\n", rhsshift, mult);
-    #endif
-
-    // add [A+B*m] or subtract [A+B*(-m)]
-    res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits),
-                              rhs->lsu, D2U(rhs->digits),
-                              rhsshift, acc, mult)
-               *DECDPUN;           // [units -> digits]
-    if (res->digits<0) {           // borrowed...
-      res->digits=-res->digits;
-      res->bits^=DECNEG;           // flip the sign
-      }
-    #if DECTRACE
-      decDumpAr('+', acc, D2U(res->digits));
-    #endif
-
-    // If a buffer was used the result must be copied back, possibly
-    // shortening.  (If no buffer was used then the result must have
-    // fit, so can't need rounding and residue must be 0.)
-    residue=0;                     // clear accumulator
-    if (acc!=res->lsu) {
-      #if DECSUBSET
-      if (set->extended) {         // round from first significant digit
-      #endif
-        // remove leading zeros that were added due to rounding up to
-        // integral Units -- before the test for rounding.
-        if (res->digits>reqdigits)
-          res->digits=decGetDigits(acc, D2U(res->digits));
-        decSetCoeff(res, set, acc, res->digits, &residue, status);
-      #if DECSUBSET
-        }
-       else { // subset arithmetic rounds from original significant digit
-        // May have an underestimate.  This only occurs when both
-        // numbers fit in DECDPUN digits and are padding with a
-        // negative multiple (-10, -100...) and the top digit(s) become
-        // 0.  (This only matters when using X3.274 rules where the
-        // leading zero could be included in the rounding.)
-        if (res->digits<maxdigits) {
-          *(acc+D2U(res->digits))=0; // ensure leading 0 is there
-          res->digits=maxdigits;
-          }
-         else {
-          // remove leading zeros that added due to rounding up to
-          // integral Units (but only those in excess of the original
-          // maxdigits length, unless extended) before test for rounding.
-          if (res->digits>reqdigits) {
-            res->digits=decGetDigits(acc, D2U(res->digits));
-            if (res->digits<maxdigits) res->digits=maxdigits;
-            }
-          }
-        decSetCoeff(res, set, acc, res->digits, &residue, status);
-        // Now apply rounding if needed before removing leading zeros.
-        // This is safe because subnormals are not a possibility
-        if (residue!=0) {
-          decApplyRound(res, set, residue, status);
-          residue=0;                 // did what needed to be done
-          }
-        } // subset
-      #endif
-      } // used buffer
-
-    // strip leading zeros [these were left on in case of subset subtract]
-    res->digits=decGetDigits(res->lsu, D2U(res->digits));
-
-    // apply checks and rounding
-    decFinish(res, set, &residue, status);
-
-    // "When the sum of two operands with opposite signs is exactly
-    // zero, the sign of that sum shall be '+' in all rounding modes
-    // except round toward -Infinity, in which mode that sign shall be
-    // '-'."  [Subset zeros also never have '-', set by decFinish.]
-    if (ISZERO(res)
-     && diffsign
-     #if DECSUBSET
-     && set->extended
-     #endif
-     && (*status&DEC_Inexact)==0) {
-      if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG;   // sign -
-                                  else res->bits&=~DECNEG;  // sign +
-      }
-    } while(0);                              // end protected
-
-  if (allocacc!=NULL) free(allocacc);        // drop any storage used
-  #if DECSUBSET
-  if (allocrhs!=NULL) free(allocrhs);        // ..
-  if (alloclhs!=NULL) free(alloclhs);        // ..
-  #endif
-  return res;
-  } // decAddOp
-
-/* ------------------------------------------------------------------ */
-/* decDivideOp -- division operation                                  */
-/*                                                                    */
-/*  This routine performs the calculations for all four division      */
-/*  operators (divide, divideInteger, remainder, remainderNear).      */
-/*                                                                    */
-/*  C=A op B                                                          */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X/X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*   op  is DIVIDE, DIVIDEINT, REMAINDER, or REMNEAR respectively.    */
-/*   status is the usual accumulator                                  */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/*                                                                    */
-/* ------------------------------------------------------------------ */
-/*   The underlying algorithm of this routine is the same as in the   */
-/*   1981 S/370 implementation, that is, non-restoring long division  */
-/*   with bi-unit (rather than bi-digit) estimation for each unit     */
-/*   multiplier.  In this pseudocode overview, complications for the  */
-/*   Remainder operators and division residues for exact rounding are */
-/*   omitted for clarity.                                             */
-/*                                                                    */
-/*     Prepare operands and handle special values                     */
-/*     Test for x/0 and then 0/x                                      */
-/*     Exp =Exp1 - Exp2                                               */
-/*     Exp =Exp +len(var1) -len(var2)                                 */
-/*     Sign=Sign1 * Sign2                                             */
-/*     Pad accumulator (Var1) to double-length with 0's (pad1)        */
-/*     Pad Var2 to same length as Var1                                */
-/*     msu2pair/plus=1st 2 or 1 units of var2, +1 to allow for round  */
-/*     have=0                                                         */
-/*     Do until (have=digits+1 OR residue=0)                          */
-/*       if exp<0 then if integer divide/residue then leave           */
-/*       this_unit=0                                                  */
-/*       Do forever                                                   */
-/*          compare numbers                                           */
-/*          if <0 then leave inner_loop                               */
-/*          if =0 then (* quick exit without subtract *) do           */
-/*             this_unit=this_unit+1; output this_unit                */
-/*             leave outer_loop; end                                  */
-/*          Compare lengths of numbers (mantissae):                   */
-/*          If same then tops2=msu2pair -- {units 1&2 of var2}        */
-/*                  else tops2=msu2plus -- {0, unit 1 of var2}        */
-/*          tops1=first_unit_of_Var1*10**DECDPUN +second_unit_of_var1 */
-/*          mult=tops1/tops2  -- Good and safe guess at divisor       */
-/*          if mult=0 then mult=1                                     */
-/*          this_unit=this_unit+mult                                  */
-/*          subtract                                                  */
-/*          end inner_loop                                            */
-/*        if have\=0 | this_unit\=0 then do                           */
-/*          output this_unit                                          */
-/*          have=have+1; end                                          */
-/*        var2=var2/10                                                */
-/*        exp=exp-1                                                   */
-/*        end outer_loop                                              */
-/*     exp=exp+1   -- set the proper exponent                         */
-/*     if have=0 then generate answer=0                               */
-/*     Return (Result is defined by Var1)                             */
-/*                                                                    */
-/* ------------------------------------------------------------------ */
-/* Two working buffers are needed during the division; one (digits+   */
-/* 1) to accumulate the result, and the other (up to 2*digits+1) for  */
-/* long subtractions.  These are acc and var1 respectively.           */
-/* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/
-/* ------------------------------------------------------------------ */
-static decNumber * decDivideOp(decNumber *res,
-                               const decNumber *lhs, const decNumber *rhs,
-                               decContext *set, Flag op, uInt *status) {
-  #if DECSUBSET
-  decNumber *alloclhs=NULL;        // non-NULL if rounded lhs allocated
-  decNumber *allocrhs=NULL;        // .., rhs
-  #endif
-  Unit  accbuff[SD2U(DECBUFFER+DECDPUN)]; // local buffer
-  Unit  *acc=accbuff;              // -> accumulator array for result
-  Unit  *allocacc=NULL;            // -> allocated buffer, iff allocated
-  Unit  *accnext;                  // -> where next digit will go
-  Int   acclength;                 // length of acc needed [Units]
-  Int   accunits;                  // count of units accumulated
-  Int   accdigits;                 // count of digits accumulated
-
-  Unit  varbuff[SD2U(DECBUFFER*2+DECDPUN)*sizeof(Unit)]; // buffer for var1
-  Unit  *var1=varbuff;             // -> var1 array for long subtraction
-  Unit  *varalloc=NULL;            // -> allocated buffer, iff used
-  Unit  *msu1;                     // -> msu of var1
-
-  const Unit *var2;                // -> var2 array
-  const Unit *msu2;                // -> msu of var2
-  Int   msu2plus;                  // msu2 plus one [does not vary]
-  eInt  msu2pair;                  // msu2 pair plus one [does not vary]
-
-  Int   var1units, var2units;      // actual lengths
-  Int   var2ulen;                  // logical length (units)
-  Int   var1initpad=0;             // var1 initial padding (digits)
-  Int   maxdigits;                 // longest LHS or required acc length
-  Int   mult;                      // multiplier for subtraction
-  Unit  thisunit;                  // current unit being accumulated
-  Int   residue;                   // for rounding
-  Int   reqdigits=set->digits;     // requested DIGITS
-  Int   exponent;                  // working exponent
-  Int   maxexponent=0;             // DIVIDE maximum exponent if unrounded
-  uByte bits;                      // working sign
-  Unit  *target;                   // work
-  const Unit *source;              // ..
-  uInt  const *pow;                // ..
-  Int   shift, cut;                // ..
-  #if DECSUBSET
-  Int   dropped;                   // work
-  #endif
-
-  #if DECCHECK
-  if (decCheckOperands(res, lhs, rhs, set)) return res;
-  #endif
-
-  do {                             // protect allocated storage
-    #if DECSUBSET
-    if (!set->extended) {
-      // reduce operands and set lostDigits status, as needed
-      if (lhs->digits>reqdigits) {
-        alloclhs=decRoundOperand(lhs, set, status);
-        if (alloclhs==NULL) break;
-        lhs=alloclhs;
-        }
-      if (rhs->digits>reqdigits) {
-        allocrhs=decRoundOperand(rhs, set, status);
-        if (allocrhs==NULL) break;
-        rhs=allocrhs;
-        }
-      }
-    #endif
-    // [following code does not require input rounding]
-
-    bits=(lhs->bits^rhs->bits)&DECNEG;  // assumed sign for divisions
-
-    // handle infinities and NaNs
-    if (SPECIALARGS) {                  // a special bit set
-      if (SPECIALARGS & (DECSNAN | DECNAN)) { // one or two NaNs
-        decNaNs(res, lhs, rhs, status);
-        break;
-        }
-      // one or two infinities
-      if (decNumberIsInfinite(lhs)) {   // LHS (dividend) is infinite
-        if (decNumberIsInfinite(rhs) || // two infinities are invalid ..
-            op & (REMAINDER | REMNEAR)) { // as is remainder of infinity
-          *status|=DEC_Invalid_operation;
-          break;
-          }
-        // [Note that infinity/0 raises no exceptions]
-        decNumberZero(res);
-        res->bits=bits|DECINF;          // set +/- infinity
-        break;
-        }
-       else {                           // RHS (divisor) is infinite
-        residue=0;
-        if (op&(REMAINDER|REMNEAR)) {
-          // result is [finished clone of] lhs
-          decCopyFit(res, lhs, set, &residue, status);
-          }
-         else {  // a division
-          decNumberZero(res);
-          res->bits=bits;               // set +/- zero
-          // for DIVIDEINT the exponent is always 0.  For DIVIDE, result
-          // is a 0 with infinitely negative exponent, clamped to minimum
-          if (op&DIVIDE) {
-            res->exponent=set->emin-set->digits+1;
-            *status|=DEC_Clamped;
-            }
-          }
-        decFinish(res, set, &residue, status);
-        break;
-        }
-      }
-
-    // handle 0 rhs (x/0)
-    if (ISZERO(rhs)) {                  // x/0 is always exceptional
-      if (ISZERO(lhs)) {
-        decNumberZero(res);             // [after lhs test]
-        *status|=DEC_Division_undefined;// 0/0 will become NaN
-        }
-       else {
-        decNumberZero(res);
-        if (op&(REMAINDER|REMNEAR)) *status|=DEC_Invalid_operation;
-         else {
-          *status|=DEC_Division_by_zero; // x/0
-          res->bits=bits|DECINF;         // .. is +/- Infinity
-          }
-        }
-      break;}
-
-    // handle 0 lhs (0/x)
-    if (ISZERO(lhs)) {                  // 0/x [x!=0]
-      #if DECSUBSET
-      if (!set->extended) decNumberZero(res);
-       else {
-      #endif
-        if (op&DIVIDE) {
-          residue=0;
-          exponent=lhs->exponent-rhs->exponent; // ideal exponent
-          decNumberCopy(res, lhs);      // [zeros always fit]
-          res->bits=bits;               // sign as computed
-          res->exponent=exponent;       // exponent, too
-          decFinalize(res, set, &residue, status);   // check exponent
-          }
-         else if (op&DIVIDEINT) {
-          decNumberZero(res);           // integer 0
-          res->bits=bits;               // sign as computed
-          }
-         else {                         // a remainder
-          exponent=rhs->exponent;       // [save in case overwrite]
-          decNumberCopy(res, lhs);      // [zeros always fit]
-          if (exponent<res->exponent) res->exponent=exponent; // use lower
-          }
-      #if DECSUBSET
-        }
-      #endif
-      break;}
-
-    // Precalculate exponent.  This starts off adjusted (and hence fits
-    // in 31 bits) and becomes the usual unadjusted exponent as the
-    // division proceeds.  The order of evaluation is important, here,
-    // to avoid wrap.
-    exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits);
-
-    // If the working exponent is -ve, then some quick exits are
-    // possible because the quotient is known to be <1
-    // [for REMNEAR, it needs to be < -1, as -0.5 could need work]
-    if (exponent<0 && !(op==DIVIDE)) {
-      if (op&DIVIDEINT) {
-        decNumberZero(res);                  // integer part is 0
-        #if DECSUBSET
-        if (set->extended)
-        #endif
-          res->bits=bits;                    // set +/- zero
-        break;}
-      // fastpath remainders so long as the lhs has the smaller
-      // (or equal) exponent
-      if (lhs->exponent<=rhs->exponent) {
-        if (op&REMAINDER || exponent<-1) {
-          // It is REMAINDER or safe REMNEAR; result is [finished
-          // clone of] lhs  (r = x - 0*y)
-          residue=0;
-          decCopyFit(res, lhs, set, &residue, status);
-          decFinish(res, set, &residue, status);
-          break;
-          }
-        // [unsafe REMNEAR drops through]
-        }
-      } // fastpaths
-
-    /* Long (slow) division is needed; roll up the sleeves... */
-
-    // The accumulator will hold the quotient of the division.
-    // If it needs to be too long for stack storage, then allocate.
-    acclength=D2U(reqdigits+DECDPUN);   // in Units
-    if (acclength*sizeof(Unit)>sizeof(accbuff)) {
-      allocacc=(Unit *)malloc(acclength*sizeof(Unit));
-      if (allocacc==NULL) {             // hopeless -- abandon
-        *status|=DEC_Insufficient_storage;
-        break;}
-      acc=allocacc;                     // use the allocated space
-      }
-
-    // var1 is the padded LHS ready for subtractions.
-    // If it needs to be too long for stack storage, then allocate.
-    // The maximum units needed for var1 (long subtraction) is:
-    // Enough for
-    //     (rhs->digits+reqdigits-1) -- to allow full slide to right
-    // or  (lhs->digits)             -- to allow for long lhs
-    // whichever is larger
-    //   +1                -- for rounding of slide to right
-    //   +1                -- for leading 0s
-    //   +1                -- for pre-adjust if a remainder or DIVIDEINT
-    // [Note: unused units do not participate in decUnitAddSub data]
-    maxdigits=rhs->digits+reqdigits-1;
-    if (lhs->digits>maxdigits) maxdigits=lhs->digits;
-    var1units=D2U(maxdigits)+2;
-    // allocate a guard unit above msu1 for REMAINDERNEAR
-    if (!(op&DIVIDE)) var1units++;
-    if ((var1units+1)*sizeof(Unit)>sizeof(varbuff)) {
-      varalloc=(Unit *)malloc((var1units+1)*sizeof(Unit));
-      if (varalloc==NULL) {             // hopeless -- abandon
-        *status|=DEC_Insufficient_storage;
-        break;}
-      var1=varalloc;                    // use the allocated space
-      }
-
-    // Extend the lhs and rhs to full long subtraction length.  The lhs
-    // is truly extended into the var1 buffer, with 0 padding, so a
-    // subtract in place is always possible.  The rhs (var2) has
-    // virtual padding (implemented by decUnitAddSub).
-    // One guard unit was allocated above msu1 for rem=rem+rem in
-    // REMAINDERNEAR.
-    msu1=var1+var1units-1;              // msu of var1
-    source=lhs->lsu+D2U(lhs->digits)-1; // msu of input array
-    for (target=msu1; source>=lhs->lsu; source--, target--) *target=*source;
-    for (; target>=var1; target--) *target=0;
-
-    // rhs (var2) is left-aligned with var1 at the start
-    var2ulen=var1units;                 // rhs logical length (units)
-    var2units=D2U(rhs->digits);         // rhs actual length (units)
-    var2=rhs->lsu;                      // -> rhs array
-    msu2=var2+var2units-1;              // -> msu of var2 [never changes]
-    // now set up the variables which will be used for estimating the
-    // multiplication factor.  If these variables are not exact, add
-    // 1 to make sure that the multiplier is never overestimated.
-    msu2plus=*msu2;                     // it's value ..
-    if (var2units>1) msu2plus++;        // .. +1 if any more
-    msu2pair=(eInt)*msu2*(DECDPUNMAX+1);// top two pair ..
-    if (var2units>1) {                  // .. [else treat 2nd as 0]
-      msu2pair+=*(msu2-1);              // ..
-      if (var2units>2) msu2pair++;      // .. +1 if any more
-      }
-
-    // The calculation is working in units, which may have leading zeros,
-    // but the exponent was calculated on the assumption that they are
-    // both left-aligned.  Adjust the exponent to compensate: add the
-    // number of leading zeros in var1 msu and subtract those in var2 msu.
-    // [This is actually done by counting the digits and negating, as
-    // lead1=DECDPUN-digits1, and similarly for lead2.]
-    for (pow=&powers[1]; *msu1>=*pow; pow++) exponent--;
-    for (pow=&powers[1]; *msu2>=*pow; pow++) exponent++;
-
-    // Now, if doing an integer divide or remainder, ensure that
-    // the result will be Unit-aligned.  To do this, shift the var1
-    // accumulator towards least if need be.  (It's much easier to
-    // do this now than to reassemble the residue afterwards, if
-    // doing a remainder.)  Also ensure the exponent is not negative.
-    if (!(op&DIVIDE)) {
-      Unit *u;                          // work
-      // save the initial 'false' padding of var1, in digits
-      var1initpad=(var1units-D2U(lhs->digits))*DECDPUN;
-      // Determine the shift to do.
-      if (exponent<0) cut=-exponent;
-       else cut=DECDPUN-exponent%DECDPUN;
-      decShiftToLeast(var1, var1units, cut);
-      exponent+=cut;                    // maintain numerical value
-      var1initpad-=cut;                 // .. and reduce padding
-      // clean any most-significant units which were just emptied
-      for (u=msu1; cut>=DECDPUN; cut-=DECDPUN, u--) *u=0;
-      } // align
-     else { // is DIVIDE
-      maxexponent=lhs->exponent-rhs->exponent;    // save
-      // optimization: if the first iteration will just produce 0,
-      // preadjust to skip it [valid for DIVIDE only]
-      if (*msu1<*msu2) {
-        var2ulen--;                     // shift down
-        exponent-=DECDPUN;              // update the exponent
-        }
-      }
-
-    // ---- start the long-division loops ------------------------------
-    accunits=0;                         // no units accumulated yet
-    accdigits=0;                        // .. or digits
-    accnext=acc+acclength-1;            // -> msu of acc [NB: allows digits+1]
-    for (;;) {                          // outer forever loop
-      thisunit=0;                       // current unit assumed 0
-      // find the next unit
-      for (;;) {                        // inner forever loop
-        // strip leading zero units [from either pre-adjust or from
-        // subtract last time around].  Leave at least one unit.
-        for (; *msu1==0 && msu1>var1; msu1--) var1units--;
-
-        if (var1units<var2ulen) break;       // var1 too low for subtract
-        if (var1units==var2ulen) {           // unit-by-unit compare needed
-          // compare the two numbers, from msu
-          const Unit *pv1, *pv2;
-          Unit v2;                           // units to compare
-          pv2=msu2;                          // -> msu
-          for (pv1=msu1; ; pv1--, pv2--) {
-            // v1=*pv1 -- always OK
-            v2=0;                            // assume in padding
-            if (pv2>=var2) v2=*pv2;          // in range
-            if (*pv1!=v2) break;             // no longer the same
-            if (pv1==var1) break;            // done; leave pv1 as is
-            }
-          // here when all inspected or a difference seen
-          if (*pv1<v2) break;                // var1 too low to subtract
-          if (*pv1==v2) {                    // var1 == var2
-            // reach here if var1 and var2 are identical; subtraction
-            // would increase digit by one, and the residue will be 0 so
-            // the calculation is done; leave the loop with residue=0.
-            thisunit++;                      // as though subtracted
-            *var1=0;                         // set var1 to 0
-            var1units=1;                     // ..
-            break;  // from inner
-            } // var1 == var2
-          // *pv1>v2.  Prepare for real subtraction; the lengths are equal
-          // Estimate the multiplier (there's always a msu1-1)...
-          // Bring in two units of var2 to provide a good estimate.
-          mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2pair);
-          } // lengths the same
-         else { // var1units > var2ulen, so subtraction is safe
-          // The var2 msu is one unit towards the lsu of the var1 msu,
-          // so only one unit for var2 can be used.
-          mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2plus);
-          }
-        if (mult==0) mult=1;                 // must always be at least 1
-        // subtraction needed; var1 is > var2
-        thisunit=(Unit)(thisunit+mult);      // accumulate
-        // subtract var1-var2, into var1; only the overlap needs
-        // processing, as this is an in-place calculation
-        shift=var2ulen-var2units;
-        #if DECTRACE
-          decDumpAr('1', &var1[shift], var1units-shift);
-          decDumpAr('2', var2, var2units);
-          printf("m=%d\n", -mult);
-        #endif
-        decUnitAddSub(&var1[shift], var1units-shift,
-                      var2, var2units, 0,
-                      &var1[shift], -mult);
-        #if DECTRACE
-          decDumpAr('#', &var1[shift], var1units-shift);
-        #endif
-        // var1 now probably has leading zeros; these are removed at the
-        // top of the inner loop.
-        } // inner loop
-
-      // The next unit has been calculated in full; unless it's a
-      // leading zero, add to acc
-      if (accunits!=0 || thisunit!=0) {      // is first or non-zero
-        *accnext=thisunit;                   // store in accumulator
-        // account exactly for the new digits
-        if (accunits==0) {
-          accdigits++;                       // at least one
-          for (pow=&powers[1]; thisunit>=*pow; pow++) accdigits++;
-          }
-         else accdigits+=DECDPUN;
-        accunits++;                          // update count
-        accnext--;                           // ready for next
-        if (accdigits>reqdigits) break;      // have enough digits
-        }
-
-      // if the residue is zero, the operation is done (unless divide
-      // or divideInteger and still not enough digits yet)
-      if (*var1==0 && var1units==1) {        // residue is 0
-        if (op&(REMAINDER|REMNEAR)) break;
-        if ((op&DIVIDE) && (exponent<=maxexponent)) break;
-        // [drop through if divideInteger]
-        }
-      // also done enough if calculating remainder or integer
-      // divide and just did the last ('units') unit
-      if (exponent==0 && !(op&DIVIDE)) break;
-
-      // to get here, var1 is less than var2, so divide var2 by the per-
-      // Unit power of ten and go for the next digit
-      var2ulen--;                            // shift down
-      exponent-=DECDPUN;                     // update the exponent
-      } // outer loop
-
-    // ---- division is complete ---------------------------------------
-    // here: acc      has at least reqdigits+1 of good results (or fewer
-    //                if early stop), starting at accnext+1 (its lsu)
-    //       var1     has any residue at the stopping point
-    //       accunits is the number of digits collected in acc
-    if (accunits==0) {             // acc is 0
-      accunits=1;                  // show have a unit ..
-      accdigits=1;                 // ..
-      *accnext=0;                  // .. whose value is 0
-      }
-     else accnext++;               // back to last placed
-    // accnext now -> lowest unit of result
-
-    residue=0;                     // assume no residue
-    if (op&DIVIDE) {
-      // record the presence of any residue, for rounding
-      if (*var1!=0 || var1units>1) residue=1;
-       else { // no residue
-        // Had an exact division; clean up spurious trailing 0s.
-        // There will be at most DECDPUN-1, from the final multiply,
-        // and then only if the result is non-0 (and even) and the
-        // exponent is 'loose'.
-        #if DECDPUN>1
-        Unit lsu=*accnext;
-        if (!(lsu&0x01) && (lsu!=0)) {
-          // count the trailing zeros
-          Int drop=0;
-          for (;; drop++) {    // [will terminate because lsu!=0]
-            if (exponent>=maxexponent) break;     // don't chop real 0s
-            #if DECDPUN<=4
-              if ((lsu-QUOT10(lsu, drop+1)
-                  *powers[drop+1])!=0) break;     // found non-0 digit
-            #else
-              if (lsu%powers[drop+1]!=0) break;   // found non-0 digit
-            #endif
-            exponent++;
-            }
-          if (drop>0) {
-            accunits=decShiftToLeast(accnext, accunits, drop);
-            accdigits=decGetDigits(accnext, accunits);
-            accunits=D2U(accdigits);
-            // [exponent was adjusted in the loop]
-            }
-          } // neither odd nor 0
-        #endif
-        } // exact divide
-      } // divide
-     else /* op!=DIVIDE */ {
-      // check for coefficient overflow
-      if (accdigits+exponent>reqdigits) {
-        *status|=DEC_Division_impossible;
-        break;
-        }
-      if (op & (REMAINDER|REMNEAR)) {
-        // [Here, the exponent will be 0, because var1 was adjusted
-        // appropriately.]
-        Int postshift;                       // work
-        Flag wasodd=0;                       // integer was odd
-        Unit *quotlsu;                       // for save
-        Int  quotdigits;                     // ..
-
-        // Fastpath when residue is truly 0 is worthwhile [and
-        // simplifies the code below]
-        if (*var1==0 && var1units==1) {      // residue is 0
-          Int exp=lhs->exponent;             // save min(exponents)
-          if (rhs->exponent<exp) exp=rhs->exponent;
-          decNumberZero(res);                // 0 coefficient
-          #if DECSUBSET
-          if (set->extended)
-          #endif
-          res->exponent=exp;                 // .. with proper exponent
-          break;
-          }
-        // note if the quotient was odd
-        if (*accnext & 0x01) wasodd=1;       // acc is odd
-        quotlsu=accnext;                     // save in case need to reinspect
-        quotdigits=accdigits;                // ..
-
-        // treat the residue, in var1, as the value to return, via acc
-        // calculate the unused zero digits.  This is the smaller of:
-        //   var1 initial padding (saved above)
-        //   var2 residual padding, which happens to be given by:
-        postshift=var1initpad+exponent-lhs->exponent+rhs->exponent;
-        // [the 'exponent' term accounts for the shifts during divide]
-        if (var1initpad<postshift) postshift=var1initpad;
-
-        // shift var1 the requested amount, and adjust its digits
-        var1units=decShiftToLeast(var1, var1units, postshift);
-        accnext=var1;
-        accdigits=decGetDigits(var1, var1units);
-        accunits=D2U(accdigits);
-
-        exponent=lhs->exponent;         // exponent is smaller of lhs & rhs
-        if (rhs->exponent<exponent) exponent=rhs->exponent;
-        bits=lhs->bits;                 // remainder sign is always as lhs
-
-        // Now correct the result if doing remainderNear; if it
-        // (looking just at coefficients) is > rhs/2, or == rhs/2 and
-        // the integer was odd then the result should be rem-rhs.
-        if (op&REMNEAR) {
-          Int compare, tarunits;        // work
-          Unit *up;                     // ..
-
-
-          // calculate remainder*2 into the var1 buffer (which has
-          // 'headroom' of an extra unit and hence enough space)
-          // [a dedicated 'double' loop would be faster, here]
-          tarunits=decUnitAddSub(accnext, accunits, accnext, accunits,
-                                 0, accnext, 1);
-          // decDumpAr('r', accnext, tarunits);
-
-          // Here, accnext (var1) holds tarunits Units with twice the
-          // remainder's coefficient, which must now be compared to the
-          // RHS.  The remainder's exponent may be smaller than the RHS's.
-          compare=decUnitCompare(accnext, tarunits, rhs->lsu, D2U(rhs->digits),
-                                 rhs->exponent-exponent);
-          if (compare==BADINT) {             // deep trouble
-            *status|=DEC_Insufficient_storage;
-            break;}
-
-          // now restore the remainder by dividing by two; the lsu
-          // is known to be even.
-          for (up=accnext; up<accnext+tarunits; up++) {
-            Int half;              // half to add to lower unit
-            half=*up & 0x01;
-            *up/=2;                // [shift]
-            if (!half) continue;
-            *(up-1)+=(DECDPUNMAX+1)/2;
-            }
-          // [accunits still describes the original remainder length]
-
-          if (compare>0 || (compare==0 && wasodd)) { // adjustment needed
-            Int exp, expunits, exprem;       // work
-            // This is effectively causing round-up of the quotient,
-            // so if it was the rare case where it was full and all
-            // nines, it would overflow and hence division-impossible
-            // should be raised
-            Flag allnines=0;                 // 1 if quotient all nines
-            if (quotdigits==reqdigits) {     // could be borderline
-              for (up=quotlsu; ; up++) {
-                if (quotdigits>DECDPUN) {
-                  if (*up!=DECDPUNMAX) break;// non-nines
-                  }
-                 else {                      // this is the last Unit
-                  if (*up==powers[quotdigits]-1) allnines=1;
-                  break;
-                  }
-                quotdigits-=DECDPUN;         // checked those digits
-                } // up
-              } // borderline check
-            if (allnines) {
-              *status|=DEC_Division_impossible;
-              break;}
-
-            // rem-rhs is needed; the sign will invert.  Again, var1
-            // can safely be used for the working Units array.
-            exp=rhs->exponent-exponent;      // RHS padding needed
-            // Calculate units and remainder from exponent.
-            expunits=exp/DECDPUN;
-            exprem=exp%DECDPUN;
-            // subtract [A+B*(-m)]; the result will always be negative
-            accunits=-decUnitAddSub(accnext, accunits,
-                                    rhs->lsu, D2U(rhs->digits),
-                                    expunits, accnext, -(Int)powers[exprem]);
-            accdigits=decGetDigits(accnext, accunits); // count digits exactly
-            accunits=D2U(accdigits);    // and recalculate the units for copy
-            // [exponent is as for original remainder]
-            bits^=DECNEG;               // flip the sign
-            }
-          } // REMNEAR
-        } // REMAINDER or REMNEAR
-      } // not DIVIDE
-
-    // Set exponent and bits
-    res->exponent=exponent;
-    res->bits=(uByte)(bits&DECNEG);          // [cleaned]
-
-    // Now the coefficient.
-    decSetCoeff(res, set, accnext, accdigits, &residue, status);
-
-    decFinish(res, set, &residue, status);   // final cleanup
-
-    #if DECSUBSET
-    // If a divide then strip trailing zeros if subset [after round]
-    if (!set->extended && (op==DIVIDE)) decTrim(res, 0, &dropped);
-    #endif
-    } while(0);                              // end protected
-
-  if (varalloc!=NULL) free(varalloc);   // drop any storage used
-  if (allocacc!=NULL) free(allocacc);   // ..
-  #if DECSUBSET
-  if (allocrhs!=NULL) free(allocrhs);   // ..
-  if (alloclhs!=NULL) free(alloclhs);   // ..
-  #endif
-  return res;
-  } // decDivideOp
-
-/* ------------------------------------------------------------------ */
-/* decMultiplyOp -- multiplication operation                          */
-/*                                                                    */
-/*  This routine performs the multiplication C=A x B.                 */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X*X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*   status is the usual accumulator                                  */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/*                                                                    */
-/* ------------------------------------------------------------------ */
-/* 'Classic' multiplication is used rather than Karatsuba, as the     */
-/* latter would give only a minor improvement for the short numbers   */
-/* expected to be handled most (and uses much more memory).           */
-/*                                                                    */
-/* There are two major paths here: the general-purpose ('old code')   */
-/* path which handles all DECDPUN values, and a fastpath version      */
-/* which is used if 64-bit ints are available, DECDPUN<=4, and more   */
-/* than two calls to decUnitAddSub would be made.                     */
-/*                                                                    */
-/* The fastpath version lumps units together into 8-digit or 9-digit  */
-/* chunks, and also uses a lazy carry strategy to minimise expensive  */
-/* 64-bit divisions.  The chunks are then broken apart again into     */
-/* units for continuing processing.  Despite this overhead, the       */
-/* fastpath can speed up some 16-digit operations by 10x (and much    */
-/* more for higher-precision calculations).                           */
-/*                                                                    */
-/* A buffer always has to be used for the accumulator; in the         */
-/* fastpath, buffers are also always needed for the chunked copies of */
-/* of the operand coefficients.                                       */
-/* ------------------------------------------------------------------ */
-#define FASTMUL (DECUSE64 && DECDPUN<5)
-static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs,
-                                 const decNumber *rhs, decContext *set,
-                                 uInt *status) {
-  Int    accunits;                 // Units of accumulator in use
-  Int    exponent;                 // work
-  Int    residue=0;                // rounding residue
-  uByte  bits;                     // result sign
-  Unit  *acc;                      // -> accumulator Unit array
-  Int    needbytes;                // size calculator
-  void  *allocacc=NULL;            // -> allocated accumulator, iff allocated
-  Unit accbuff[SD2U(DECBUFFER*2+5)]; // buffer (+1 for DECBUFFER==0,
-                                   // + 4 for calls from other operations)
-  const Unit *mer, *mermsup;       // work
-  Int  madlength;                  // Units in multiplicand
-  Int  shift;                      // Units to shift multiplicand by
-
-  #if FASTMUL
-    // if DECDPUN is 1 or 3 work in base 10**9, otherwise
-    // (DECDPUN is 2 or 4) then work in base 10**8
-    #if DECDPUN & 1                // odd
-      #define FASTBASE 1000000000  // base
-      #define FASTDIGS          9  // digits in base
-      #define FASTLAZY         18  // carry resolution point [1->18]
-    #else
-      #define FASTBASE  100000000
-      #define FASTDIGS          8
-      #define FASTLAZY       1844  // carry resolution point [1->1844]
-    #endif
-    // three buffers are used, two for chunked copies of the operands
-    // (base 10**8 or base 10**9) and one base 2**64 accumulator with
-    // lazy carry evaluation
-    uInt   zlhibuff[(DECBUFFER+7)/8+1]; // buffer (+1 for DECBUFFER==0)
-    uInt  *zlhi=zlhibuff;               // -> lhs array
-    uInt  *alloclhi=NULL;               // -> allocated buffer, iff allocated
-    uInt   zrhibuff[(DECBUFFER+7)/8+1]; // buffer (+1 for DECBUFFER==0)
-    uInt  *zrhi=zrhibuff;               // -> rhs array
-    uInt  *allocrhi=NULL;               // -> allocated buffer, iff allocated
-    uLong  zaccbuff[(DECBUFFER+3)/4+2]; // buffer (+1 for DECBUFFER==0)
-                                        // + 1 for calls from other operations)
-    // [allocacc is shared for both paths, as only one will run]
-    uLong *zacc=zaccbuff;          // -> accumulator array for exact result
-    #if DECDPUN==1
-    Int    zoff;                   // accumulator offset
-    #endif
-    uInt  *lip, *rip;              // item pointers
-    uInt  *lmsi, *rmsi;            // most significant items
-    Int    ilhs, irhs, iacc;       // item counts in the arrays
-    Int    lazy;                   // lazy carry counter
-    uLong  lcarry;                 // uLong carry
-    uInt   carry;                  // carry (NB not uLong)
-    Int    count;                  // work
-    const  Unit *cup;              // ..
-    Unit  *up;                     // ..
-    uLong *lp;                     // ..
-    Int    p;                      // ..
-  #endif
-
-  #if DECSUBSET
-    decNumber *alloclhs=NULL;      // -> allocated buffer, iff allocated
-    decNumber *allocrhs=NULL;      // -> allocated buffer, iff allocated
-  #endif
-
-  #if DECCHECK
-  if (decCheckOperands(res, lhs, rhs, set)) return res;
-  #endif
-
-  // precalculate result sign
-  bits=(uByte)((lhs->bits^rhs->bits)&DECNEG);
-
-  // handle infinities and NaNs
-  if (SPECIALARGS) {               // a special bit set
-    if (SPECIALARGS & (DECSNAN | DECNAN)) { // one or two NaNs
-      decNaNs(res, lhs, rhs, status);
-      return res;}
-    // one or two infinities; Infinity * 0 is invalid
-    if (((lhs->bits & DECINF)==0 && ISZERO(lhs))
-      ||((rhs->bits & DECINF)==0 && ISZERO(rhs))) {
-      *status|=DEC_Invalid_operation;
-      return res;}
-    decNumberZero(res);
-    res->bits=bits|DECINF;         // infinity
-    return res;}
-
-  // For best speed, as in DMSRCN [the original Rexx numerics
-  // module], use the shorter number as the multiplier (rhs) and
-  // the longer as the multiplicand (lhs) to minimise the number of
-  // adds (partial products)
-  if (lhs->digits<rhs->digits) {   // swap...
-    const decNumber *hold=lhs;
-    lhs=rhs;
-    rhs=hold;
-    }
-
-  do {                             // protect allocated storage
-    #if DECSUBSET
-    if (!set->extended) {
-      // reduce operands and set lostDigits status, as needed
-      if (lhs->digits>set->digits) {
-        alloclhs=decRoundOperand(lhs, set, status);
-        if (alloclhs==NULL) break;
-        lhs=alloclhs;
-        }
-      if (rhs->digits>set->digits) {
-        allocrhs=decRoundOperand(rhs, set, status);
-        if (allocrhs==NULL) break;
-        rhs=allocrhs;
-        }
-      }
-    #endif
-    // [following code does not require input rounding]
-
-    #if FASTMUL                    // fastpath can be used
-    // use the fast path if there are enough digits in the shorter
-    // operand to make the setup and takedown worthwhile
-    #define NEEDTWO (DECDPUN*2)    // within two decUnitAddSub calls
-    if (rhs->digits>NEEDTWO) {     // use fastpath...
-      // calculate the number of elements in each array
-      ilhs=(lhs->digits+FASTDIGS-1)/FASTDIGS; // [ceiling]
-      irhs=(rhs->digits+FASTDIGS-1)/FASTDIGS; // ..
-      iacc=ilhs+irhs;
-
-      // allocate buffers if required, as usual
-      needbytes=ilhs*sizeof(uInt);
-      if (needbytes>(Int)sizeof(zlhibuff)) {
-        alloclhi=(uInt *)malloc(needbytes);
-        zlhi=alloclhi;}
-      needbytes=irhs*sizeof(uInt);
-      if (needbytes>(Int)sizeof(zrhibuff)) {
-        allocrhi=(uInt *)malloc(needbytes);
-        zrhi=allocrhi;}
-
-      // Allocating the accumulator space needs a special case when
-      // DECDPUN=1 because when converting the accumulator to Units
-      // after the multiplication each 8-byte item becomes 9 1-byte
-      // units.  Therefore iacc extra bytes are needed at the front
-      // (rounded up to a multiple of 8 bytes), and the uLong
-      // accumulator starts offset the appropriate number of units
-      // to the right to avoid overwrite during the unchunking.
-      needbytes=iacc*sizeof(uLong);
-      #if DECDPUN==1
-      zoff=(iacc+7)/8;        // items to offset by
-      needbytes+=zoff*8;
-      #endif
-      if (needbytes>(Int)sizeof(zaccbuff)) {
-        allocacc=(uLong *)malloc(needbytes);
-        zacc=(uLong *)allocacc;}
-      if (zlhi==NULL||zrhi==NULL||zacc==NULL) {
-        *status|=DEC_Insufficient_storage;
-        break;}
-
-      acc=(Unit *)zacc;       // -> target Unit array
-      #if DECDPUN==1
-      zacc+=zoff;             // start uLong accumulator to right
-      #endif
-
-      // assemble the chunked copies of the left and right sides
-      for (count=lhs->digits, cup=lhs->lsu, lip=zlhi; count>0; lip++)
-        for (p=0, *lip=0; p<FASTDIGS && count>0;
-             p+=DECDPUN, cup++, count-=DECDPUN)
-          *lip+=*cup*powers[p];
-      lmsi=lip-1;     // save -> msi
-      for (count=rhs->digits, cup=rhs->lsu, rip=zrhi; count>0; rip++)
-        for (p=0, *rip=0; p<FASTDIGS && count>0;
-             p+=DECDPUN, cup++, count-=DECDPUN)
-          *rip+=*cup*powers[p];
-      rmsi=rip-1;     // save -> msi
-
-      // zero the accumulator
-      for (lp=zacc; lp<zacc+iacc; lp++) *lp=0;
-
-      /* Start the multiplication */
-      // Resolving carries can dominate the cost of accumulating the
-      // partial products, so this is only done when necessary.
-      // Each uLong item in the accumulator can hold values up to
-      // 2**64-1, and each partial product can be as large as
-      // (10**FASTDIGS-1)**2.  When FASTDIGS=9, this can be added to
-      // itself 18.4 times in a uLong without overflowing, so during
-      // the main calculation resolution is carried out every 18th
-      // add -- every 162 digits.  Similarly, when FASTDIGS=8, the
-      // partial products can be added to themselves 1844.6 times in
-      // a uLong without overflowing, so intermediate carry
-      // resolution occurs only every 14752 digits.  Hence for common
-      // short numbers usually only the one final carry resolution
-      // occurs.
-      // (The count is set via FASTLAZY to simplify experiments to
-      // measure the value of this approach: a 35% improvement on a
-      // [34x34] multiply.)
-      lazy=FASTLAZY;                         // carry delay count
-      for (rip=zrhi; rip<=rmsi; rip++) {     // over each item in rhs
-        lp=zacc+(rip-zrhi);                  // where to add the lhs
-        for (lip=zlhi; lip<=lmsi; lip++, lp++) { // over each item in lhs
-          *lp+=(uLong)(*lip)*(*rip);         // [this should in-line]
-          } // lip loop
-        lazy--;
-        if (lazy>0 && rip!=rmsi) continue;
-        lazy=FASTLAZY;                       // reset delay count
-        // spin up the accumulator resolving overflows
-        for (lp=zacc; lp<zacc+iacc; lp++) {
-          if (*lp<FASTBASE) continue;        // it fits
-          lcarry=*lp/FASTBASE;               // top part [slow divide]
-          // lcarry can exceed 2**32-1, so check again; this check
-          // and occasional extra divide (slow) is well worth it, as
-          // it allows FASTLAZY to be increased to 18 rather than 4
-          // in the FASTDIGS=9 case
-          if (lcarry<FASTBASE) carry=(uInt)lcarry;  // [usual]
-           else { // two-place carry [fairly rare]
-            uInt carry2=(uInt)(lcarry/FASTBASE);    // top top part
-            *(lp+2)+=carry2;                        // add to item+2
-            *lp-=((uLong)FASTBASE*FASTBASE*carry2); // [slow]
-            carry=(uInt)(lcarry-((uLong)FASTBASE*carry2)); // [inline]
-            }
-          *(lp+1)+=carry;                    // add to item above [inline]
-          *lp-=((uLong)FASTBASE*carry);      // [inline]
-          } // carry resolution
-        } // rip loop
-
-      // The multiplication is complete; time to convert back into
-      // units.  This can be done in-place in the accumulator and in
-      // 32-bit operations, because carries were resolved after the
-      // final add.  This needs N-1 divides and multiplies for
-      // each item in the accumulator (which will become up to N
-      // units, where 2<=N<=9).
-      for (lp=zacc, up=acc; lp<zacc+iacc; lp++) {
-        uInt item=(uInt)*lp;                 // decapitate to uInt
-        for (p=0; p<FASTDIGS-DECDPUN; p+=DECDPUN, up++) {
-          uInt part=item/(DECDPUNMAX+1);
-          *up=(Unit)(item-(part*(DECDPUNMAX+1)));
-          item=part;
-          } // p
-        *up=(Unit)item; up++;                // [final needs no division]
-        } // lp
-      accunits=up-acc;                       // count of units
-      }
-     else { // here to use units directly, without chunking ['old code']
-    #endif
-
-      // if accumulator will be too long for local storage, then allocate
-      acc=accbuff;                 // -> assume buffer for accumulator
-      needbytes=(D2U(lhs->digits)+D2U(rhs->digits))*sizeof(Unit);
-      if (needbytes>(Int)sizeof(accbuff)) {
-        allocacc=(Unit *)malloc(needbytes);
-        if (allocacc==NULL) {*status|=DEC_Insufficient_storage; break;}
-        acc=(Unit *)allocacc;                // use the allocated space
-        }
-
-      /* Now the main long multiplication loop */
-      // Unlike the equivalent in the IBM Java implementation, there
-      // is no advantage in calculating from msu to lsu.  So, do it
-      // by the book, as it were.
-      // Each iteration calculates ACC=ACC+MULTAND*MULT
-      accunits=1;                  // accumulator starts at '0'
-      *acc=0;                      // .. (lsu=0)
-      shift=0;                     // no multiplicand shift at first
-      madlength=D2U(lhs->digits);  // this won't change
-      mermsup=rhs->lsu+D2U(rhs->digits); // -> msu+1 of multiplier
-
-      for (mer=rhs->lsu; mer<mermsup; mer++) {
-        // Here, *mer is the next Unit in the multiplier to use
-        // If non-zero [optimization] add it...
-        if (*mer!=0) accunits=decUnitAddSub(&acc[shift], accunits-shift,
-                                            lhs->lsu, madlength, 0,
-                                            &acc[shift], *mer)
-                                            + shift;
-         else { // extend acc with a 0; it will be used shortly
-          *(acc+accunits)=0;       // [this avoids length of <=0 later]
-          accunits++;
-          }
-        // multiply multiplicand by 10**DECDPUN for next Unit to left
-        shift++;                   // add this for 'logical length'
-        } // n
-    #if FASTMUL
-      } // unchunked units
-    #endif
-    // common end-path
-    #if DECTRACE
-      decDumpAr('*', acc, accunits);         // Show exact result
-    #endif
-
-    // acc now contains the exact result of the multiplication,
-    // possibly with a leading zero unit; build the decNumber from
-    // it, noting if any residue
-    res->bits=bits;                          // set sign
-    res->digits=decGetDigits(acc, accunits); // count digits exactly
-
-    // There can be a 31-bit wrap in calculating the exponent.
-    // This can only happen if both input exponents are negative and
-    // both their magnitudes are large.  If there was a wrap, set a
-    // safe very negative exponent, from which decFinalize() will
-    // raise a hard underflow shortly.
-    exponent=lhs->exponent+rhs->exponent;    // calculate exponent
-    if (lhs->exponent<0 && rhs->exponent<0 && exponent>0)
-      exponent=-2*DECNUMMAXE;                // force underflow
-    res->exponent=exponent;                  // OK to overwrite now
-
-    // Set the coefficient.  If any rounding, residue records
-    decSetCoeff(res, set, acc, res->digits, &residue, status);
-    decFinish(res, set, &residue, status);   // final cleanup
-    } while(0);                         // end protected
-
-  if (allocacc!=NULL) free(allocacc);   // drop any storage used
-  #if DECSUBSET
-  if (allocrhs!=NULL) free(allocrhs);   // ..
-  if (alloclhs!=NULL) free(alloclhs);   // ..
-  #endif
-  #if FASTMUL
-  if (allocrhi!=NULL) free(allocrhi);   // ..
-  if (alloclhi!=NULL) free(alloclhi);   // ..
-  #endif
-  return res;
-  } // decMultiplyOp
-
-/* ------------------------------------------------------------------ */
-/* decExpOp -- effect exponentiation                                  */
-/*                                                                    */
-/*   This computes C = exp(A)                                         */
-/*                                                                    */
-/*   res is C, the result.  C may be A                                */
-/*   rhs is A                                                         */
-/*   set is the context; note that rounding mode has no effect        */
-/*                                                                    */
-/* C must have space for set->digits digits. status is updated but    */
-/* not set.                                                           */
-/*                                                                    */
-/* Restrictions:                                                      */
-/*                                                                    */
-/*   digits, emax, and -emin in the context must be less than         */
-/*   2*DEC_MAX_MATH (1999998), and the rhs must be within these       */
-/*   bounds or a zero.  This is an internal routine, so these         */
-/*   restrictions are contractual and not enforced.                   */
-/*                                                                    */
-/* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will      */
-/* almost always be correctly rounded, but may be up to 1 ulp in      */
-/* error in rare cases.                                               */
-/*                                                                    */
-/* Finite results will always be full precision and Inexact, except   */
-/* when A is a zero or -Infinity (giving 1 or 0 respectively).        */
-/* ------------------------------------------------------------------ */
-/* This approach used here is similar to the algorithm described in   */
-/*                                                                    */
-/*   Variable Precision Exponential Function, T. E. Hull and          */
-/*   A. Abrham, ACM Transactions on Mathematical Software, Vol 12 #2, */
-/*   pp79-91, ACM, June 1986.                                         */
-/*                                                                    */
-/* with the main difference being that the iterations in the series   */
-/* evaluation are terminated dynamically (which does not require the  */
-/* extra variable-precision variables which are expensive in this     */
-/* context).                                                          */
-/*                                                                    */
-/* The error analysis in Hull & Abrham's paper applies except for the */
-/* round-off error accumulation during the series evaluation.  This   */
-/* code does not precalculate the number of iterations and so cannot  */
-/* use Horner's scheme.  Instead, the accumulation is done at double- */
-/* precision, which ensures that the additions of the terms are exact */
-/* and do not accumulate round-off (and any round-off errors in the   */
-/* terms themselves move 'to the right' faster than they can          */
-/* accumulate).  This code also extends the calculation by allowing,  */
-/* in the spirit of other decNumber operators, the input to be more   */
-/* precise than the result (the precision used is based on the more   */
-/* precise of the input or requested result).                         */
-/*                                                                    */
-/* Implementation notes:                                              */
-/*                                                                    */
-/* 1. This is separated out as decExpOp so it can be called from      */
-/*    other Mathematical functions (notably Ln) with a wider range    */
-/*    than normal.  In particular, it can handle the slightly wider   */
-/*    (double) range needed by Ln (which has to be able to calculate  */
-/*    exp(-x) where x can be the tiniest number (Ntiny).              */
-/*                                                                    */
-/* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop         */
-/*    iterations by appoximately a third with additional (although    */
-/*    diminishing) returns as the range is reduced to even smaller    */
-/*    fractions.  However, h (the power of 10 used to correct the     */
-/*    result at the end, see below) must be kept <=8 as otherwise     */
-/*    the final result cannot be computed.  Hence the leverage is a   */
-/*    sliding value (8-h), where potentially the range is reduced     */
-/*    more for smaller values.                                        */
-/*                                                                    */
-/*    The leverage that can be applied in this way is severely        */
-/*    limited by the cost of the raise-to-the power at the end,       */
-/*    which dominates when the number of iterations is small (less    */
-/*    than ten) or when rhs is short.  As an example, the adjustment  */
-/*    x**10,000,000 needs 31 multiplications, all but one full-width. */
-/*                                                                    */
-/* 3. The restrictions (especially precision) could be raised with    */
-/*    care, but the full decNumber range seems very hard within the   */
-/*    32-bit limits.                                                  */
-/* ------------------------------------------------------------------ */
-decNumber * decExpOp(decNumber *res, const decNumber *rhs,
-                         decContext *set, uInt *status) {
-  uInt ignore=0;                   // working status
-  Int h;                           // adjusted exponent for 0.xxxx
-  Int p;                           // working precision
-  Int residue;                     // rounding residue
-  uInt needbytes;                  // for space calculations
-  const decNumber *x=rhs;          // (may point to safe copy later)
-  decContext aset, tset, dset;     // working contexts
-
-  // the argument is often copied to normalize it, so (unusually) it
-  // is treated like other buffers, using DECBUFFER, +1 in case
-  // DECBUFFER is 0
-  decNumber bufr[D2N(DECBUFFER+1)];
-  decNumber *allocrhs=NULL;        // non-NULL if rhs buffer allocated
-
-  // the working precision will be no more than set->digits+8+1
-  // so for on-stack buffers DECBUFFER+9 is used, +1 in case DECBUFFER
-  // is 0 (and twice that for the accumulator)
-
-  // buffer for t, term (working precision plus)
-  decNumber buft[D2N(DECBUFFER+9+1)];
-  decNumber *allocbuft=NULL;       // -> allocated buft, iff allocated
-  decNumber *t=buft;               // term
-  // buffer for a, accumulator (working precision * 2), at least 9
-  decNumber bufa[D2N(DECBUFFER*2+18+1)];
-  decNumber *allocbufa=NULL;       // -> allocated bufa, iff allocated
-  decNumber *a=bufa;               // accumulator
-  // decNumber for the divisor term; this needs at most 9 digits
-  // and so can be fixed size [16 so can use standard context]
-  decNumber bufd[D2N(16)];
-  decNumber *d=bufd;               // divisor
-  decNumber numone;                // constant 1
-
-  #if DECCHECK
-  Int iterations=0;                // for later sanity check
-  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
-  #endif
-
-  do {                                  // protect allocated storage
-    if (SPECIALARG) {                   // handle infinities and NaNs
-      if (decNumberIsInfinite(rhs)) {   // an infinity
-        if (decNumberIsNegative(rhs))   // -Infinity -> +0
-          decNumberZero(res);
-         else decNumberCopy(res, rhs);  // +Infinity -> self
-        }
-       else decNaNs(res, rhs, NULL, status); // a NaN
-      break;}
-
-    if (ISZERO(rhs)) {                  // zeros -> exact 1
-      decNumberZero(res);               // make clean 1
-      *res->lsu=1;                      // ..
-      break;}                           // [no status to set]
-
-    // e**x when 0 < x < 0.66 is < 1+3x/2, hence can fast-path
-    // positive and negative tiny cases which will result in inexact
-    // 1.  This also allows the later add-accumulate to always be
-    // exact (because its length will never be more than twice the
-    // working precision).
-    // The comparator (tiny) needs just one digit, so use the
-    // decNumber d for it (reused as the divisor, etc., below); its
-    // exponent is such that if x is positive it will have
-    // set->digits-1 zeros between the decimal point and the digit,
-    // which is 4, and if x is negative one more zero there as the
-    // more precise result will be of the form 0.9999999 rather than
-    // 1.0000001.  Hence, tiny will be 0.0000004  if digits=7 and x>0
-    // or 0.00000004 if digits=7 and x<0.  If RHS not larger than
-    // this then the result will be 1.000000
-    decNumberZero(d);                   // clean
-    *d->lsu=4;                          // set 4 ..
-    d->exponent=-set->digits;           // * 10**(-d)
-    if (decNumberIsNegative(rhs)) d->exponent--;  // negative case
-    if (decCompare(d, rhs, 1)>=0) {     // signless compare
-      Int shift=set->digits-1;
-      decNumberZero(res);               // set 1
-      *res->lsu=1;                      // ..
-      res->digits=decShiftToMost(res->lsu, 1, shift);
-      res->exponent=-shift;                  // make 1.0000...
-      *status|=DEC_Inexact | DEC_Rounded;    // .. inexactly
-      break;} // tiny
-
-    // set up the context to be used for calculating a, as this is
-    // used on both paths below
-    decContextDefault(&aset, DEC_INIT_DECIMAL64);
-    // accumulator bounds are as requested (could underflow)
-    aset.emax=set->emax;                // usual bounds
-    aset.emin=set->emin;                // ..
-    aset.clamp=0;                       // and no concrete format
-
-    // calculate the adjusted (Hull & Abrham) exponent (where the
-    // decimal point is just to the left of the coefficient msd)
-    h=rhs->exponent+rhs->digits;
-    // if h>8 then 10**h cannot be calculated safely; however, when
-    // h=8 then exp(|rhs|) will be at least exp(1E+7) which is at
-    // least 6.59E+4342944, so (due to the restriction on Emax/Emin)
-    // overflow (or underflow to 0) is guaranteed -- so this case can
-    // be handled by simply forcing the appropriate excess
-    if (h>8) {                          // overflow/underflow
-      // set up here so Power call below will over or underflow to
-      // zero; set accumulator to either 2 or 0.02
-      // [stack buffer for a is always big enough for this]
-      decNumberZero(a);
-      *a->lsu=2;                        // not 1 but < exp(1)
-      if (decNumberIsNegative(rhs)) a->exponent=-2; // make 0.02
-      h=8;                              // clamp so 10**h computable
-      p=9;                              // set a working precision
-      }
-     else {                             // h<=8
-      Int maxlever=(rhs->digits>8?1:0);
-      // [could/should increase this for precisions >40 or so, too]
-
-      // if h is 8, cannot normalize to a lower upper limit because
-      // the final result will not be computable (see notes above),
-      // but leverage can be applied whenever h is less than 8.
-      // Apply as much as possible, up to a MAXLEVER digits, which
-      // sets the tradeoff against the cost of the later a**(10**h).
-      // As h is increased, the working precision below also
-      // increases to compensate for the "constant digits at the
-      // front" effect.
-      Int lever=MIN(8-h, maxlever);     // leverage attainable
-      Int use=-rhs->digits-lever;       // exponent to use for RHS
-      h+=lever;                         // apply leverage selected
-      if (h<0) {                        // clamp
-        use+=h;                         // [may end up subnormal]
-        h=0;
-        }
-      // Take a copy of RHS if it needs normalization (true whenever x>=1)
-      if (rhs->exponent!=use) {
-        decNumber *newrhs=bufr;         // assume will fit on stack
-        needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
-        if (needbytes>sizeof(bufr)) {   // need malloc space
-          allocrhs=(decNumber *)malloc(needbytes);
-          if (allocrhs==NULL) {         // hopeless -- abandon
-            *status|=DEC_Insufficient_storage;
-            break;}
-          newrhs=allocrhs;              // use the allocated space
-          }
-        decNumberCopy(newrhs, rhs);     // copy to safe space
-        newrhs->exponent=use;           // normalize; now <1
-        x=newrhs;                       // ready for use
-        // decNumberShow(x);
-        }
-
-      // Now use the usual power series to evaluate exp(x).  The
-      // series starts as 1 + x + x^2/2 ... so prime ready for the
-      // third term by setting the term variable t=x, the accumulator
-      // a=1, and the divisor d=2.
-
-      // First determine the working precision.  From Hull & Abrham
-      // this is set->digits+h+2.  However, if x is 'over-precise' we
-      // need to allow for all its digits to potentially participate
-      // (consider an x where all the excess digits are 9s) so in
-      // this case use x->digits+h+2
-      p=MAX(x->digits, set->digits)+h+2;
-
-      // a and t are variable precision, and depend on p, so space
-      // must be allocated for them if necessary
-
-      // the accumulator needs to be able to hold 2p digits so that
-      // the additions on the second and subsequent iterations are
-      // sufficiently exact.
-      needbytes=sizeof(decNumber)+(D2U(p*2)-1)*sizeof(Unit);
-      if (needbytes>sizeof(bufa)) {     // need malloc space
-        allocbufa=(decNumber *)malloc(needbytes);
-        if (allocbufa==NULL) {          // hopeless -- abandon
-          *status|=DEC_Insufficient_storage;
-          break;}
-        a=allocbufa;                    // use the allocated space
-        }
-      // the term needs to be able to hold p digits (which is
-      // guaranteed to be larger than x->digits, so the initial copy
-      // is safe); it may also be used for the raise-to-power
-      // calculation below, which needs an extra two digits
-      needbytes=sizeof(decNumber)+(D2U(p+2)-1)*sizeof(Unit);
-      if (needbytes>sizeof(buft)) {     // need malloc space
-        allocbuft=(decNumber *)malloc(needbytes);
-        if (allocbuft==NULL) {          // hopeless -- abandon
-          *status|=DEC_Insufficient_storage;
-          break;}
-        t=allocbuft;                    // use the allocated space
-        }
-
-      decNumberCopy(t, x);              // term=x
-      decNumberZero(a); *a->lsu=1;      // accumulator=1
-      decNumberZero(d); *d->lsu=2;      // divisor=2
-      decNumberZero(&numone); *numone.lsu=1; // constant 1 for increment
-
-      // set up the contexts for calculating a, t, and d
-      decContextDefault(&tset, DEC_INIT_DECIMAL64);
-      dset=tset;
-      // accumulator bounds are set above, set precision now
-      aset.digits=p*2;                  // double
-      // term bounds avoid any underflow or overflow
-      tset.digits=p;
-      tset.emin=DEC_MIN_EMIN;           // [emax is plenty]
-      // [dset.digits=16, etc., are sufficient]
-
-      // finally ready to roll
-      for (;;) {
-        #if DECCHECK
-        iterations++;
-        #endif
-        // only the status from the accumulation is interesting
-        // [but it should remain unchanged after first add]
-        decAddOp(a, a, t, &aset, 0, status);           // a=a+t
-        decMultiplyOp(t, t, x, &tset, &ignore);        // t=t*x
-        decDivideOp(t, t, d, &tset, DIVIDE, &ignore);  // t=t/d
-        // the iteration ends when the term cannot affect the result,
-        // if rounded to p digits, which is when its value is smaller
-        // than the accumulator by p+1 digits.  There must also be
-        // full precision in a.
-        if (((a->digits+a->exponent)>=(t->digits+t->exponent+p+1))
-            && (a->digits>=p)) break;
-        decAddOp(d, d, &numone, &dset, 0, &ignore);    // d=d+1
-        } // iterate
-
-      #if DECCHECK
-      // just a sanity check; comment out test to show always
-      if (iterations>p+3)
-        printf("Exp iterations=%d, status=%08x, p=%d, d=%d\n",
-               iterations, *status, p, x->digits);
-      #endif
-      } // h<=8
-
-    // apply postconditioning: a=a**(10**h) -- this is calculated
-    // at a slightly higher precision than Hull & Abrham suggest
-    if (h>0) {
-      Int seenbit=0;               // set once a 1-bit is seen
-      Int i;                       // counter
-      Int n=powers[h];             // always positive
-      aset.digits=p+2;             // sufficient precision
-      // avoid the overhead and many extra digits of decNumberPower
-      // as all that is needed is the short 'multipliers' loop; here
-      // accumulate the answer into t
-      decNumberZero(t); *t->lsu=1; // acc=1
-      for (i=1;;i++){              // for each bit [top bit ignored]
-        // abandon if have had overflow or terminal underflow
-        if (*status & (DEC_Overflow|DEC_Underflow)) { // interesting?
-          if (*status&DEC_Overflow || ISZERO(t)) break;}
-        n=n<<1;                    // move next bit to testable position
-        if (n<0) {                 // top bit is set
-          seenbit=1;               // OK, have a significant bit
-          decMultiplyOp(t, t, a, &aset, status); // acc=acc*x
-          }
-        if (i==31) break;          // that was the last bit
-        if (!seenbit) continue;    // no need to square 1
-        decMultiplyOp(t, t, t, &aset, status); // acc=acc*acc [square]
-        } /*i*/ // 32 bits
-      // decNumberShow(t);
-      a=t;                         // and carry on using t instead of a
-      }
-
-    // Copy and round the result to res
-    residue=1;                          // indicate dirt to right ..
-    if (ISZERO(a)) residue=0;           // .. unless underflowed to 0
-    aset.digits=set->digits;            // [use default rounding]
-    decCopyFit(res, a, &aset, &residue, status); // copy & shorten
-    decFinish(res, set, &residue, status);       // cleanup/set flags
-    } while(0);                         // end protected
-
-  if (allocrhs !=NULL) free(allocrhs);  // drop any storage used
-  if (allocbufa!=NULL) free(allocbufa); // ..
-  if (allocbuft!=NULL) free(allocbuft); // ..
-  // [status is handled by caller]
-  return res;
-  } // decExpOp
-
-/* ------------------------------------------------------------------ */
-/* Initial-estimate natural logarithm table                           */
-/*                                                                    */
-/*   LNnn -- 90-entry 16-bit table for values from .10 through .99.   */
-/*           The result is a 4-digit encode of the coefficient (c=the */
-/*           top 14 bits encoding 0-9999) and a 2-digit encode of the */
-/*           exponent (e=the bottom 2 bits encoding 0-3)              */
-/*                                                                    */
-/*           The resulting value is given by:                         */
-/*                                                                    */
-/*             v = -c * 10**(-e-3)                                    */
-/*                                                                    */
-/*           where e and c are extracted from entry k = LNnn[x-10]    */
-/*           where x is truncated (NB) into the range 10 through 99,  */
-/*           and then c = k>>2 and e = k&3.                           */
-/* ------------------------------------------------------------------ */
-const uShort LNnn[90]={9016,  8652,  8316,  8008,  7724,  7456,  7208,
-  6972,  6748,  6540,  6340,  6148,  5968,  5792,  5628,  5464,  5312,
-  5164,  5020,  4884,  4748,  4620,  4496,  4376,  4256,  4144,  4032,
- 39233, 38181, 37157, 36157, 35181, 34229, 33297, 32389, 31501, 30629,
- 29777, 28945, 28129, 27329, 26545, 25777, 25021, 24281, 23553, 22837,
- 22137, 21445, 20769, 20101, 19445, 18801, 18165, 17541, 16925, 16321,
- 15721, 15133, 14553, 13985, 13421, 12865, 12317, 11777, 11241, 10717,
- 10197,  9685,  9177,  8677,  8185,  7697,  7213,  6737,  6269,  5801,
-  5341,  4889,  4437, 39930, 35534, 31186, 26886, 22630, 18418, 14254,
- 10130,  6046, 20055};
-
-/* ------------------------------------------------------------------ */
-/* decLnOp -- effect natural logarithm                                */
-/*                                                                    */
-/*   This computes C = ln(A)                                          */
-/*                                                                    */
-/*   res is C, the result.  C may be A                                */
-/*   rhs is A                                                         */
-/*   set is the context; note that rounding mode has no effect        */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/*                                                                    */
-/* Notable cases:                                                     */
-/*   A<0 -> Invalid                                                   */
-/*   A=0 -> -Infinity (Exact)                                         */
-/*   A=+Infinity -> +Infinity (Exact)                                 */
-/*   A=1 exactly -> 0 (Exact)                                         */
-/*                                                                    */
-/* Restrictions (as for Exp):                                         */
-/*                                                                    */
-/*   digits, emax, and -emin in the context must be less than         */
-/*   DEC_MAX_MATH+11 (1000010), and the rhs must be within these      */
-/*   bounds or a zero.  This is an internal routine, so these         */
-/*   restrictions are contractual and not enforced.                   */
-/*                                                                    */
-/* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will      */
-/* almost always be correctly rounded, but may be up to 1 ulp in      */
-/* error in rare cases.                                               */
-/* ------------------------------------------------------------------ */
-/* The result is calculated using Newton's method, with each          */
-/* iteration calculating a' = a + x * exp(-a) - 1.  See, for example, */
-/* Epperson 1989.                                                     */
-/*                                                                    */
-/* The iteration ends when the adjustment x*exp(-a)-1 is tiny enough. */
-/* This has to be calculated at the sum of the precision of x and the */
-/* working precision.                                                 */
-/*                                                                    */
-/* Implementation notes:                                              */
-/*                                                                    */
-/* 1. This is separated out as decLnOp so it can be called from       */
-/*    other Mathematical functions (e.g., Log 10) with a wider range  */
-/*    than normal.  In particular, it can handle the slightly wider   */
-/*    (+9+2) range needed by a power function.                        */
-/*                                                                    */
-/* 2. The speed of this function is about 10x slower than exp, as     */
-/*    it typically needs 4-6 iterations for short numbers, and the    */
-/*    extra precision needed adds a squaring effect, twice.           */
-/*                                                                    */
-/* 3. Fastpaths are included for ln(10) and ln(2), up to length 40,   */
-/*    as these are common requests.  ln(10) is used by log10(x).      */
-/*                                                                    */
-/* 4. An iteration might be saved by widening the LNnn table, and     */
-/*    would certainly save at least one if it were made ten times     */
-/*    bigger, too (for truncated fractions 0.100 through 0.999).      */
-/*    However, for most practical evaluations, at least four or five  */
-/*    iterations will be neede -- so this would only speed up by      */
-/*    20-25% and that probably does not justify increasing the table  */
-/*    size.                                                           */
-/* ------------------------------------------------------------------ */
-decNumber * decLnOp(decNumber *res, const decNumber *rhs,
-                    decContext *set, uInt *status) {
-  uInt ignore=0;                   // working status accumulator
-  uInt needbytes;                  // for space calculations
-  Int residue;                     // rounding residue
-  Int r;                           // rhs=f*10**r [see below]
-  Int p;                           // working precision
-  Int pp;                          // precision for iteration
-  Int t;                           // work
-
-  // buffers for a (accumulator, typically precision+2) and b
-  // (adjustment calculator, same size)
-  decNumber bufa[D2N(DECBUFFER+2)];
-  decNumber *allocbufa=NULL;       // -> allocated bufa, iff allocated
-  decNumber *a=bufa;               // accumulator/work
-  decNumber bufb[D2N(DECBUFFER+2)];
-  decNumber *allocbufb=NULL;       // -> allocated bufa, iff allocated
-  decNumber *b=bufb;               // adjustment/work
-
-  decNumber  numone;               // constant 1
-  decNumber  cmp;                  // work
-  decContext aset, bset;           // working contexts
-
-  #if DECCHECK
-  Int iterations=0;                // for later sanity check
-  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
-  #endif
-
-  do {                                  // protect allocated storage
-    if (SPECIALARG) {                   // handle infinities and NaNs
-      if (decNumberIsInfinite(rhs)) {   // an infinity
-        if (decNumberIsNegative(rhs))   // -Infinity -> error
-          *status|=DEC_Invalid_operation;
-         else decNumberCopy(res, rhs);  // +Infinity -> self
-        }
-       else decNaNs(res, rhs, NULL, status); // a NaN
-      break;}
-
-    if (ISZERO(rhs)) {                  // +/- zeros -> -Infinity
-      decNumberZero(res);               // make clean
-      res->bits=DECINF|DECNEG;          // set - infinity
-      break;}                           // [no status to set]
-
-    // Non-zero negatives are bad...
-    if (decNumberIsNegative(rhs)) {     // -x -> error
-      *status|=DEC_Invalid_operation;
-      break;}
-
-    // Here, rhs is positive, finite, and in range
-
-    // lookaside fastpath code for ln(2) and ln(10) at common lengths
-    if (rhs->exponent==0 && set->digits<=40) {
-      #if DECDPUN==1
-      if (rhs->lsu[0]==0 && rhs->lsu[1]==1 && rhs->digits==2) { // ln(10)
-      #else
-      if (rhs->lsu[0]==10 && rhs->digits==2) {                  // ln(10)
-      #endif
-        aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
-        #define LN10 "2.302585092994045684017991454684364207601"
-        decNumberFromString(res, LN10, &aset);
-        *status|=(DEC_Inexact | DEC_Rounded); // is inexact
-        break;}
-      if (rhs->lsu[0]==2 && rhs->digits==1) { // ln(2)
-        aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
-        #define LN2 "0.6931471805599453094172321214581765680755"
-        decNumberFromString(res, LN2, &aset);
-        *status|=(DEC_Inexact | DEC_Rounded);
-        break;}
-      } // integer and short
-
-    // Determine the working precision.  This is normally the
-    // requested precision + 2, with a minimum of 9.  However, if
-    // the rhs is 'over-precise' then allow for all its digits to
-    // potentially participate (consider an rhs where all the excess
-    // digits are 9s) so in this case use rhs->digits+2.
-    p=MAX(rhs->digits, MAX(set->digits, 7))+2;
-
-    // Allocate space for the accumulator and the high-precision
-    // adjustment calculator, if necessary.  The accumulator must
-    // be able to hold p digits, and the adjustment up to
-    // rhs->digits+p digits.  They are also made big enough for 16
-    // digits so that they can be used for calculating the initial
-    // estimate.
-    needbytes=sizeof(decNumber)+(D2U(MAX(p,16))-1)*sizeof(Unit);
-    if (needbytes>sizeof(bufa)) {     // need malloc space
-      allocbufa=(decNumber *)malloc(needbytes);
-      if (allocbufa==NULL) {          // hopeless -- abandon
-        *status|=DEC_Insufficient_storage;
-        break;}
-      a=allocbufa;                    // use the allocated space
-      }
-    pp=p+rhs->digits;
-    needbytes=sizeof(decNumber)+(D2U(MAX(pp,16))-1)*sizeof(Unit);
-    if (needbytes>sizeof(bufb)) {     // need malloc space
-      allocbufb=(decNumber *)malloc(needbytes);
-      if (allocbufb==NULL) {          // hopeless -- abandon
-        *status|=DEC_Insufficient_storage;
-        break;}
-      b=allocbufb;                    // use the allocated space
-      }
-
-    // Prepare an initial estimate in acc. Calculate this by
-    // considering the coefficient of x to be a normalized fraction,
-    // f, with the decimal point at far left and multiplied by
-    // 10**r.  Then, rhs=f*10**r and 0.1<=f<1, and
-    //   ln(x) = ln(f) + ln(10)*r
-    // Get the initial estimate for ln(f) from a small lookup
-    // table (see above) indexed by the first two digits of f,
-    // truncated.
-
-    decContextDefault(&aset, DEC_INIT_DECIMAL64); // 16-digit extended
-    r=rhs->exponent+rhs->digits;        // 'normalised' exponent
-    decPutInt(a, r);                    // a=r
-    decPutInt(b, 2302585);              // b=ln(10) (2.302585)
-    b->exponent=-6;                     //  ..
-    decMultiplyOp(a, a, b, &aset, &ignore);  // a=a*b
-    // now get top two digits of rhs into b by simple truncate and
-    // force to integer
-    residue=0;                          // (no residue)
-    aset.digits=2; aset.round=DEC_ROUND_DOWN;
-    decCopyFit(b, rhs, &aset, &residue, &ignore); // copy & shorten
-    b->exponent=0;                      // make integer
-    t=decGetInt(b);                     // [cannot fail]
-    if (t<10) t=X10(t);                 // adjust single-digit b
-    t=LNnn[t-10];                       // look up ln(b)
-    decPutInt(b, t>>2);                 // b=ln(b) coefficient
-    b->exponent=-(t&3)-3;               // set exponent
-    b->bits=DECNEG;                     // ln(0.10)->ln(0.99) always -ve
-    aset.digits=16; aset.round=DEC_ROUND_HALF_EVEN; // restore
-    decAddOp(a, a, b, &aset, 0, &ignore); // acc=a+b
-    // the initial estimate is now in a, with up to 4 digits correct.
-    // When rhs is at or near Nmax the estimate will be low, so we
-    // will approach it from below, avoiding overflow when calling exp.
-
-    decNumberZero(&numone); *numone.lsu=1;   // constant 1 for adjustment
-
-    // accumulator bounds are as requested (could underflow, but
-    // cannot overflow)
-    aset.emax=set->emax;
-    aset.emin=set->emin;
-    aset.clamp=0;                       // no concrete format
-    // set up a context to be used for the multiply and subtract
-    bset=aset;
-    bset.emax=DEC_MAX_MATH*2;           // use double bounds for the
-    bset.emin=-DEC_MAX_MATH*2;          // adjustment calculation
-                                        // [see decExpOp call below]
-    // for each iteration double the number of digits to calculate,
-    // up to a maximum of p
-    pp=9;                               // initial precision
-    // [initially 9 as then the sequence starts 7+2, 16+2, and
-    // 34+2, which is ideal for standard-sized numbers]
-    aset.digits=pp;                     // working context
-    bset.digits=pp+rhs->digits;         // wider context
-    for (;;) {                          // iterate
-      #if DECCHECK
-      iterations++;
-      if (iterations>24) break;         // consider 9 * 2**24
-      #endif
-      // calculate the adjustment (exp(-a)*x-1) into b.  This is a
-      // catastrophic subtraction but it really is the difference
-      // from 1 that is of interest.
-      // Use the internal entry point to Exp as it allows the double
-      // range for calculating exp(-a) when a is the tiniest subnormal.
-      a->bits^=DECNEG;                  // make -a
-      decExpOp(b, a, &bset, &ignore);   // b=exp(-a)
-      a->bits^=DECNEG;                  // restore sign of a
-      // now multiply by rhs and subtract 1, at the wider precision
-      decMultiplyOp(b, b, rhs, &bset, &ignore);        // b=b*rhs
-      decAddOp(b, b, &numone, &bset, DECNEG, &ignore); // b=b-1
-
-      // the iteration ends when the adjustment cannot affect the
-      // result by >=0.5 ulp (at the requested digits), which
-      // is when its value is smaller than the accumulator by
-      // set->digits+1 digits (or it is zero) -- this is a looser
-      // requirement than for Exp because all that happens to the
-      // accumulator after this is the final rounding (but note that
-      // there must also be full precision in a, or a=0).
-
-      if (decNumberIsZero(b) ||
-          (a->digits+a->exponent)>=(b->digits+b->exponent+set->digits+1)) {
-        if (a->digits==p) break;
-        if (decNumberIsZero(a)) {
-          decCompareOp(&cmp, rhs, &numone, &aset, COMPARE, &ignore); // rhs=1 ?
-          if (cmp.lsu[0]==0) a->exponent=0;            // yes, exact 0
-           else *status|=(DEC_Inexact | DEC_Rounded);  // no, inexact
-          break;
-          }
-        // force padding if adjustment has gone to 0 before full length
-        if (decNumberIsZero(b)) b->exponent=a->exponent-p;
-        }
-
-      // not done yet ...
-      decAddOp(a, a, b, &aset, 0, &ignore);  // a=a+b for next estimate
-      if (pp==p) continue;                   // precision is at maximum
-      // lengthen the next calculation
-      pp=pp*2;                               // double precision
-      if (pp>p) pp=p;                        // clamp to maximum
-      aset.digits=pp;                        // working context
-      bset.digits=pp+rhs->digits;            // wider context
-      } // Newton's iteration
-
-    #if DECCHECK
-    // just a sanity check; remove the test to show always
-    if (iterations>24)
-      printf("Ln iterations=%d, status=%08x, p=%d, d=%d\n",
-            iterations, *status, p, rhs->digits);
-    #endif
-
-    // Copy and round the result to res
-    residue=1;                          // indicate dirt to right
-    if (ISZERO(a)) residue=0;           // .. unless underflowed to 0
-    aset.digits=set->digits;            // [use default rounding]
-    decCopyFit(res, a, &aset, &residue, status); // copy & shorten
-    decFinish(res, set, &residue, status);       // cleanup/set flags
-    } while(0);                         // end protected
-
-  if (allocbufa!=NULL) free(allocbufa); // drop any storage used
-  if (allocbufb!=NULL) free(allocbufb); // ..
-  // [status is handled by caller]
-  return res;
-  } // decLnOp
-
-/* ------------------------------------------------------------------ */
-/* decQuantizeOp  -- force exponent to requested value                */
-/*                                                                    */
-/*   This computes C = op(A, B), where op adjusts the coefficient     */
-/*   of C (by rounding or shifting) such that the exponent (-scale)   */
-/*   of C has the value B or matches the exponent of B.               */
-/*   The numerical value of C will equal A, except for the effects of */
-/*   any rounding that occurred.                                      */
-/*                                                                    */
-/*   res is C, the result.  C may be A or B                           */
-/*   lhs is A, the number to adjust                                   */
-/*   rhs is B, the requested exponent                                 */
-/*   set is the context                                               */
-/*   quant is 1 for quantize or 0 for rescale                         */
-/*   status is the status accumulator (this can be called without     */
-/*          risk of control loss)                                     */
-/*                                                                    */
-/* C must have space for set->digits digits.                          */
-/*                                                                    */
-/* Unless there is an error or the result is infinite, the exponent   */
-/* after the operation is guaranteed to be that requested.            */
-/* ------------------------------------------------------------------ */
-static decNumber * decQuantizeOp(decNumber *res, const decNumber *lhs,
-                                 const decNumber *rhs, decContext *set,
-                                 Flag quant, uInt *status) {
-  #if DECSUBSET
-  decNumber *alloclhs=NULL;        // non-NULL if rounded lhs allocated
-  decNumber *allocrhs=NULL;        // .., rhs
-  #endif
-  const decNumber *inrhs=rhs;      // save original rhs
-  Int   reqdigits=set->digits;     // requested DIGITS
-  Int   reqexp;                    // requested exponent [-scale]
-  Int   residue=0;                 // rounding residue
-  Int   etiny=set->emin-(reqdigits-1);
-
-  #if DECCHECK
-  if (decCheckOperands(res, lhs, rhs, set)) return res;
-  #endif
-
-  do {                             // protect allocated storage
-    #if DECSUBSET
-    if (!set->extended) {
-      // reduce operands and set lostDigits status, as needed
-      if (lhs->digits>reqdigits) {
-        alloclhs=decRoundOperand(lhs, set, status);
-        if (alloclhs==NULL) break;
-        lhs=alloclhs;
-        }
-      if (rhs->digits>reqdigits) { // [this only checks lostDigits]
-        allocrhs=decRoundOperand(rhs, set, status);
-        if (allocrhs==NULL) break;
-        rhs=allocrhs;
-        }
-      }
-    #endif
-    // [following code does not require input rounding]
-
-    // Handle special values
-    if (SPECIALARGS) {
-      // NaNs get usual processing
-      if (SPECIALARGS & (DECSNAN | DECNAN))
-        decNaNs(res, lhs, rhs, status);
-      // one infinity but not both is bad
-      else if ((lhs->bits ^ rhs->bits) & DECINF)
-        *status|=DEC_Invalid_operation;
-      // both infinity: return lhs
-      else decNumberCopy(res, lhs);          // [nop if in place]
-      break;
-      }
-
-    // set requested exponent
-    if (quant) reqexp=inrhs->exponent;  // quantize -- match exponents
-     else {                             // rescale -- use value of rhs
-      // Original rhs must be an integer that fits and is in range,
-      // which could be from -1999999997 to +999999999, thanks to
-      // subnormals
-      reqexp=decGetInt(inrhs);               // [cannot fail]
-      }
-
-    #if DECSUBSET
-    if (!set->extended) etiny=set->emin;     // no subnormals
-    #endif
-
-    if (reqexp==BADINT                       // bad (rescale only) or ..
-     || reqexp==BIGODD || reqexp==BIGEVEN    // very big (ditto) or ..
-     || (reqexp<etiny)                       // < lowest
-     || (reqexp>set->emax)) {                // > emax
-      *status|=DEC_Invalid_operation;
-      break;}
-
-    // the RHS has been processed, so it can be overwritten now if necessary
-    if (ISZERO(lhs)) {                       // zero coefficient unchanged
-      decNumberCopy(res, lhs);               // [nop if in place]
-      res->exponent=reqexp;                  // .. just set exponent
-      #if DECSUBSET
-      if (!set->extended) res->bits=0;       // subset specification; no -0
-      #endif
-      }
-     else {                                  // non-zero lhs
-      Int adjust=reqexp-lhs->exponent;       // digit adjustment needed
-      // if adjusted coefficient will definitely not fit, give up now
-      if ((lhs->digits-adjust)>reqdigits) {
-        *status|=DEC_Invalid_operation;
-        break;
-        }
-
-      if (adjust>0) {                        // increasing exponent
-        // this will decrease the length of the coefficient by adjust
-        // digits, and must round as it does so
-        decContext workset;                  // work
-        workset=*set;                        // clone rounding, etc.
-        workset.digits=lhs->digits-adjust;   // set requested length
-        // [note that the latter can be <1, here]
-        decCopyFit(res, lhs, &workset, &residue, status); // fit to result
-        decApplyRound(res, &workset, residue, status);    // .. and round
-        residue=0;                                        // [used]
-        // If just rounded a 999s case, exponent will be off by one;
-        // adjust back (after checking space), if so.
-        if (res->exponent>reqexp) {
-          // re-check needed, e.g., for quantize(0.9999, 0.001) under
-          // set->digits==3
-          if (res->digits==reqdigits) {      // cannot shift by 1
-            *status&=~(DEC_Inexact | DEC_Rounded); // [clean these]
-            *status|=DEC_Invalid_operation;
-            break;
-            }
-          res->digits=decShiftToMost(res->lsu, res->digits, 1); // shift
-          res->exponent--;                   // (re)adjust the exponent.
-          }
-        #if DECSUBSET
-        if (ISZERO(res) && !set->extended) res->bits=0; // subset; no -0
-        #endif
-        } // increase
-       else /* adjust<=0 */ {                // decreasing or = exponent
-        // this will increase the length of the coefficient by -adjust
-        // digits, by adding zero or more trailing zeros; this is
-        // already checked for fit, above
-        decNumberCopy(res, lhs);             // [it will fit]
-        // if padding needed (adjust<0), add it now...
-        if (adjust<0) {
-          res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
-          res->exponent+=adjust;             // adjust the exponent
-          }
-        } // decrease
-      } // non-zero
-
-    // Check for overflow [do not use Finalize in this case, as an
-    // overflow here is a "don't fit" situation]
-    if (res->exponent>set->emax-res->digits+1) {  // too big
-      *status|=DEC_Invalid_operation;
-      break;
-      }
-     else {
-      decFinalize(res, set, &residue, status);    // set subnormal flags
-      *status&=~DEC_Underflow;          // suppress Underflow [754r]
-      }
-    } while(0);                         // end protected
-
-  #if DECSUBSET
-  if (allocrhs!=NULL) free(allocrhs);   // drop any storage used
-  if (alloclhs!=NULL) free(alloclhs);   // ..
-  #endif
-  return res;
-  } // decQuantizeOp
-
-/* ------------------------------------------------------------------ */
-/* decCompareOp -- compare, min, or max two Numbers                   */
-/*                                                                    */
-/*   This computes C = A ? B and carries out one of four operations:  */
-/*     COMPARE   -- returns the signum (as a number) giving the       */
-/*                  result of a comparison unless one or both         */
-/*                  operands is a NaN (in which case a NaN results)   */
-/*     COMPMAX   -- returns the larger of the operands, using the     */
-/*                  754r maxnum operation                             */
-/*     COMPMIN   -- the 754r minnum operation                         */
-/*     COMTOTAL  -- returns the signum (as a number) giving the       */
-/*                  result of a comparison using 754r total ordering  */
-/*                                                                    */
-/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
-/*   lhs is A                                                         */
-/*   rhs is B                                                         */
-/*   set is the context                                               */
-/*   op  is the operation flag                                        */
-/*   status is the usual accumulator                                  */
-/*                                                                    */
-/* C must have space for one digit for COMPARE or set->digits for     */
-/* COMPMAX and COMPMIN.                                               */
-/* ------------------------------------------------------------------ */
-/* The emphasis here is on speed for common cases, and avoiding       */
-/* coefficient comparison if possible.                                */
-/* ------------------------------------------------------------------ */
-decNumber * decCompareOp(decNumber *res, const decNumber *lhs,
-                         const decNumber *rhs, decContext *set,
-                         Flag op, uInt *status) {
-  #if DECSUBSET
-  decNumber *alloclhs=NULL;        // non-NULL if rounded lhs allocated
-  decNumber *allocrhs=NULL;        // .., rhs
-  #endif
-  Int   result=0;                  // default result value
-  uByte merged;                    // work
-
-  #if DECCHECK
-  if (decCheckOperands(res, lhs, rhs, set)) return res;
-  #endif
-
-  do {                             // protect allocated storage
-    #if DECSUBSET
-    if (!set->extended) {
-      // reduce operands and set lostDigits status, as needed
-      if (lhs->digits>set->digits) {
-        alloclhs=decRoundOperand(lhs, set, status);
-        if (alloclhs==NULL) {result=BADINT; break;}
-        lhs=alloclhs;
-        }
-      if (rhs->digits>set->digits) {
-        allocrhs=decRoundOperand(rhs, set, status);
-        if (allocrhs==NULL) {result=BADINT; break;}
-        rhs=allocrhs;
-        }
-      }
-    #endif
-    // [following code does not require input rounding]
-
-    // If total ordering then handle differing signs 'up front'
-    if (op == COMPTOTAL) {              // total ordering
-      if (decNumberIsNegative(lhs) & !decNumberIsNegative(rhs)) {
-        result=-1;
-        break;
-        }
-      if (!decNumberIsNegative(lhs) & decNumberIsNegative(rhs)) {
-        result=+1;
-        break;
-        }
-      }
-
-    // handle NaNs specially; let infinities drop through
-    // This assumes sNaN (even just one) leads to NaN.
-    merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN);
-    if (merged) {                       // a NaN bit set
-      if (op == COMPARE);               // result will be NaN
-       else if (op == COMPTOTAL) {      // total ordering, always finite
-        // signs are known to be the same; compute the ordering here
-        // as if the signs are both positive, then invert for negatives
-        if (!decNumberIsNaN(lhs)) result=-1;
-         else if (!decNumberIsNaN(rhs)) result=+1;
-         // here if both NaNs
-         else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1;
-         else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1;
-         else { // both NaN or both sNaN
-          // now it just depends on the payload
-          result=decUnitCompare(lhs->lsu, D2U(lhs->digits),
-                                rhs->lsu, D2U(rhs->digits), 0);
-          // [Error not possible, as these are 'aligned']
-          } // both same NaNs
-        if (decNumberIsNegative(lhs)) result=-result;
-        break;
-        } // total order
-
-       else if (merged & DECSNAN);      // sNaN -> qNaN
-       else { // here if MIN or MAX and one or two quiet NaNs
-        // min or max -- 754r rules ignore single NaN
-        if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) {
-          // just one NaN; force choice to be the non-NaN operand
-          op=COMPMAX;
-          if (lhs->bits & DECNAN) result=-1; // pick rhs
-                             else result=+1; // pick lhs
-          break;
-          }
-        } // max or min
-      op = COMPNAN;                     // use special path
-      decNaNs(res, lhs, rhs, status);
-      break;
-      }
-    result=decCompare(lhs, rhs, 0);     // have numbers
-    } while(0);                         // end protected
-
-  if (result==BADINT) *status|=DEC_Insufficient_storage; // rare
-   else {
-    if (op == COMPARE || op == COMPTOTAL) {  // returning signum
-      if (op == COMPTOTAL && result==0) {
-        // operands are numerically equal or same NaN (and same sign,
-        // tested first); if identical, leave result 0
-        if (lhs->exponent!=rhs->exponent) {
-          if (lhs->exponent<rhs->exponent) result=-1;
-           else result=+1;
-          if (decNumberIsNegative(lhs)) result=-result;
-          } // lexp!=rexp
-        } // total-order by exponent
-      decNumberZero(res);               // [always a valid result]
-      if (result!=0) {                  // must be -1 or +1
-        *res->lsu=1;
-        if (result<0) res->bits=DECNEG;
-        }
-      }
-     else if (op == COMPNAN);           // special, drop through
-     else {                             // MAX or MIN, non-NaN result
-      Int residue=0;                    // rounding accumulator
-      // choose the operand for the result
-      const decNumber *choice;
-      if (result==0) { // operands are numerically equal
-        // choose according to sign then exponent (see 754r)
-        uByte slhs=(lhs->bits & DECNEG);
-        uByte srhs=(rhs->bits & DECNEG);
-        #if DECSUBSET
-        if (!set->extended) {           // subset: force left-hand
-          op=COMPMAX;
-          result=+1;
-          }
-        else
-        #endif
-        if (slhs!=srhs) {          // signs differ
-          if (slhs) result=-1;     // rhs is max
-               else result=+1;     // lhs is max
-          }
-         else if (slhs && srhs) {  // both negative
-          if (lhs->exponent<rhs->exponent) result=+1;
-                                      else result=-1;
-          // [if equal, use lhs, technically identical]
-          }
-         else {                    // both positive
-          if (lhs->exponent>rhs->exponent) result=+1;
-                                      else result=-1;
-          // [ditto]
-          }
-        } // numerically equal
-      // here result will be non-0
-      if (op == COMPMIN) result=-result;// reverse if looking for MIN
-      choice=(result>0 ? lhs : rhs);    // choose
-      // copy chosen to result, rounding if need be
-      decCopyFit(res, choice, set, &residue, status);
-      decFinish(res, set, &residue, status);
-      }
-    }
-  #if DECSUBSET
-  if (allocrhs!=NULL) free(allocrhs);   // free any storage used
-  if (alloclhs!=NULL) free(alloclhs);   // ..
-  #endif
-  return res;
-  } // decCompareOp
-
-/* ------------------------------------------------------------------ */
-/* decCompare -- compare two decNumbers by numerical value            */
-/*                                                                    */
-/*  This routine compares A ? B without altering them.                */
-/*                                                                    */
-/*  Arg1 is A, a decNumber which is not a NaN                         */
-/*  Arg2 is B, a decNumber which is not a NaN                         */
-/*  Arg3 is 1 for a sign-independent compare, 0 otherwise             */
-/*                                                                    */
-/*  returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure   */
-/*  (the only possible failure is an allocation error)                */
-/* ------------------------------------------------------------------ */
-static Int decCompare(const decNumber *lhs, const decNumber *rhs,
-                      Flag abs) {
-  Int   result;                    // result value
-  Int   sigr;                      // rhs signum
-  Int   compare;                   // work
-
-  result=1;                                  // assume signum(lhs)
-  if (ISZERO(lhs)) result=0;
-  if (abs) {
-    if (!ISZERO(rhs)) result=1;              // not both 0
-    }
-   else {                                    // signs matter
-    if (result && decNumberIsNegative(lhs)) result=-1;
-    sigr=1;                                  // compute signum(rhs)
-    if (ISZERO(rhs)) sigr=0;
-     else if (decNumberIsNegative(rhs)) sigr=-1;
-    if (result > sigr) return +1;            // L > R, return 1
-    if (result < sigr) return -1;            // R < L, return -1
-    }
-
-  // signums are the same
-  if (result==0) return 0;                   // both 0
-  // Both non-zero
-  if ((lhs->bits | rhs->bits) & DECINF) {    // one or more infinities
-    if (decNumberIsInfinite(rhs)) {
-      if (decNumberIsInfinite(lhs)) result=0;// both infinite
-       else result=-result;                  // only rhs infinite
-      }
-    return result;
-    }
-
-  // must compare the coefficients, allowing for exponents
-  if (lhs->exponent>rhs->exponent) {         // LHS exponent larger
-    // swap sides, and sign
-    const decNumber *temp=lhs;
-    lhs=rhs;
-    rhs=temp;
-    result=-result;
-    }
-
-  compare=decUnitCompare(lhs->lsu, D2U(lhs->digits),
-                         rhs->lsu, D2U(rhs->digits),
-                         rhs->exponent-lhs->exponent);
-
-  if (compare!=BADINT) compare*=result;      // comparison succeeded
-  return compare;
-  } // decCompare
-
-/* ------------------------------------------------------------------ */
-/* decUnitCompare -- compare two >=0 integers in Unit arrays          */
-/*                                                                    */
-/*  This routine compares A ? B*10**E where A and B are unit arrays   */
-/*  A is a plain integer                                              */
-/*  B has an exponent of E (which must be non-negative)               */
-/*                                                                    */
-/*  Arg1 is A first Unit (lsu)                                        */
-/*  Arg2 is A length in Units                                         */
-/*  Arg3 is B first Unit (lsu)                                        */
-/*  Arg4 is B length in Units                                         */
-/*  Arg5 is E (0 if the units are aligned)                            */
-/*                                                                    */
-/*  returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure   */
-/*  (the only possible failure is an allocation error, which can      */
-/*  only occur if E!=0)                                               */
-/* ------------------------------------------------------------------ */
-static Int decUnitCompare(const Unit *a, Int alength,
-                          const Unit *b, Int blength, Int exp) {
-  Unit  *acc;                      // accumulator for result
-  Unit  accbuff[SD2U(DECBUFFER+1)];// local buffer
-  Unit  *allocacc=NULL;            // -> allocated acc buffer, iff allocated
-  Int   accunits, need;            // units in use or needed for acc
-  const Unit *l, *r, *u;           // work
-  Int   expunits, exprem, result;  // ..
-
-  if (exp==0) {                    // aligned; fastpath
-    if (alength>blength) return 1;
-    if (alength<blength) return -1;
-    // same number of units in both -- need unit-by-unit compare
-    l=a+alength-1;
-    r=b+alength-1;
-    for (;l>=a; l--, r--) {
-      if (*l>*r) return 1;
-      if (*l<*r) return -1;
-      }
-    return 0;                      // all units match
-    } // aligned
-
-  // Unaligned.  If one is >1 unit longer than the other, padded
-  // approximately, then can return easily
-  if (alength>blength+(Int)D2U(exp)) return 1;
-  if (alength+1<blength+(Int)D2U(exp)) return -1;
-
-  // Need to do a real subtract.  For this, a result buffer is needed
-  // even though only the sign is of interest.  Its length needs
-  // to be the larger of alength and padded blength, +2
-  need=blength+D2U(exp);                // maximum real length of B
-  if (need<alength) need=alength;
-  need+=2;
-  acc=accbuff;                          // assume use local buffer
-  if (need*sizeof(Unit)>sizeof(accbuff)) {
-    allocacc=(Unit *)malloc(need*sizeof(Unit));
-    if (allocacc==NULL) return BADINT;  // hopeless -- abandon
-    acc=allocacc;
-    }
-  // Calculate units and remainder from exponent.
-  expunits=exp/DECDPUN;
-  exprem=exp%DECDPUN;
-  // subtract [A+B*(-m)]
-  accunits=decUnitAddSub(a, alength, b, blength, expunits, acc,
-                         -(Int)powers[exprem]);
-  // [UnitAddSub result may have leading zeros, even on zero]
-  if (accunits<0) result=-1;            // negative result
-   else {                               // non-negative result
-    // check units of the result before freeing any storage
-    for (u=acc; u<acc+accunits-1 && *u==0;) u++;
-    result=(*u==0 ? 0 : +1);
-    }
-  // clean up and return the result
-  if (allocacc!=NULL) free(allocacc);   // drop any storage used
-  return result;
-  } // decUnitCompare
-
-/* ------------------------------------------------------------------ */
-/* decUnitAddSub -- add or subtract two >=0 integers in Unit arrays   */
-/*                                                                    */
-/*  This routine performs the calculation:                            */
-/*                                                                    */
-/*  C=A+(B*M)                                                         */
-/*                                                                    */
-/*  Where M is in the range -DECDPUNMAX through +DECDPUNMAX.          */
-/*                                                                    */
-/*  A may be shorter or longer than B.                                */
-/*                                                                    */
-/*  Leading zeros are not removed after a calculation.  The result is */
-/*  either the same length as the longer of A and B (adding any       */
-/*  shift), or one Unit longer than that (if a Unit carry occurred).  */
-/*                                                                    */
-/*  A and B content are not altered unless C is also A or B.          */
-/*  C may be the same array as A or B, but only if no zero padding is */
-/*  requested (that is, C may be B only if bshift==0).                */
-/*  C is filled from the lsu; only those units necessary to complete  */
-/*  the calculation are referenced.                                   */
-/*                                                                    */
-/*  Arg1 is A first Unit (lsu)                                        */
-/*  Arg2 is A length in Units                                         */
-/*  Arg3 is B first Unit (lsu)                                        */
-/*  Arg4 is B length in Units                                         */
-/*  Arg5 is B shift in Units  (>=0; pads with 0 units if positive)    */
-/*  Arg6 is C first Unit (lsu)                                        */
-/*  Arg7 is M, the multiplier                                         */
-/*                                                                    */
-/*  returns the count of Units written to C, which will be non-zero   */
-/*  and negated if the result is negative.  That is, the sign of the  */
-/*  returned Int is the sign of the result (positive for zero) and    */
-/*  the absolute value of the Int is the count of Units.              */
-/*                                                                    */
-/*  It is the caller's responsibility to make sure that C size is     */
-/*  safe, allowing space if necessary for a one-Unit carry.           */
-/*                                                                    */
-/*  This routine is severely performance-critical; *any* change here  */
-/*  must be measured (timed) to assure no performance degradation.    */
-/*  In particular, trickery here tends to be counter-productive, as   */
-/*  increased complexity of code hurts register optimizations on      */
-/*  register-poor architectures.  Avoiding divisions is nearly        */
-/*  always a Good Idea, however.                                      */
-/*                                                                    */
-/* Special thanks to Rick McGuire (IBM Cambridge, MA) and Dave Clark  */
-/* (IBM Warwick, UK) for some of the ideas used in this routine.      */
-/* ------------------------------------------------------------------ */
-static Int decUnitAddSub(const Unit *a, Int alength,
-                         const Unit *b, Int blength, Int bshift,
-                         Unit *c, Int m) {
-  const Unit *alsu=a;              // A lsu [need to remember it]
-  Unit *clsu=c;                    // C ditto
-  Unit *minC;                      // low water mark for C
-  Unit *maxC;                      // high water mark for C
-  eInt carry=0;                    // carry integer (could be Long)
-  Int  add;                        // work
-  #if DECDPUN<=4                   // myriadal, millenary, etc.
-  Int  est;                        // estimated quotient
-  #endif
-
-  #if DECTRACE
-  if (alength<1 || blength<1)
-    printf("decUnitAddSub: alen blen m %d %d [%d]\n", alength, blength, m);
-  #endif
-
-  maxC=c+alength;                  // A is usually the longer
-  minC=c+blength;                  // .. and B the shorter
-  if (bshift!=0) {                 // B is shifted; low As copy across
-    minC+=bshift;
-    // if in place [common], skip copy unless there's a gap [rare]
-    if (a==c && bshift<=alength) {
-      c+=bshift;
-      a+=bshift;
-      }
-     else for (; c<clsu+bshift; a++, c++) {  // copy needed
-      if (a<alsu+alength) *c=*a;
-       else *c=0;
-      }
-    }
-  if (minC>maxC) { // swap
-    Unit *hold=minC;
-    minC=maxC;
-    maxC=hold;
-    }
-
-  // For speed, do the addition as two loops; the first where both A
-  // and B contribute, and the second (if necessary) where only one or
-  // other of the numbers contribute.
-  // Carry handling is the same (i.e., duplicated) in each case.
-  for (; c<minC; c++) {
-    carry+=*a;
-    a++;
-    carry+=((eInt)*b)*m;                // [special-casing m=1/-1
-    b++;                                // here is not a win]
-    // here carry is new Unit of digits; it could be +ve or -ve
-    if ((ueInt)carry<=DECDPUNMAX) {     // fastpath 0-DECDPUNMAX
-      *c=(Unit)carry;
-      carry=0;
-      continue;
-      }
-    #if DECDPUN==4                           // use divide-by-multiply
-      if (carry>=0) {
-        est=(((ueInt)carry>>11)*53687)>>18;
-        *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder
-        carry=est;                           // likely quotient [89%]
-        if (*c<DECDPUNMAX+1) continue;       // estimate was correct
-        carry++;
-        *c-=DECDPUNMAX+1;
-        continue;
-        }
-      // negative case
-      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
-      est=(((ueInt)carry>>11)*53687)>>18;
-      *c=(Unit)(carry-est*(DECDPUNMAX+1));
-      carry=est-(DECDPUNMAX+1);              // correctly negative
-      if (*c<DECDPUNMAX+1) continue;         // was OK
-      carry++;
-      *c-=DECDPUNMAX+1;
-    #elif DECDPUN==3
-      if (carry>=0) {
-        est=(((ueInt)carry>>3)*16777)>>21;
-        *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder
-        carry=est;                           // likely quotient [99%]
-        if (*c<DECDPUNMAX+1) continue;       // estimate was correct
-        carry++;
-        *c-=DECDPUNMAX+1;
-        continue;
-        }
-      // negative case
-      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
-      est=(((ueInt)carry>>3)*16777)>>21;
-      *c=(Unit)(carry-est*(DECDPUNMAX+1));
-      carry=est-(DECDPUNMAX+1);              // correctly negative
-      if (*c<DECDPUNMAX+1) continue;         // was OK
-      carry++;
-      *c-=DECDPUNMAX+1;
-    #elif DECDPUN<=2
-      // Can use QUOT10 as carry <= 4 digits
-      if (carry>=0) {
-        est=QUOT10(carry, DECDPUN);
-        *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder
-        carry=est;                           // quotient
-        continue;
-        }
-      // negative case
-      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
-      est=QUOT10(carry, DECDPUN);
-      *c=(Unit)(carry-est*(DECDPUNMAX+1));
-      carry=est-(DECDPUNMAX+1);              // correctly negative
-    #else
-      // remainder operator is undefined if negative, so must test
-      if ((ueInt)carry<(DECDPUNMAX+1)*2) {   // fastpath carry +1
-        *c=(Unit)(carry-(DECDPUNMAX+1));     // [helps additions]
-        carry=1;
-        continue;
-        }
-      if (carry>=0) {
-        *c=(Unit)(carry%(DECDPUNMAX+1));
-        carry=carry/(DECDPUNMAX+1);
-        continue;
-        }
-      // negative case
-      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
-      *c=(Unit)(carry%(DECDPUNMAX+1));
-      carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
-    #endif
-    } // c
-
-  // now may have one or other to complete
-  // [pretest to avoid loop setup/shutdown]
-  if (c<maxC) for (; c<maxC; c++) {
-    if (a<alsu+alength) {               // still in A
-      carry+=*a;
-      a++;
-      }
-     else {                             // inside B
-      carry+=((eInt)*b)*m;
-      b++;
-      }
-    // here carry is new Unit of digits; it could be +ve or -ve and
-    // magnitude up to DECDPUNMAX squared
-    if ((ueInt)carry<=DECDPUNMAX) {     // fastpath 0-DECDPUNMAX
-      *c=(Unit)carry;
-      carry=0;
-      continue;
-      }
-    // result for this unit is negative or >DECDPUNMAX
-    #if DECDPUN==4                           // use divide-by-multiply
-      if (carry>=0) {
-        est=(((ueInt)carry>>11)*53687)>>18;
-        *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder
-        carry=est;                           // likely quotient [79.7%]
-        if (*c<DECDPUNMAX+1) continue;       // estimate was correct
-        carry++;
-        *c-=DECDPUNMAX+1;
-        continue;
-        }
-      // negative case
-      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
-      est=(((ueInt)carry>>11)*53687)>>18;
-      *c=(Unit)(carry-est*(DECDPUNMAX+1));
-      carry=est-(DECDPUNMAX+1);              // correctly negative
-      if (*c<DECDPUNMAX+1) continue;         // was OK
-      carry++;
-      *c-=DECDPUNMAX+1;
-    #elif DECDPUN==3
-      if (carry>=0) {
-        est=(((ueInt)carry>>3)*16777)>>21;
-        *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder
-        carry=est;                           // likely quotient [99%]
-        if (*c<DECDPUNMAX+1) continue;       // estimate was correct
-        carry++;
-        *c-=DECDPUNMAX+1;
-        continue;
-        }
-      // negative case
-      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
-      est=(((ueInt)carry>>3)*16777)>>21;
-      *c=(Unit)(carry-est*(DECDPUNMAX+1));
-      carry=est-(DECDPUNMAX+1);              // correctly negative
-      if (*c<DECDPUNMAX+1) continue;         // was OK
-      carry++;
-      *c-=DECDPUNMAX+1;
-    #elif DECDPUN<=2
-      if (carry>=0) {
-        est=QUOT10(carry, DECDPUN);
-        *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder
-        carry=est;                           // quotient
-        continue;
-        }
-      // negative case
-      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
-      est=QUOT10(carry, DECDPUN);
-      *c=(Unit)(carry-est*(DECDPUNMAX+1));
-      carry=est-(DECDPUNMAX+1);              // correctly negative
-    #else
-      if ((ueInt)carry<(DECDPUNMAX+1)*2){    // fastpath carry 1
-        *c=(Unit)(carry-(DECDPUNMAX+1));
-        carry=1;
-        continue;
-        }
-      // remainder operator is undefined if negative, so must test
-      if (carry>=0) {
-        *c=(Unit)(carry%(DECDPUNMAX+1));
-        carry=carry/(DECDPUNMAX+1);
-        continue;
-        }
-      // negative case
-      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
-      *c=(Unit)(carry%(DECDPUNMAX+1));
-      carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
-    #endif
-    } // c
-
-  // OK, all A and B processed; might still have carry or borrow
-  // return number of Units in the result, negated if a borrow
-  if (carry==0) return c-clsu;     // no carry, so no more to do
-  if (carry>0) {                   // positive carry
-    *c=(Unit)carry;                // place as new unit
-    c++;                           // ..
-    return c-clsu;
-    }
-  // -ve carry: it's a borrow; complement needed
-  add=1;                           // temporary carry...
-  for (c=clsu; c<maxC; c++) {
-    add=DECDPUNMAX+add-*c;
-    if (add<=DECDPUNMAX) {
-      *c=(Unit)add;
-      add=0;
-      }
-     else {
-      *c=0;
-      add=1;
-      }
-    }
-  // add an extra unit iff it would be non-zero
-  #if DECTRACE
-    printf("UAS borrow: add %d, carry %d\n", add, carry);
-  #endif
-  if ((add-carry-1)!=0) {
-    *c=(Unit)(add-carry-1);
-    c++;                      // interesting, include it
-    }
-  return clsu-c;              // -ve result indicates borrowed
-  } // decUnitAddSub
-
-/* ------------------------------------------------------------------ */
-/* decTrim -- trim trailing zeros or normalize                        */
-/*                                                                    */
-/*   dn is the number to trim or normalize                            */
-/*   all is 1 to remove all trailing zeros, 0 for just fraction ones  */
-/*   dropped returns the number of discarded trailing zeros           */
-/*   returns dn                                                       */
-/*                                                                    */
-/* All fields are updated as required.  This is a utility operation,  */
-/* so special values are unchanged and no error is possible.          */
-/* ------------------------------------------------------------------ */
-static decNumber * decTrim(decNumber *dn, Flag all, Int *dropped) {
-  Int   d, exp;                    // work
-  uInt  cut;                       // ..
-  Unit  *up;                       // -> current Unit
-
-  #if DECCHECK
-  if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNUSED)) return dn;
-  #endif
-
-  *dropped=0;                           // assume no zeros dropped
-  if ((dn->bits & DECSPECIAL)           // fast exit if special ..
-    || (*dn->lsu & 0x01)) return dn;    // .. or odd
-  if (ISZERO(dn)) {                     // .. or 0
-    dn->exponent=0;                     // (sign is preserved)
-    return dn;
-    }
-
-  // have a finite number which is even
-  exp=dn->exponent;
-  cut=1;                           // digit (1-DECDPUN) in Unit
-  up=dn->lsu;                      // -> current Unit
-  for (d=0; d<dn->digits-1; d++) { // [don't strip the final digit]
-    // slice by powers
-    #if DECDPUN<=4
-      uInt quot=QUOT10(*up, cut);
-      if ((*up-quot*powers[cut])!=0) break;  // found non-0 digit
-    #else
-      if (*up%powers[cut]!=0) break;         // found non-0 digit
-    #endif
-    // have a trailing 0
-    if (!all) {                    // trimming
-      // [if exp>0 then all trailing 0s are significant for trim]
-      if (exp<=0) {                // if digit might be significant
-        if (exp==0) break;         // then quit
-        exp++;                     // next digit might be significant
-        }
-      }
-    cut++;                         // next power
-    if (cut>DECDPUN) {             // need new Unit
-      up++;
-      cut=1;
-      }
-    } // d
-  if (d==0) return dn;             // none dropped
-
-  // effect the drop
-  decShiftToLeast(dn->lsu, D2U(dn->digits), d);
-  dn->exponent+=d;                 // maintain numerical value
-  dn->digits-=d;                   // new length
-  *dropped=d;                      // report the count
-  return dn;
-  } // decTrim
-
-/* ------------------------------------------------------------------ */
-/* decShiftToMost -- shift digits in array towards most significant   */
-/*                                                                    */
-/*   uar    is the array                                              */
-/*   digits is the count of digits in use in the array                */
-/*   shift  is the number of zeros to pad with (least significant);   */
-/*     it must be zero or positive                                    */
-/*                                                                    */
-/*   returns the new length of the integer in the array, in digits    */
-/*                                                                    */
-/* No overflow is permitted (that is, the uar array must be known to  */
-/* be large enough to hold the result, after shifting).               */
-/* ------------------------------------------------------------------ */
-static Int decShiftToMost(Unit *uar, Int digits, Int shift) {
-  Unit  *target, *source, *first;  // work
-  Int   cut;                       // odd 0's to add
-  uInt  next;                      // work
-
-  if (shift==0) return digits;     // [fastpath] nothing to do
-  if ((digits+shift)<=DECDPUN) {   // [fastpath] single-unit case
-    *uar=(Unit)(*uar*powers[shift]);
-    return digits+shift;
-    }
-
-  next=0;                          // all paths
-  source=uar+D2U(digits)-1;        // where msu comes from
-  target=source+D2U(shift);        // where upper part of first cut goes
-  cut=DECDPUN-MSUDIGITS(shift);    // where to slice
-  if (cut==0) {                    // unit-boundary case
-    for (; source>=uar; source--, target--) *target=*source;
-    }
-   else {
-    first=uar+D2U(digits+shift)-1; // where msu of source will end up
-    for (; source>=uar; source--, target--) {
-      // split the source Unit and accumulate remainder for next
-      #if DECDPUN<=4
-        uInt quot=QUOT10(*source, cut);
-        uInt rem=*source-quot*powers[cut];
-        next+=quot;
-      #else
-        uInt rem=*source%powers[cut];
-        next+=*source/powers[cut];
-      #endif
-      if (target<=first) *target=(Unit)next;   // write to target iff valid
-      next=rem*powers[DECDPUN-cut];            // save remainder for next Unit
-      }
-    } // shift-move
-
-  // propagate any partial unit to one below and clear the rest
-  for (; target>=uar; target--) {
-    *target=(Unit)next;
-    next=0;
-    }
-  return digits+shift;
-  } // decShiftToMost
-
-/* ------------------------------------------------------------------ */
-/* decShiftToLeast -- shift digits in array towards least significant */
-/*                                                                    */
-/*   uar   is the array                                               */
-/*   units is length of the array, in units                           */
-/*   shift is the number of digits to remove from the lsu end; it     */
-/*     must be zero or positive and less than units*DECDPUN.          */
-/*                                                                    */
-/*   returns the new length of the integer in the array, in units     */
-/*                                                                    */
-/* Removed digits are discarded (lost).  Units not required to hold   */
-/* the final result are unchanged.                                    */
-/* ------------------------------------------------------------------ */
-static Int decShiftToLeast(Unit *uar, Int units, Int shift) {
-  Unit  *target, *up;              // work
-  Int   cut, count;                // work
-  Int   quot, rem;                 // for division
-
-  if (shift==0) return units;      // [fastpath] nothing to do
-
-  target=uar;                      // both paths
-  cut=MSUDIGITS(shift);
-  if (cut==DECDPUN) {              // unit-boundary case; easy
-    up=uar+D2U(shift);
-    for (; up<uar+units; target++, up++) *target=*up;
-    return target-uar;
-    }
-
-  // messier
-  up=uar+D2U(shift-cut);           // source; correct to whole Units
-  count=units*DECDPUN-shift;       // the maximum new length
-  #if DECDPUN<=4
-    quot=QUOT10(*up, cut);
-  #else
-    quot=*up/powers[cut];
-  #endif
-  for (; ; target++) {
-    *target=(Unit)quot;
-    count-=(DECDPUN-cut);
-    if (count<=0) break;
-    up++;
-    quot=*up;
-    #if DECDPUN<=4
-      quot=QUOT10(quot, cut);
-      rem=*up-quot*powers[cut];
-    #else
-      rem=quot%powers[cut];
-      quot=quot/powers[cut];
-    #endif
-    *target=(Unit)(*target+rem*powers[DECDPUN-cut]);
-    count-=cut;
-    if (count<=0) break;
-    }
-  return target-uar+1;
-  } // decShiftToLeast
-
-#if DECSUBSET
-/* ------------------------------------------------------------------ */
-/* decRoundOperand -- round an operand  [used for subset only]        */
-/*                                                                    */
-/*   dn is the number to round (dn->digits is > set->digits)          */
-/*   set is the relevant context                                      */
-/*   status is the status accumulator                                 */
-/*                                                                    */
-/*   returns an allocated decNumber with the rounded result.          */
-/*                                                                    */
-/* lostDigits and other status may be set by this.                    */
-/*                                                                    */
-/* Since the input is an operand, it must not be modified.            */
-/* Instead, return an allocated decNumber, rounded as required.       */
-/* It is the caller's responsibility to free the allocated storage.   */
-/*                                                                    */
-/* If no storage is available then the result cannot be used, so NULL */
-/* is returned.                                                       */
-/* ------------------------------------------------------------------ */
-static decNumber *decRoundOperand(const decNumber *dn, decContext *set,
-                                  uInt *status) {
-  decNumber *res;                       // result structure
-  uInt newstatus=0;                     // status from round
-  Int  residue=0;                       // rounding accumulator
-
-  // Allocate storage for the returned decNumber, big enough for the
-  // length specified by the context
-  res=(decNumber *)malloc(sizeof(decNumber)
-                          +(D2U(set->digits)-1)*sizeof(Unit));
-  if (res==NULL) {
-    *status|=DEC_Insufficient_storage;
-    return NULL;
-    }
-  decCopyFit(res, dn, set, &residue, &newstatus);
-  decApplyRound(res, set, residue, &newstatus);
-
-  // If that set Inexact then "lost digits" is raised...
-  if (newstatus & DEC_Inexact) newstatus|=DEC_Lost_digits;
-  *status|=newstatus;
-  return res;
-  } // decRoundOperand
-#endif
-
-/* ------------------------------------------------------------------ */
-/* decCopyFit -- copy a number, truncating the coefficient if needed  */
-/*                                                                    */
-/*   dest is the target decNumber                                     */
-/*   src  is the source decNumber                                     */
-/*   set is the context [used for length (digits) and rounding mode]  */
-/*   residue is the residue accumulator                               */
-/*   status contains the current status to be updated                 */
-/*                                                                    */
-/* (dest==src is allowed and will be a no-op if fits)                 */
-/* All fields are updated as required.                                */
-/* ------------------------------------------------------------------ */
-static void decCopyFit(decNumber *dest, const decNumber *src,
-                       decContext *set, Int *residue, uInt *status) {
-  dest->bits=src->bits;
-  dest->exponent=src->exponent;
-  decSetCoeff(dest, set, src->lsu, src->digits, residue, status);
-  } // decCopyFit
-
-/* ------------------------------------------------------------------ */
-/* decSetCoeff -- set the coefficient of a number                     */
-/*                                                                    */
-/*   dn    is the number whose coefficient array is to be set.        */
-/*         It must have space for set->digits digits                  */
-/*   set   is the context [for size]                                  */
-/*   lsu   -> lsu of the source coefficient [may be dn->lsu]          */
-/*   len   is digits in the source coefficient [may be dn->digits]    */
-/*   residue is the residue accumulator.  This has values as in       */
-/*         decApplyRound, and will be unchanged unless the            */
-/*         target size is less than len.  In this case, the           */
-/*         coefficient is truncated and the residue is updated to     */
-/*         reflect the previous residue and the dropped digits.       */
-/*   status is the status accumulator, as usual                       */
-/*                                                                    */
-/* The coefficient may already be in the number, or it can be an      */
-/* external intermediate array.  If it is in the number, lsu must ==  */
-/* dn->lsu and len must == dn->digits.                                */
-/*                                                                    */
-/* Note that the coefficient length (len) may be < set->digits, and   */
-/* in this case this merely copies the coefficient (or is a no-op     */
-/* if dn->lsu==lsu).                                                  */
-/*                                                                    */
-/* Note also that (only internally, from decQuantizeOp and            */
-/* decSetSubnormal) the value of set->digits may be less than one,    */
-/* indicating a round to left.  This routine handles that case        */
-/* correctly; caller ensures space.                                   */
-/*                                                                    */
-/* dn->digits, dn->lsu (and as required), and dn->exponent are        */
-/* updated as necessary.   dn->bits (sign) is unchanged.              */
-/*                                                                    */
-/* DEC_Rounded status is set if any digits are discarded.             */
-/* DEC_Inexact status is set if any non-zero digits are discarded, or */
-/*                       incoming residue was non-0 (implies rounded) */
-/* ------------------------------------------------------------------ */
-// mapping array: maps 0-9 to canonical residues, so that a residue
-// can be adjusted in the range [-1, +1] and achieve correct rounding
-//                             0  1  2  3  4  5  6  7  8  9
-static const uByte resmap[10]={0, 3, 3, 3, 3, 5, 7, 7, 7, 7};
-static void decSetCoeff(decNumber *dn, decContext *set, const Unit *lsu,
-                        Int len, Int *residue, uInt *status) {
-  Int   discard;              // number of digits to discard
-  uInt  cut;                  // cut point in Unit
-  const Unit *up;             // work
-  Unit  *target;              // ..
-  Int   count;                // ..
-  #if DECDPUN<=4
-  uInt  temp;                 // ..
-  #endif
-
-  discard=len-set->digits;    // digits to discard
-  if (discard<=0) {           // no digits are being discarded
-    if (dn->lsu!=lsu) {       // copy needed
-      // copy the coefficient array to the result number; no shift needed
-      count=len;              // avoids D2U
-      up=lsu;
-      for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
-        *target=*up;
-      dn->digits=len;         // set the new length
-      }
-    // dn->exponent and residue are unchanged, record any inexactitude
-    if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded);
-    return;
-    }
-
-  // some digits must be discarded ...
-  dn->exponent+=discard;      // maintain numerical value
-  *status|=DEC_Rounded;       // accumulate Rounded status
-  if (*residue>1) *residue=1; // previous residue now to right, so reduce
-
-  if (discard>len) {          // everything, +1, is being discarded
-    // guard digit is 0
-    // residue is all the number [NB could be all 0s]
-    if (*residue<=0) {        // not already positive
-      count=len;              // avoids D2U
-      for (up=lsu; count>0; up++, count-=DECDPUN) if (*up!=0) { // found non-0
-        *residue=1;
-        break;                // no need to check any others
-        }
-      }
-    if (*residue!=0) *status|=DEC_Inexact; // record inexactitude
-    *dn->lsu=0;               // coefficient will now be 0
-    dn->digits=1;             // ..
-    return;
-    } // total discard
-
-  // partial discard [most common case]
-  // here, at least the first (most significant) discarded digit exists
-
-  // spin up the number, noting residue during the spin, until get to
-  // the Unit with the first discarded digit.  When reach it, extract
-  // it and remember its position
-  count=0;
-  for (up=lsu;; up++) {
-    count+=DECDPUN;
-    if (count>=discard) break; // full ones all checked
-    if (*up!=0) *residue=1;
-    } // up
-
-  // here up -> Unit with first discarded digit
-  cut=discard-(count-DECDPUN)-1;
-  if (cut==DECDPUN-1) {       // unit-boundary case (fast)
-    Unit half=(Unit)powers[DECDPUN]>>1;
-    // set residue directly
-    if (*up>=half) {
-      if (*up>half) *residue=7;
-      else *residue+=5;       // add sticky bit
-      }
-     else { // <half
-      if (*up!=0) *residue=3; // [else is 0, leave as sticky bit]
-      }
-    if (set->digits<=0) {     // special for Quantize/Subnormal :-(
-      *dn->lsu=0;             // .. result is 0
-      dn->digits=1;           // ..
-      }
-     else {                   // shift to least
-      count=set->digits;      // now digits to end up with
-      dn->digits=count;       // set the new length
-      up++;                   // move to next
-      // on unit boundary, so shift-down copy loop is simple
-      for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
-        *target=*up;
-      }
-    } // unit-boundary case
-
-   else { // discard digit is in low digit(s), and not top digit
-    uInt  discard1;                // first discarded digit
-    uInt  quot, rem;               // for divisions
-    if (cut==0) quot=*up;          // is at bottom of unit
-     else /* cut>0 */ {            // it's not at bottom of unit
-      #if DECDPUN<=4
-        quot=QUOT10(*up, cut);
-        rem=*up-quot*powers[cut];
-      #else
-        rem=*up%powers[cut];
-        quot=*up/powers[cut];
-      #endif
-      if (rem!=0) *residue=1;
-      }
-    // discard digit is now at bottom of quot
-    #if DECDPUN<=4
-      temp=(quot*6554)>>16;        // fast /10
-      // Vowels algorithm here not a win (9 instructions)
-      discard1=quot-X10(temp);
-      quot=temp;
-    #else
-      discard1=quot%10;
-      quot=quot/10;
-    #endif
-    // here, discard1 is the guard digit, and residue is everything
-    // else [use mapping array to accumulate residue safely]
-    *residue+=resmap[discard1];
-    cut++;                         // update cut
-    // here: up -> Unit of the array with bottom digit
-    //       cut is the division point for each Unit
-    //       quot holds the uncut high-order digits for the current unit
-    if (set->digits<=0) {          // special for Quantize/Subnormal :-(
-      *dn->lsu=0;                  // .. result is 0
-      dn->digits=1;                // ..
-      }
-     else {                        // shift to least needed
-      count=set->digits;           // now digits to end up with
-      dn->digits=count;            // set the new length
-      // shift-copy the coefficient array to the result number
-      for (target=dn->lsu; ; target++) {
-        *target=(Unit)quot;
-        count-=(DECDPUN-cut);
-        if (count<=0) break;
-        up++;
-        quot=*up;
-        #if DECDPUN<=4
-          quot=QUOT10(quot, cut);
-          rem=*up-quot*powers[cut];
-        #else
-          rem=quot%powers[cut];
-          quot=quot/powers[cut];
-        #endif
-        *target=(Unit)(*target+rem*powers[DECDPUN-cut]);
-        count-=cut;
-        if (count<=0) break;
-        } // shift-copy loop
-      } // shift to least
-    } // not unit boundary
-
-  if (*residue!=0) *status|=DEC_Inexact; // record inexactitude
-  return;
-  } // decSetCoeff
-
-/* ------------------------------------------------------------------ */
-/* decApplyRound -- apply pending rounding to a number                */
-/*                                                                    */
-/*   dn    is the number, with space for set->digits digits           */
-/*   set   is the context [for size and rounding mode]                */
-/*   residue indicates pending rounding, being any accumulated        */
-/*         guard and sticky information.  It may be:                  */
-/*         6-9: rounding digit is >5                                  */
-/*         5:   rounding digit is exactly half-way                    */
-/*         1-4: rounding digit is <5 and >0                           */
-/*         0:   the coefficient is exact                              */
-/*        -1:   as 1, but the hidden digits are subtractive, that     */
-/*              is, of the opposite sign to dn.  In this case the     */
-/*              coefficient must be non-0.                            */
-/*   status is the status accumulator, as usual                       */
-/*                                                                    */
-/* This routine applies rounding while keeping the length of the      */
-/* coefficient constant.  The exponent and status are unchanged       */
-/* except if:                                                         */
-/*                                                                    */
-/*   -- the coefficient was increased and is all nines (in which      */
-/*      case Overflow could occur, and is handled directly here so    */
-/*      the caller does not need to re-test for overflow)             */
-/*                                                                    */
-/*   -- the coefficient was decreased and becomes all nines (in which */
-/*      case Underflow could occur, and is also handled directly).    */
-/*                                                                    */
-/* All fields in dn are updated as required.                          */
-/*                                                                    */
-/* ------------------------------------------------------------------ */
-static void decApplyRound(decNumber *dn, decContext *set, Int residue,
-                          uInt *status) {
-  Int  bump;                  // 1 if coefficient needs to be incremented
-                              // -1 if coefficient needs to be decremented
-
-  if (residue==0) return;     // nothing to apply
-
-  bump=0;                     // assume a smooth ride
-
-  // now decide whether, and how, to round, depending on mode
-  switch (set->round) {
-    case DEC_ROUND_DOWN: {
-      // no change, except if negative residue
-      if (residue<0) bump=-1;
-      break;} // r-d
-
-    case DEC_ROUND_HALF_DOWN: {
-      if (residue>5) bump=1;
-      break;} // r-h-d
-
-    case DEC_ROUND_HALF_EVEN: {
-      if (residue>5) bump=1;            // >0.5 goes up
-       else if (residue==5) {           // exactly 0.5000...
-        // 0.5 goes up iff [new] lsd is odd
-        if (*dn->lsu & 0x01) bump=1;
-        }
-      break;} // r-h-e
-
-    case DEC_ROUND_HALF_UP: {
-      if (residue>=5) bump=1;
-      break;} // r-h-u
-
-    case DEC_ROUND_UP: {
-      if (residue>0) bump=1;
-      break;} // r-u
-
-    case DEC_ROUND_CEILING: {
-      // same as _UP for positive numbers, and as _DOWN for negatives
-      // [negative residue cannot occur on 0]
-      if (decNumberIsNegative(dn)) {
-        if (residue<0) bump=-1;
-        }
-       else {
-        if (residue>0) bump=1;
-        }
-      break;} // r-c
-
-    case DEC_ROUND_FLOOR: {
-      // same as _UP for negative numbers, and as _DOWN for positive
-      // [negative residue cannot occur on 0]
-      if (!decNumberIsNegative(dn)) {
-        if (residue<0) bump=-1;
-        }
-       else {
-        if (residue>0) bump=1;
-        }
-      break;} // r-f
-
-    default: {      // e.g., DEC_ROUND_MAX
-      *status|=DEC_Invalid_context;
-      #if DECTRACE
-      printf("Unknown rounding mode: %d\n", set->round);
-      #endif
-      break;}
-    } // switch
-
-  // now bump the number, up or down, if need be
-  if (bump==0) return;                       // no action required
-
-  // Simply use decUnitAddSub unless bumping up and the number is
-  // all nines.  In this special case set to 100... explicitly
-  // and adjust the exponent by one (as otherwise could overflow
-  // the array)
-  // Similarly handle all-nines result if bumping down.
-  if (bump>0) {
-    Unit *up;                                // work
-    uInt count=dn->digits;                   // digits to be checked
-    for (up=dn->lsu; ; up++) {
-      if (count<=DECDPUN) {
-        // this is the last Unit (the msu)
-        if (*up!=powers[count]-1) break;     // not still 9s
-        // here if it, too, is all nines
-        *up=(Unit)powers[count-1];           // here 999 -> 100 etc.
-        for (up=up-1; up>=dn->lsu; up--) *up=0; // others all to 0
-        dn->exponent++;                      // and bump exponent
-        // [which, very rarely, could cause Overflow...]
-        if ((dn->exponent+dn->digits)>set->emax+1) {
-          decSetOverflow(dn, set, status);
-          }
-        return;                              // done
-        }
-      // a full unit to check, with more to come
-      if (*up!=DECDPUNMAX) break;            // not still 9s
-      count-=DECDPUN;
-      } // up
-    } // bump>0
-   else {                                    // -1
-    // here checking for a pre-bump of 1000... (leading 1, all
-    // other digits zero)
-    Unit *up, *sup;                          // work
-    uInt count=dn->digits;                   // digits to be checked
-    for (up=dn->lsu; ; up++) {
-      if (count<=DECDPUN) {
-        // this is the last Unit (the msu)
-        if (*up!=powers[count-1]) break;     // not 100..
-        // here if have the 1000... case
-        sup=up;                              // save msu pointer
-        *up=(Unit)powers[count]-1;           // here 100 in msu -> 999
-        // others all to all-nines, too
-        for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1;
-        dn->exponent--;                      // and bump exponent
-
-        // iff the number was at the subnormal boundary (exponent=etiny)
-        // then the exponent is now out of range, so it will in fact get
-        // clamped to etiny and the final 9 dropped.
-        // printf(">> emin=%d exp=%d sdig=%d\n", set->emin,
-        //        dn->exponent, set->digits);
-        if (dn->exponent+1==set->emin-set->digits+1) {
-          if (count==1 && dn->digits==1) *sup=0;  // here 9 -> 0[.9]
-           else {
-            *sup=(Unit)powers[count-1]-1;    // here 999.. in msu -> 99..
-            dn->digits--;
-            }
-          dn->exponent++;
-          *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
-          }
-        return;                              // done
-        }
-
-      // a full unit to check, with more to come
-      if (*up!=0) break;                     // not still 0s
-      count-=DECDPUN;
-      } // up
-
-    } // bump<0
-
-  // Actual bump needed.  Do it.
-  decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump);
-  } // decApplyRound
-
-#if DECSUBSET
-/* ------------------------------------------------------------------ */
-/* decFinish -- finish processing a number                            */
-/*                                                                    */
-/*   dn is the number                                                 */
-/*   set is the context                                               */
-/*   residue is the rounding accumulator (as in decApplyRound)        */
-/*   status is the accumulator                                        */
-/*                                                                    */
-/* This finishes off the current number by:                           */
-/*    1. If not extended:                                             */
-/*       a. Converting a zero result to clean '0'                     */
-/*       b. Reducing positive exponents to 0, if would fit in digits  */
-/*    2. Checking for overflow and subnormals (always)                */
-/* Note this is just Finalize when no subset arithmetic.              */
-/* All fields are updated as required.                                */
-/* ------------------------------------------------------------------ */
-static void decFinish(decNumber *dn, decContext *set, Int *residue,
-                      uInt *status) {
-  if (!set->extended) {
-    if ISZERO(dn) {                // value is zero
-      dn->exponent=0;              // clean exponent ..
-      dn->bits=0;                  // .. and sign
-      return;                      // no error possible
-      }
-    if (dn->exponent>=0) {         // non-negative exponent
-      // >0; reduce to integer if possible
-      if (set->digits >= (dn->exponent+dn->digits)) {
-        dn->digits=decShiftToMost(dn->lsu, dn->digits, dn->exponent);
-        dn->exponent=0;
-        }
-      }
-    } // !extended
-
-  decFinalize(dn, set, residue, status);
-  } // decFinish
-#endif
-
-/* ------------------------------------------------------------------ */
-/* decFinalize -- final check, clamp, and round of a number           */
-/*                                                                    */
-/*   dn is the number                                                 */
-/*   set is the context                                               */
-/*   residue is the rounding accumulator (as in decApplyRound)        */
-/*   status is the status accumulator                                 */
-/*                                                                    */
-/* This finishes off the current number by checking for subnormal     */
-/* results, applying any pending rounding, checking for overflow,     */
-/* and applying any clamping.                                         */
-/* Underflow and overflow conditions are raised as appropriate.       */
-/* All fields are updated as required.                                */
-/* ------------------------------------------------------------------ */
-static void decFinalize(decNumber *dn, decContext *set, Int *residue,
-                        uInt *status) {
-  Int shift;                            // shift needed if clamping
-  Int tinyexp=set->emin-dn->digits+1;   // precalculate subnormal boundary
-
-  // Must be careful, here, when checking the exponent as the
-  // adjusted exponent could overflow 31 bits [because it may already
-  // be up to twice the expected].
-
-  // First test for subnormal.  This must be done before any final
-  // round as the result could be rounded to Nmin or 0.
-  if (dn->exponent<=tinyexp) {          // prefilter
-    decNumber nmin;
-    // A very nasty case here is dn == Nmin and residue<0
-    if (dn->exponent<tinyexp) {
-      // Go handle subnormals; this will apply round if needed.
-      decSetSubnormal(dn, set, residue, status);
-      return;
-      }
-    // Equals case: only subnormal if dn=Nmin and negative residue
-    decNumberZero(&nmin);
-    nmin.lsu[0]=1;
-    nmin.exponent=set->emin;
-    if (*residue<0 && decCompare(dn, &nmin, 1)==0) { // (signless compare)
-      decApplyRound(dn, set, *residue, status);   // might force down
-      decSetSubnormal(dn, set, residue, status);
-      return;
-      }
-    }
-
-  // now apply any pending round (this could raise overflow).
-  if (*residue!=0) decApplyRound(dn, set, *residue, status);
-
-  // Check for overflow [redundant in the 'rare' case] or clamp
-  if (dn->exponent<=set->emax-set->digits+1) return;   // neither needed
-
-  // here when might have an overflow or clamp to do
-  if (dn->exponent>set->emax-dn->digits+1) {           // too big
-    decSetOverflow(dn, set, status);
-    return;
-    }
-  // here when the result is normal but in clamp range
-  if (!set->clamp) return;
-
-  // here when need to apply the IEEE exponent clamp (fold-down)
-  shift=dn->exponent-(set->emax-set->digits+1);
-
-  // shift coefficient (if non-zero)
-  if (!ISZERO(dn)) {
-    dn->digits=decShiftToMost(dn->lsu, dn->digits, shift);
-    }
-  dn->exponent-=shift;   // adjust the exponent to match
-  *status|=DEC_Clamped;  // and record the dirty deed
-  return;
-  } // decFinalize
-
-/* ------------------------------------------------------------------ */
-/* decSetOverflow -- set number to proper overflow value              */
-/*                                                                    */
-/*   dn is the number (used for sign [only] and result)               */
-/*   set is the context [used for the rounding mode]                  */
-/*   status contains the current status to be updated                 */
-/*                                                                    */
-/* This sets the sign of a number and sets its value to either        */
-/* Infinity or the maximum finite value, depending on the sign of     */
-/* dn and therounding mode, following IEEE 854 rules.                 */
-/* ------------------------------------------------------------------ */
-static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) {
-  Flag needmax=0;                  // result is maximum finite value
-  uByte sign=dn->bits&DECNEG;      // clean and save sign bit
-
-  if (ISZERO(dn)) {                // zero does not overflow magnitude
-    Int emax=set->emax;                      // limit value
-    if (set->clamp) emax-=set->digits-1;     // lower if clamping
-    if (dn->exponent>emax) {                 // clamp required
-      dn->exponent=emax;
-      *status|=DEC_Clamped;
-      }
-    return;
-    }
-
-  decNumberZero(dn);
-  switch (set->round) {
-    case DEC_ROUND_DOWN: {
-      needmax=1;                   // never Infinity
-      break;} // r-d
-    case DEC_ROUND_CEILING: {
-      if (sign) needmax=1;         // Infinity if non-negative
-      break;} // r-c
-    case DEC_ROUND_FLOOR: {
-      if (!sign) needmax=1;        // Infinity if negative
-      break;} // r-f
-    default: break;                // Infinity in all other cases
-    }
-  if (needmax) {
-    Unit *up;                      // work
-    Int count=set->digits;         // nines to add
-    dn->digits=count;
-    // fill in all nines to set maximum value
-    for (up=dn->lsu; ; up++) {
-      if (count>DECDPUN) *up=DECDPUNMAX;     // unit full o'nines
-       else {                                // this is the msu
-        *up=(Unit)(powers[count]-1);
-        break;
-        }
-      count-=DECDPUN;              // filled those digits
-      } // up
-    dn->bits=sign;                 // sign
-    dn->exponent=set->emax-set->digits+1;
-    }
-   else dn->bits=sign|DECINF;      // Value is +/-Infinity
-  *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded;
-  } // decSetOverflow
-
-/* ------------------------------------------------------------------ */
-/* decSetSubnormal -- process value whose exponent is <Emin           */
-/*                                                                    */
-/*   dn is the number (used as input as well as output; it may have   */
-/*         an allowed subnormal value, which may need to be rounded)  */
-/*   set is the context [used for the rounding mode]                  */
-/*   residue is any pending residue                                   */
-/*   status contains the current status to be updated                 */
-/*                                                                    */
-/* If subset mode, set result to zero and set Underflow flags.        */
-/*                                                                    */
-/* Value may be zero with a low exponent; this does not set Subnormal */
-/* but the exponent will be clamped to Etiny.                         */
-/*                                                                    */
-/* Otherwise ensure exponent is not out of range, and round as        */
-/* necessary.  Underflow is set if the result is Inexact.             */
-/* ------------------------------------------------------------------ */
-static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue,
-                            uInt *status) {
-// unused  Int        dnexp;           // saves original exponent
-  decContext workset;         // work
-  Int        etiny, adjust;   // ..
-
-  #if DECSUBSET
-  // simple set to zero and 'hard underflow' for subset
-  if (!set->extended) {
-    decNumberZero(dn);
-    // always full overflow
-    *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
-    return;
-    }
-  #endif
-
-  // Full arithmetic -- allow subnormals, rounded to minimum exponent
-  // (Etiny) if needed
-  etiny=set->emin-(set->digits-1);      // smallest allowed exponent
-
-  if ISZERO(dn) {                       // value is zero
-    // residue can never be non-zero here
-    #if DECCHECK
-      if (*residue!=0) {
-        printf("++ Subnormal 0 residue %d\n", *residue);
-        *status|=DEC_Invalid_operation;
-        }
-    #endif
-    if (dn->exponent<etiny) {           // clamp required
-      dn->exponent=etiny;
-      *status|=DEC_Clamped;
-      }
-    return;
-    }
-
-  *status|=DEC_Subnormal;               // have a non-zero subnormal
-  adjust=etiny-dn->exponent;            // calculate digits to remove
-  if (adjust<=0) {                      // not out of range; unrounded
-    // residue can never be non-zero here, except in the Nmin-residue
-    // case (which is a subnormal result), so can take fast-path here
-    // it may already be inexact (from setting the coefficient)
-    if (*status&DEC_Inexact) *status|=DEC_Underflow;
-    return;
-    }
-
-  // adjust>0, so need to rescale the result so exponent becomes Etiny
-  // [this code is similar to that in rescale]
-// ununsed  dnexp=dn->exponent;                   // save exponent
-  workset=*set;                         // clone rounding, etc.
-  workset.digits=dn->digits-adjust;     // set requested length
-  workset.emin-=adjust;                 // and adjust emin to match
-  // [note that the latter can be <1, here, similar to Rescale case]
-  decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status);
-  decApplyRound(dn, &workset, *residue, status);
-
-  // Use 754R/854 default rule: Underflow is set iff Inexact
-  // [independent of whether trapped]
-  if (*status&DEC_Inexact) *status|=DEC_Underflow;
-
-  // if rounded up a 999s case, exponent will be off by one; adjust
-  // back if so [it will fit, because it was shortened earlier]
-  if (dn->exponent>etiny) {
-    dn->digits=decShiftToMost(dn->lsu, dn->digits, 1);
-    dn->exponent--;                     // (re)adjust the exponent.
-    }
-
-  // if rounded to zero, it is by definition clamped...
-  if (ISZERO(dn)) *status|=DEC_Clamped;
-  } // decSetSubnormal
-
-/* ------------------------------------------------------------------ */
-/* decCheckMath - check entry conditions for a math function          */
-/*                                                                    */
-/*   This checks the context and the operand                          */
-/*                                                                    */
-/*   rhs is the operand to check                                      */
-/*   set is the context to check                                      */
-/*   status is unchanged if both are good                             */
-/*                                                                    */
-/* returns non-zero if status is changed, 0 otherwise                 */
-/*                                                                    */
-/* Restrictions enforced:                                             */
-/*                                                                    */
-/*   digits, emax, and -emin in the context must be less than         */
-/*   DEC_MAX_MATH (999999), and A must be within these bounds if      */
-/*   non-zero.  Invalid_operation is set in the status if a           */
-/*   restriction is violated.                                         */
-/* ------------------------------------------------------------------ */
-static uInt decCheckMath(const decNumber *rhs, decContext *set,
-                         uInt *status) {
-  uInt save=*status;                         // record
-  if (set->digits>DEC_MAX_MATH
-   || set->emax>DEC_MAX_MATH
-   || -set->emin>DEC_MAX_MATH) *status|=DEC_Invalid_context;
-   else if ((rhs->digits>DEC_MAX_MATH
-     || rhs->exponent+rhs->digits>DEC_MAX_MATH+1
-     || rhs->exponent+rhs->digits<2*(1-DEC_MAX_MATH))
-     && !ISZERO(rhs)) *status|=DEC_Invalid_operation;
-  return (*status!=save);
-  } // decCheckMath
-
-/* ------------------------------------------------------------------ */
-/* decGetInt -- get integer from a number                             */
-/*                                                                    */
-/*   dn is the number [which will not be altered]                     */
-/*                                                                    */
-/*   returns one of:                                                  */
-/*     BADINT if there is a non-zero fraction                         */
-/*     the converted integer                                          */
-/*     BIGEVEN if the integer is even and > 2*10**9                   */
-/*     BIGODD  if the integer is odd  and > 2*10**9                   */
-/*                                                                    */
-/* This checks and gets a whole number from the input decNumber.      */
-/* The sign can be determined from dn by the caller when BIGEVEN or   */
-/* BIGODD is returned.                                                */
-/* ------------------------------------------------------------------ */
-static Int decGetInt(const decNumber *dn) {
-  Int  theInt;                          // result accumulator
-  const Unit *up;                       // work
-  Int  got;                             // digits (real or not) processed
-  Int  ilength=dn->digits+dn->exponent; // integral length
-  Flag neg=decNumberIsNegative(dn);     // 1 if -ve
-
-  // The number must be an integer that fits in 10 digits
-  // Assert, here, that 10 is enough for any rescale Etiny
-  #if DEC_MAX_EMAX > 999999999
-    #error GetInt may need updating [for Emax]
-  #endif
-  #if DEC_MIN_EMIN < -999999999
-    #error GetInt may need updating [for Emin]
-  #endif
-  if (ISZERO(dn)) return 0;             // zeros are OK, with any exponent
-
-  up=dn->lsu;                           // ready for lsu
-  theInt=0;                             // ready to accumulate
-  if (dn->exponent>=0) {                // relatively easy
-    // no fractional part [usual]; allow for positive exponent
-    got=dn->exponent;
-    }
-   else { // -ve exponent; some fractional part to check and discard
-    Int count=-dn->exponent;            // digits to discard
-    // spin up whole units until reach the Unit with the unit digit
-    for (; count>=DECDPUN; up++) {
-      if (*up!=0) return BADINT;        // non-zero Unit to discard
-      count-=DECDPUN;
-      }
-    if (count==0) got=0;                // [a multiple of DECDPUN]
-     else {                             // [not multiple of DECDPUN]
-      Int rem;                          // work
-      // slice off fraction digits and check for non-zero
-      #if DECDPUN<=4
-        theInt=QUOT10(*up, count);
-        rem=*up-theInt*powers[count];
-      #else
-        rem=*up%powers[count];          // slice off discards
-        theInt=*up/powers[count];
-      #endif
-      if (rem!=0) return BADINT;        // non-zero fraction
-      // it looks good
-      got=DECDPUN-count;                // number of digits so far
-      up++;                             // ready for next
-      }
-    }
-  // now it's known there's no fractional part
-
-  // tricky code now, to accumulate up to 9.3 digits
-  if (got==0) {theInt=*up; got+=DECDPUN; up++;} // ensure lsu is there
-
-  if (ilength<11) {
-    Int save=theInt;
-    // collect any remaining unit(s)
-    for (; got<ilength; up++) {
-      theInt+=*up*powers[got];
-      got+=DECDPUN;
-      }
-    if (ilength==10) {                  // need to check for wrap
-      if (theInt/(Int)powers[got-DECDPUN]!=(Int)*(up-1)) ilength=11;
-         // [that test also disallows the BADINT result case]
-       else if (neg && theInt>1999999997) ilength=11;
-       else if (!neg && theInt>999999999) ilength=11;
-      if (ilength==11) theInt=save;     // restore correct low bit
-      }
-    }
-
-  if (ilength>10) {                     // too big
-    if (theInt&1) return BIGODD;        // bottom bit 1
-    return BIGEVEN;                     // bottom bit 0
-    }
-
-  if (neg) theInt=-theInt;              // apply sign
-  return theInt;
-  } // decGetInt
-
-/* ------------------------------------------------------------------ */
-/* decPutInt -- put integer into a number                             */
-/*                                                                    */
-/*   res is the target number, with enough space for the biggest      */
-/*       integer that the second argument will be                     */
-/*   in  is the input integer                                         */
-/*                                                                    */
-/* Returns res, an integral value; no error is possible.              */
-/* ------------------------------------------------------------------ */
-static decNumber *decPutInt(decNumber *res, Int in) {
-  Unit *up;                             // work pointer
-
-  decNumberZero(res);                   // clean
-  if (in<=0) {                          // handle sign, 0, and BADINT
-    if (in==0) return res;              // easy
-     else if (in!=BADINT) {
-      res->bits=DECNEG;                 // set sign
-      in=-in;                           // invert and drop through
-      }
-     else {                             // BADINT: invert would fail
-      decContext set;
-      decContextDefault(&set, DEC_INIT_DECIMAL64);     // 16 digits
-      decNumberFromString(res, "-2147483648", &set);   // ugh
-      return res;
-      }
-    }
-  // in is now positive
-  for (up=res->lsu; in>0; up++) {
-    *up=(Unit)(in%(DECDPUNMAX+1));
-    in=in/(DECDPUNMAX+1);
-    }
-  res->digits=decGetDigits(res->lsu, up-res->lsu);
-  return res;
-  } // decPutInt
-
-/* ------------------------------------------------------------------ */
-/* decBiStr -- compare string with pairwise options                   */
-/*                                                                    */
-/*   targ is the string to compare                                    */
-/*   str1 is one of the strings to compare against (length may be 0)  */
-/*   str2 is the other; it must be the same length as str1            */
-/*                                                                    */
-/*   returns 1 if strings compare equal, (that is, it is the same     */
-/*   length as str1 and str2, and each character of targ is in either */
-/*   str1 or str2 in the corresponding position), or 0 otherwise      */
-/*                                                                    */
-/* This is used for generic caseless compare, including the awkward   */
-/* case of the Turkish dotted and dotless Is.  Use as (for example):  */
-/*   if (decBiStr(test, "mike", "MIKE")) ...                          */
-/* ------------------------------------------------------------------ */
-static Flag decBiStr(const char *targ, const char *str1, const char *str2) {
-  for (;;targ++, str1++, str2++) {
-    if (*targ!=*str1 && *targ!=*str2) return 0;
-    // *targ has a match in one (or both, if terminator)
-    if (*targ=='\0') break;
-    } // forever
-  return 1;
-  } // decBiStr
-
-/* ------------------------------------------------------------------ */
-/* decNaNs -- handle NaN operand or operands                          */
-/*                                                                    */
-/*   res    is the result number                                      */
-/*   lhs    is the first operand                                      */
-/*   rhs    is the second operand, or NULL if none                    */
-/*   status contains the current status                               */
-/*   returns res in case convenient                                   */
-/*                                                                    */
-/* Called when one or both operands is a NaN, and propagates the      */
-/* appropriate result to res.  When an sNaN is found, it is changed   */
-/* to a qNaN and Invalid operation is set.                            */
-/* ------------------------------------------------------------------ */
-static decNumber * decNaNs(decNumber *res, const decNumber *lhs,
-                           const decNumber *rhs, uInt *status) {
-  // This decision tree ends up with LHS being the source pointer,
-  // and status updated if need be
-  if (lhs->bits & DECSNAN)
-    *status|=DEC_Invalid_operation | DEC_sNaN;
-   else if (rhs==NULL);
-   else if (rhs->bits & DECSNAN) {
-    lhs=rhs;
-    *status|=DEC_Invalid_operation | DEC_sNaN;
-    }
-   else if (lhs->bits & DECNAN);
-   else lhs=rhs;
-
-  decNumberCopy(res, lhs);
-  res->bits&=~DECSNAN;        // convert any sNaN to NaN, while
-  res->bits|=DECNAN;          // .. preserving sign
-  res->exponent=0;            // clean exponent
-                              // [coefficient was copied]
-  return res;
-  } // decNaNs
-
-/* ------------------------------------------------------------------ */
-/* decStatus -- apply non-zero status                                 */
-/*                                                                    */
-/*   dn     is the number to set if error                             */
-/*   status contains the current status (not yet in context)          */
-/*   set    is the context                                            */
-/*                                                                    */
-/* If the status is an error status, the number is set to a NaN,      */
-/* unless the error was an overflow, divide-by-zero, or underflow,    */
-/* in which case the number will have already been set.               */
-/*                                                                    */
-/* The context status is then updated with the new status.  Note that */
-/* this may raise a signal, so control may never return from this     */
-/* routine (hence resources must be recovered before it is called).   */
-/* ------------------------------------------------------------------ */
-static void decStatus(decNumber *dn, uInt status, decContext *set) {
-  if (status & DEC_NaNs) {              // error status -> NaN
-    // if cause was an sNaN, clear and propagate [NaN is already set up]
-    if (status & DEC_sNaN) status&=~DEC_sNaN;
-     else {
-      decNumberZero(dn);                // other error: clean throughout
-      dn->bits=DECNAN;                  // and make a quiet NaN
-      }
-    }
-  decContextSetStatus(set, status);     // [may not return]
-  return;
-  } // decStatus
-
-/* ------------------------------------------------------------------ */
-/* decGetDigits -- count digits in a Units array                      */
-/*                                                                    */
-/*   uar is the Unit array holding the number (this is often an       */
-/*          accumulator of some sort)                                 */
-/*   len is the length of the array in units                          */
-/*                                                                    */
-/*   returns the number of (significant) digits in the array          */
-/*                                                                    */
-/* All leading zeros are excluded, except the last if the array has   */
-/* only zero Units.                                                   */
-/* ------------------------------------------------------------------ */
-// This may be called twice during some operations.
-static Int decGetDigits(Unit *uar, Int len) {
-  Unit *up=uar+(len-1);            // -> msu
-  Int  digits=(len-1)*DECDPUN+1;   // possible digits excluding msu
-                                   // (at least 1 in final msu)
-  #if DECDPUN>4
-  uInt const *pow;                 // work
-  #endif
-
-  for (; up>=uar; up--) {
-    if (*up==0) {                  // unit is all 0s
-      if (digits==1) break;        // a zero has one digit
-      digits-=DECDPUN;             // adjust for 0 unit
-      continue;}
-    // found the first (most significant) non-zero Unit
-    #if DECDPUN>1                  // not done yet
-    if (*up<10) break;             // is 1-9
-    digits++;
-    #if DECDPUN>2                  // not done yet
-    if (*up<100) break;            // is 10-99
-    digits++;
-    #if DECDPUN>3                  // not done yet
-    if (*up<1000) break;           // is 100-999
-    digits++;
-    #if DECDPUN>4                  // count the rest ...
-    for (pow=&powers[4]; *up>=*pow; pow++) digits++;
-    #endif
-    #endif
-    #endif
-    #endif
-    break;
-    } // up
-  return digits;
-  } // decGetDigits
-
-
-#if DECTRACE | DECCHECK
-/* ------------------------------------------------------------------ */
-/* decNumberShow -- display a number [debug aid]                      */
-/*   dn is the number to show                                         */
-/*                                                                    */
-/* Shows: sign, exponent, coefficient (msu first), digits             */
-/*    or: sign, special-value                                         */
-/* ------------------------------------------------------------------ */
-// this is public so other modules can use it
-void decNumberShow(const decNumber *dn) {
-  const Unit *up;                  // work
-  uInt u, d;                       // ..
-  Int cut;                         // ..
-  char isign='+';                  // main sign
-  if (dn==NULL) {
-    printf("NULL\n");
-    return;}
-  if (decNumberIsNegative(dn)) isign='-';
-  printf(" >> %c ", isign);
-  if (dn->bits&DECSPECIAL) {       // Is a special value
-    if (decNumberIsInfinite(dn)) printf("Infinity");
-     else {                                  // a NaN
-      if (dn->bits&DECSNAN) printf("sNaN");  // signalling NaN
-       else printf("NaN");
-      }
-    // if coefficient and exponent are 0, no more to do
-    if (dn->exponent==0 && dn->digits==1 && *dn->lsu==0) {
-      printf("\n");
-      return;}
-    // drop through to report other information
-    printf(" ");
-    }
-
-  // now carefully display the coefficient
-  up=dn->lsu+D2U(dn->digits)-1;         // msu
-  printf("%d", *up);
-  for (up=up-1; up>=dn->lsu; up--) {
-    u=*up;
-    printf(":");
-    for (cut=DECDPUN-1; cut>=0; cut--) {
-      d=u/powers[cut];
-      u-=d*powers[cut];
-      printf("%d", d);
-      } // cut
-    } // up
-  if (dn->exponent!=0) {
-    char esign='+';
-    if (dn->exponent<0) esign='-';
-    printf(" E%c%d", esign, abs(dn->exponent));
-    }
-  printf(" [%d]\n", dn->digits);
-  } // decNumberShow
-#endif
-
-#if DECTRACE || DECCHECK
-/* ------------------------------------------------------------------ */
-/* decDumpAr -- display a unit array [debug aid]                      */
-/*   name is a single-character tag name                              */
-/*   ar   is the array to display                                     */
-/*   len  is the length of the array in Units                         */
-/* ------------------------------------------------------------------ */
-static void decDumpAr(char name, const Unit *ar, Int len) {
-  Int i;
-  #if DECDPUN==9
-    char *spec="%09d ";
-  #elif DECDPUN==8
-    char *spec="%08d ";
-  #elif DECDPUN==7
-    char *spec="%07d ";
-  #elif DECDPUN==6
-    char *spec="%06d ";
-  #elif DECDPUN==5
-    char *spec="%05d ";
-  #elif DECDPUN==4
-    char *spec="%04d ";
-  #elif DECDPUN==3
-    char *spec="%03d ";
-  #elif DECDPUN==2
-    char *spec="%02d ";
-  #else
-    char *spec="%d ";
-  #endif
-  printf("  :%c: ", name);
-  for (i=len-1; i>=0; i--) {
-    if (i==len-1) printf("%d ", ar[i]);
-     else printf(spec, ar[i]);
-    }
-  printf("\n");
-  return;}
-#endif
-
-#if DECCHECK
-/* ------------------------------------------------------------------ */
-/* decCheckOperands -- check operand(s) to a routine                  */
-/*   res is the result structure (not checked; it will be set to      */
-/*          quiet NaN if error found (and it is not NULL))            */
-/*   lhs is the first operand (may be DECUNUSED)                      */
-/*   rhs is the second (may be DECUNUSED)                             */
-/*   set is the context (may be DECUNUSED)                            */
-/*   returns 0 if both operands, and the context are clean, or 1      */
-/*     otherwise (in which case the context will show an error,       */
-/*     unless NULL).  Note that res is not cleaned; caller should     */
-/*     handle this so res=NULL case is safe.                          */
-/* The caller is expected to abandon immediately if 1 is returned.    */
-/* ------------------------------------------------------------------ */
-static Flag decCheckOperands(decNumber *res, const decNumber *lhs,
-                             const decNumber *rhs, decContext *set) {
-  Flag bad=0;
-  if (set==NULL) {                 // oops; hopeless
-    #if DECTRACE
-    printf("Context is NULL.\n");
-    #endif
-    bad=1;
-    return 1;}
-   else if (set!=DECUNUSED
-     && (set->digits<1 || set->round<0 || set->round>=DEC_ROUND_MAX)) {
-    bad=1;
-    #if DECTRACE
-    printf("Bad context [digits=%d round=%d].\n", set->digits, set->round);
-    #endif
-    }
-   else {
-    if (res==NULL) {
-      bad=1;
-      #if DECTRACE
-      printf("Bad result [is NULL].\n");
-      #endif
-      }
-    if (!bad && lhs!=DECUNUSED) bad=(decCheckNumber(lhs, set));
-    if (!bad && rhs!=DECUNUSED) bad=(decCheckNumber(rhs, set));
-    }
-  if (bad) {
-    if (set!=DECUNUSED) decContextSetStatus(set, DEC_Invalid_operation);
-    if (res!=DECUNUSED && res!=NULL) {
-      decNumberZero(res);
-      res->bits=DECNAN;       // qNaN
-      }
-    }
-  return bad;
-  } // decCheckOperands
-
-/* ------------------------------------------------------------------ */
-/* decCheckNumber -- check a number                                   */
-/*   dn is the number to check                                        */
-/*   set is the context (may be DECUNUSED)                            */
-/*   returns 0 if the number is clean, or 1 otherwise                 */
-/*                                                                    */
-/* The number is considered valid if it could be a result from some   */
-/* operation in some valid context (not necessarily the current one). */
-/* ------------------------------------------------------------------ */
-static Flag decCheckNumber(const decNumber *dn, decContext *set) {
-  const Unit *up;             // work
-  uInt maxuint;               // ..
-  Int ae, d, digits;          // ..
-  Int emin, emax;             // ..
-
-  if (dn==NULL) {             // hopeless
-    #if DECTRACE
-    printf("Reference to decNumber is NULL.\n");
-    #endif
-    return 1;}
-
-  // check special values
-  if (dn->bits & DECSPECIAL) {
-    if (dn->exponent!=0) {
-      #if DECTRACE
-      printf("Exponent %d (not 0) for a special value.\n", dn->exponent);
-      #endif
-      return 1;}
-
-    // 2003.09.08: NaNs may now have coefficients, so next tests Inf only
-    if (decNumberIsInfinite(dn)) {
-      if (dn->digits!=1) {
-        #if DECTRACE
-        printf("Digits %d (not 1) for an infinity.\n", dn->digits);
-        #endif
-        return 1;}
-      if (*dn->lsu!=0) {
-        #if DECTRACE
-        printf("LSU %d (not 0) for an infinity.\n", *dn->lsu);
-        #endif
-        return 1;}
-      } // Inf
-    // 2002.12.26: negative NaNs can now appear through proposed IEEE
-    //             concrete formats (decimal64, etc.), though they are
-    //             never visible in strings.
-    return 0;
-
-    // if ((dn->bits & DECINF) || (dn->bits & DECNEG)==0) return 0;
-    // #if DECTRACE
-    // printf("Negative NaN in number.\n");
-    // #endif
-    // return 1;
-    }
-
-  // check the coefficient
-  if (dn->digits<1 || dn->digits>DECNUMMAXP) {
-    #if DECTRACE
-    printf("Digits %d in number.\n", dn->digits);
-    #endif
-    return 1;}
-
-  d=dn->digits;
-
-  for (up=dn->lsu; d>0; up++) {
-    if (d>DECDPUN) maxuint=DECDPUNMAX;
-     else {                   // reached the msu
-      maxuint=powers[d]-1;
-      if (dn->digits>1 && *up<powers[d-1]) {
-        #if DECTRACE
-        printf("Leading 0 in number.\n");
-        decNumberShow(dn);
-        #endif
-        return 1;}
-      }
-    if (*up>maxuint) {
-      #if DECTRACE
-      printf("Bad Unit [%08x] in %d-digit number at offset %d [maxuint %d].\n",
-              *up, dn->digits, up-dn->lsu, maxuint);
-      #endif
-      return 1;}
-    d-=DECDPUN;
-    }
-
-  // check the exponent.  Note that input operands can have exponents
-  // which are out of the set->emin/set->emax and set->digits range
-  // (just as they can have more digits than set->digits).
-  ae=dn->exponent+dn->digits-1;    // adjusted exponent
-  emax=DECNUMMAXE;
-  emin=DECNUMMINE;
-  digits=DECNUMMAXP;
-  if (ae<emin-(digits-1)) {
-    #if DECTRACE
-    printf("Adjusted exponent underflow [%d].\n", ae);
-    decNumberShow(dn);
-    #endif
-    return 1;}
-  if (ae>+emax) {
-    #if DECTRACE
-    printf("Adjusted exponent overflow [%d].\n", ae);
-    decNumberShow(dn);
-    #endif
-    return 1;}
-
-  return 0;              // it's OK
-  } // decCheckNumber
-
-
-/* ------------------------------------------------------------------ */
-/* decCheckInexact -- check a normal finite inexact result has digits */
-/*   dn is the number to check                                        */
-/*   set is the context (for status and precision)                    */
-/*   sets Invalid operation, etc., if some digits are missing         */
-/* [this check is not made for DECSUBSET compilation]                 */
-/* ------------------------------------------------------------------ */
-static void decCheckInexact(const decNumber *dn, decContext *set) {
-  #if !DECSUBSET
-    if ((set->status & (DEC_Inexact|DEC_Subnormal))==DEC_Inexact
-     && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) {
-      decContextSetStatus(set, DEC_Invalid_operation);
-      #if DECTRACE
-      printf("Insufficient digits [%d] on normal Inexact result.\n", dn->digits);
-      decNumberShow(dn);
-      #endif
-      }
-  #endif
-  return;
-  } // decCheckInexact
-#endif
-
-#if DECALLOC
-#undef malloc
-#undef free
-/* ------------------------------------------------------------------ */
-/* decMalloc -- accountable allocation routine                        */
-/*   n is the number of bytes to allocate                             */
-/*                                                                    */
-/* Semantics is the same as the stdlib malloc routine, but bytes      */
-/* allocated are accounted for globally, and corruption fences are    */
-/* added before and after the 'actual' storage.                       */
-/* ------------------------------------------------------------------ */
-/* This routine allocates storage with an extra twelve bytes; 8 are   */
-/* at the start and hold:                                             */
-/*   0-3 the original length requested                                */
-/*   4-7 buffer corruption detection fence (DECFENCE, x4)             */
-/* The 4 bytes at the end also hold a corruption fence (DECFENCE, x4) */
-/* ------------------------------------------------------------------ */
-static void *decMalloc(size_t n) {
-  uInt  size=n+12;                 // true size
-  void  *alloc;                    // -> allocated storage
-  uInt  *j;                        // work
-  uByte *b, *b0;                   // ..
-
-  alloc=malloc(size);              // -> allocated storage
-  if (alloc==NULL) return NULL;    // out of strorage
-  b0=(uByte *)alloc;               // as bytes
-  decAllocBytes+=n;                // account for storage
-  j=(uInt *)alloc;                 // -> first four bytes
-  *j=n;                            // save n
-  // printf(" allo ++ dAB: %d (%d)\n", decAllocBytes, n);
-  for (b=b0+4; b<b0+8; b++) *b=DECFENCE;
-  for (b=b0+n+8; b<b0+n+12; b++) *b=DECFENCE;
-  return b0+8;                     // -> play area
-  } // decMalloc
-
-/* ------------------------------------------------------------------ */
-/* decFree -- accountable free routine                                */
-/*   alloc is the storage to free                                     */
-/*                                                                    */
-/* Semantics is the same as the stdlib malloc routine, except that    */
-/* the global storage accounting is updated and the fences are        */
-/* checked to ensure that no routine has written 'out of bounds'.     */
-/* ------------------------------------------------------------------ */
-/* This routine first checks that the fences have not been corrupted. */
-/* It then frees the storage using the 'truw' storage address (that   */
-/* is, offset by 8).                                                  */
-/* ------------------------------------------------------------------ */
-static void decFree(void *alloc) {
-  uInt  *j, n;                     // pointer, original length
-  uByte *b, *b0;                   // work
-
-  if (alloc==NULL) return;         // allowed; it's a nop
-  b0=(uByte *)alloc;               // as bytes
-  b0-=8;                           // -> true start of storage
-  j=(uInt *)b0;                    // -> first four bytes
-  n=*j;                            // lift
-  for (b=b0+4; b<b0+8; b++) if (*b!=DECFENCE)
-    printf("=== Corrupt byte [%02x] at offset %d from %d ===\n", *b,
-           b-b0-8, (Int)b0);
-  for (b=b0+n+8; b<b0+n+12; b++) if (*b!=DECFENCE)
-    printf("=== Corrupt byte [%02x] at offset +%d from %d, n=%d ===\n", *b,
-           b-b0-8, (Int)b0, n);
-  free(b0);                        // drop the storage
-  decAllocBytes-=n;                // account for storage
-  // printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n);
-  } // decFree
-#define malloc(a) decMalloc(a)
-#define free(a) decFree(a)
-#endif
+/* ------------------------------------------------------------------ */
+/* Decimal Number arithmetic module                                   */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2009.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is called decNumber.pdf.  This document is           */
+/* available, together with arithmetic and format specifications,     */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+/* This module comprises the routines for arbitrary-precision General */
+/* Decimal Arithmetic as defined in the specification which may be    */
+/* found on the General Decimal Arithmetic pages.  It implements both */
+/* the full ('extended') arithmetic and the simpler ('subset')        */
+/* arithmetic.                                                        */
+/*                                                                    */
+/* Usage notes:                                                       */
+/*                                                                    */
+/* 1. This code is ANSI C89 except:                                   */
+/*                                                                    */
+/*    a) C99 line comments (double forward slash) are used.  (Most C  */
+/*       compilers accept these.  If yours does not, a simple script  */
+/*       can be used to convert them to ANSI C comments.)             */
+/*                                                                    */
+/*    b) Types from C99 stdint.h are used.  If you do not have this   */
+/*       header file, see the User's Guide section of the decNumber   */
+/*       documentation; this lists the necessary definitions.         */
+/*                                                                    */
+/*    c) If DECDPUN>4 or DECUSE64=1, the C99 64-bit int64_t and       */
+/*       uint64_t types may be used.  To avoid these, set DECUSE64=0  */
+/*       and DECDPUN<=4 (see documentation).                          */
+/*                                                                    */
+/*    The code also conforms to C99 restrictions; in particular,      */
+/*    strict aliasing rules are observed.                             */
+/*                                                                    */
+/* 2. The decNumber format which this library uses is optimized for   */
+/*    efficient processing of relatively short numbers; in particular */
+/*    it allows the use of fixed sized structures and minimizes copy  */
+/*    and move operations.  It does, however, support arbitrary       */
+/*    precision (up to 999,999,999 digits) and arbitrary exponent     */
+/*    range (Emax in the range 0 through 999,999,999 and Emin in the  */
+/*    range -999,999,999 through 0).  Mathematical functions (for     */
+/*    example decNumberExp) as identified below are restricted more   */
+/*    tightly: digits, emax, and -emin in the context must be <=      */
+/*    DEC_MAX_MATH (999999), and their operand(s) must be within      */
+/*    these bounds.                                                   */
+/*                                                                    */
+/* 3. Logical functions are further restricted; their operands must   */
+/*    be finite, positive, have an exponent of zero, and all digits   */
+/*    must be either 0 or 1.  The result will only contain digits     */
+/*    which are 0 or 1 (and will have exponent=0 and a sign of 0).    */
+/*                                                                    */
+/* 4. Operands to operator functions are never modified unless they   */
+/*    are also specified to be the result number (which is always     */
+/*    permitted).  Other than that case, operands must not overlap.   */
+/*                                                                    */
+/* 5. Error handling: the type of the error is ORed into the status   */
+/*    flags in the current context (decContext structure).  The       */
+/*    SIGFPE signal is then raised if the corresponding trap-enabler  */
+/*    flag in the decContext is set (is 1).                           */
+/*                                                                    */
+/*    It is the responsibility of the caller to clear the status      */
+/*    flags as required.                                              */
+/*                                                                    */
+/*    The result of any routine which returns a number will always    */
+/*    be a valid number (which may be a special value, such as an     */
+/*    Infinity or NaN).                                               */
+/*                                                                    */
+/* 6. The decNumber format is not an exchangeable concrete            */
+/*    representation as it comprises fields which may be machine-     */
+/*    dependent (packed or unpacked, or special length, for example). */
+/*    Canonical conversions to and from strings are provided; other   */
+/*    conversions are available in separate modules.                  */
+/*                                                                    */
+/* 7. Normally, input operands are assumed to be valid.  Set DECCHECK */
+/*    to 1 for extended operand checking (including NULL operands).   */
+/*    Results are undefined if a badly-formed structure (or a NULL    */
+/*    pointer to a structure) is provided, though with DECCHECK       */
+/*    enabled the operator routines are protected against exceptions. */
+/*    (Except if the result pointer is NULL, which is unrecoverable.) */
+/*                                                                    */
+/*    However, the routines will never cause exceptions if they are   */
+/*    given well-formed operands, even if the value of the operands   */
+/*    is inappropriate for the operation and DECCHECK is not set.     */
+/*    (Except for SIGFPE, as and where documented.)                   */
+/*                                                                    */
+/* 8. Subset arithmetic is available only if DECSUBSET is set to 1.   */
+/* ------------------------------------------------------------------ */
+/* Implementation notes for maintenance of this module:               */
+/*                                                                    */
+/* 1. Storage leak protection:  Routines which use malloc are not     */
+/*    permitted to use return for fastpath or error exits (i.e.,      */
+/*    they follow strict structured programming conventions).         */
+/*    Instead they have a do{}while(0); construct surrounding the     */
+/*    code which is protected -- break may be used to exit this.      */
+/*    Other routines can safely use the return statement inline.      */
+/*                                                                    */
+/*    Storage leak accounting can be enabled using DECALLOC.          */
+/*                                                                    */
+/* 2. All loops use the for(;;) construct.  Any do construct does     */
+/*    not loop; it is for allocation protection as just described.    */
+/*                                                                    */
+/* 3. Setting status in the context must always be the very last      */
+/*    action in a routine, as non-0 status may raise a trap and hence */
+/*    the call to set status may not return (if the handler uses long */
+/*    jump).  Therefore all cleanup must be done first.  In general,  */
+/*    to achieve this status is accumulated and is only applied just  */
+/*    before return by calling decContextSetStatus (via decStatus).   */
+/*                                                                    */
+/*    Routines which allocate storage cannot, in general, use the     */
+/*    'top level' routines which could cause a non-returning          */
+/*    transfer of control.  The decXxxxOp routines are safe (do not   */
+/*    call decStatus even if traps are set in the context) and should */
+/*    be used instead (they are also a little faster).                */
+/*                                                                    */
+/* 4. Exponent checking is minimized by allowing the exponent to      */
+/*    grow outside its limits during calculations, provided that      */
+/*    the decFinalize function is called later.  Multiplication and   */
+/*    division, and intermediate calculations in exponentiation,      */
+/*    require more careful checks because of the risk of 31-bit       */
+/*    overflow (the most negative valid exponent is -1999999997, for  */
+/*    a 999999999-digit number with adjusted exponent of -999999999). */
+/*                                                                    */
+/* 5. Rounding is deferred until finalization of results, with any    */
+/*    'off to the right' data being represented as a single digit     */
+/*    residue (in the range -1 through 9).  This avoids any double-   */
+/*    rounding when more than one shortening takes place (for         */
+/*    example, when a result is subnormal).                           */
+/*                                                                    */
+/* 6. The digits count is allowed to rise to a multiple of DECDPUN    */
+/*    during many operations, so whole Units are handled and exact    */
+/*    accounting of digits is not needed.  The correct digits value   */
+/*    is found by decGetDigits, which accounts for leading zeros.     */
+/*    This must be called before any rounding if the number of digits */
+/*    is not known exactly.                                           */
+/*                                                                    */
+/* 7. The multiply-by-reciprocal 'trick' is used for partitioning     */
+/*    numbers up to four digits, using appropriate constants.  This   */
+/*    is not useful for longer numbers because overflow of 32 bits    */
+/*    would lead to 4 multiplies, which is almost as expensive as     */
+/*    a divide (unless a floating-point or 64-bit multiply is         */
+/*    assumed to be available).                                       */
+/*                                                                    */
+/* 8. Unusual abbreviations that may be used in the commentary:       */
+/*      lhs -- left hand side (operand, of an operation)              */
+/*      lsd -- least significant digit (of coefficient)               */
+/*      lsu -- least significant Unit (of coefficient)                */
+/*      msd -- most significant digit (of coefficient)                */
+/*      msi -- most significant item (in an array)                    */
+/*      msu -- most significant Unit (of coefficient)                 */
+/*      rhs -- right hand side (operand, of an operation)             */
+/*      +ve -- positive                                               */
+/*      -ve -- negative                                               */
+/*      **  -- raise to the power                                     */
+/* ------------------------------------------------------------------ */
+
+#include <stdlib.h>                // for malloc, free, etc.
+#include <stdio.h>                 // for printf [if needed]
+#include <string.h>                // for strcpy
+#include <ctype.h>                 // for lower
+#include "decNumber.h"             // base number library
+#include "decNumberLocal.h"        // decNumber local types, etc.
+
+/* Constants */
+// Public lookup table used by the D2U macro
+const uByte d2utable[DECMAXD2U+1]=D2UTABLE;
+
+#define DECVERB     1              // set to 1 for verbose DECCHECK
+#define powers      DECPOWERS      // old internal name
+
+// Local constants
+#define DIVIDE      0x80           // Divide operators
+#define REMAINDER   0x40           // ..
+#define DIVIDEINT   0x20           // ..
+#define REMNEAR     0x10           // ..
+#define COMPARE     0x01           // Compare operators
+#define COMPMAX     0x02           // ..
+#define COMPMIN     0x03           // ..
+#define COMPTOTAL   0x04           // ..
+#define COMPNAN     0x05           // .. [NaN processing]
+#define COMPSIG     0x06           // .. [signaling COMPARE]
+#define COMPMAXMAG  0x07           // ..
+#define COMPMINMAG  0x08           // ..
+
+#define DEC_sNaN     0x40000000    // local status: sNaN signal
+#define BADINT  (Int)0x80000000    // most-negative Int; error indicator
+// Next two indicate an integer >= 10**6, and its parity (bottom bit)
+#define BIGEVEN (Int)0x80000002
+#define BIGODD  (Int)0x80000003
+
+static Unit uarrone[1]={1};   // Unit array of 1, used for incrementing
+
+/* Granularity-dependent code */
+#if DECDPUN<=4
+  #define eInt  Int           // extended integer
+  #define ueInt uInt          // unsigned extended integer
+  // Constant multipliers for divide-by-power-of five using reciprocal
+  // multiply, after removing powers of 2 by shifting, and final shift
+  // of 17 [we only need up to **4]
+  static const uInt multies[]={131073, 26215, 5243, 1049, 210};
+  // QUOT10 -- macro to return the quotient of unit u divided by 10**n
+  #define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17)
+#else
+  // For DECDPUN>4 non-ANSI-89 64-bit types are needed.
+  #if !DECUSE64
+    #error decNumber.c: DECUSE64 must be 1 when DECDPUN>4
+  #endif
+  #define eInt  Long          // extended integer
+  #define ueInt uLong         // unsigned extended integer
+#endif
+
+/* Local routines */
+static decNumber * decAddOp(decNumber *, const decNumber *, const decNumber *,
+                              decContext *, uByte, uInt *);
+static Flag        decBiStr(const char *, const char *, const char *);
+static uInt        decCheckMath(const decNumber *, decContext *, uInt *);
+static void        decApplyRound(decNumber *, decContext *, Int, uInt *);
+static Int         decCompare(const decNumber *lhs, const decNumber *rhs, Flag);
+static decNumber * decCompareOp(decNumber *, const decNumber *,
+                              const decNumber *, decContext *,
+                              Flag, uInt *);
+static void        decCopyFit(decNumber *, const decNumber *, decContext *,
+                              Int *, uInt *);
+static decNumber * decDecap(decNumber *, Int);
+static decNumber * decDivideOp(decNumber *, const decNumber *,
+                              const decNumber *, decContext *, Flag, uInt *);
+static decNumber * decExpOp(decNumber *, const decNumber *,
+                              decContext *, uInt *);
+static void        decFinalize(decNumber *, decContext *, Int *, uInt *);
+static Int         decGetDigits(Unit *, Int);
+static Int         decGetInt(const decNumber *);
+static decNumber * decLnOp(decNumber *, const decNumber *,
+                              decContext *, uInt *);
+static decNumber * decMultiplyOp(decNumber *, const decNumber *,
+                              const decNumber *, decContext *,
+                              uInt *);
+static decNumber * decNaNs(decNumber *, const decNumber *,
+                              const decNumber *, decContext *, uInt *);
+static decNumber * decQuantizeOp(decNumber *, const decNumber *,
+                              const decNumber *, decContext *, Flag,
+                              uInt *);
+static void        decReverse(Unit *, Unit *);
+static void        decSetCoeff(decNumber *, decContext *, const Unit *,
+                              Int, Int *, uInt *);
+static void        decSetMaxValue(decNumber *, decContext *);
+static void        decSetOverflow(decNumber *, decContext *, uInt *);
+static void        decSetSubnormal(decNumber *, decContext *, Int *, uInt *);
+static Int         decShiftToLeast(Unit *, Int, Int);
+static Int         decShiftToMost(Unit *, Int, Int);
+static void        decStatus(decNumber *, uInt, decContext *);
+static void        decToString(const decNumber *, char[], Flag);
+static decNumber * decTrim(decNumber *, decContext *, Flag, Flag, Int *);
+static Int         decUnitAddSub(const Unit *, Int, const Unit *, Int, Int,
+                              Unit *, Int);
+static Int         decUnitCompare(const Unit *, Int, const Unit *, Int, Int);
+
+#if !DECSUBSET
+/* decFinish == decFinalize when no subset arithmetic needed */
+#define decFinish(a,b,c,d) decFinalize(a,b,c,d)
+#else
+static void        decFinish(decNumber *, decContext *, Int *, uInt *);
+static decNumber * decRoundOperand(const decNumber *, decContext *, uInt *);
+#endif
+
+/* Local macros */
+// masked special-values bits
+#define SPECIALARG  (rhs->bits & DECSPECIAL)
+#define SPECIALARGS ((lhs->bits | rhs->bits) & DECSPECIAL)
+
+/* Diagnostic macros, etc. */
+#if DECALLOC
+// Handle malloc/free accounting.  If enabled, our accountable routines
+// are used; otherwise the code just goes straight to the system malloc
+// and free routines.
+#define malloc(a) decMalloc(a)
+#define free(a) decFree(a)
+#define DECFENCE 0x5a              // corruption detector
+// 'Our' malloc and free:
+static void *decMalloc(size_t);
+static void  decFree(void *);
+uInt decAllocBytes=0;              // count of bytes allocated
+// Note that DECALLOC code only checks for storage buffer overflow.
+// To check for memory leaks, the decAllocBytes variable must be
+// checked to be 0 at appropriate times (e.g., after the test
+// harness completes a set of tests).  This checking may be unreliable
+// if the testing is done in a multi-thread environment.
+#endif
+
+#if DECCHECK
+// Optional checking routines.  Enabling these means that decNumber
+// and decContext operands to operator routines are checked for
+// correctness.  This roughly doubles the execution time of the
+// fastest routines (and adds 600+ bytes), so should not normally be
+// used in 'production'.
+// decCheckInexact is used to check that inexact results have a full
+// complement of digits (where appropriate -- this is not the case
+// for Quantize, for example)
+#define DECUNRESU ((decNumber *)(void *)0xffffffff)
+#define DECUNUSED ((const decNumber *)(void *)0xffffffff)
+#define DECUNCONT ((decContext *)(void *)(0xffffffff))
+static Flag decCheckOperands(decNumber *, const decNumber *,
+                             const decNumber *, decContext *);
+static Flag decCheckNumber(const decNumber *);
+static void decCheckInexact(const decNumber *, decContext *);
+#endif
+
+#if DECTRACE || DECCHECK
+// Optional trace/debugging routines (may or may not be used)
+void decNumberShow(const decNumber *);  // displays the components of a number
+static void decDumpAr(char, const Unit *, Int);
+#endif
+
+/* ================================================================== */
+/* Conversions                                                        */
+/* ================================================================== */
+
+/* ------------------------------------------------------------------ */
+/* from-int32 -- conversion from Int or uInt                          */
+/*                                                                    */
+/*  dn is the decNumber to receive the integer                        */
+/*  in or uin is the integer to be converted                          */
+/*  returns dn                                                        */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberFromInt32(decNumber *dn, Int in) {
+  uInt unsig;
+  if (in>=0) unsig=in;
+   else {                               // negative (possibly BADINT)
+    if (in==BADINT) unsig=(uInt)1073741824*2; // special case
+     else unsig=-in;                    // invert
+    }
+  // in is now positive
+  decNumberFromUInt32(dn, unsig);
+  if (in<0) dn->bits=DECNEG;            // sign needed
+  return dn;
+  } // decNumberFromInt32
+
+decNumber * decNumberFromUInt32(decNumber *dn, uInt uin) {
+  Unit *up;                             // work pointer
+  decNumberZero(dn);                    // clean
+  if (uin==0) return dn;                // [or decGetDigits bad call]
+  for (up=dn->lsu; uin>0; up++) {
+    *up=(Unit)(uin%(DECDPUNMAX+1));
+    uin=uin/(DECDPUNMAX+1);
+    }
+  dn->digits=decGetDigits(dn->lsu, up-dn->lsu);
+  return dn;
+  } // decNumberFromUInt32
+
+/* ------------------------------------------------------------------ */
+/* to-int32 -- conversion to Int or uInt                              */
+/*                                                                    */
+/*  dn is the decNumber to convert                                    */
+/*  set is the context for reporting errors                           */
+/*  returns the converted decNumber, or 0 if Invalid is set           */
+/*                                                                    */
+/* Invalid is set if the decNumber does not have exponent==0 or if    */
+/* it is a NaN, Infinite, or out-of-range.                            */
+/* ------------------------------------------------------------------ */
+Int decNumberToInt32(const decNumber *dn, decContext *set) {
+  #if DECCHECK
+  if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
+  #endif
+
+  // special or too many digits, or bad exponent
+  if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0) ; // bad
+   else { // is a finite integer with 10 or fewer digits
+    Int d;                         // work
+    const Unit *up;                // ..
+    uInt hi=0, lo;                 // ..
+    up=dn->lsu;                    // -> lsu
+    lo=*up;                        // get 1 to 9 digits
+    #if DECDPUN>1                  // split to higher
+      hi=lo/10;
+      lo=lo%10;
+    #endif
+    up++;
+    // collect remaining Units, if any, into hi
+    for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
+    // now low has the lsd, hi the remainder
+    if (hi>214748364 || (hi==214748364 && lo>7)) { // out of range?
+      // most-negative is a reprieve
+      if (dn->bits&DECNEG && hi==214748364 && lo==8) return 0x80000000;
+      // bad -- drop through
+      }
+     else { // in-range always
+      Int i=X10(hi)+lo;
+      if (dn->bits&DECNEG) return -i;
+      return i;
+      }
+    } // integer
+  decContextSetStatus(set, DEC_Invalid_operation); // [may not return]
+  return 0;
+  } // decNumberToInt32
+
+uInt decNumberToUInt32(const decNumber *dn, decContext *set) {
+  #if DECCHECK
+  if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
+  #endif
+  // special or too many digits, or bad exponent, or negative (<0)
+  if (dn->bits&DECSPECIAL || dn->digits>10 || dn->exponent!=0
+    || (dn->bits&DECNEG && !ISZERO(dn)));                   // bad
+   else { // is a finite integer with 10 or fewer digits
+    Int d;                         // work
+    const Unit *up;                // ..
+    uInt hi=0, lo;                 // ..
+    up=dn->lsu;                    // -> lsu
+    lo=*up;                        // get 1 to 9 digits
+    #if DECDPUN>1                  // split to higher
+      hi=lo/10;
+      lo=lo%10;
+    #endif
+    up++;
+    // collect remaining Units, if any, into hi
+    for (d=DECDPUN; d<dn->digits; up++, d+=DECDPUN) hi+=*up*powers[d-1];
+
+    // now low has the lsd, hi the remainder
+    if (hi>429496729 || (hi==429496729 && lo>5)) ; // no reprieve possible
+     else return X10(hi)+lo;
+    } // integer
+  decContextSetStatus(set, DEC_Invalid_operation); // [may not return]
+  return 0;
+  } // decNumberToUInt32
+
+/* ------------------------------------------------------------------ */
+/* to-scientific-string -- conversion to numeric string               */
+/* to-engineering-string -- conversion to numeric string              */
+/*                                                                    */
+/*   decNumberToString(dn, string);                                   */
+/*   decNumberToEngString(dn, string);                                */
+/*                                                                    */
+/*  dn is the decNumber to convert                                    */
+/*  string is the string where the result will be laid out            */
+/*                                                                    */
+/*  string must be at least dn->digits+14 characters long             */
+/*                                                                    */
+/*  No error is possible, and no status can be set.                   */
+/* ------------------------------------------------------------------ */
+char * decNumberToString(const decNumber *dn, char *string){
+  decToString(dn, string, 0);
+  return string;
+  } // DecNumberToString
+
+char * decNumberToEngString(const decNumber *dn, char *string){
+  decToString(dn, string, 1);
+  return string;
+  } // DecNumberToEngString
+
+/* ------------------------------------------------------------------ */
+/* to-number -- conversion from numeric string                        */
+/*                                                                    */
+/* decNumberFromString -- convert string to decNumber                 */
+/*   dn        -- the number structure to fill                        */
+/*   chars[]   -- the string to convert ('\0' terminated)             */
+/*   set       -- the context used for processing any error,          */
+/*                determining the maximum precision available         */
+/*                (set.digits), determining the maximum and minimum   */
+/*                exponent (set.emax and set.emin), determining if    */
+/*                extended values are allowed, and checking the       */
+/*                rounding mode if overflow occurs or rounding is     */
+/*                needed.                                             */
+/*                                                                    */
+/* The length of the coefficient and the size of the exponent are     */
+/* checked by this routine, so the correct error (Underflow or        */
+/* Overflow) can be reported or rounding applied, as necessary.       */
+/*                                                                    */
+/* If bad syntax is detected, the result will be a quiet NaN.         */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberFromString(decNumber *dn, const char chars[],
+                                decContext *set) {
+  Int   exponent=0;                // working exponent [assume 0]
+  uByte bits=0;                    // working flags [assume +ve]
+  Unit  *res;                      // where result will be built
+  Unit  resbuff[SD2U(DECBUFFER+9)];// local buffer in case need temporary
+                                   // [+9 allows for ln() constants]
+  Unit  *allocres=NULL;            // -> allocated result, iff allocated
+  Int   d=0;                       // count of digits found in decimal part
+  const char *dotchar=NULL;        // where dot was found
+  const char *cfirst=chars;        // -> first character of decimal part
+  const char *last=NULL;           // -> last digit of decimal part
+  const char *c;                   // work
+  Unit  *up;                       // ..
+  #if DECDPUN>1
+  Int   cut, out;                  // ..
+  #endif
+  Int   residue;                   // rounding residue
+  uInt  status=0;                  // error code
+
+  #if DECCHECK
+  if (decCheckOperands(DECUNRESU, DECUNUSED, DECUNUSED, set))
+    return decNumberZero(dn);
+  #endif
+
+  do {                             // status & malloc protection
+    for (c=chars;; c++) {          // -> input character
+      if (*c>='0' && *c<='9') {    // test for Arabic digit
+        last=c;
+        d++;                       // count of real digits
+        continue;                  // still in decimal part
+        }
+      if (*c=='.' && dotchar==NULL) { // first '.'
+        dotchar=c;                 // record offset into decimal part
+        if (c==cfirst) cfirst++;   // first digit must follow
+        continue;}
+      if (c==chars) {              // first in string...
+        if (*c=='-') {             // valid - sign
+          cfirst++;
+          bits=DECNEG;
+          continue;}
+        if (*c=='+') {             // valid + sign
+          cfirst++;
+          continue;}
+        }
+      // *c is not a digit, or a valid +, -, or '.'
+      break;
+      } // c
+
+    if (last==NULL) {              // no digits yet
+      status=DEC_Conversion_syntax;// assume the worst
+      if (*c=='\0') break;         // and no more to come...
+      #if DECSUBSET
+      // if subset then infinities and NaNs are not allowed
+      if (!set->extended) break;   // hopeless
+      #endif
+      // Infinities and NaNs are possible, here
+      if (dotchar!=NULL) break;    // .. unless had a dot
+      decNumberZero(dn);           // be optimistic
+      if (decBiStr(c, "infinity", "INFINITY")
+       || decBiStr(c, "inf", "INF")) {
+        dn->bits=bits | DECINF;
+        status=0;                  // is OK
+        break; // all done
+        }
+      // a NaN expected
+      // 2003.09.10 NaNs are now permitted to have a sign
+      dn->bits=bits | DECNAN;      // assume simple NaN
+      if (*c=='s' || *c=='S') {    // looks like an sNaN
+        c++;
+        dn->bits=bits | DECSNAN;
+        }
+      if (*c!='n' && *c!='N') break;    // check caseless "NaN"
+      c++;
+      if (*c!='a' && *c!='A') break;    // ..
+      c++;
+      if (*c!='n' && *c!='N') break;    // ..
+      c++;
+      // now either nothing, or nnnn payload, expected
+      // -> start of integer and skip leading 0s [including plain 0]
+      for (cfirst=c; *cfirst=='0';) cfirst++;
+      if (*cfirst=='\0') {         // "NaN" or "sNaN", maybe with all 0s
+        status=0;                  // it's good
+        break;                     // ..
+        }
+      // something other than 0s; setup last and d as usual [no dots]
+      for (c=cfirst;; c++, d++) {
+        if (*c<'0' || *c>'9') break; // test for Arabic digit
+        last=c;
+        }
+      if (*c!='\0') break;         // not all digits
+      if (d>set->digits-1) {
+        // [NB: payload in a decNumber can be full length unless
+        // clamped, in which case can only be digits-1]
+        if (set->clamp) break;
+        if (d>set->digits) break;
+        } // too many digits?
+      // good; drop through to convert the integer to coefficient
+      status=0;                    // syntax is OK
+      bits=dn->bits;               // for copy-back
+      } // last==NULL
+
+     else if (*c!='\0') {          // more to process...
+      // had some digits; exponent is only valid sequence now
+      Flag nege;                   // 1=negative exponent
+      const char *firstexp;        // -> first significant exponent digit
+      status=DEC_Conversion_syntax;// assume the worst
+      if (*c!='e' && *c!='E') break;
+      /* Found 'e' or 'E' -- now process explicit exponent */
+      // 1998.07.11: sign no longer required
+      nege=0;
+      c++;                         // to (possible) sign
+      if (*c=='-') {nege=1; c++;}
+       else if (*c=='+') c++;
+      if (*c=='\0') break;
+
+      for (; *c=='0' && *(c+1)!='\0';) c++;  // strip insignificant zeros
+      firstexp=c;                            // save exponent digit place
+      for (; ;c++) {
+        if (*c<'0' || *c>'9') break;         // not a digit
+        exponent=X10(exponent)+(Int)*c-(Int)'0';
+        } // c
+      // if not now on a '\0', *c must not be a digit
+      if (*c!='\0') break;
+
+      // (this next test must be after the syntax checks)
+      // if it was too long the exponent may have wrapped, so check
+      // carefully and set it to a certain overflow if wrap possible
+      if (c>=firstexp+9+1) {
+        if (c>firstexp+9+1 || *firstexp>'1') exponent=DECNUMMAXE*2;
+        // [up to 1999999999 is OK, for example 1E-1000000998]
+        }
+      if (nege) exponent=-exponent;     // was negative
+      status=0;                         // is OK
+      } // stuff after digits
+
+    // Here when whole string has been inspected; syntax is good
+    // cfirst->first digit (never dot), last->last digit (ditto)
+
+    // strip leading zeros/dot [leave final 0 if all 0's]
+    if (*cfirst=='0') {                 // [cfirst has stepped over .]
+      for (c=cfirst; c<last; c++, cfirst++) {
+        if (*c=='.') continue;          // ignore dots
+        if (*c!='0') break;             // non-zero found
+        d--;                            // 0 stripped
+        } // c
+      #if DECSUBSET
+      // make a rapid exit for easy zeros if !extended
+      if (*cfirst=='0' && !set->extended) {
+        decNumberZero(dn);              // clean result
+        break;                          // [could be return]
+        }
+      #endif
+      } // at least one leading 0
+
+    // Handle decimal point...
+    if (dotchar!=NULL && dotchar<last)  // non-trailing '.' found?
+      exponent-=(last-dotchar);         // adjust exponent
+    // [we can now ignore the .]
+
+    // OK, the digits string is good.  Assemble in the decNumber, or in
+    // a temporary units array if rounding is needed
+    if (d<=set->digits) res=dn->lsu;    // fits into supplied decNumber
+     else {                             // rounding needed
+      Int needbytes=D2U(d)*sizeof(Unit);// bytes needed
+      res=resbuff;                      // assume use local buffer
+      if (needbytes>(Int)sizeof(resbuff)) { // too big for local
+        allocres=(Unit *)malloc(needbytes);
+        if (allocres==NULL) {status|=DEC_Insufficient_storage; break;}
+        res=allocres;
+        }
+      }
+    // res now -> number lsu, buffer, or allocated storage for Unit array
+
+    // Place the coefficient into the selected Unit array
+    // [this is often 70% of the cost of this function when DECDPUN>1]
+    #if DECDPUN>1
+    out=0;                         // accumulator
+    up=res+D2U(d)-1;               // -> msu
+    cut=d-(up-res)*DECDPUN;        // digits in top unit
+    for (c=cfirst;; c++) {         // along the digits
+      if (*c=='.') continue;       // ignore '.' [don't decrement cut]
+      out=X10(out)+(Int)*c-(Int)'0';
+      if (c==last) break;          // done [never get to trailing '.']
+      cut--;
+      if (cut>0) continue;         // more for this unit
+      *up=(Unit)out;               // write unit
+      up--;                        // prepare for unit below..
+      cut=DECDPUN;                 // ..
+      out=0;                       // ..
+      } // c
+    *up=(Unit)out;                 // write lsu
+
+    #else
+    // DECDPUN==1
+    up=res;                        // -> lsu
+    for (c=last; c>=cfirst; c--) { // over each character, from least
+      if (*c=='.') continue;       // ignore . [don't step up]
+      *up=(Unit)((Int)*c-(Int)'0');
+      up++;
+      } // c
+    #endif
+
+    dn->bits=bits;
+    dn->exponent=exponent;
+    dn->digits=d;
+
+    // if not in number (too long) shorten into the number
+    if (d>set->digits) {
+      residue=0;
+      decSetCoeff(dn, set, res, d, &residue, &status);
+      // always check for overflow or subnormal and round as needed
+      decFinalize(dn, set, &residue, &status);
+      }
+     else { // no rounding, but may still have overflow or subnormal
+      // [these tests are just for performance; finalize repeats them]
+      if ((dn->exponent-1<set->emin-dn->digits)
+       || (dn->exponent-1>set->emax-set->digits)) {
+        residue=0;
+        decFinalize(dn, set, &residue, &status);
+        }
+      }
+    // decNumberShow(dn);
+    } while(0);                         // [for break]
+
+  if (allocres!=NULL) free(allocres);   // drop any storage used
+  if (status!=0) decStatus(dn, status, set);
+  return dn;
+  } /* decNumberFromString */
+
+/* ================================================================== */
+/* Operators                                                          */
+/* ================================================================== */
+
+/* ------------------------------------------------------------------ */
+/* decNumberAbs -- absolute value operator                            */
+/*                                                                    */
+/*   This computes C = abs(A)                                         */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* See also decNumberCopyAbs for a quiet bitwise version of this.     */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+/* This has the same effect as decNumberPlus unless A is negative,    */
+/* in which case it has the same effect as decNumberMinus.            */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberAbs(decNumber *res, const decNumber *rhs,
+                         decContext *set) {
+  decNumber dzero;                      // for 0
+  uInt status=0;                        // accumulator
+
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  decNumberZero(&dzero);                // set 0
+  dzero.exponent=rhs->exponent;         // [no coefficient expansion]
+  decAddOp(res, &dzero, rhs, set, (uByte)(rhs->bits & DECNEG), &status);
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberAbs
+
+/* ------------------------------------------------------------------ */
+/* decNumberAdd -- add two Numbers                                    */
+/*                                                                    */
+/*   This computes C = A + B                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X+X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+/* This just calls the routine shared with Subtract                   */
+decNumber * decNumberAdd(decNumber *res, const decNumber *lhs,
+                         const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+  decAddOp(res, lhs, rhs, set, 0, &status);
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberAdd
+
+/* ------------------------------------------------------------------ */
+/* decNumberAnd -- AND two Numbers, digitwise                         */
+/*                                                                    */
+/*   This computes C = A & B                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X&X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context (used for result length and error report)     */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* Logical function restrictions apply (see above); a NaN is          */
+/* returned with Invalid_operation if a restriction is violated.      */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberAnd(decNumber *res, const decNumber *lhs,
+                         const decNumber *rhs, decContext *set) {
+  const Unit *ua, *ub;                  // -> operands
+  const Unit *msua, *msub;              // -> operand msus
+  Unit *uc,  *msuc;                     // -> result and its msu
+  Int   msudigs;                        // digits in res msu
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  #endif
+
+  if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
+   || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
+    decStatus(res, DEC_Invalid_operation, set);
+    return res;
+    }
+
+  // operands are valid
+  ua=lhs->lsu;                          // bottom-up
+  ub=rhs->lsu;                          // ..
+  uc=res->lsu;                          // ..
+  msua=ua+D2U(lhs->digits)-1;           // -> msu of lhs
+  msub=ub+D2U(rhs->digits)-1;           // -> msu of rhs
+  msuc=uc+D2U(set->digits)-1;           // -> msu of result
+  msudigs=MSUDIGITS(set->digits);       // [faster than remainder]
+  for (; uc<=msuc; ua++, ub++, uc++) {  // Unit loop
+    Unit a, b;                          // extract units
+    if (ua>msua) a=0;
+     else a=*ua;
+    if (ub>msub) b=0;
+     else b=*ub;
+    *uc=0;                              // can now write back
+    if (a|b) {                          // maybe 1 bits to examine
+      Int i, j;
+      *uc=0;                            // can now write back
+      // This loop could be unrolled and/or use BIN2BCD tables
+      for (i=0; i<DECDPUN; i++) {
+        if (a&b&1) *uc=*uc+(Unit)powers[i];  // effect AND
+        j=a%10;
+        a=a/10;
+        j|=b%10;
+        b=b/10;
+        if (j>1) {
+          decStatus(res, DEC_Invalid_operation, set);
+          return res;
+          }
+        if (uc==msuc && i==msudigs-1) break; // just did final digit
+        } // each digit
+      } // both OK
+    } // each unit
+  // [here uc-1 is the msu of the result]
+  res->digits=decGetDigits(res->lsu, uc-res->lsu);
+  res->exponent=0;                      // integer
+  res->bits=0;                          // sign=0
+  return res;  // [no status to set]
+  } // decNumberAnd
+
+/* ------------------------------------------------------------------ */
+/* decNumberCompare -- compare two Numbers                            */
+/*                                                                    */
+/*   This computes C = A ? B                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for one digit (or NaN).                          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberCompare(decNumber *res, const decNumber *lhs,
+                             const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+  decCompareOp(res, lhs, rhs, set, COMPARE, &status);
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberCompare
+
+/* ------------------------------------------------------------------ */
+/* decNumberCompareSignal -- compare, signalling on all NaNs          */
+/*                                                                    */
+/*   This computes C = A ? B                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for one digit (or NaN).                          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberCompareSignal(decNumber *res, const decNumber *lhs,
+                                   const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+  decCompareOp(res, lhs, rhs, set, COMPSIG, &status);
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberCompareSignal
+
+/* ------------------------------------------------------------------ */
+/* decNumberCompareTotal -- compare two Numbers, using total ordering */
+/*                                                                    */
+/*   This computes C = A ? B, under total ordering                    */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for one digit; the result will always be one of  */
+/* -1, 0, or 1.                                                       */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberCompareTotal(decNumber *res, const decNumber *lhs,
+                                  const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+  decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberCompareTotal
+
+/* ------------------------------------------------------------------ */
+/* decNumberCompareTotalMag -- compare, total ordering of magnitudes  */
+/*                                                                    */
+/*   This computes C = |A| ? |B|, under total ordering                */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for one digit; the result will always be one of  */
+/* -1, 0, or 1.                                                       */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberCompareTotalMag(decNumber *res, const decNumber *lhs,
+                                     const decNumber *rhs, decContext *set) {
+  uInt status=0;                   // accumulator
+  uInt needbytes;                  // for space calculations
+  decNumber bufa[D2N(DECBUFFER+1)];// +1 in case DECBUFFER=0
+  decNumber *allocbufa=NULL;       // -> allocated bufa, iff allocated
+  decNumber bufb[D2N(DECBUFFER+1)];
+  decNumber *allocbufb=NULL;       // -> allocated bufb, iff allocated
+  decNumber *a, *b;                // temporary pointers
+
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  #endif
+
+  do {                                  // protect allocated storage
+    // if either is negative, take a copy and absolute
+    if (decNumberIsNegative(lhs)) {     // lhs<0
+      a=bufa;
+      needbytes=sizeof(decNumber)+(D2U(lhs->digits)-1)*sizeof(Unit);
+      if (needbytes>sizeof(bufa)) {     // need malloc space
+        allocbufa=(decNumber *)malloc(needbytes);
+        if (allocbufa==NULL) {          // hopeless -- abandon
+          status|=DEC_Insufficient_storage;
+          break;}
+        a=allocbufa;                    // use the allocated space
+        }
+      decNumberCopy(a, lhs);            // copy content
+      a->bits&=~DECNEG;                 // .. and clear the sign
+      lhs=a;                            // use copy from here on
+      }
+    if (decNumberIsNegative(rhs)) {     // rhs<0
+      b=bufb;
+      needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
+      if (needbytes>sizeof(bufb)) {     // need malloc space
+        allocbufb=(decNumber *)malloc(needbytes);
+        if (allocbufb==NULL) {          // hopeless -- abandon
+          status|=DEC_Insufficient_storage;
+          break;}
+        b=allocbufb;                    // use the allocated space
+        }
+      decNumberCopy(b, rhs);            // copy content
+      b->bits&=~DECNEG;                 // .. and clear the sign
+      rhs=b;                            // use copy from here on
+      }
+    decCompareOp(res, lhs, rhs, set, COMPTOTAL, &status);
+    } while(0);                         // end protected
+
+  if (allocbufa!=NULL) free(allocbufa); // drop any storage used
+  if (allocbufb!=NULL) free(allocbufb); // ..
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberCompareTotalMag
+
+/* ------------------------------------------------------------------ */
+/* decNumberDivide -- divide one number by another                    */
+/*                                                                    */
+/*   This computes C = A / B                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X/X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberDivide(decNumber *res, const decNumber *lhs,
+                            const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+  decDivideOp(res, lhs, rhs, set, DIVIDE, &status);
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberDivide
+
+/* ------------------------------------------------------------------ */
+/* decNumberDivideInteger -- divide and return integer quotient       */
+/*                                                                    */
+/*   This computes C = A # B, where # is the integer divide operator  */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X#X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberDivideInteger(decNumber *res, const decNumber *lhs,
+                                   const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+  decDivideOp(res, lhs, rhs, set, DIVIDEINT, &status);
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberDivideInteger
+
+/* ------------------------------------------------------------------ */
+/* decNumberExp -- exponentiation                                     */
+/*                                                                    */
+/*   This computes C = exp(A)                                         */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*   set is the context; note that rounding mode has no effect        */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* Mathematical function restrictions apply (see above); a NaN is     */
+/* returned with Invalid_operation if a restriction is violated.      */
+/*                                                                    */
+/* Finite results will always be full precision and Inexact, except   */
+/* when A is a zero or -Infinity (giving 1 or 0 respectively).        */
+/*                                                                    */
+/* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
+/* almost always be correctly rounded, but may be up to 1 ulp in      */
+/* error in rare cases.                                               */
+/* ------------------------------------------------------------------ */
+/* This is a wrapper for decExpOp which can handle the slightly wider */
+/* (double) range needed by Ln (which has to be able to calculate     */
+/* exp(-a) where a can be the tiniest number (Ntiny).                 */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberExp(decNumber *res, const decNumber *rhs,
+                         decContext *set) {
+  uInt status=0;                        // accumulator
+  #if DECSUBSET
+  decNumber *allocrhs=NULL;        // non-NULL if rounded rhs allocated
+  #endif
+
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  // Check restrictions; these restrictions ensure that if h=8 (see
+  // decExpOp) then the result will either overflow or underflow to 0.
+  // Other math functions restrict the input range, too, for inverses.
+  // If not violated then carry out the operation.
+  if (!decCheckMath(rhs, set, &status)) do { // protect allocation
+    #if DECSUBSET
+    if (!set->extended) {
+      // reduce operand and set lostDigits status, as needed
+      if (rhs->digits>set->digits) {
+        allocrhs=decRoundOperand(rhs, set, &status);
+        if (allocrhs==NULL) break;
+        rhs=allocrhs;
+        }
+      }
+    #endif
+    decExpOp(res, rhs, set, &status);
+    } while(0);                         // end protected
+
+  #if DECSUBSET
+  if (allocrhs !=NULL) free(allocrhs);  // drop any storage used
+  #endif
+  // apply significant status
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberExp
+
+/* ------------------------------------------------------------------ */
+/* decNumberFMA -- fused multiply add                                 */
+/*                                                                    */
+/*   This computes D = (A * B) + C with only one rounding             */
+/*                                                                    */
+/*   res is D, the result.  D may be A or B or C (e.g., X=FMA(X,X,X)) */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   fhs is C [far hand side]                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* Mathematical function restrictions apply (see above); a NaN is     */
+/* returned with Invalid_operation if a restriction is violated.      */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberFMA(decNumber *res, const decNumber *lhs,
+                         const decNumber *rhs, const decNumber *fhs,
+                         decContext *set) {
+  uInt status=0;                   // accumulator
+  decContext dcmul;                // context for the multiplication
+  uInt needbytes;                  // for space calculations
+  decNumber bufa[D2N(DECBUFFER*2+1)];
+  decNumber *allocbufa=NULL;       // -> allocated bufa, iff allocated
+  decNumber *acc;                  // accumulator pointer
+  decNumber dzero;                 // work
+
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  if (decCheckOperands(res, fhs, DECUNUSED, set)) return res;
+  #endif
+
+  do {                                  // protect allocated storage
+    #if DECSUBSET
+    if (!set->extended) {               // [undefined if subset]
+      status|=DEC_Invalid_operation;
+      break;}
+    #endif
+    // Check math restrictions [these ensure no overflow or underflow]
+    if ((!decNumberIsSpecial(lhs) && decCheckMath(lhs, set, &status))
+     || (!decNumberIsSpecial(rhs) && decCheckMath(rhs, set, &status))
+     || (!decNumberIsSpecial(fhs) && decCheckMath(fhs, set, &status))) break;
+    // set up context for multiply
+    dcmul=*set;
+    dcmul.digits=lhs->digits+rhs->digits; // just enough
+    // [The above may be an over-estimate for subset arithmetic, but that's OK]
+    dcmul.emax=DEC_MAX_EMAX;            // effectively unbounded ..
+    dcmul.emin=DEC_MIN_EMIN;            // [thanks to Math restrictions]
+    // set up decNumber space to receive the result of the multiply
+    acc=bufa;                           // may fit
+    needbytes=sizeof(decNumber)+(D2U(dcmul.digits)-1)*sizeof(Unit);
+    if (needbytes>sizeof(bufa)) {       // need malloc space
+      allocbufa=(decNumber *)malloc(needbytes);
+      if (allocbufa==NULL) {            // hopeless -- abandon
+        status|=DEC_Insufficient_storage;
+        break;}
+      acc=allocbufa;                    // use the allocated space
+      }
+    // multiply with extended range and necessary precision
+    //printf("emin=%ld\n", dcmul.emin);
+    decMultiplyOp(acc, lhs, rhs, &dcmul, &status);
+    // Only Invalid operation (from sNaN or Inf * 0) is possible in
+    // status; if either is seen than ignore fhs (in case it is
+    // another sNaN) and set acc to NaN unless we had an sNaN
+    // [decMultiplyOp leaves that to caller]
+    // Note sNaN has to go through addOp to shorten payload if
+    // necessary
+    if ((status&DEC_Invalid_operation)!=0) {
+      if (!(status&DEC_sNaN)) {         // but be true invalid
+        decNumberZero(res);             // acc not yet set
+        res->bits=DECNAN;
+        break;
+        }
+      decNumberZero(&dzero);            // make 0 (any non-NaN would do)
+      fhs=&dzero;                       // use that
+      }
+    #if DECCHECK
+     else { // multiply was OK
+      if (status!=0) printf("Status=%08lx after FMA multiply\n", (LI)status);
+      }
+    #endif
+    // add the third operand and result -> res, and all is done
+    decAddOp(res, acc, fhs, set, 0, &status);
+    } while(0);                         // end protected
+
+  if (allocbufa!=NULL) free(allocbufa); // drop any storage used
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberFMA
+
+/* ------------------------------------------------------------------ */
+/* decNumberInvert -- invert a Number, digitwise                      */
+/*                                                                    */
+/*   This computes C = ~A                                             */
+/*                                                                    */
+/*   res is C, the result.  C may be A (e.g., X=~X)                   */
+/*   rhs is A                                                         */
+/*   set is the context (used for result length and error report)     */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* Logical function restrictions apply (see above); a NaN is          */
+/* returned with Invalid_operation if a restriction is violated.      */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberInvert(decNumber *res, const decNumber *rhs,
+                            decContext *set) {
+  const Unit *ua, *msua;                // -> operand and its msu
+  Unit  *uc, *msuc;                     // -> result and its msu
+  Int   msudigs;                        // digits in res msu
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  if (rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
+    decStatus(res, DEC_Invalid_operation, set);
+    return res;
+    }
+  // operand is valid
+  ua=rhs->lsu;                          // bottom-up
+  uc=res->lsu;                          // ..
+  msua=ua+D2U(rhs->digits)-1;           // -> msu of rhs
+  msuc=uc+D2U(set->digits)-1;           // -> msu of result
+  msudigs=MSUDIGITS(set->digits);       // [faster than remainder]
+  for (; uc<=msuc; ua++, uc++) {        // Unit loop
+    Unit a;                             // extract unit
+    Int  i, j;                          // work
+    if (ua>msua) a=0;
+     else a=*ua;
+    *uc=0;                              // can now write back
+    // always need to examine all bits in rhs
+    // This loop could be unrolled and/or use BIN2BCD tables
+    for (i=0; i<DECDPUN; i++) {
+      if ((~a)&1) *uc=*uc+(Unit)powers[i];   // effect INVERT
+      j=a%10;
+      a=a/10;
+      if (j>1) {
+        decStatus(res, DEC_Invalid_operation, set);
+        return res;
+        }
+      if (uc==msuc && i==msudigs-1) break;   // just did final digit
+      } // each digit
+    } // each unit
+  // [here uc-1 is the msu of the result]
+  res->digits=decGetDigits(res->lsu, uc-res->lsu);
+  res->exponent=0;                      // integer
+  res->bits=0;                          // sign=0
+  return res;  // [no status to set]
+  } // decNumberInvert
+
+/* ------------------------------------------------------------------ */
+/* decNumberLn -- natural logarithm                                   */
+/*                                                                    */
+/*   This computes C = ln(A)                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*   set is the context; note that rounding mode has no effect        */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* Notable cases:                                                     */
+/*   A<0 -> Invalid                                                   */
+/*   A=0 -> -Infinity (Exact)                                         */
+/*   A=+Infinity -> +Infinity (Exact)                                 */
+/*   A=1 exactly -> 0 (Exact)                                         */
+/*                                                                    */
+/* Mathematical function restrictions apply (see above); a NaN is     */
+/* returned with Invalid_operation if a restriction is violated.      */
+/*                                                                    */
+/* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
+/* almost always be correctly rounded, but may be up to 1 ulp in      */
+/* error in rare cases.                                               */
+/* ------------------------------------------------------------------ */
+/* This is a wrapper for decLnOp which can handle the slightly wider  */
+/* (+11) range needed by Ln, Log10, etc. (which may have to be able   */
+/* to calculate at p+e+2).                                            */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberLn(decNumber *res, const decNumber *rhs,
+                        decContext *set) {
+  uInt status=0;                   // accumulator
+  #if DECSUBSET
+  decNumber *allocrhs=NULL;        // non-NULL if rounded rhs allocated
+  #endif
+
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  // Check restrictions; this is a math function; if not violated
+  // then carry out the operation.
+  if (!decCheckMath(rhs, set, &status)) do { // protect allocation
+    #if DECSUBSET
+    if (!set->extended) {
+      // reduce operand and set lostDigits status, as needed
+      if (rhs->digits>set->digits) {
+        allocrhs=decRoundOperand(rhs, set, &status);
+        if (allocrhs==NULL) break;
+        rhs=allocrhs;
+        }
+      // special check in subset for rhs=0
+      if (ISZERO(rhs)) {                // +/- zeros -> error
+        status|=DEC_Invalid_operation;
+        break;}
+      } // extended=0
+    #endif
+    decLnOp(res, rhs, set, &status);
+    } while(0);                         // end protected
+
+  #if DECSUBSET
+  if (allocrhs !=NULL) free(allocrhs);  // drop any storage used
+  #endif
+  // apply significant status
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberLn
+
+/* ------------------------------------------------------------------ */
+/* decNumberLogB - get adjusted exponent, by 754 rules                */
+/*                                                                    */
+/*   This computes C = adjustedexponent(A)                            */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*   set is the context, used only for digits and status              */
+/*                                                                    */
+/* For an unrounded result, digits may need to be 10 (A might have    */
+/* 10**9 digits and an exponent of +999999999, or one digit and an    */
+/* exponent of -1999999999).                                          */
+/*                                                                    */
+/* This returns the adjusted exponent of A after (in theory) padding  */
+/* with zeros on the right to set->digits digits while keeping the    */
+/* same value.  The exponent is not limited by emin/emax.             */
+/*                                                                    */
+/* Notable cases:                                                     */
+/*   A<0 -> Use |A|                                                   */
+/*   A=0 -> -Infinity (Division by zero)                              */
+/*   A=Infinite -> +Infinity (Exact)                                  */
+/*   A=1 exactly -> 0 (Exact)                                         */
+/*   NaNs are propagated as usual                                     */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberLogB(decNumber *res, const decNumber *rhs,
+                          decContext *set) {
+  uInt status=0;                   // accumulator
+
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  // NaNs as usual; Infinities return +Infinity; 0->oops
+  if (decNumberIsNaN(rhs)) decNaNs(res, rhs, NULL, set, &status);
+   else if (decNumberIsInfinite(rhs)) decNumberCopyAbs(res, rhs);
+   else if (decNumberIsZero(rhs)) {
+    decNumberZero(res);                 // prepare for Infinity
+    res->bits=DECNEG|DECINF;            // -Infinity
+    status|=DEC_Division_by_zero;       // as per 754
+    }
+   else { // finite non-zero
+    Int ae=rhs->exponent+rhs->digits-1; // adjusted exponent
+    if (set->digits>=10) decNumberFromInt32(res, ae);  // lay it out
+     else {
+      decNumber buft[D2N(10)];          // temporary number
+      decNumber *t=buft;                // ..
+      decNumberFromInt32(t, ae);        // lay it out
+      decNumberPlus(res, t, set);       // round as necessary
+      }
+    }
+
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberLogB
+
+/* ------------------------------------------------------------------ */
+/* decNumberLog10 -- logarithm in base 10                             */
+/*                                                                    */
+/*   This computes C = log10(A)                                       */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*   set is the context; note that rounding mode has no effect        */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* Notable cases:                                                     */
+/*   A<0 -> Invalid                                                   */
+/*   A=0 -> -Infinity (Exact)                                         */
+/*   A=+Infinity -> +Infinity (Exact)                                 */
+/*   A=10**n (if n is an integer) -> n (Exact)                        */
+/*                                                                    */
+/* Mathematical function restrictions apply (see above); a NaN is     */
+/* returned with Invalid_operation if a restriction is violated.      */
+/*                                                                    */
+/* An Inexact result is rounded using DEC_ROUND_HALF_EVEN; it will    */
+/* almost always be correctly rounded, but may be up to 1 ulp in      */
+/* error in rare cases.                                               */
+/* ------------------------------------------------------------------ */
+/* This calculates ln(A)/ln(10) using appropriate precision.  For     */
+/* ln(A) this is the max(p, rhs->digits + t) + 3, where p is the      */
+/* requested digits and t is the number of digits in the exponent     */
+/* (maximum 6).  For ln(10) it is p + 3; this is often handled by the */
+/* fastpath in decLnOp.  The final division is done to the requested  */
+/* precision.                                                         */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberLog10(decNumber *res, const decNumber *rhs,
+                          decContext *set) {
+  uInt status=0, ignore=0;         // status accumulators
+  uInt needbytes;                  // for space calculations
+  Int p;                           // working precision
+  Int t;                           // digits in exponent of A
+
+  // buffers for a and b working decimals
+  // (adjustment calculator, same size)
+  decNumber bufa[D2N(DECBUFFER+2)];
+  decNumber *allocbufa=NULL;       // -> allocated bufa, iff allocated
+  decNumber *a=bufa;               // temporary a
+  decNumber bufb[D2N(DECBUFFER+2)];
+  decNumber *allocbufb=NULL;       // -> allocated bufb, iff allocated
+  decNumber *b=bufb;               // temporary b
+  decNumber bufw[D2N(10)];         // working 2-10 digit number
+  decNumber *w=bufw;               // ..
+  #if DECSUBSET
+  decNumber *allocrhs=NULL;        // non-NULL if rounded rhs allocated
+  #endif
+
+  decContext aset;                 // working context
+
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  // Check restrictions; this is a math function; if not violated
+  // then carry out the operation.
+  if (!decCheckMath(rhs, set, &status)) do { // protect malloc
+    #if DECSUBSET
+    if (!set->extended) {
+      // reduce operand and set lostDigits status, as needed
+      if (rhs->digits>set->digits) {
+        allocrhs=decRoundOperand(rhs, set, &status);
+        if (allocrhs==NULL) break;
+        rhs=allocrhs;
+        }
+      // special check in subset for rhs=0
+      if (ISZERO(rhs)) {                // +/- zeros -> error
+        status|=DEC_Invalid_operation;
+        break;}
+      } // extended=0
+    #endif
+
+    decContextDefault(&aset, DEC_INIT_DECIMAL64); // clean context
+
+    // handle exact powers of 10; only check if +ve finite
+    if (!(rhs->bits&(DECNEG|DECSPECIAL)) && !ISZERO(rhs)) {
+      Int residue=0;               // (no residue)
+      uInt copystat=0;             // clean status
+
+      // round to a single digit...
+      aset.digits=1;
+      decCopyFit(w, rhs, &aset, &residue, &copystat); // copy & shorten
+      // if exact and the digit is 1, rhs is a power of 10
+      if (!(copystat&DEC_Inexact) && w->lsu[0]==1) {
+        // the exponent, conveniently, is the power of 10; making
+        // this the result needs a little care as it might not fit,
+        // so first convert it into the working number, and then move
+        // to res
+        decNumberFromInt32(w, w->exponent);
+        residue=0;
+        decCopyFit(res, w, set, &residue, &status); // copy & round
+        decFinish(res, set, &residue, &status);     // cleanup/set flags
+        break;
+        } // not a power of 10
+      } // not a candidate for exact
+
+    // simplify the information-content calculation to use 'total
+    // number of digits in a, including exponent' as compared to the
+    // requested digits, as increasing this will only rarely cost an
+    // iteration in ln(a) anyway
+    t=6;                                // it can never be >6
+
+    // allocate space when needed...
+    p=(rhs->digits+t>set->digits?rhs->digits+t:set->digits)+3;
+    needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
+    if (needbytes>sizeof(bufa)) {       // need malloc space
+      allocbufa=(decNumber *)malloc(needbytes);
+      if (allocbufa==NULL) {            // hopeless -- abandon
+        status|=DEC_Insufficient_storage;
+        break;}
+      a=allocbufa;                      // use the allocated space
+      }
+    aset.digits=p;                      // as calculated
+    aset.emax=DEC_MAX_MATH;             // usual bounds
+    aset.emin=-DEC_MAX_MATH;            // ..
+    aset.clamp=0;                       // and no concrete format
+    decLnOp(a, rhs, &aset, &status);    // a=ln(rhs)
+
+    // skip the division if the result so far is infinite, NaN, or
+    // zero, or there was an error; note NaN from sNaN needs copy
+    if (status&DEC_NaNs && !(status&DEC_sNaN)) break;
+    if (a->bits&DECSPECIAL || ISZERO(a)) {
+      decNumberCopy(res, a);            // [will fit]
+      break;}
+
+    // for ln(10) an extra 3 digits of precision are needed
+    p=set->digits+3;
+    needbytes=sizeof(decNumber)+(D2U(p)-1)*sizeof(Unit);
+    if (needbytes>sizeof(bufb)) {       // need malloc space
+      allocbufb=(decNumber *)malloc(needbytes);
+      if (allocbufb==NULL) {            // hopeless -- abandon
+        status|=DEC_Insufficient_storage;
+        break;}
+      b=allocbufb;                      // use the allocated space
+      }
+    decNumberZero(w);                   // set up 10...
+    #if DECDPUN==1
+    w->lsu[1]=1; w->lsu[0]=0;           // ..
+    #else
+    w->lsu[0]=10;                       // ..
+    #endif
+    w->digits=2;                        // ..
+
+    aset.digits=p;
+    decLnOp(b, w, &aset, &ignore);      // b=ln(10)
+
+    aset.digits=set->digits;            // for final divide
+    decDivideOp(res, a, b, &aset, DIVIDE, &status); // into result
+    } while(0);                         // [for break]
+
+  if (allocbufa!=NULL) free(allocbufa); // drop any storage used
+  if (allocbufb!=NULL) free(allocbufb); // ..
+  #if DECSUBSET
+  if (allocrhs !=NULL) free(allocrhs);  // ..
+  #endif
+  // apply significant status
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberLog10
+
+/* ------------------------------------------------------------------ */
+/* decNumberMax -- compare two Numbers and return the maximum         */
+/*                                                                    */
+/*   This computes C = A ? B, returning the maximum by 754 rules      */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberMax(decNumber *res, const decNumber *lhs,
+                         const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+  decCompareOp(res, lhs, rhs, set, COMPMAX, &status);
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberMax
+
+/* ------------------------------------------------------------------ */
+/* decNumberMaxMag -- compare and return the maximum by magnitude     */
+/*                                                                    */
+/*   This computes C = A ? B, returning the maximum by 754 rules      */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberMaxMag(decNumber *res, const decNumber *lhs,
+                         const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+  decCompareOp(res, lhs, rhs, set, COMPMAXMAG, &status);
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberMaxMag
+
+/* ------------------------------------------------------------------ */
+/* decNumberMin -- compare two Numbers and return the minimum         */
+/*                                                                    */
+/*   This computes C = A ? B, returning the minimum by 754 rules      */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberMin(decNumber *res, const decNumber *lhs,
+                         const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+  decCompareOp(res, lhs, rhs, set, COMPMIN, &status);
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberMin
+
+/* ------------------------------------------------------------------ */
+/* decNumberMinMag -- compare and return the minimum by magnitude     */
+/*                                                                    */
+/*   This computes C = A ? B, returning the minimum by 754 rules      */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberMinMag(decNumber *res, const decNumber *lhs,
+                         const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+  decCompareOp(res, lhs, rhs, set, COMPMINMAG, &status);
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberMinMag
+
+/* ------------------------------------------------------------------ */
+/* decNumberMinus -- prefix minus operator                            */
+/*                                                                    */
+/*   This computes C = 0 - A                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* See also decNumberCopyNegate for a quiet bitwise version of this.  */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+/* Simply use AddOp for the subtract, which will do the necessary.    */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberMinus(decNumber *res, const decNumber *rhs,
+                           decContext *set) {
+  decNumber dzero;
+  uInt status=0;                        // accumulator
+
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  decNumberZero(&dzero);                // make 0
+  dzero.exponent=rhs->exponent;         // [no coefficient expansion]
+  decAddOp(res, &dzero, rhs, set, DECNEG, &status);
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberMinus
+
+/* ------------------------------------------------------------------ */
+/* decNumberNextMinus -- next towards -Infinity                       */
+/*                                                                    */
+/*   This computes C = A - infinitesimal, rounded towards -Infinity   */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* This is a generalization of 754 NextDown.                          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberNextMinus(decNumber *res, const decNumber *rhs,
+                               decContext *set) {
+  decNumber dtiny;                           // constant
+  decContext workset=*set;                   // work
+  uInt status=0;                             // accumulator
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  // +Infinity is the special case
+  if ((rhs->bits&(DECINF|DECNEG))==DECINF) {
+    decSetMaxValue(res, set);                // is +ve
+    // there is no status to set
+    return res;
+    }
+  decNumberZero(&dtiny);                     // start with 0
+  dtiny.lsu[0]=1;                            // make number that is ..
+  dtiny.exponent=DEC_MIN_EMIN-1;             // .. smaller than tiniest
+  workset.round=DEC_ROUND_FLOOR;
+  decAddOp(res, rhs, &dtiny, &workset, DECNEG, &status);
+  status&=DEC_Invalid_operation|DEC_sNaN;    // only sNaN Invalid please
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberNextMinus
+
+/* ------------------------------------------------------------------ */
+/* decNumberNextPlus -- next towards +Infinity                        */
+/*                                                                    */
+/*   This computes C = A + infinitesimal, rounded towards +Infinity   */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* This is a generalization of 754 NextUp.                            */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberNextPlus(decNumber *res, const decNumber *rhs,
+                              decContext *set) {
+  decNumber dtiny;                           // constant
+  decContext workset=*set;                   // work
+  uInt status=0;                             // accumulator
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  // -Infinity is the special case
+  if ((rhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
+    decSetMaxValue(res, set);
+    res->bits=DECNEG;                        // negative
+    // there is no status to set
+    return res;
+    }
+  decNumberZero(&dtiny);                     // start with 0
+  dtiny.lsu[0]=1;                            // make number that is ..
+  dtiny.exponent=DEC_MIN_EMIN-1;             // .. smaller than tiniest
+  workset.round=DEC_ROUND_CEILING;
+  decAddOp(res, rhs, &dtiny, &workset, 0, &status);
+  status&=DEC_Invalid_operation|DEC_sNaN;    // only sNaN Invalid please
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberNextPlus
+
+/* ------------------------------------------------------------------ */
+/* decNumberNextToward -- next towards rhs                            */
+/*                                                                    */
+/*   This computes C = A +/- infinitesimal, rounded towards           */
+/*   +/-Infinity in the direction of B, as per 754-1985 nextafter     */
+/*   modified during revision but dropped from 754-2008.              */
+/*                                                                    */
+/*   res is C, the result.  C may be A or B.                          */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* This is a generalization of 754-1985 NextAfter.                    */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberNextToward(decNumber *res, const decNumber *lhs,
+                                const decNumber *rhs, decContext *set) {
+  decNumber dtiny;                           // constant
+  decContext workset=*set;                   // work
+  Int result;                                // ..
+  uInt status=0;                             // accumulator
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  #endif
+
+  if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) {
+    decNaNs(res, lhs, rhs, set, &status);
+    }
+   else { // Is numeric, so no chance of sNaN Invalid, etc.
+    result=decCompare(lhs, rhs, 0);     // sign matters
+    if (result==BADINT) status|=DEC_Insufficient_storage; // rare
+     else { // valid compare
+      if (result==0) decNumberCopySign(res, lhs, rhs); // easy
+       else { // differ: need NextPlus or NextMinus
+        uByte sub;                      // add or subtract
+        if (result<0) {                 // lhs<rhs, do nextplus
+          // -Infinity is the special case
+          if ((lhs->bits&(DECINF|DECNEG))==(DECINF|DECNEG)) {
+            decSetMaxValue(res, set);
+            res->bits=DECNEG;           // negative
+            return res;                 // there is no status to set
+            }
+          workset.round=DEC_ROUND_CEILING;
+          sub=0;                        // add, please
+          } // plus
+         else {                         // lhs>rhs, do nextminus
+          // +Infinity is the special case
+          if ((lhs->bits&(DECINF|DECNEG))==DECINF) {
+            decSetMaxValue(res, set);
+            return res;                 // there is no status to set
+            }
+          workset.round=DEC_ROUND_FLOOR;
+          sub=DECNEG;                   // subtract, please
+          } // minus
+        decNumberZero(&dtiny);          // start with 0
+        dtiny.lsu[0]=1;                 // make number that is ..
+        dtiny.exponent=DEC_MIN_EMIN-1;  // .. smaller than tiniest
+        decAddOp(res, lhs, &dtiny, &workset, sub, &status); // + or -
+        // turn off exceptions if the result is a normal number
+        // (including Nmin), otherwise let all status through
+        if (decNumberIsNormal(res, set)) status=0;
+        } // unequal
+      } // compare OK
+    } // numeric
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberNextToward
+
+/* ------------------------------------------------------------------ */
+/* decNumberOr -- OR two Numbers, digitwise                           */
+/*                                                                    */
+/*   This computes C = A | B                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X|X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context (used for result length and error report)     */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* Logical function restrictions apply (see above); a NaN is          */
+/* returned with Invalid_operation if a restriction is violated.      */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberOr(decNumber *res, const decNumber *lhs,
+                        const decNumber *rhs, decContext *set) {
+  const Unit *ua, *ub;                  // -> operands
+  const Unit *msua, *msub;              // -> operand msus
+  Unit  *uc, *msuc;                     // -> result and its msu
+  Int   msudigs;                        // digits in res msu
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  #endif
+
+  if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
+   || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
+    decStatus(res, DEC_Invalid_operation, set);
+    return res;
+    }
+  // operands are valid
+  ua=lhs->lsu;                          // bottom-up
+  ub=rhs->lsu;                          // ..
+  uc=res->lsu;                          // ..
+  msua=ua+D2U(lhs->digits)-1;           // -> msu of lhs
+  msub=ub+D2U(rhs->digits)-1;           // -> msu of rhs
+  msuc=uc+D2U(set->digits)-1;           // -> msu of result
+  msudigs=MSUDIGITS(set->digits);       // [faster than remainder]
+  for (; uc<=msuc; ua++, ub++, uc++) {  // Unit loop
+    Unit a, b;                          // extract units
+    if (ua>msua) a=0;
+     else a=*ua;
+    if (ub>msub) b=0;
+     else b=*ub;
+    *uc=0;                              // can now write back
+    if (a|b) {                          // maybe 1 bits to examine
+      Int i, j;
+      // This loop could be unrolled and/or use BIN2BCD tables
+      for (i=0; i<DECDPUN; i++) {
+        if ((a|b)&1) *uc=*uc+(Unit)powers[i];     // effect OR
+        j=a%10;
+        a=a/10;
+        j|=b%10;
+        b=b/10;
+        if (j>1) {
+          decStatus(res, DEC_Invalid_operation, set);
+          return res;
+          }
+        if (uc==msuc && i==msudigs-1) break;      // just did final digit
+        } // each digit
+      } // non-zero
+    } // each unit
+  // [here uc-1 is the msu of the result]
+  res->digits=decGetDigits(res->lsu, uc-res->lsu);
+  res->exponent=0;                      // integer
+  res->bits=0;                          // sign=0
+  return res;  // [no status to set]
+  } // decNumberOr
+
+/* ------------------------------------------------------------------ */
+/* decNumberPlus -- prefix plus operator                              */
+/*                                                                    */
+/*   This computes C = 0 + A                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* See also decNumberCopy for a quiet bitwise version of this.        */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+/* This simply uses AddOp; Add will take fast path after preparing A. */
+/* Performance is a concern here, as this routine is often used to    */
+/* check operands and apply rounding and overflow/underflow testing.  */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberPlus(decNumber *res, const decNumber *rhs,
+                          decContext *set) {
+  decNumber dzero;
+  uInt status=0;                        // accumulator
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  decNumberZero(&dzero);                // make 0
+  dzero.exponent=rhs->exponent;         // [no coefficient expansion]
+  decAddOp(res, &dzero, rhs, set, 0, &status);
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberPlus
+
+/* ------------------------------------------------------------------ */
+/* decNumberMultiply -- multiply two Numbers                          */
+/*                                                                    */
+/*   This computes C = A x B                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X+X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberMultiply(decNumber *res, const decNumber *lhs,
+                              const decNumber *rhs, decContext *set) {
+  uInt status=0;                   // accumulator
+  decMultiplyOp(res, lhs, rhs, set, &status);
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberMultiply
+
+/* ------------------------------------------------------------------ */
+/* decNumberPower -- raise a number to a power                        */
+/*                                                                    */
+/*   This computes C = A ** B                                         */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X**X)        */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* Mathematical function restrictions apply (see above); a NaN is     */
+/* returned with Invalid_operation if a restriction is violated.      */
+/*                                                                    */
+/* However, if 1999999997<=B<=999999999 and B is an integer then the  */
+/* restrictions on A and the context are relaxed to the usual bounds, */
+/* for compatibility with the earlier (integer power only) version    */
+/* of this function.                                                  */
+/*                                                                    */
+/* When B is an integer, the result may be exact, even if rounded.    */
+/*                                                                    */
+/* The final result is rounded according to the context; it will      */
+/* almost always be correctly rounded, but may be up to 1 ulp in      */
+/* error in rare cases.                                               */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberPower(decNumber *res, const decNumber *lhs,
+                           const decNumber *rhs, decContext *set) {
+  #if DECSUBSET
+  decNumber *alloclhs=NULL;        // non-NULL if rounded lhs allocated
+  decNumber *allocrhs=NULL;        // .., rhs
+  #endif
+  decNumber *allocdac=NULL;        // -> allocated acc buffer, iff used
+  decNumber *allocinv=NULL;        // -> allocated 1/x buffer, iff used
+  Int   reqdigits=set->digits;     // requested DIGITS
+  Int   n;                         // rhs in binary
+  Flag  rhsint=0;                  // 1 if rhs is an integer
+  Flag  useint=0;                  // 1 if can use integer calculation
+  Flag  isoddint=0;                // 1 if rhs is an integer and odd
+  Int   i;                         // work
+  #if DECSUBSET
+  Int   dropped;                   // ..
+  #endif
+  uInt  needbytes;                 // buffer size needed
+  Flag  seenbit;                   // seen a bit while powering
+  Int   residue=0;                 // rounding residue
+  uInt  status=0;                  // accumulators
+  uByte bits=0;                    // result sign if errors
+  decContext aset;                 // working context
+  decNumber dnOne;                 // work value 1...
+  // local accumulator buffer [a decNumber, with digits+elength+1 digits]
+  decNumber dacbuff[D2N(DECBUFFER+9)];
+  decNumber *dac=dacbuff;          // -> result accumulator
+  // same again for possible 1/lhs calculation
+  decNumber invbuff[D2N(DECBUFFER+9)];
+
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  #endif
+
+  do {                             // protect allocated storage
+    #if DECSUBSET
+    if (!set->extended) { // reduce operands and set status, as needed
+      if (lhs->digits>reqdigits) {
+        alloclhs=decRoundOperand(lhs, set, &status);
+        if (alloclhs==NULL) break;
+        lhs=alloclhs;
+        }
+      if (rhs->digits>reqdigits) {
+        allocrhs=decRoundOperand(rhs, set, &status);
+        if (allocrhs==NULL) break;
+        rhs=allocrhs;
+        }
+      }
+    #endif
+    // [following code does not require input rounding]
+
+    // handle NaNs and rhs Infinity (lhs infinity is harder)
+    if (SPECIALARGS) {
+      if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs)) { // NaNs
+        decNaNs(res, lhs, rhs, set, &status);
+        break;}
+      if (decNumberIsInfinite(rhs)) {   // rhs Infinity
+        Flag rhsneg=rhs->bits&DECNEG;   // save rhs sign
+        if (decNumberIsNegative(lhs)    // lhs<0
+         && !decNumberIsZero(lhs))      // ..
+          status|=DEC_Invalid_operation;
+         else {                         // lhs >=0
+          decNumberZero(&dnOne);        // set up 1
+          dnOne.lsu[0]=1;
+          decNumberCompare(dac, lhs, &dnOne, set); // lhs ? 1
+          decNumberZero(res);           // prepare for 0/1/Infinity
+          if (decNumberIsNegative(dac)) {    // lhs<1
+            if (rhsneg) res->bits|=DECINF;   // +Infinity [else is +0]
+            }
+           else if (dac->lsu[0]==0) {        // lhs=1
+            // 1**Infinity is inexact, so return fully-padded 1.0000
+            Int shift=set->digits-1;
+            *res->lsu=1;                     // was 0, make int 1
+            res->digits=decShiftToMost(res->lsu, 1, shift);
+            res->exponent=-shift;            // make 1.0000...
+            status|=DEC_Inexact|DEC_Rounded; // deemed inexact
+            }
+           else {                            // lhs>1
+            if (!rhsneg) res->bits|=DECINF;  // +Infinity [else is +0]
+            }
+          } // lhs>=0
+        break;}
+      // [lhs infinity drops through]
+      } // specials
+
+    // Original rhs may be an integer that fits and is in range
+    n=decGetInt(rhs);
+    if (n!=BADINT) {                    // it is an integer
+      rhsint=1;                         // record the fact for 1**n
+      isoddint=(Flag)n&1;               // [works even if big]
+      if (n!=BIGEVEN && n!=BIGODD)      // can use integer path?
+        useint=1;                       // looks good
+      }
+
+    if (decNumberIsNegative(lhs)        // -x ..
+      && isoddint) bits=DECNEG;         // .. to an odd power
+
+    // handle LHS infinity
+    if (decNumberIsInfinite(lhs)) {     // [NaNs already handled]
+      uByte rbits=rhs->bits;            // save
+      decNumberZero(res);               // prepare
+      if (n==0) *res->lsu=1;            // [-]Inf**0 => 1
+       else {
+        // -Inf**nonint -> error
+        if (!rhsint && decNumberIsNegative(lhs)) {
+          status|=DEC_Invalid_operation;     // -Inf**nonint is error
+          break;}
+        if (!(rbits & DECNEG)) bits|=DECINF; // was not a **-n
+        // [otherwise will be 0 or -0]
+        res->bits=bits;
+        }
+      break;}
+
+    // similarly handle LHS zero
+    if (decNumberIsZero(lhs)) {
+      if (n==0) {                            // 0**0 => Error
+        #if DECSUBSET
+        if (!set->extended) {                // [unless subset]
+          decNumberZero(res);
+          *res->lsu=1;                       // return 1
+          break;}
+        #endif
+        status|=DEC_Invalid_operation;
+        }
+       else {                                // 0**x
+        uByte rbits=rhs->bits;               // save
+        if (rbits & DECNEG) {                // was a 0**(-n)
+          #if DECSUBSET
+          if (!set->extended) {              // [bad if subset]
+            status|=DEC_Invalid_operation;
+            break;}
+          #endif
+          bits|=DECINF;
+          }
+        decNumberZero(res);                  // prepare
+        // [otherwise will be 0 or -0]
+        res->bits=bits;
+        }
+      break;}
+
+    // here both lhs and rhs are finite; rhs==0 is handled in the
+    // integer path.  Next handle the non-integer cases
+    if (!useint) {                      // non-integral rhs
+      // any -ve lhs is bad, as is either operand or context out of
+      // bounds
+      if (decNumberIsNegative(lhs)) {
+        status|=DEC_Invalid_operation;
+        break;}
+      if (decCheckMath(lhs, set, &status)
+       || decCheckMath(rhs, set, &status)) break; // variable status
+
+      decContextDefault(&aset, DEC_INIT_DECIMAL64); // clean context
+      aset.emax=DEC_MAX_MATH;           // usual bounds
+      aset.emin=-DEC_MAX_MATH;          // ..
+      aset.clamp=0;                     // and no concrete format
+
+      // calculate the result using exp(ln(lhs)*rhs), which can
+      // all be done into the accumulator, dac.  The precision needed
+      // is enough to contain the full information in the lhs (which
+      // is the total digits, including exponent), or the requested
+      // precision, if larger, + 4; 6 is used for the exponent
+      // maximum length, and this is also used when it is shorter
+      // than the requested digits as it greatly reduces the >0.5 ulp
+      // cases at little cost (because Ln doubles digits each
+      // iteration so a few extra digits rarely causes an extra
+      // iteration)
+      aset.digits=MAXI(lhs->digits, set->digits)+6+4;
+      } // non-integer rhs
+
+     else { // rhs is in-range integer
+      if (n==0) {                       // x**0 = 1
+        // (0**0 was handled above)
+        decNumberZero(res);             // result=1
+        *res->lsu=1;                    // ..
+        break;}
+      // rhs is a non-zero integer
+      if (n<0) n=-n;                    // use abs(n)
+
+      aset=*set;                        // clone the context
+      aset.round=DEC_ROUND_HALF_EVEN;   // internally use balanced
+      // calculate the working DIGITS
+      aset.digits=reqdigits+(rhs->digits+rhs->exponent)+2;
+      #if DECSUBSET
+      if (!set->extended) aset.digits--;     // use classic precision
+      #endif
+      // it's an error if this is more than can be handled
+      if (aset.digits>DECNUMMAXP) {status|=DEC_Invalid_operation; break;}
+      } // integer path
+
+    // aset.digits is the count of digits for the accumulator needed
+    // if accumulator is too long for local storage, then allocate
+    needbytes=sizeof(decNumber)+(D2U(aset.digits)-1)*sizeof(Unit);
+    // [needbytes also used below if 1/lhs needed]
+    if (needbytes>sizeof(dacbuff)) {
+      allocdac=(decNumber *)malloc(needbytes);
+      if (allocdac==NULL) {   // hopeless -- abandon
+        status|=DEC_Insufficient_storage;
+        break;}
+      dac=allocdac;           // use the allocated space
+      }
+    // here, aset is set up and accumulator is ready for use
+
+    if (!useint) {                           // non-integral rhs
+      // x ** y; special-case x=1 here as it will otherwise always
+      // reduce to integer 1; decLnOp has a fastpath which detects
+      // the case of x=1
+      decLnOp(dac, lhs, &aset, &status);     // dac=ln(lhs)
+      // [no error possible, as lhs 0 already handled]
+      if (ISZERO(dac)) {                     // x==1, 1.0, etc.
+        // need to return fully-padded 1.0000 etc., but rhsint->1
+        *dac->lsu=1;                         // was 0, make int 1
+        if (!rhsint) {                       // add padding
+          Int shift=set->digits-1;
+          dac->digits=decShiftToMost(dac->lsu, 1, shift);
+          dac->exponent=-shift;              // make 1.0000...
+          status|=DEC_Inexact|DEC_Rounded;   // deemed inexact
+          }
+        }
+       else {
+        decMultiplyOp(dac, dac, rhs, &aset, &status);  // dac=dac*rhs
+        decExpOp(dac, dac, &aset, &status);            // dac=exp(dac)
+        }
+      // and drop through for final rounding
+      } // non-integer rhs
+
+     else {                             // carry on with integer
+      decNumberZero(dac);               // acc=1
+      *dac->lsu=1;                      // ..
+
+      // if a negative power the constant 1 is needed, and if not subset
+      // invert the lhs now rather than inverting the result later
+      if (decNumberIsNegative(rhs)) {   // was a **-n [hence digits>0]
+        decNumber *inv=invbuff;         // asssume use fixed buffer
+        decNumberCopy(&dnOne, dac);     // dnOne=1;  [needed now or later]
+        #if DECSUBSET
+        if (set->extended) {            // need to calculate 1/lhs
+        #endif
+          // divide lhs into 1, putting result in dac [dac=1/dac]
+          decDivideOp(dac, &dnOne, lhs, &aset, DIVIDE, &status);
+          // now locate or allocate space for the inverted lhs
+          if (needbytes>sizeof(invbuff)) {
+            allocinv=(decNumber *)malloc(needbytes);
+            if (allocinv==NULL) {       // hopeless -- abandon
+              status|=DEC_Insufficient_storage;
+              break;}
+            inv=allocinv;               // use the allocated space
+            }
+          // [inv now points to big-enough buffer or allocated storage]
+          decNumberCopy(inv, dac);      // copy the 1/lhs
+          decNumberCopy(dac, &dnOne);   // restore acc=1
+          lhs=inv;                      // .. and go forward with new lhs
+        #if DECSUBSET
+          }
+        #endif
+        }
+
+      // Raise-to-the-power loop...
+      seenbit=0;                   // set once a 1-bit is encountered
+      for (i=1;;i++){              // for each bit [top bit ignored]
+        // abandon if had overflow or terminal underflow
+        if (status & (DEC_Overflow|DEC_Underflow)) { // interesting?
+          if (status&DEC_Overflow || ISZERO(dac)) break;
+          }
+        // [the following two lines revealed an optimizer bug in a C++
+        // compiler, with symptom: 5**3 -> 25, when n=n+n was used]
+        n=n<<1;                    // move next bit to testable position
+        if (n<0) {                 // top bit is set
+          seenbit=1;               // OK, significant bit seen
+          decMultiplyOp(dac, dac, lhs, &aset, &status); // dac=dac*x
+          }
+        if (i==31) break;          // that was the last bit
+        if (!seenbit) continue;    // no need to square 1
+        decMultiplyOp(dac, dac, dac, &aset, &status); // dac=dac*dac [square]
+        } /*i*/ // 32 bits
+
+      // complete internal overflow or underflow processing
+      if (status & (DEC_Overflow|DEC_Underflow)) {
+        #if DECSUBSET
+        // If subset, and power was negative, reverse the kind of -erflow
+        // [1/x not yet done]
+        if (!set->extended && decNumberIsNegative(rhs)) {
+          if (status & DEC_Overflow)
+            status^=DEC_Overflow | DEC_Underflow | DEC_Subnormal;
+           else { // trickier -- Underflow may or may not be set
+            status&=~(DEC_Underflow | DEC_Subnormal); // [one or both]
+            status|=DEC_Overflow;
+            }
+          }
+        #endif
+        dac->bits=(dac->bits & ~DECNEG) | bits; // force correct sign
+        // round subnormals [to set.digits rather than aset.digits]
+        // or set overflow result similarly as required
+        decFinalize(dac, set, &residue, &status);
+        decNumberCopy(res, dac);   // copy to result (is now OK length)
+        break;
+        }
+
+      #if DECSUBSET
+      if (!set->extended &&                  // subset math
+          decNumberIsNegative(rhs)) {        // was a **-n [hence digits>0]
+        // so divide result into 1 [dac=1/dac]
+        decDivideOp(dac, &dnOne, dac, &aset, DIVIDE, &status);
+        }
+      #endif
+      } // rhs integer path
+
+    // reduce result to the requested length and copy to result
+    decCopyFit(res, dac, set, &residue, &status);
+    decFinish(res, set, &residue, &status);  // final cleanup
+    #if DECSUBSET
+    if (!set->extended) decTrim(res, set, 0, 1, &dropped); // trailing zeros
+    #endif
+    } while(0);                         // end protected
+
+  if (allocdac!=NULL) free(allocdac);   // drop any storage used
+  if (allocinv!=NULL) free(allocinv);   // ..
+  #if DECSUBSET
+  if (alloclhs!=NULL) free(alloclhs);   // ..
+  if (allocrhs!=NULL) free(allocrhs);   // ..
+  #endif
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberPower
+
+/* ------------------------------------------------------------------ */
+/* decNumberQuantize -- force exponent to requested value             */
+/*                                                                    */
+/*   This computes C = op(A, B), where op adjusts the coefficient     */
+/*   of C (by rounding or shifting) such that the exponent (-scale)   */
+/*   of C has exponent of B.  The numerical value of C will equal A,  */
+/*   except for the effects of any rounding that occurred.            */
+/*                                                                    */
+/*   res is C, the result.  C may be A or B                           */
+/*   lhs is A, the number to adjust                                   */
+/*   rhs is B, the number with exponent to match                      */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* Unless there is an error or the result is infinite, the exponent   */
+/* after the operation is guaranteed to be equal to that of B.        */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberQuantize(decNumber *res, const decNumber *lhs,
+                              const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+  decQuantizeOp(res, lhs, rhs, set, 1, &status);
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberQuantize
+
+/* ------------------------------------------------------------------ */
+/* decNumberReduce -- remove trailing zeros                           */
+/*                                                                    */
+/*   This computes C = 0 + A, and normalizes the result               */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+// Previously known as Normalize
+decNumber * decNumberNormalize(decNumber *res, const decNumber *rhs,
+                               decContext *set) {
+  return decNumberReduce(res, rhs, set);
+  } // decNumberNormalize
+
+decNumber * decNumberReduce(decNumber *res, const decNumber *rhs,
+                            decContext *set) {
+  #if DECSUBSET
+  decNumber *allocrhs=NULL;        // non-NULL if rounded rhs allocated
+  #endif
+  uInt status=0;                   // as usual
+  Int  residue=0;                  // as usual
+  Int  dropped;                    // work
+
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  do {                             // protect allocated storage
+    #if DECSUBSET
+    if (!set->extended) {
+      // reduce operand and set lostDigits status, as needed
+      if (rhs->digits>set->digits) {
+        allocrhs=decRoundOperand(rhs, set, &status);
+        if (allocrhs==NULL) break;
+        rhs=allocrhs;
+        }
+      }
+    #endif
+    // [following code does not require input rounding]
+
+    // Infinities copy through; NaNs need usual treatment
+    if (decNumberIsNaN(rhs)) {
+      decNaNs(res, rhs, NULL, set, &status);
+      break;
+      }
+
+    // reduce result to the requested length and copy to result
+    decCopyFit(res, rhs, set, &residue, &status); // copy & round
+    decFinish(res, set, &residue, &status);       // cleanup/set flags
+    decTrim(res, set, 1, 0, &dropped);            // normalize in place
+                                                  // [may clamp]
+    } while(0);                              // end protected
+
+  #if DECSUBSET
+  if (allocrhs !=NULL) free(allocrhs);       // ..
+  #endif
+  if (status!=0) decStatus(res, status, set);// then report status
+  return res;
+  } // decNumberReduce
+
+/* ------------------------------------------------------------------ */
+/* decNumberRescale -- force exponent to requested value              */
+/*                                                                    */
+/*   This computes C = op(A, B), where op adjusts the coefficient     */
+/*   of C (by rounding or shifting) such that the exponent (-scale)   */
+/*   of C has the value B.  The numerical value of C will equal A,    */
+/*   except for the effects of any rounding that occurred.            */
+/*                                                                    */
+/*   res is C, the result.  C may be A or B                           */
+/*   lhs is A, the number to adjust                                   */
+/*   rhs is B, the requested exponent                                 */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* Unless there is an error or the result is infinite, the exponent   */
+/* after the operation is guaranteed to be equal to B.                */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberRescale(decNumber *res, const decNumber *lhs,
+                             const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+  decQuantizeOp(res, lhs, rhs, set, 0, &status);
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberRescale
+
+/* ------------------------------------------------------------------ */
+/* decNumberRemainder -- divide and return remainder                  */
+/*                                                                    */
+/*   This computes C = A % B                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X%X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberRemainder(decNumber *res, const decNumber *lhs,
+                               const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+  decDivideOp(res, lhs, rhs, set, REMAINDER, &status);
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberRemainder
+
+/* ------------------------------------------------------------------ */
+/* decNumberRemainderNear -- divide and return remainder from nearest */
+/*                                                                    */
+/*   This computes C = A % B, where % is the IEEE remainder operator  */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X%X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberRemainderNear(decNumber *res, const decNumber *lhs,
+                                   const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+  decDivideOp(res, lhs, rhs, set, REMNEAR, &status);
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberRemainderNear
+
+/* ------------------------------------------------------------------ */
+/* decNumberRotate -- rotate the coefficient of a Number left/right   */
+/*                                                                    */
+/*   This computes C = A rot B  (in base ten and rotating set->digits */
+/*   digits).                                                         */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=XrotX)       */
+/*   lhs is A                                                         */
+/*   rhs is B, the number of digits to rotate (-ve to right)          */
+/*   set is the context                                               */
+/*                                                                    */
+/* The digits of the coefficient of A are rotated to the left (if B   */
+/* is positive) or to the right (if B is negative) without adjusting  */
+/* the exponent or the sign of A.  If lhs->digits is less than        */
+/* set->digits the coefficient is padded with zeros on the left       */
+/* before the rotate.  Any leading zeros in the result are removed    */
+/* as usual.                                                          */
+/*                                                                    */
+/* B must be an integer (q=0) and in the range -set->digits through   */
+/* +set->digits.                                                      */
+/* C must have space for set->digits digits.                          */
+/* NaNs are propagated as usual.  Infinities are unaffected (but      */
+/* B must be valid).  No status is set unless B is invalid or an      */
+/* operand is an sNaN.                                                */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberRotate(decNumber *res, const decNumber *lhs,
+                           const decNumber *rhs, decContext *set) {
+  uInt status=0;              // accumulator
+  Int  rotate;                // rhs as an Int
+
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  #endif
+
+  // NaNs propagate as normal
+  if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
+    decNaNs(res, lhs, rhs, set, &status);
+   // rhs must be an integer
+   else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
+    status=DEC_Invalid_operation;
+   else { // both numeric, rhs is an integer
+    rotate=decGetInt(rhs);                   // [cannot fail]
+    if (rotate==BADINT                       // something bad ..
+     || rotate==BIGODD || rotate==BIGEVEN    // .. very big ..
+     || abs(rotate)>set->digits)             // .. or out of range
+      status=DEC_Invalid_operation;
+     else {                                  // rhs is OK
+      decNumberCopy(res, lhs);
+      // convert -ve rotate to equivalent positive rotation
+      if (rotate<0) rotate=set->digits+rotate;
+      if (rotate!=0 && rotate!=set->digits   // zero or full rotation
+       && !decNumberIsInfinite(res)) {       // lhs was infinite
+        // left-rotate to do; 0 < rotate < set->digits
+        uInt units, shift;                   // work
+        uInt msudigits;                      // digits in result msu
+        Unit *msu=res->lsu+D2U(res->digits)-1;    // current msu
+        Unit *msumax=res->lsu+D2U(set->digits)-1; // rotation msu
+        for (msu++; msu<=msumax; msu++) *msu=0;   // ensure high units=0
+        res->digits=set->digits;                  // now full-length
+        msudigits=MSUDIGITS(res->digits);         // actual digits in msu
+
+        // rotation here is done in-place, in three steps
+        // 1. shift all to least up to one unit to unit-align final
+        //    lsd [any digits shifted out are rotated to the left,
+        //    abutted to the original msd (which may require split)]
+        //
+        //    [if there are no whole units left to rotate, the
+        //    rotation is now complete]
+        //
+        // 2. shift to least, from below the split point only, so that
+        //    the final msd is in the right place in its Unit [any
+        //    digits shifted out will fit exactly in the current msu,
+        //    left aligned, no split required]
+        //
+        // 3. rotate all the units by reversing left part, right
+        //    part, and then whole
+        //
+        // example: rotate right 8 digits (2 units + 2), DECDPUN=3.
+        //
+        //   start: 00a bcd efg hij klm npq
+        //
+        //      1a  000 0ab cde fgh|ijk lmn [pq saved]
+        //      1b  00p qab cde fgh|ijk lmn
+        //
+        //      2a  00p qab cde fgh|00i jkl [mn saved]
+        //      2b  mnp qab cde fgh|00i jkl
+        //
+        //      3a  fgh cde qab mnp|00i jkl
+        //      3b  fgh cde qab mnp|jkl 00i
+        //      3c  00i jkl mnp qab cde fgh
+
+        // Step 1: amount to shift is the partial right-rotate count
+        rotate=set->digits-rotate;      // make it right-rotate
+        units=rotate/DECDPUN;           // whole units to rotate
+        shift=rotate%DECDPUN;           // left-over digits count
+        if (shift>0) {                  // not an exact number of units
+          uInt save=res->lsu[0]%powers[shift];    // save low digit(s)
+          decShiftToLeast(res->lsu, D2U(res->digits), shift);
+          if (shift>msudigits) {        // msumax-1 needs >0 digits
+            uInt rem=save%powers[shift-msudigits];// split save
+            *msumax=(Unit)(save/powers[shift-msudigits]); // and insert
+            *(msumax-1)=*(msumax-1)
+                       +(Unit)(rem*powers[DECDPUN-(shift-msudigits)]); // ..
+            }
+           else { // all fits in msumax
+            *msumax=*msumax+(Unit)(save*powers[msudigits-shift]); // [maybe *1]
+            }
+          } // digits shift needed
+
+        // If whole units to rotate...
+        if (units>0) {                  // some to do
+          // Step 2: the units to touch are the whole ones in rotate,
+          //   if any, and the shift is DECDPUN-msudigits (which may be
+          //   0, again)
+          shift=DECDPUN-msudigits;
+          if (shift>0) {                // not an exact number of units
+            uInt save=res->lsu[0]%powers[shift];  // save low digit(s)
+            decShiftToLeast(res->lsu, units, shift);
+            *msumax=*msumax+(Unit)(save*powers[msudigits]);
+            } // partial shift needed
+
+          // Step 3: rotate the units array using triple reverse
+          // (reversing is easy and fast)
+          decReverse(res->lsu+units, msumax);     // left part
+          decReverse(res->lsu, res->lsu+units-1); // right part
+          decReverse(res->lsu, msumax);           // whole
+          } // whole units to rotate
+        // the rotation may have left an undetermined number of zeros
+        // on the left, so true length needs to be calculated
+        res->digits=decGetDigits(res->lsu, msumax-res->lsu+1);
+        } // rotate needed
+      } // rhs OK
+    } // numerics
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberRotate
+
+/* ------------------------------------------------------------------ */
+/* decNumberSameQuantum -- test for equal exponents                   */
+/*                                                                    */
+/*   res is the result number, which will contain either 0 or 1       */
+/*   lhs is a number to test                                          */
+/*   rhs is the second (usually a pattern)                            */
+/*                                                                    */
+/* No errors are possible and no context is needed.                   */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberSameQuantum(decNumber *res, const decNumber *lhs,
+                                 const decNumber *rhs) {
+  Unit ret=0;                      // return value
+
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, DECUNCONT)) return res;
+  #endif
+
+  if (SPECIALARGS) {
+    if (decNumberIsNaN(lhs) && decNumberIsNaN(rhs)) ret=1;
+     else if (decNumberIsInfinite(lhs) && decNumberIsInfinite(rhs)) ret=1;
+     // [anything else with a special gives 0]
+    }
+   else if (lhs->exponent==rhs->exponent) ret=1;
+
+  decNumberZero(res);              // OK to overwrite an operand now
+  *res->lsu=ret;
+  return res;
+  } // decNumberSameQuantum
+
+/* ------------------------------------------------------------------ */
+/* decNumberScaleB -- multiply by a power of 10                       */
+/*                                                                    */
+/* This computes C = A x 10**B where B is an integer (q=0) with       */
+/* maximum magnitude 2*(emax+digits)                                  */
+/*                                                                    */
+/*   res is C, the result.  C may be A or B                           */
+/*   lhs is A, the number to adjust                                   */
+/*   rhs is B, the requested power of ten to use                      */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* The result may underflow or overflow.                              */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberScaleB(decNumber *res, const decNumber *lhs,
+                            const decNumber *rhs, decContext *set) {
+  Int  reqexp;                // requested exponent change [B]
+  uInt status=0;              // accumulator
+  Int  residue;               // work
+
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  #endif
+
+  // Handle special values except lhs infinite
+  if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
+    decNaNs(res, lhs, rhs, set, &status);
+    // rhs must be an integer
+   else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
+    status=DEC_Invalid_operation;
+   else {
+    // lhs is a number; rhs is a finite with q==0
+    reqexp=decGetInt(rhs);                   // [cannot fail]
+    // maximum range is larger than getInt can handle, so this is
+    // more restrictive than the specification
+    if (reqexp==BADINT                       // something bad ..
+     || reqexp==BIGODD || reqexp==BIGEVEN    // it was huge
+     || (abs(reqexp)+1)/2>(set->digits+set->emax)) // .. or out of range
+      status=DEC_Invalid_operation;
+     else {                                  // rhs is OK
+      decNumberCopy(res, lhs);               // all done if infinite lhs
+      if (!decNumberIsInfinite(res)) {       // prepare to scale
+        Int exp=res->exponent;               // save for overflow test
+        res->exponent+=reqexp;               // adjust the exponent
+        if (((exp^reqexp)>=0)                // same sign ...
+         && ((exp^res->exponent)<0)) {       // .. but result had different
+          // the calculation overflowed, so force right treatment
+          if (exp<0) res->exponent=DEC_MIN_EMIN-DEC_MAX_DIGITS;
+           else      res->exponent=DEC_MAX_EMAX+1;
+          }
+        residue=0;
+        decFinalize(res, set, &residue, &status); // final check
+        } // finite LHS
+      } // rhs OK
+    } // rhs finite
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberScaleB
+
+/* ------------------------------------------------------------------ */
+/* decNumberShift -- shift the coefficient of a Number left or right  */
+/*                                                                    */
+/*   This computes C = A << B or C = A >> -B  (in base ten).          */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X<<X)        */
+/*   lhs is A                                                         */
+/*   rhs is B, the number of digits to shift (-ve to right)           */
+/*   set is the context                                               */
+/*                                                                    */
+/* The digits of the coefficient of A are shifted to the left (if B   */
+/* is positive) or to the right (if B is negative) without adjusting  */
+/* the exponent or the sign of A.                                     */
+/*                                                                    */
+/* B must be an integer (q=0) and in the range -set->digits through   */
+/* +set->digits.                                                      */
+/* C must have space for set->digits digits.                          */
+/* NaNs are propagated as usual.  Infinities are unaffected (but      */
+/* B must be valid).  No status is set unless B is invalid or an      */
+/* operand is an sNaN.                                                */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberShift(decNumber *res, const decNumber *lhs,
+                           const decNumber *rhs, decContext *set) {
+  uInt status=0;              // accumulator
+  Int  shift;                 // rhs as an Int
+
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  #endif
+
+  // NaNs propagate as normal
+  if (decNumberIsNaN(lhs) || decNumberIsNaN(rhs))
+    decNaNs(res, lhs, rhs, set, &status);
+   // rhs must be an integer
+   else if (decNumberIsInfinite(rhs) || rhs->exponent!=0)
+    status=DEC_Invalid_operation;
+   else { // both numeric, rhs is an integer
+    shift=decGetInt(rhs);                    // [cannot fail]
+    if (shift==BADINT                        // something bad ..
+     || shift==BIGODD || shift==BIGEVEN      // .. very big ..
+     || abs(shift)>set->digits)              // .. or out of range
+      status=DEC_Invalid_operation;
+     else {                                  // rhs is OK
+      decNumberCopy(res, lhs);
+      if (shift!=0 && !decNumberIsInfinite(res)) { // something to do
+        if (shift>0) {                       // to left
+          if (shift==set->digits) {          // removing all
+            *res->lsu=0;                     // so place 0
+            res->digits=1;                   // ..
+            }
+           else {                            //
+            // first remove leading digits if necessary
+            if (res->digits+shift>set->digits) {
+              decDecap(res, res->digits+shift-set->digits);
+              // that updated res->digits; may have gone to 1 (for a
+              // single digit or for zero
+              }
+            if (res->digits>1 || *res->lsu)  // if non-zero..
+              res->digits=decShiftToMost(res->lsu, res->digits, shift);
+            } // partial left
+          } // left
+         else { // to right
+          if (-shift>=res->digits) {         // discarding all
+            *res->lsu=0;                     // so place 0
+            res->digits=1;                   // ..
+            }
+           else {
+            decShiftToLeast(res->lsu, D2U(res->digits), -shift);
+            res->digits-=(-shift);
+            }
+          } // to right
+        } // non-0 non-Inf shift
+      } // rhs OK
+    } // numerics
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberShift
+
+/* ------------------------------------------------------------------ */
+/* decNumberSquareRoot -- square root operator                        */
+/*                                                                    */
+/*   This computes C = squareroot(A)                                  */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*   set is the context; note that rounding mode has no effect        */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+/* This uses the following varying-precision algorithm in:            */
+/*                                                                    */
+/*   Properly Rounded Variable Precision Square Root, T. E. Hull and  */
+/*   A. Abrham, ACM Transactions on Mathematical Software, Vol 11 #3, */
+/*   pp229-237, ACM, September 1985.                                  */
+/*                                                                    */
+/* The square-root is calculated using Newton's method, after which   */
+/* a check is made to ensure the result is correctly rounded.         */
+/*                                                                    */
+/* % [Reformatted original Numerical Turing source code follows.]     */
+/* function sqrt(x : real) : real                                     */
+/* % sqrt(x) returns the properly rounded approximation to the square */
+/* % root of x, in the precision of the calling environment, or it    */
+/* % fails if x < 0.                                                  */
+/* % t e hull and a abrham, august, 1984                              */
+/* if x <= 0 then                                                     */
+/*   if x < 0 then                                                    */
+/*     assert false                                                   */
+/*   else                                                             */
+/*     result 0                                                       */
+/*   end if                                                           */
+/* end if                                                             */
+/* var f := setexp(x, 0)  % fraction part of x   [0.1 <= x < 1]       */
+/* var e := getexp(x)     % exponent part of x                        */
+/* var approx : real                                                  */
+/* if e mod 2 = 0  then                                               */
+/*   approx := .259 + .819 * f   % approx to root of f                */
+/* else                                                               */
+/*   f := f/l0                   % adjustments                        */
+/*   e := e + 1                  %   for odd                          */
+/*   approx := .0819 + 2.59 * f  %   exponent                         */
+/* end if                                                             */
+/*                                                                    */
+/* var p:= 3                                                          */
+/* const maxp := currentprecision + 2                                 */
+/* loop                                                               */
+/*   p := min(2*p - 2, maxp)     % p = 4,6,10, . . . , maxp           */
+/*   precision p                                                      */
+/*   approx := .5 * (approx + f/approx)                               */
+/*   exit when p = maxp                                               */
+/* end loop                                                           */
+/*                                                                    */
+/* % approx is now within 1 ulp of the properly rounded square root   */
+/* % of f; to ensure proper rounding, compare squares of (approx -    */
+/* % l/2 ulp) and (approx + l/2 ulp) with f.                          */
+/* p := currentprecision                                              */
+/* begin                                                              */
+/*   precision p + 2                                                  */
+/*   const approxsubhalf := approx - setexp(.5, -p)                   */
+/*   if mulru(approxsubhalf, approxsubhalf) > f then                  */
+/*     approx := approx - setexp(.l, -p + 1)                          */
+/*   else                                                             */
+/*     const approxaddhalf := approx + setexp(.5, -p)                 */
+/*     if mulrd(approxaddhalf, approxaddhalf) < f then                */
+/*       approx := approx + setexp(.l, -p + 1)                        */
+/*     end if                                                         */
+/*   end if                                                           */
+/* end                                                                */
+/* result setexp(approx, e div 2)  % fix exponent                     */
+/* end sqrt                                                           */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberSquareRoot(decNumber *res, const decNumber *rhs,
+                                decContext *set) {
+  decContext workset, approxset;   // work contexts
+  decNumber dzero;                 // used for constant zero
+  Int  maxp;                       // largest working precision
+  Int  workp;                      // working precision
+  Int  residue=0;                  // rounding residue
+  uInt status=0, ignore=0;         // status accumulators
+  uInt rstatus;                    // ..
+  Int  exp;                        // working exponent
+  Int  ideal;                      // ideal (preferred) exponent
+  Int  needbytes;                  // work
+  Int  dropped;                    // ..
+
+  #if DECSUBSET
+  decNumber *allocrhs=NULL;        // non-NULL if rounded rhs allocated
+  #endif
+  // buffer for f [needs +1 in case DECBUFFER 0]
+  decNumber buff[D2N(DECBUFFER+1)];
+  // buffer for a [needs +2 to match likely maxp]
+  decNumber bufa[D2N(DECBUFFER+2)];
+  // buffer for temporary, b [must be same size as a]
+  decNumber bufb[D2N(DECBUFFER+2)];
+  decNumber *allocbuff=NULL;       // -> allocated buff, iff allocated
+  decNumber *allocbufa=NULL;       // -> allocated bufa, iff allocated
+  decNumber *allocbufb=NULL;       // -> allocated bufb, iff allocated
+  decNumber *f=buff;               // reduced fraction
+  decNumber *a=bufa;               // approximation to result
+  decNumber *b=bufb;               // intermediate result
+  // buffer for temporary variable, up to 3 digits
+  decNumber buft[D2N(3)];
+  decNumber *t=buft;               // up-to-3-digit constant or work
+
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  do {                             // protect allocated storage
+    #if DECSUBSET
+    if (!set->extended) {
+      // reduce operand and set lostDigits status, as needed
+      if (rhs->digits>set->digits) {
+        allocrhs=decRoundOperand(rhs, set, &status);
+        if (allocrhs==NULL) break;
+        // [Note: 'f' allocation below could reuse this buffer if
+        // used, but as this is rare they are kept separate for clarity.]
+        rhs=allocrhs;
+        }
+      }
+    #endif
+    // [following code does not require input rounding]
+
+    // handle infinities and NaNs
+    if (SPECIALARG) {
+      if (decNumberIsInfinite(rhs)) {         // an infinity
+        if (decNumberIsNegative(rhs)) status|=DEC_Invalid_operation;
+         else decNumberCopy(res, rhs);        // +Infinity
+        }
+       else decNaNs(res, rhs, NULL, set, &status); // a NaN
+      break;
+      }
+
+    // calculate the ideal (preferred) exponent [floor(exp/2)]
+    // [It would be nicer to write: ideal=rhs->exponent>>1, but this
+    // generates a compiler warning.  Generated code is the same.]
+    ideal=(rhs->exponent&~1)/2;         // target
+
+    // handle zeros
+    if (ISZERO(rhs)) {
+      decNumberCopy(res, rhs);          // could be 0 or -0
+      res->exponent=ideal;              // use the ideal [safe]
+      // use decFinish to clamp any out-of-range exponent, etc.
+      decFinish(res, set, &residue, &status);
+      break;
+      }
+
+    // any other -x is an oops
+    if (decNumberIsNegative(rhs)) {
+      status|=DEC_Invalid_operation;
+      break;
+      }
+
+    // space is needed for three working variables
+    //   f -- the same precision as the RHS, reduced to 0.01->0.99...
+    //   a -- Hull's approximation -- precision, when assigned, is
+    //        currentprecision+1 or the input argument precision,
+    //        whichever is larger (+2 for use as temporary)
+    //   b -- intermediate temporary result (same size as a)
+    // if any is too long for local storage, then allocate
+    workp=MAXI(set->digits+1, rhs->digits);  // actual rounding precision
+    workp=MAXI(workp, 7);                    // at least 7 for low cases
+    maxp=workp+2;                            // largest working precision
+
+    needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
+    if (needbytes>(Int)sizeof(buff)) {
+      allocbuff=(decNumber *)malloc(needbytes);
+      if (allocbuff==NULL) {  // hopeless -- abandon
+        status|=DEC_Insufficient_storage;
+        break;}
+      f=allocbuff;            // use the allocated space
+      }
+    // a and b both need to be able to hold a maxp-length number
+    needbytes=sizeof(decNumber)+(D2U(maxp)-1)*sizeof(Unit);
+    if (needbytes>(Int)sizeof(bufa)) {            // [same applies to b]
+      allocbufa=(decNumber *)malloc(needbytes);
+      allocbufb=(decNumber *)malloc(needbytes);
+      if (allocbufa==NULL || allocbufb==NULL) {   // hopeless
+        status|=DEC_Insufficient_storage;
+        break;}
+      a=allocbufa;            // use the allocated spaces
+      b=allocbufb;            // ..
+      }
+
+    // copy rhs -> f, save exponent, and reduce so 0.1 <= f < 1
+    decNumberCopy(f, rhs);
+    exp=f->exponent+f->digits;               // adjusted to Hull rules
+    f->exponent=-(f->digits);                // to range
+
+    // set up working context
+    decContextDefault(&workset, DEC_INIT_DECIMAL64);
+    workset.emax=DEC_MAX_EMAX;
+    workset.emin=DEC_MIN_EMIN;
+
+    // [Until further notice, no error is possible and status bits
+    // (Rounded, etc.) should be ignored, not accumulated.]
+
+    // Calculate initial approximation, and allow for odd exponent
+    workset.digits=workp;                    // p for initial calculation
+    t->bits=0; t->digits=3;
+    a->bits=0; a->digits=3;
+    if ((exp & 1)==0) {                      // even exponent
+      // Set t=0.259, a=0.819
+      t->exponent=-3;
+      a->exponent=-3;
+      #if DECDPUN>=3
+        t->lsu[0]=259;
+        a->lsu[0]=819;
+      #elif DECDPUN==2
+        t->lsu[0]=59; t->lsu[1]=2;
+        a->lsu[0]=19; a->lsu[1]=8;
+      #else
+        t->lsu[0]=9; t->lsu[1]=5; t->lsu[2]=2;
+        a->lsu[0]=9; a->lsu[1]=1; a->lsu[2]=8;
+      #endif
+      }
+     else {                                  // odd exponent
+      // Set t=0.0819, a=2.59
+      f->exponent--;                         // f=f/10
+      exp++;                                 // e=e+1
+      t->exponent=-4;
+      a->exponent=-2;
+      #if DECDPUN>=3
+        t->lsu[0]=819;
+        a->lsu[0]=259;
+      #elif DECDPUN==2
+        t->lsu[0]=19; t->lsu[1]=8;
+        a->lsu[0]=59; a->lsu[1]=2;
+      #else
+        t->lsu[0]=9; t->lsu[1]=1; t->lsu[2]=8;
+        a->lsu[0]=9; a->lsu[1]=5; a->lsu[2]=2;
+      #endif
+      }
+
+    decMultiplyOp(a, a, f, &workset, &ignore);    // a=a*f
+    decAddOp(a, a, t, &workset, 0, &ignore);      // ..+t
+    // [a is now the initial approximation for sqrt(f), calculated with
+    // currentprecision, which is also a's precision.]
+
+    // the main calculation loop
+    decNumberZero(&dzero);                   // make 0
+    decNumberZero(t);                        // set t = 0.5
+    t->lsu[0]=5;                             // ..
+    t->exponent=-1;                          // ..
+    workset.digits=3;                        // initial p
+    for (; workset.digits<maxp;) {
+      // set p to min(2*p - 2, maxp)  [hence 3; or: 4, 6, 10, ... , maxp]
+      workset.digits=MINI(workset.digits*2-2, maxp);
+      // a = 0.5 * (a + f/a)
+      // [calculated at p then rounded to currentprecision]
+      decDivideOp(b, f, a, &workset, DIVIDE, &ignore); // b=f/a
+      decAddOp(b, b, a, &workset, 0, &ignore);         // b=b+a
+      decMultiplyOp(a, b, t, &workset, &ignore);       // a=b*0.5
+      } // loop
+
+    // Here, 0.1 <= a < 1 [Hull], and a has maxp digits
+    // now reduce to length, etc.; this needs to be done with a
+    // having the correct exponent so as to handle subnormals
+    // correctly
+    approxset=*set;                          // get emin, emax, etc.
+    approxset.round=DEC_ROUND_HALF_EVEN;
+    a->exponent+=exp/2;                      // set correct exponent
+    rstatus=0;                               // clear status
+    residue=0;                               // .. and accumulator
+    decCopyFit(a, a, &approxset, &residue, &rstatus);  // reduce (if needed)
+    decFinish(a, &approxset, &residue, &rstatus);      // clean and finalize
+
+    // Overflow was possible if the input exponent was out-of-range,
+    // in which case quit
+    if (rstatus&DEC_Overflow) {
+      status=rstatus;                        // use the status as-is
+      decNumberCopy(res, a);                 // copy to result
+      break;
+      }
+
+    // Preserve status except Inexact/Rounded
+    status|=(rstatus & ~(DEC_Rounded|DEC_Inexact));
+
+    // Carry out the Hull correction
+    a->exponent-=exp/2;                      // back to 0.1->1
+
+    // a is now at final precision and within 1 ulp of the properly
+    // rounded square root of f; to ensure proper rounding, compare
+    // squares of (a - l/2 ulp) and (a + l/2 ulp) with f.
+    // Here workset.digits=maxp and t=0.5, and a->digits determines
+    // the ulp
+    workset.digits--;                             // maxp-1 is OK now
+    t->exponent=-a->digits-1;                     // make 0.5 ulp
+    decAddOp(b, a, t, &workset, DECNEG, &ignore); // b = a - 0.5 ulp
+    workset.round=DEC_ROUND_UP;
+    decMultiplyOp(b, b, b, &workset, &ignore);    // b = mulru(b, b)
+    decCompareOp(b, f, b, &workset, COMPARE, &ignore); // b ? f, reversed
+    if (decNumberIsNegative(b)) {                 // f < b [i.e., b > f]
+      // this is the more common adjustment, though both are rare
+      t->exponent++;                              // make 1.0 ulp
+      t->lsu[0]=1;                                // ..
+      decAddOp(a, a, t, &workset, DECNEG, &ignore); // a = a - 1 ulp
+      // assign to approx [round to length]
+      approxset.emin-=exp/2;                      // adjust to match a
+      approxset.emax-=exp/2;
+      decAddOp(a, &dzero, a, &approxset, 0, &ignore);
+      }
+     else {
+      decAddOp(b, a, t, &workset, 0, &ignore);    // b = a + 0.5 ulp
+      workset.round=DEC_ROUND_DOWN;
+      decMultiplyOp(b, b, b, &workset, &ignore);  // b = mulrd(b, b)
+      decCompareOp(b, b, f, &workset, COMPARE, &ignore);   // b ? f
+      if (decNumberIsNegative(b)) {               // b < f
+        t->exponent++;                            // make 1.0 ulp
+        t->lsu[0]=1;                              // ..
+        decAddOp(a, a, t, &workset, 0, &ignore);  // a = a + 1 ulp
+        // assign to approx [round to length]
+        approxset.emin-=exp/2;                    // adjust to match a
+        approxset.emax-=exp/2;
+        decAddOp(a, &dzero, a, &approxset, 0, &ignore);
+        }
+      }
+    // [no errors are possible in the above, and rounding/inexact during
+    // estimation are irrelevant, so status was not accumulated]
+
+    // Here, 0.1 <= a < 1  (still), so adjust back
+    a->exponent+=exp/2;                      // set correct exponent
+
+    // count droppable zeros [after any subnormal rounding] by
+    // trimming a copy
+    decNumberCopy(b, a);
+    decTrim(b, set, 1, 1, &dropped);         // [drops trailing zeros]
+
+    // Set Inexact and Rounded.  The answer can only be exact if
+    // it is short enough so that squaring it could fit in workp
+    // digits, so this is the only (relatively rare) condition that
+    // a careful check is needed
+    if (b->digits*2-1 > workp) {             // cannot fit
+      status|=DEC_Inexact|DEC_Rounded;
+      }
+     else {                                  // could be exact/unrounded
+      uInt mstatus=0;                        // local status
+      decMultiplyOp(b, b, b, &workset, &mstatus); // try the multiply
+      if (mstatus&DEC_Overflow) {            // result just won't fit
+        status|=DEC_Inexact|DEC_Rounded;
+        }
+       else {                                // plausible
+        decCompareOp(t, b, rhs, &workset, COMPARE, &mstatus); // b ? rhs
+        if (!ISZERO(t)) status|=DEC_Inexact|DEC_Rounded; // not equal
+         else {                              // is Exact
+          // here, dropped is the count of trailing zeros in 'a'
+          // use closest exponent to ideal...
+          Int todrop=ideal-a->exponent;      // most that can be dropped
+          if (todrop<0) status|=DEC_Rounded; // ideally would add 0s
+           else {                            // unrounded
+            // there are some to drop, but emax may not allow all
+            Int maxexp=set->emax-set->digits+1;
+            Int maxdrop=maxexp-a->exponent;
+            if (todrop>maxdrop && set->clamp) { // apply clamping
+              todrop=maxdrop;
+              status|=DEC_Clamped;
+              }
+            if (dropped<todrop) {            // clamp to those available
+              todrop=dropped;
+              status|=DEC_Clamped;
+              }
+            if (todrop>0) {                  // have some to drop
+              decShiftToLeast(a->lsu, D2U(a->digits), todrop);
+              a->exponent+=todrop;           // maintain numerical value
+              a->digits-=todrop;             // new length
+              }
+            }
+          }
+        }
+      }
+
+    // double-check Underflow, as perhaps the result could not have
+    // been subnormal (initial argument too big), or it is now Exact
+    if (status&DEC_Underflow) {
+      Int ae=rhs->exponent+rhs->digits-1;    // adjusted exponent
+      // check if truly subnormal
+      #if DECEXTFLAG                         // DEC_Subnormal too
+        if (ae>=set->emin*2) status&=~(DEC_Subnormal|DEC_Underflow);
+      #else
+        if (ae>=set->emin*2) status&=~DEC_Underflow;
+      #endif
+      // check if truly inexact
+      if (!(status&DEC_Inexact)) status&=~DEC_Underflow;
+      }
+
+    decNumberCopy(res, a);                   // a is now the result
+    } while(0);                              // end protected
+
+  if (allocbuff!=NULL) free(allocbuff);      // drop any storage used
+  if (allocbufa!=NULL) free(allocbufa);      // ..
+  if (allocbufb!=NULL) free(allocbufb);      // ..
+  #if DECSUBSET
+  if (allocrhs !=NULL) free(allocrhs);       // ..
+  #endif
+  if (status!=0) decStatus(res, status, set);// then report status
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberSquareRoot
+
+/* ------------------------------------------------------------------ */
+/* decNumberSubtract -- subtract two Numbers                          */
+/*                                                                    */
+/*   This computes C = A - B                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X-X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberSubtract(decNumber *res, const decNumber *lhs,
+                              const decNumber *rhs, decContext *set) {
+  uInt status=0;                        // accumulator
+
+  decAddOp(res, lhs, rhs, set, DECNEG, &status);
+  if (status!=0) decStatus(res, status, set);
+  #if DECCHECK
+  decCheckInexact(res, set);
+  #endif
+  return res;
+  } // decNumberSubtract
+
+/* ------------------------------------------------------------------ */
+/* decNumberToIntegralExact -- round-to-integral-value with InExact   */
+/* decNumberToIntegralValue -- round-to-integral-value                */
+/*                                                                    */
+/*   res is the result                                                */
+/*   rhs is input number                                              */
+/*   set is the context                                               */
+/*                                                                    */
+/* res must have space for any value of rhs.                          */
+/*                                                                    */
+/* This implements the IEEE special operators and therefore treats    */
+/* special values as valid.  For finite numbers it returns            */
+/* rescale(rhs, 0) if rhs->exponent is <0.                            */
+/* Otherwise the result is rhs (so no error is possible, except for   */
+/* sNaN).                                                             */
+/*                                                                    */
+/* The context is used for rounding mode and status after sNaN, but   */
+/* the digits setting is ignored.  The Exact version will signal      */
+/* Inexact if the result differs numerically from rhs; the other      */
+/* never signals Inexact.                                             */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberToIntegralExact(decNumber *res, const decNumber *rhs,
+                                     decContext *set) {
+  decNumber dn;
+  decContext workset;              // working context
+  uInt status=0;                   // accumulator
+
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  // handle infinities and NaNs
+  if (SPECIALARG) {
+    if (decNumberIsInfinite(rhs)) decNumberCopy(res, rhs); // an Infinity
+     else decNaNs(res, rhs, NULL, set, &status); // a NaN
+    }
+   else { // finite
+    // have a finite number; no error possible (res must be big enough)
+    if (rhs->exponent>=0) return decNumberCopy(res, rhs);
+    // that was easy, but if negative exponent there is work to do...
+    workset=*set;                  // clone rounding, etc.
+    workset.digits=rhs->digits;    // no length rounding
+    workset.traps=0;               // no traps
+    decNumberZero(&dn);            // make a number with exponent 0
+    decNumberQuantize(res, rhs, &dn, &workset);
+    status|=workset.status;
+    }
+  if (status!=0) decStatus(res, status, set);
+  return res;
+  } // decNumberToIntegralExact
+
+decNumber * decNumberToIntegralValue(decNumber *res, const decNumber *rhs,
+                                     decContext *set) {
+  decContext workset=*set;         // working context
+  workset.traps=0;                 // no traps
+  decNumberToIntegralExact(res, rhs, &workset);
+  // this never affects set, except for sNaNs; NaN will have been set
+  // or propagated already, so no need to call decStatus
+  set->status|=workset.status&DEC_Invalid_operation;
+  return res;
+  } // decNumberToIntegralValue
+
+/* ------------------------------------------------------------------ */
+/* decNumberXor -- XOR two Numbers, digitwise                         */
+/*                                                                    */
+/*   This computes C = A ^ B                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X^X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context (used for result length and error report)     */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* Logical function restrictions apply (see above); a NaN is          */
+/* returned with Invalid_operation if a restriction is violated.      */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberXor(decNumber *res, const decNumber *lhs,
+                         const decNumber *rhs, decContext *set) {
+  const Unit *ua, *ub;                  // -> operands
+  const Unit *msua, *msub;              // -> operand msus
+  Unit  *uc, *msuc;                     // -> result and its msu
+  Int   msudigs;                        // digits in res msu
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  #endif
+
+  if (lhs->exponent!=0 || decNumberIsSpecial(lhs) || decNumberIsNegative(lhs)
+   || rhs->exponent!=0 || decNumberIsSpecial(rhs) || decNumberIsNegative(rhs)) {
+    decStatus(res, DEC_Invalid_operation, set);
+    return res;
+    }
+  // operands are valid
+  ua=lhs->lsu;                          // bottom-up
+  ub=rhs->lsu;                          // ..
+  uc=res->lsu;                          // ..
+  msua=ua+D2U(lhs->digits)-1;           // -> msu of lhs
+  msub=ub+D2U(rhs->digits)-1;           // -> msu of rhs
+  msuc=uc+D2U(set->digits)-1;           // -> msu of result
+  msudigs=MSUDIGITS(set->digits);       // [faster than remainder]
+  for (; uc<=msuc; ua++, ub++, uc++) {  // Unit loop
+    Unit a, b;                          // extract units
+    if (ua>msua) a=0;
+     else a=*ua;
+    if (ub>msub) b=0;
+     else b=*ub;
+    *uc=0;                              // can now write back
+    if (a|b) {                          // maybe 1 bits to examine
+      Int i, j;
+      // This loop could be unrolled and/or use BIN2BCD tables
+      for (i=0; i<DECDPUN; i++) {
+        if ((a^b)&1) *uc=*uc+(Unit)powers[i];     // effect XOR
+        j=a%10;
+        a=a/10;
+        j|=b%10;
+        b=b/10;
+        if (j>1) {
+          decStatus(res, DEC_Invalid_operation, set);
+          return res;
+          }
+        if (uc==msuc && i==msudigs-1) break;      // just did final digit
+        } // each digit
+      } // non-zero
+    } // each unit
+  // [here uc-1 is the msu of the result]
+  res->digits=decGetDigits(res->lsu, uc-res->lsu);
+  res->exponent=0;                      // integer
+  res->bits=0;                          // sign=0
+  return res;  // [no status to set]
+  } // decNumberXor
+
+
+/* ================================================================== */
+/* Utility routines                                                   */
+/* ================================================================== */
+
+/* ------------------------------------------------------------------ */
+/* decNumberClass -- return the decClass of a decNumber               */
+/*   dn -- the decNumber to test                                      */
+/*   set -- the context to use for Emin                               */
+/*   returns the decClass enum                                        */
+/* ------------------------------------------------------------------ */
+enum decClass decNumberClass(const decNumber *dn, decContext *set) {
+  if (decNumberIsSpecial(dn)) {
+    if (decNumberIsQNaN(dn)) return DEC_CLASS_QNAN;
+    if (decNumberIsSNaN(dn)) return DEC_CLASS_SNAN;
+    // must be an infinity
+    if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_INF;
+    return DEC_CLASS_POS_INF;
+    }
+  // is finite
+  if (decNumberIsNormal(dn, set)) { // most common
+    if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_NORMAL;
+    return DEC_CLASS_POS_NORMAL;
+    }
+  // is subnormal or zero
+  if (decNumberIsZero(dn)) {    // most common
+    if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_ZERO;
+    return DEC_CLASS_POS_ZERO;
+    }
+  if (decNumberIsNegative(dn)) return DEC_CLASS_NEG_SUBNORMAL;
+  return DEC_CLASS_POS_SUBNORMAL;
+  } // decNumberClass
+
+/* ------------------------------------------------------------------ */
+/* decNumberClassToString -- convert decClass to a string             */
+/*                                                                    */
+/*  eclass is a valid decClass                                        */
+/*  returns a constant string describing the class (max 13+1 chars)   */
+/* ------------------------------------------------------------------ */
+const char *decNumberClassToString(enum decClass eclass) {
+  if (eclass==DEC_CLASS_POS_NORMAL)    return DEC_ClassString_PN;
+  if (eclass==DEC_CLASS_NEG_NORMAL)    return DEC_ClassString_NN;
+  if (eclass==DEC_CLASS_POS_ZERO)      return DEC_ClassString_PZ;
+  if (eclass==DEC_CLASS_NEG_ZERO)      return DEC_ClassString_NZ;
+  if (eclass==DEC_CLASS_POS_SUBNORMAL) return DEC_ClassString_PS;
+  if (eclass==DEC_CLASS_NEG_SUBNORMAL) return DEC_ClassString_NS;
+  if (eclass==DEC_CLASS_POS_INF)       return DEC_ClassString_PI;
+  if (eclass==DEC_CLASS_NEG_INF)       return DEC_ClassString_NI;
+  if (eclass==DEC_CLASS_QNAN)          return DEC_ClassString_QN;
+  if (eclass==DEC_CLASS_SNAN)          return DEC_ClassString_SN;
+  return DEC_ClassString_UN;           // Unknown
+  } // decNumberClassToString
+
+/* ------------------------------------------------------------------ */
+/* decNumberCopy -- copy a number                                     */
+/*                                                                    */
+/*   dest is the target decNumber                                     */
+/*   src  is the source decNumber                                     */
+/*   returns dest                                                     */
+/*                                                                    */
+/* (dest==src is allowed and is a no-op)                              */
+/* All fields are updated as required.  This is a utility operation,  */
+/* so special values are unchanged and no error is possible.          */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberCopy(decNumber *dest, const decNumber *src) {
+
+  #if DECCHECK
+  if (src==NULL) return decNumberZero(dest);
+  #endif
+
+  if (dest==src) return dest;                // no copy required
+
+  // Use explicit assignments here as structure assignment could copy
+  // more than just the lsu (for small DECDPUN).  This would not affect
+  // the value of the results, but could disturb test harness spill
+  // checking.
+  dest->bits=src->bits;
+  dest->exponent=src->exponent;
+  dest->digits=src->digits;
+  dest->lsu[0]=src->lsu[0];
+  if (src->digits>DECDPUN) {                 // more Units to come
+    const Unit *smsup, *s;                   // work
+    Unit  *d;                                // ..
+    // memcpy for the remaining Units would be safe as they cannot
+    // overlap.  However, this explicit loop is faster in short cases.
+    d=dest->lsu+1;                           // -> first destination
+    smsup=src->lsu+D2U(src->digits);         // -> source msu+1
+    for (s=src->lsu+1; s<smsup; s++, d++) *d=*s;
+    }
+  return dest;
+  } // decNumberCopy
+
+/* ------------------------------------------------------------------ */
+/* decNumberCopyAbs -- quiet absolute value operator                  */
+/*                                                                    */
+/*   This sets C = abs(A)                                             */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* No exception or error can occur; this is a quiet bitwise operation.*/
+/* See also decNumberAbs for a checking version of this.              */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberCopyAbs(decNumber *res, const decNumber *rhs) {
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
+  #endif
+  decNumberCopy(res, rhs);
+  res->bits&=~DECNEG;                   // turn off sign
+  return res;
+  } // decNumberCopyAbs
+
+/* ------------------------------------------------------------------ */
+/* decNumberCopyNegate -- quiet negate value operator                 */
+/*                                                                    */
+/*   This sets C = negate(A)                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* No exception or error can occur; this is a quiet bitwise operation.*/
+/* See also decNumberMinus for a checking version of this.            */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberCopyNegate(decNumber *res, const decNumber *rhs) {
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
+  #endif
+  decNumberCopy(res, rhs);
+  res->bits^=DECNEG;                    // invert the sign
+  return res;
+  } // decNumberCopyNegate
+
+/* ------------------------------------------------------------------ */
+/* decNumberCopySign -- quiet copy and set sign operator              */
+/*                                                                    */
+/*   This sets C = A with the sign of B                               */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* No exception or error can occur; this is a quiet bitwise operation.*/
+/* ------------------------------------------------------------------ */
+decNumber * decNumberCopySign(decNumber *res, const decNumber *lhs,
+                              const decNumber *rhs) {
+  uByte sign;                           // rhs sign
+  #if DECCHECK
+  if (decCheckOperands(res, DECUNUSED, rhs, DECUNCONT)) return res;
+  #endif
+  sign=rhs->bits & DECNEG;              // save sign bit
+  decNumberCopy(res, lhs);
+  res->bits&=~DECNEG;                   // clear the sign
+  res->bits|=sign;                      // set from rhs
+  return res;
+  } // decNumberCopySign
+
+/* ------------------------------------------------------------------ */
+/* decNumberGetBCD -- get the coefficient in BCD8                     */
+/*   dn is the source decNumber                                       */
+/*   bcd is the uInt array that will receive dn->digits BCD bytes,    */
+/*     most-significant at offset 0                                   */
+/*   returns bcd                                                      */
+/*                                                                    */
+/* bcd must have at least dn->digits bytes.  No error is possible; if */
+/* dn is a NaN or Infinite, digits must be 1 and the coefficient 0.   */
+/* ------------------------------------------------------------------ */
+uByte * decNumberGetBCD(const decNumber *dn, uByte *bcd) {
+  uByte *ub=bcd+dn->digits-1;      // -> lsd
+  const Unit *up=dn->lsu;          // Unit pointer, -> lsu
+
+  #if DECDPUN==1                   // trivial simple copy
+    for (; ub>=bcd; ub--, up++) *ub=*up;
+  #else                            // chopping needed
+    uInt u=*up;                    // work
+    uInt cut=DECDPUN;              // downcounter through unit
+    for (; ub>=bcd; ub--) {
+      *ub=(uByte)(u%10);           // [*6554 trick inhibits, here]
+      u=u/10;
+      cut--;
+      if (cut>0) continue;         // more in this unit
+      up++;
+      u=*up;
+      cut=DECDPUN;
+      }
+  #endif
+  return bcd;
+  } // decNumberGetBCD
+
+/* ------------------------------------------------------------------ */
+/* decNumberSetBCD -- set (replace) the coefficient from BCD8         */
+/*   dn is the target decNumber                                       */
+/*   bcd is the uInt array that will source n BCD bytes, most-        */
+/*     significant at offset 0                                        */
+/*   n is the number of digits in the source BCD array (bcd)          */
+/*   returns dn                                                       */
+/*                                                                    */
+/* dn must have space for at least n digits.  No error is possible;   */
+/* if dn is a NaN, or Infinite, or is to become a zero, n must be 1   */
+/* and bcd[0] zero.                                                   */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberSetBCD(decNumber *dn, const uByte *bcd, uInt n) {
+  Unit *up=dn->lsu+D2U(dn->digits)-1;   // -> msu [target pointer]
+  const uByte *ub=bcd;                  // -> source msd
+
+  #if DECDPUN==1                        // trivial simple copy
+    for (; ub<bcd+n; ub++, up--) *up=*ub;
+  #else                                 // some assembly needed
+    // calculate how many digits in msu, and hence first cut
+    Int cut=MSUDIGITS(n);               // [faster than remainder]
+    for (;up>=dn->lsu; up--) {          // each Unit from msu
+      *up=0;                            // will take <=DECDPUN digits
+      for (; cut>0; ub++, cut--) *up=X10(*up)+*ub;
+      cut=DECDPUN;                      // next Unit has all digits
+      }
+  #endif
+  dn->digits=n;                         // set digit count
+  return dn;
+  } // decNumberSetBCD
+
+/* ------------------------------------------------------------------ */
+/* decNumberIsNormal -- test normality of a decNumber                 */
+/*   dn is the decNumber to test                                      */
+/*   set is the context to use for Emin                               */
+/*   returns 1 if |dn| is finite and >=Nmin, 0 otherwise              */
+/* ------------------------------------------------------------------ */
+Int decNumberIsNormal(const decNumber *dn, decContext *set) {
+  Int ae;                               // adjusted exponent
+  #if DECCHECK
+  if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
+  #endif
+
+  if (decNumberIsSpecial(dn)) return 0; // not finite
+  if (decNumberIsZero(dn)) return 0;    // not non-zero
+
+  ae=dn->exponent+dn->digits-1;         // adjusted exponent
+  if (ae<set->emin) return 0;           // is subnormal
+  return 1;
+  } // decNumberIsNormal
+
+/* ------------------------------------------------------------------ */
+/* decNumberIsSubnormal -- test subnormality of a decNumber           */
+/*   dn is the decNumber to test                                      */
+/*   set is the context to use for Emin                               */
+/*   returns 1 if |dn| is finite, non-zero, and <Nmin, 0 otherwise    */
+/* ------------------------------------------------------------------ */
+Int decNumberIsSubnormal(const decNumber *dn, decContext *set) {
+  Int ae;                               // adjusted exponent
+  #if DECCHECK
+  if (decCheckOperands(DECUNRESU, DECUNUSED, dn, set)) return 0;
+  #endif
+
+  if (decNumberIsSpecial(dn)) return 0; // not finite
+  if (decNumberIsZero(dn)) return 0;    // not non-zero
+
+  ae=dn->exponent+dn->digits-1;         // adjusted exponent
+  if (ae<set->emin) return 1;           // is subnormal
+  return 0;
+  } // decNumberIsSubnormal
+
+/* ------------------------------------------------------------------ */
+/* decNumberTrim -- remove insignificant zeros                        */
+/*                                                                    */
+/*   dn is the number to trim                                         */
+/*   returns dn                                                       */
+/*                                                                    */
+/* All fields are updated as required.  This is a utility operation,  */
+/* so special values are unchanged and no error is possible.  The     */
+/* zeros are removed unconditionally.                                 */
+/* ------------------------------------------------------------------ */
+decNumber * decNumberTrim(decNumber *dn) {
+  Int  dropped;                    // work
+  decContext set;                  // ..
+  #if DECCHECK
+  if (decCheckOperands(DECUNRESU, DECUNUSED, dn, DECUNCONT)) return dn;
+  #endif
+  decContextDefault(&set, DEC_INIT_BASE);    // clamp=0
+  return decTrim(dn, &set, 0, 1, &dropped);
+  } // decNumberTrim
+
+/* ------------------------------------------------------------------ */
+/* decNumberVersion -- return the name and version of this module     */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+const char * decNumberVersion(void) {
+  return DECVERSION;
+  } // decNumberVersion
+
+/* ------------------------------------------------------------------ */
+/* decNumberZero -- set a number to 0                                 */
+/*                                                                    */
+/*   dn is the number to set, with space for one digit                */
+/*   returns dn                                                       */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+// Memset is not used as it is much slower in some environments.
+decNumber * decNumberZero(decNumber *dn) {
+
+  #if DECCHECK
+  if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
+  #endif
+
+  dn->bits=0;
+  dn->exponent=0;
+  dn->digits=1;
+  dn->lsu[0]=0;
+  return dn;
+  } // decNumberZero
+
+/* ================================================================== */
+/* Local routines                                                     */
+/* ================================================================== */
+
+/* ------------------------------------------------------------------ */
+/* decToString -- lay out a number into a string                      */
+/*                                                                    */
+/*   dn     is the number to lay out                                  */
+/*   string is where to lay out the number                            */
+/*   eng    is 1 if Engineering, 0 if Scientific                      */
+/*                                                                    */
+/* string must be at least dn->digits+14 characters long              */
+/* No error is possible.                                              */
+/*                                                                    */
+/* Note that this routine can generate a -0 or 0.000.  These are      */
+/* never generated in subset to-number or arithmetic, but can occur   */
+/* in non-subset arithmetic (e.g., -1*0 or 1.234-1.234).              */
+/* ------------------------------------------------------------------ */
+// If DECCHECK is enabled the string "?" is returned if a number is
+// invalid.
+static void decToString(const decNumber *dn, char *string, Flag eng) {
+  Int exp=dn->exponent;       // local copy
+  Int e;                      // E-part value
+  Int pre;                    // digits before the '.'
+  Int cut;                    // for counting digits in a Unit
+  char *c=string;             // work [output pointer]
+  const Unit *up=dn->lsu+D2U(dn->digits)-1; // -> msu [input pointer]
+  uInt u, pow;                // work
+
+  #if DECCHECK
+  if (decCheckOperands(DECUNRESU, dn, DECUNUSED, DECUNCONT)) {
+    strcpy(string, "?");
+    return;}
+  #endif
+
+  if (decNumberIsNegative(dn)) {   // Negatives get a minus
+    *c='-';
+    c++;
+    }
+  if (dn->bits&DECSPECIAL) {       // Is a special value
+    if (decNumberIsInfinite(dn)) {
+      strcpy(c,   "Inf");
+      strcpy(c+3, "inity");
+      return;}
+    // a NaN
+    if (dn->bits&DECSNAN) {        // signalling NaN
+      *c='s';
+      c++;
+      }
+    strcpy(c, "NaN");
+    c+=3;                          // step past
+    // if not a clean non-zero coefficient, that's all there is in a
+    // NaN string
+    if (exp!=0 || (*dn->lsu==0 && dn->digits==1)) return;
+    // [drop through to add integer]
+    }
+
+  // calculate how many digits in msu, and hence first cut
+  cut=MSUDIGITS(dn->digits);       // [faster than remainder]
+  cut--;                           // power of ten for digit
+
+  if (exp==0) {                    // simple integer [common fastpath]
+    for (;up>=dn->lsu; up--) {     // each Unit from msu
+      u=*up;                       // contains DECDPUN digits to lay out
+      for (; cut>=0; c++, cut--) TODIGIT(u, cut, c, pow);
+      cut=DECDPUN-1;               // next Unit has all digits
+      }
+    *c='\0';                       // terminate the string
+    return;}
+
+  /* non-0 exponent -- assume plain form */
+  pre=dn->digits+exp;              // digits before '.'
+  e=0;                             // no E
+  if ((exp>0) || (pre<-5)) {       // need exponential form
+    e=exp+dn->digits-1;            // calculate E value
+    pre=1;                         // assume one digit before '.'
+    if (eng && (e!=0)) {           // engineering: may need to adjust
+      Int adj;                     // adjustment
+      // The C remainder operator is undefined for negative numbers, so
+      // a positive remainder calculation must be used here
+      if (e<0) {
+        adj=(-e)%3;
+        if (adj!=0) adj=3-adj;
+        }
+       else { // e>0
+        adj=e%3;
+        }
+      e=e-adj;
+      // if dealing with zero still produce an exponent which is a
+      // multiple of three, as expected, but there will only be the
+      // one zero before the E, still.  Otherwise note the padding.
+      if (!ISZERO(dn)) pre+=adj;
+       else {  // is zero
+        if (adj!=0) {              // 0.00Esnn needed
+          e=e+3;
+          pre=-(2-adj);
+          }
+        } // zero
+      } // eng
+    } // need exponent
+
+  /* lay out the digits of the coefficient, adding 0s and . as needed */
+  u=*up;
+  if (pre>0) {                     // xxx.xxx or xx00 (engineering) form
+    Int n=pre;
+    for (; pre>0; pre--, c++, cut--) {
+      if (cut<0) {                 // need new Unit
+        if (up==dn->lsu) break;    // out of input digits (pre>digits)
+        up--;
+        cut=DECDPUN-1;
+        u=*up;
+        }
+      TODIGIT(u, cut, c, pow);
+      }
+    if (n<dn->digits) {            // more to come, after '.'
+      *c='.'; c++;
+      for (;; c++, cut--) {
+        if (cut<0) {               // need new Unit
+          if (up==dn->lsu) break;  // out of input digits
+          up--;
+          cut=DECDPUN-1;
+          u=*up;
+          }
+        TODIGIT(u, cut, c, pow);
+        }
+      }
+     else for (; pre>0; pre--, c++) *c='0'; // 0 padding (for engineering) needed
+    }
+   else {                          // 0.xxx or 0.000xxx form
+    *c='0'; c++;
+    *c='.'; c++;
+    for (; pre<0; pre++, c++) *c='0';   // add any 0's after '.'
+    for (; ; c++, cut--) {
+      if (cut<0) {                 // need new Unit
+        if (up==dn->lsu) break;    // out of input digits
+        up--;
+        cut=DECDPUN-1;
+        u=*up;
+        }
+      TODIGIT(u, cut, c, pow);
+      }
+    }
+
+  /* Finally add the E-part, if needed.  It will never be 0, has a
+     base maximum and minimum of +999999999 through -999999999, but
+     could range down to -1999999998 for anormal numbers */
+  if (e!=0) {
+    Flag had=0;               // 1=had non-zero
+    *c='E'; c++;
+    *c='+'; c++;              // assume positive
+    u=e;                      // ..
+    if (e<0) {
+      *(c-1)='-';             // oops, need -
+      u=-e;                   // uInt, please
+      }
+    // lay out the exponent [_itoa or equivalent is not ANSI C]
+    for (cut=9; cut>=0; cut--) {
+      TODIGIT(u, cut, c, pow);
+      if (*c=='0' && !had) continue;    // skip leading zeros
+      had=1;                            // had non-0
+      c++;                              // step for next
+      } // cut
+    }
+  *c='\0';          // terminate the string (all paths)
+  return;
+  } // decToString
+
+/* ------------------------------------------------------------------ */
+/* decAddOp -- add/subtract operation                                 */
+/*                                                                    */
+/*   This computes C = A + B                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X+X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*   negate is DECNEG if rhs should be negated, or 0 otherwise        */
+/*   status accumulates status for the caller                         */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/* Inexact in status must be 0 for correct Exact zero sign in result  */
+/* ------------------------------------------------------------------ */
+/* If possible, the coefficient is calculated directly into C.        */
+/* However, if:                                                       */
+/*   -- a digits+1 calculation is needed because the numbers are      */
+/*      unaligned and span more than set->digits digits               */
+/*   -- a carry to digits+1 digits looks possible                     */
+/*   -- C is the same as A or B, and the result would destructively   */
+/*      overlap the A or B coefficient                                */
+/* then the result must be calculated into a temporary buffer.  In    */
+/* this case a local (stack) buffer is used if possible, and only if  */
+/* too long for that does malloc become the final resort.             */
+/*                                                                    */
+/* Misalignment is handled as follows:                                */
+/*   Apad: (AExp>BExp) Swap operands and proceed as for BExp>AExp.    */
+/*   BPad: Apply the padding by a combination of shifting (whole      */
+/*         units) and multiplication (part units).                    */
+/*                                                                    */
+/* Addition, especially x=x+1, is speed-critical.                     */
+/* The static buffer is larger than might be expected to allow for    */
+/* calls from higher-level funtions (notable exp).                    */
+/* ------------------------------------------------------------------ */
+static decNumber * decAddOp(decNumber *res, const decNumber *lhs,
+                            const decNumber *rhs, decContext *set,
+                            uByte negate, uInt *status) {
+  #if DECSUBSET
+  decNumber *alloclhs=NULL;        // non-NULL if rounded lhs allocated
+  decNumber *allocrhs=NULL;        // .., rhs
+  #endif
+  Int   rhsshift;                  // working shift (in Units)
+  Int   maxdigits;                 // longest logical length
+  Int   mult;                      // multiplier
+  Int   residue;                   // rounding accumulator
+  uByte bits;                      // result bits
+  Flag  diffsign;                  // non-0 if arguments have different sign
+  Unit  *acc;                      // accumulator for result
+  Unit  accbuff[SD2U(DECBUFFER*2+20)]; // local buffer [*2+20 reduces many
+                                   // allocations when called from
+                                   // other operations, notable exp]
+  Unit  *allocacc=NULL;            // -> allocated acc buffer, iff allocated
+  Int   reqdigits=set->digits;     // local copy; requested DIGITS
+  Int   padding;                   // work
+
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  #endif
+
+  do {                             // protect allocated storage
+    #if DECSUBSET
+    if (!set->extended) {
+      // reduce operands and set lostDigits status, as needed
+      if (lhs->digits>reqdigits) {
+        alloclhs=decRoundOperand(lhs, set, status);
+        if (alloclhs==NULL) break;
+        lhs=alloclhs;
+        }
+      if (rhs->digits>reqdigits) {
+        allocrhs=decRoundOperand(rhs, set, status);
+        if (allocrhs==NULL) break;
+        rhs=allocrhs;
+        }
+      }
+    #endif
+    // [following code does not require input rounding]
+
+    // note whether signs differ [used all paths]
+    diffsign=(Flag)((lhs->bits^rhs->bits^negate)&DECNEG);
+
+    // handle infinities and NaNs
+    if (SPECIALARGS) {                  // a special bit set
+      if (SPECIALARGS & (DECSNAN | DECNAN))  // a NaN
+        decNaNs(res, lhs, rhs, set, status);
+       else { // one or two infinities
+        if (decNumberIsInfinite(lhs)) { // LHS is infinity
+          // two infinities with different signs is invalid
+          if (decNumberIsInfinite(rhs) && diffsign) {
+            *status|=DEC_Invalid_operation;
+            break;
+            }
+          bits=lhs->bits & DECNEG;      // get sign from LHS
+          }
+         else bits=(rhs->bits^negate) & DECNEG;// RHS must be Infinity
+        bits|=DECINF;
+        decNumberZero(res);
+        res->bits=bits;                 // set +/- infinity
+        } // an infinity
+      break;
+      }
+
+    // Quick exit for add 0s; return the non-0, modified as need be
+    if (ISZERO(lhs)) {
+      Int adjust;                       // work
+      Int lexp=lhs->exponent;           // save in case LHS==RES
+      bits=lhs->bits;                   // ..
+      residue=0;                        // clear accumulator
+      decCopyFit(res, rhs, set, &residue, status); // copy (as needed)
+      res->bits^=negate;                // flip if rhs was negated
+      #if DECSUBSET
+      if (set->extended) {              // exponents on zeros count
+      #endif
+        // exponent will be the lower of the two
+        adjust=lexp-res->exponent;      // adjustment needed [if -ve]
+        if (ISZERO(res)) {              // both 0: special IEEE 754 rules
+          if (adjust<0) res->exponent=lexp;  // set exponent
+          // 0-0 gives +0 unless rounding to -infinity, and -0-0 gives -0
+          if (diffsign) {
+            if (set->round!=DEC_ROUND_FLOOR) res->bits=0;
+             else res->bits=DECNEG;     // preserve 0 sign
+            }
+          }
+         else { // non-0 res
+          if (adjust<0) {     // 0-padding needed
+            if ((res->digits-adjust)>set->digits) {
+              adjust=res->digits-set->digits;     // to fit exactly
+              *status|=DEC_Rounded;               // [but exact]
+              }
+            res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
+            res->exponent+=adjust;                // set the exponent.
+            }
+          } // non-0 res
+      #if DECSUBSET
+        } // extended
+      #endif
+      decFinish(res, set, &residue, status);      // clean and finalize
+      break;}
+
+    if (ISZERO(rhs)) {                  // [lhs is non-zero]
+      Int adjust;                       // work
+      Int rexp=rhs->exponent;           // save in case RHS==RES
+      bits=rhs->bits;                   // be clean
+      residue=0;                        // clear accumulator
+      decCopyFit(res, lhs, set, &residue, status); // copy (as needed)
+      #if DECSUBSET
+      if (set->extended) {              // exponents on zeros count
+      #endif
+        // exponent will be the lower of the two
+        // [0-0 case handled above]
+        adjust=rexp-res->exponent;      // adjustment needed [if -ve]
+        if (adjust<0) {     // 0-padding needed
+          if ((res->digits-adjust)>set->digits) {
+            adjust=res->digits-set->digits;     // to fit exactly
+            *status|=DEC_Rounded;               // [but exact]
+            }
+          res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
+          res->exponent+=adjust;                // set the exponent.
+          }
+      #if DECSUBSET
+        } // extended
+      #endif
+      decFinish(res, set, &residue, status);      // clean and finalize
+      break;}
+
+    // [NB: both fastpath and mainpath code below assume these cases
+    // (notably 0-0) have already been handled]
+
+    // calculate the padding needed to align the operands
+    padding=rhs->exponent-lhs->exponent;
+
+    // Fastpath cases where the numbers are aligned and normal, the RHS
+    // is all in one unit, no operand rounding is needed, and no carry,
+    // lengthening, or borrow is needed
+    if (padding==0
+        && rhs->digits<=DECDPUN
+        && rhs->exponent>=set->emin     // [some normals drop through]
+        && rhs->exponent<=set->emax-set->digits+1 // [could clamp]
+        && rhs->digits<=reqdigits
+        && lhs->digits<=reqdigits) {
+      Int partial=*lhs->lsu;
+      if (!diffsign) {                  // adding
+        partial+=*rhs->lsu;
+        if ((partial<=DECDPUNMAX)       // result fits in unit
+         && (lhs->digits>=DECDPUN ||    // .. and no digits-count change
+             partial<(Int)powers[lhs->digits])) { // ..
+          if (res!=lhs) decNumberCopy(res, lhs);  // not in place
+          *res->lsu=(Unit)partial;      // [copy could have overwritten RHS]
+          break;
+          }
+        // else drop out for careful add
+        }
+       else {                           // signs differ
+        partial-=*rhs->lsu;
+        if (partial>0) { // no borrow needed, and non-0 result
+          if (res!=lhs) decNumberCopy(res, lhs);  // not in place
+          *res->lsu=(Unit)partial;
+          // this could have reduced digits [but result>0]
+          res->digits=decGetDigits(res->lsu, D2U(res->digits));
+          break;
+          }
+        // else drop out for careful subtract
+        }
+      }
+
+    // Now align (pad) the lhs or rhs so they can be added or
+    // subtracted, as necessary.  If one number is much larger than
+    // the other (that is, if in plain form there is a least one
+    // digit between the lowest digit of one and the highest of the
+    // other) padding with up to DIGITS-1 trailing zeros may be
+    // needed; then apply rounding (as exotic rounding modes may be
+    // affected by the residue).
+    rhsshift=0;               // rhs shift to left (padding) in Units
+    bits=lhs->bits;           // assume sign is that of LHS
+    mult=1;                   // likely multiplier
+
+    // [if padding==0 the operands are aligned; no padding is needed]
+    if (padding!=0) {
+      // some padding needed; always pad the RHS, as any required
+      // padding can then be effected by a simple combination of
+      // shifts and a multiply
+      Flag swapped=0;
+      if (padding<0) {                  // LHS needs the padding
+        const decNumber *t;
+        padding=-padding;               // will be +ve
+        bits=(uByte)(rhs->bits^negate); // assumed sign is now that of RHS
+        t=lhs; lhs=rhs; rhs=t;
+        swapped=1;
+        }
+
+      // If, after pad, rhs would be longer than lhs by digits+1 or
+      // more then lhs cannot affect the answer, except as a residue,
+      // so only need to pad up to a length of DIGITS+1.
+      if (rhs->digits+padding > lhs->digits+reqdigits+1) {
+        // The RHS is sufficient
+        // for residue use the relative sign indication...
+        Int shift=reqdigits-rhs->digits;     // left shift needed
+        residue=1;                           // residue for rounding
+        if (diffsign) residue=-residue;      // signs differ
+        // copy, shortening if necessary
+        decCopyFit(res, rhs, set, &residue, status);
+        // if it was already shorter, then need to pad with zeros
+        if (shift>0) {
+          res->digits=decShiftToMost(res->lsu, res->digits, shift);
+          res->exponent-=shift;              // adjust the exponent.
+          }
+        // flip the result sign if unswapped and rhs was negated
+        if (!swapped) res->bits^=negate;
+        decFinish(res, set, &residue, status);    // done
+        break;}
+
+      // LHS digits may affect result
+      rhsshift=D2U(padding+1)-1;        // this much by Unit shift ..
+      mult=powers[padding-(rhsshift*DECDPUN)]; // .. this by multiplication
+      } // padding needed
+
+    if (diffsign) mult=-mult;           // signs differ
+
+    // determine the longer operand
+    maxdigits=rhs->digits+padding;      // virtual length of RHS
+    if (lhs->digits>maxdigits) maxdigits=lhs->digits;
+
+    // Decide on the result buffer to use; if possible place directly
+    // into result.
+    acc=res->lsu;                       // assume add direct to result
+    // If destructive overlap, or the number is too long, or a carry or
+    // borrow to DIGITS+1 might be possible, a buffer must be used.
+    // [Might be worth more sophisticated tests when maxdigits==reqdigits]
+    if ((maxdigits>=reqdigits)          // is, or could be, too large
+     || (res==rhs && rhsshift>0)) {     // destructive overlap
+      // buffer needed, choose it; units for maxdigits digits will be
+      // needed, +1 Unit for carry or borrow
+      Int need=D2U(maxdigits)+1;
+      acc=accbuff;                      // assume use local buffer
+      if (need*sizeof(Unit)>sizeof(accbuff)) {
+        // printf("malloc add %ld %ld\n", need, sizeof(accbuff));
+        allocacc=(Unit *)malloc(need*sizeof(Unit));
+        if (allocacc==NULL) {           // hopeless -- abandon
+          *status|=DEC_Insufficient_storage;
+          break;}
+        acc=allocacc;
+        }
+      }
+
+    res->bits=(uByte)(bits&DECNEG);     // it's now safe to overwrite..
+    res->exponent=lhs->exponent;        // .. operands (even if aliased)
+
+    #if DECTRACE
+      decDumpAr('A', lhs->lsu, D2U(lhs->digits));
+      decDumpAr('B', rhs->lsu, D2U(rhs->digits));
+      printf("  :h: %ld %ld\n", rhsshift, mult);
+    #endif
+
+    // add [A+B*m] or subtract [A+B*(-m)]
+    res->digits=decUnitAddSub(lhs->lsu, D2U(lhs->digits),
+                              rhs->lsu, D2U(rhs->digits),
+                              rhsshift, acc, mult)
+               *DECDPUN;           // [units -> digits]
+    if (res->digits<0) {           // borrowed...
+      res->digits=-res->digits;
+      res->bits^=DECNEG;           // flip the sign
+      }
+    #if DECTRACE
+      decDumpAr('+', acc, D2U(res->digits));
+    #endif
+
+    // If a buffer was used the result must be copied back, possibly
+    // shortening.  (If no buffer was used then the result must have
+    // fit, so can't need rounding and residue must be 0.)
+    residue=0;                     // clear accumulator
+    if (acc!=res->lsu) {
+      #if DECSUBSET
+      if (set->extended) {         // round from first significant digit
+      #endif
+        // remove leading zeros that were added due to rounding up to
+        // integral Units -- before the test for rounding.
+        if (res->digits>reqdigits)
+          res->digits=decGetDigits(acc, D2U(res->digits));
+        decSetCoeff(res, set, acc, res->digits, &residue, status);
+      #if DECSUBSET
+        }
+       else { // subset arithmetic rounds from original significant digit
+        // May have an underestimate.  This only occurs when both
+        // numbers fit in DECDPUN digits and are padding with a
+        // negative multiple (-10, -100...) and the top digit(s) become
+        // 0.  (This only matters when using X3.274 rules where the
+        // leading zero could be included in the rounding.)
+        if (res->digits<maxdigits) {
+          *(acc+D2U(res->digits))=0; // ensure leading 0 is there
+          res->digits=maxdigits;
+          }
+         else {
+          // remove leading zeros that added due to rounding up to
+          // integral Units (but only those in excess of the original
+          // maxdigits length, unless extended) before test for rounding.
+          if (res->digits>reqdigits) {
+            res->digits=decGetDigits(acc, D2U(res->digits));
+            if (res->digits<maxdigits) res->digits=maxdigits;
+            }
+          }
+        decSetCoeff(res, set, acc, res->digits, &residue, status);
+        // Now apply rounding if needed before removing leading zeros.
+        // This is safe because subnormals are not a possibility
+        if (residue!=0) {
+          decApplyRound(res, set, residue, status);
+          residue=0;                 // did what needed to be done
+          }
+        } // subset
+      #endif
+      } // used buffer
+
+    // strip leading zeros [these were left on in case of subset subtract]
+    res->digits=decGetDigits(res->lsu, D2U(res->digits));
+
+    // apply checks and rounding
+    decFinish(res, set, &residue, status);
+
+    // "When the sum of two operands with opposite signs is exactly
+    // zero, the sign of that sum shall be '+' in all rounding modes
+    // except round toward -Infinity, in which mode that sign shall be
+    // '-'."  [Subset zeros also never have '-', set by decFinish.]
+    if (ISZERO(res) && diffsign
+     #if DECSUBSET
+     && set->extended
+     #endif
+     && (*status&DEC_Inexact)==0) {
+      if (set->round==DEC_ROUND_FLOOR) res->bits|=DECNEG;   // sign -
+                                  else res->bits&=~DECNEG;  // sign +
+      }
+    } while(0);                              // end protected
+
+  if (allocacc!=NULL) free(allocacc);        // drop any storage used
+  #if DECSUBSET
+  if (allocrhs!=NULL) free(allocrhs);        // ..
+  if (alloclhs!=NULL) free(alloclhs);        // ..
+  #endif
+  return res;
+  } // decAddOp
+
+/* ------------------------------------------------------------------ */
+/* decDivideOp -- division operation                                  */
+/*                                                                    */
+/*  This routine performs the calculations for all four division      */
+/*  operators (divide, divideInteger, remainder, remainderNear).      */
+/*                                                                    */
+/*  C=A op B                                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X/X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*   op  is DIVIDE, DIVIDEINT, REMAINDER, or REMNEAR respectively.    */
+/*   status is the usual accumulator                                  */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* ------------------------------------------------------------------ */
+/*   The underlying algorithm of this routine is the same as in the   */
+/*   1981 S/370 implementation, that is, non-restoring long division  */
+/*   with bi-unit (rather than bi-digit) estimation for each unit     */
+/*   multiplier.  In this pseudocode overview, complications for the  */
+/*   Remainder operators and division residues for exact rounding are */
+/*   omitted for clarity.                                             */
+/*                                                                    */
+/*     Prepare operands and handle special values                     */
+/*     Test for x/0 and then 0/x                                      */
+/*     Exp =Exp1 - Exp2                                               */
+/*     Exp =Exp +len(var1) -len(var2)                                 */
+/*     Sign=Sign1 * Sign2                                             */
+/*     Pad accumulator (Var1) to double-length with 0's (pad1)        */
+/*     Pad Var2 to same length as Var1                                */
+/*     msu2pair/plus=1st 2 or 1 units of var2, +1 to allow for round  */
+/*     have=0                                                         */
+/*     Do until (have=digits+1 OR residue=0)                          */
+/*       if exp<0 then if integer divide/residue then leave           */
+/*       this_unit=0                                                  */
+/*       Do forever                                                   */
+/*          compare numbers                                           */
+/*          if <0 then leave inner_loop                               */
+/*          if =0 then (* quick exit without subtract *) do           */
+/*             this_unit=this_unit+1; output this_unit                */
+/*             leave outer_loop; end                                  */
+/*          Compare lengths of numbers (mantissae):                   */
+/*          If same then tops2=msu2pair -- {units 1&2 of var2}        */
+/*                  else tops2=msu2plus -- {0, unit 1 of var2}        */
+/*          tops1=first_unit_of_Var1*10**DECDPUN +second_unit_of_var1 */
+/*          mult=tops1/tops2  -- Good and safe guess at divisor       */
+/*          if mult=0 then mult=1                                     */
+/*          this_unit=this_unit+mult                                  */
+/*          subtract                                                  */
+/*          end inner_loop                                            */
+/*        if have\=0 | this_unit\=0 then do                           */
+/*          output this_unit                                          */
+/*          have=have+1; end                                          */
+/*        var2=var2/10                                                */
+/*        exp=exp-1                                                   */
+/*        end outer_loop                                              */
+/*     exp=exp+1   -- set the proper exponent                         */
+/*     if have=0 then generate answer=0                               */
+/*     Return (Result is defined by Var1)                             */
+/*                                                                    */
+/* ------------------------------------------------------------------ */
+/* Two working buffers are needed during the division; one (digits+   */
+/* 1) to accumulate the result, and the other (up to 2*digits+1) for  */
+/* long subtractions.  These are acc and var1 respectively.           */
+/* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/
+/* The static buffers may be larger than might be expected to allow   */
+/* for calls from higher-level funtions (notable exp).                */
+/* ------------------------------------------------------------------ */
+static decNumber * decDivideOp(decNumber *res,
+                               const decNumber *lhs, const decNumber *rhs,
+                               decContext *set, Flag op, uInt *status) {
+  #if DECSUBSET
+  decNumber *alloclhs=NULL;        // non-NULL if rounded lhs allocated
+  decNumber *allocrhs=NULL;        // .., rhs
+  #endif
+  Unit  accbuff[SD2U(DECBUFFER+DECDPUN+10)]; // local buffer
+  Unit  *acc=accbuff;              // -> accumulator array for result
+  Unit  *allocacc=NULL;            // -> allocated buffer, iff allocated
+  Unit  *accnext;                  // -> where next digit will go
+  Int   acclength;                 // length of acc needed [Units]
+  Int   accunits;                  // count of units accumulated
+  Int   accdigits;                 // count of digits accumulated
+
+  Unit  varbuff[SD2U(DECBUFFER*2+DECDPUN)];  // buffer for var1
+  Unit  *var1=varbuff;             // -> var1 array for long subtraction
+  Unit  *varalloc=NULL;            // -> allocated buffer, iff used
+  Unit  *msu1;                     // -> msu of var1
+
+  const Unit *var2;                // -> var2 array
+  const Unit *msu2;                // -> msu of var2
+  Int   msu2plus;                  // msu2 plus one [does not vary]
+  eInt  msu2pair;                  // msu2 pair plus one [does not vary]
+
+  Int   var1units, var2units;      // actual lengths
+  Int   var2ulen;                  // logical length (units)
+  Int   var1initpad=0;             // var1 initial padding (digits)
+  Int   maxdigits;                 // longest LHS or required acc length
+  Int   mult;                      // multiplier for subtraction
+  Unit  thisunit;                  // current unit being accumulated
+  Int   residue;                   // for rounding
+  Int   reqdigits=set->digits;     // requested DIGITS
+  Int   exponent;                  // working exponent
+  Int   maxexponent=0;             // DIVIDE maximum exponent if unrounded
+  uByte bits;                      // working sign
+  Unit  *target;                   // work
+  const Unit *source;              // ..
+  uInt  const *pow;                // ..
+  Int   shift, cut;                // ..
+  #if DECSUBSET
+  Int   dropped;                   // work
+  #endif
+
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  #endif
+
+  do {                             // protect allocated storage
+    #if DECSUBSET
+    if (!set->extended) {
+      // reduce operands and set lostDigits status, as needed
+      if (lhs->digits>reqdigits) {
+        alloclhs=decRoundOperand(lhs, set, status);
+        if (alloclhs==NULL) break;
+        lhs=alloclhs;
+        }
+      if (rhs->digits>reqdigits) {
+        allocrhs=decRoundOperand(rhs, set, status);
+        if (allocrhs==NULL) break;
+        rhs=allocrhs;
+        }
+      }
+    #endif
+    // [following code does not require input rounding]
+
+    bits=(lhs->bits^rhs->bits)&DECNEG;  // assumed sign for divisions
+
+    // handle infinities and NaNs
+    if (SPECIALARGS) {                  // a special bit set
+      if (SPECIALARGS & (DECSNAN | DECNAN)) { // one or two NaNs
+        decNaNs(res, lhs, rhs, set, status);
+        break;
+        }
+      // one or two infinities
+      if (decNumberIsInfinite(lhs)) {   // LHS (dividend) is infinite
+        if (decNumberIsInfinite(rhs) || // two infinities are invalid ..
+            op & (REMAINDER | REMNEAR)) { // as is remainder of infinity
+          *status|=DEC_Invalid_operation;
+          break;
+          }
+        // [Note that infinity/0 raises no exceptions]
+        decNumberZero(res);
+        res->bits=bits|DECINF;          // set +/- infinity
+        break;
+        }
+       else {                           // RHS (divisor) is infinite
+        residue=0;
+        if (op&(REMAINDER|REMNEAR)) {
+          // result is [finished clone of] lhs
+          decCopyFit(res, lhs, set, &residue, status);
+          }
+         else {  // a division
+          decNumberZero(res);
+          res->bits=bits;               // set +/- zero
+          // for DIVIDEINT the exponent is always 0.  For DIVIDE, result
+          // is a 0 with infinitely negative exponent, clamped to minimum
+          if (op&DIVIDE) {
+            res->exponent=set->emin-set->digits+1;
+            *status|=DEC_Clamped;
+            }
+          }
+        decFinish(res, set, &residue, status);
+        break;
+        }
+      }
+
+    // handle 0 rhs (x/0)
+    if (ISZERO(rhs)) {                  // x/0 is always exceptional
+      if (ISZERO(lhs)) {
+        decNumberZero(res);             // [after lhs test]
+        *status|=DEC_Division_undefined;// 0/0 will become NaN
+        }
+       else {
+        decNumberZero(res);
+        if (op&(REMAINDER|REMNEAR)) *status|=DEC_Invalid_operation;
+         else {
+          *status|=DEC_Division_by_zero; // x/0
+          res->bits=bits|DECINF;         // .. is +/- Infinity
+          }
+        }
+      break;}
+
+    // handle 0 lhs (0/x)
+    if (ISZERO(lhs)) {                  // 0/x [x!=0]
+      #if DECSUBSET
+      if (!set->extended) decNumberZero(res);
+       else {
+      #endif
+        if (op&DIVIDE) {
+          residue=0;
+          exponent=lhs->exponent-rhs->exponent; // ideal exponent
+          decNumberCopy(res, lhs);      // [zeros always fit]
+          res->bits=bits;               // sign as computed
+          res->exponent=exponent;       // exponent, too
+          decFinalize(res, set, &residue, status);   // check exponent
+          }
+         else if (op&DIVIDEINT) {
+          decNumberZero(res);           // integer 0
+          res->bits=bits;               // sign as computed
+          }
+         else {                         // a remainder
+          exponent=rhs->exponent;       // [save in case overwrite]
+          decNumberCopy(res, lhs);      // [zeros always fit]
+          if (exponent<res->exponent) res->exponent=exponent; // use lower
+          }
+      #if DECSUBSET
+        }
+      #endif
+      break;}
+
+    // Precalculate exponent.  This starts off adjusted (and hence fits
+    // in 31 bits) and becomes the usual unadjusted exponent as the
+    // division proceeds.  The order of evaluation is important, here,
+    // to avoid wrap.
+    exponent=(lhs->exponent+lhs->digits)-(rhs->exponent+rhs->digits);
+
+    // If the working exponent is -ve, then some quick exits are
+    // possible because the quotient is known to be <1
+    // [for REMNEAR, it needs to be < -1, as -0.5 could need work]
+    if (exponent<0 && !(op==DIVIDE)) {
+      if (op&DIVIDEINT) {
+        decNumberZero(res);                  // integer part is 0
+        #if DECSUBSET
+        if (set->extended)
+        #endif
+          res->bits=bits;                    // set +/- zero
+        break;}
+      // fastpath remainders so long as the lhs has the smaller
+      // (or equal) exponent
+      if (lhs->exponent<=rhs->exponent) {
+        if (op&REMAINDER || exponent<-1) {
+          // It is REMAINDER or safe REMNEAR; result is [finished
+          // clone of] lhs  (r = x - 0*y)
+          residue=0;
+          decCopyFit(res, lhs, set, &residue, status);
+          decFinish(res, set, &residue, status);
+          break;
+          }
+        // [unsafe REMNEAR drops through]
+        }
+      } // fastpaths
+
+    /* Long (slow) division is needed; roll up the sleeves... */
+
+    // The accumulator will hold the quotient of the division.
+    // If it needs to be too long for stack storage, then allocate.
+    acclength=D2U(reqdigits+DECDPUN);   // in Units
+    if (acclength*sizeof(Unit)>sizeof(accbuff)) {
+      // printf("malloc dvacc %ld units\n", acclength);
+      allocacc=(Unit *)malloc(acclength*sizeof(Unit));
+      if (allocacc==NULL) {             // hopeless -- abandon
+        *status|=DEC_Insufficient_storage;
+        break;}
+      acc=allocacc;                     // use the allocated space
+      }
+
+    // var1 is the padded LHS ready for subtractions.
+    // If it needs to be too long for stack storage, then allocate.
+    // The maximum units needed for var1 (long subtraction) is:
+    // Enough for
+    //     (rhs->digits+reqdigits-1) -- to allow full slide to right
+    // or  (lhs->digits)             -- to allow for long lhs
+    // whichever is larger
+    //   +1                -- for rounding of slide to right
+    //   +1                -- for leading 0s
+    //   +1                -- for pre-adjust if a remainder or DIVIDEINT
+    // [Note: unused units do not participate in decUnitAddSub data]
+    maxdigits=rhs->digits+reqdigits-1;
+    if (lhs->digits>maxdigits) maxdigits=lhs->digits;
+    var1units=D2U(maxdigits)+2;
+    // allocate a guard unit above msu1 for REMAINDERNEAR
+    if (!(op&DIVIDE)) var1units++;
+    if ((var1units+1)*sizeof(Unit)>sizeof(varbuff)) {
+      // printf("malloc dvvar %ld units\n", var1units+1);
+      varalloc=(Unit *)malloc((var1units+1)*sizeof(Unit));
+      if (varalloc==NULL) {             // hopeless -- abandon
+        *status|=DEC_Insufficient_storage;
+        break;}
+      var1=varalloc;                    // use the allocated space
+      }
+
+    // Extend the lhs and rhs to full long subtraction length.  The lhs
+    // is truly extended into the var1 buffer, with 0 padding, so a
+    // subtract in place is always possible.  The rhs (var2) has
+    // virtual padding (implemented by decUnitAddSub).
+    // One guard unit was allocated above msu1 for rem=rem+rem in
+    // REMAINDERNEAR.
+    msu1=var1+var1units-1;              // msu of var1
+    source=lhs->lsu+D2U(lhs->digits)-1; // msu of input array
+    for (target=msu1; source>=lhs->lsu; source--, target--) *target=*source;
+    for (; target>=var1; target--) *target=0;
+
+    // rhs (var2) is left-aligned with var1 at the start
+    var2ulen=var1units;                 // rhs logical length (units)
+    var2units=D2U(rhs->digits);         // rhs actual length (units)
+    var2=rhs->lsu;                      // -> rhs array
+    msu2=var2+var2units-1;              // -> msu of var2 [never changes]
+    // now set up the variables which will be used for estimating the
+    // multiplication factor.  If these variables are not exact, add
+    // 1 to make sure that the multiplier is never overestimated.
+    msu2plus=*msu2;                     // it's value ..
+    if (var2units>1) msu2plus++;        // .. +1 if any more
+    msu2pair=(eInt)*msu2*(DECDPUNMAX+1);// top two pair ..
+    if (var2units>1) {                  // .. [else treat 2nd as 0]
+      msu2pair+=*(msu2-1);              // ..
+      if (var2units>2) msu2pair++;      // .. +1 if any more
+      }
+
+    // The calculation is working in units, which may have leading zeros,
+    // but the exponent was calculated on the assumption that they are
+    // both left-aligned.  Adjust the exponent to compensate: add the
+    // number of leading zeros in var1 msu and subtract those in var2 msu.
+    // [This is actually done by counting the digits and negating, as
+    // lead1=DECDPUN-digits1, and similarly for lead2.]
+    for (pow=&powers[1]; *msu1>=*pow; pow++) exponent--;
+    for (pow=&powers[1]; *msu2>=*pow; pow++) exponent++;
+
+    // Now, if doing an integer divide or remainder, ensure that
+    // the result will be Unit-aligned.  To do this, shift the var1
+    // accumulator towards least if need be.  (It's much easier to
+    // do this now than to reassemble the residue afterwards, if
+    // doing a remainder.)  Also ensure the exponent is not negative.
+    if (!(op&DIVIDE)) {
+      Unit *u;                          // work
+      // save the initial 'false' padding of var1, in digits
+      var1initpad=(var1units-D2U(lhs->digits))*DECDPUN;
+      // Determine the shift to do.
+      if (exponent<0) cut=-exponent;
+       else cut=DECDPUN-exponent%DECDPUN;
+      decShiftToLeast(var1, var1units, cut);
+      exponent+=cut;                    // maintain numerical value
+      var1initpad-=cut;                 // .. and reduce padding
+      // clean any most-significant units which were just emptied
+      for (u=msu1; cut>=DECDPUN; cut-=DECDPUN, u--) *u=0;
+      } // align
+     else { // is DIVIDE
+      maxexponent=lhs->exponent-rhs->exponent;    // save
+      // optimization: if the first iteration will just produce 0,
+      // preadjust to skip it [valid for DIVIDE only]
+      if (*msu1<*msu2) {
+        var2ulen--;                     // shift down
+        exponent-=DECDPUN;              // update the exponent
+        }
+      }
+
+    // ---- start the long-division loops ------------------------------
+    accunits=0;                         // no units accumulated yet
+    accdigits=0;                        // .. or digits
+    accnext=acc+acclength-1;            // -> msu of acc [NB: allows digits+1]
+    for (;;) {                          // outer forever loop
+      thisunit=0;                       // current unit assumed 0
+      // find the next unit
+      for (;;) {                        // inner forever loop
+        // strip leading zero units [from either pre-adjust or from
+        // subtract last time around].  Leave at least one unit.
+        for (; *msu1==0 && msu1>var1; msu1--) var1units--;
+
+        if (var1units<var2ulen) break;       // var1 too low for subtract
+        if (var1units==var2ulen) {           // unit-by-unit compare needed
+          // compare the two numbers, from msu
+          const Unit *pv1, *pv2;
+          Unit v2;                           // units to compare
+          pv2=msu2;                          // -> msu
+          for (pv1=msu1; ; pv1--, pv2--) {
+            // v1=*pv1 -- always OK
+            v2=0;                            // assume in padding
+            if (pv2>=var2) v2=*pv2;          // in range
+            if (*pv1!=v2) break;             // no longer the same
+            if (pv1==var1) break;            // done; leave pv1 as is
+            }
+          // here when all inspected or a difference seen
+          if (*pv1<v2) break;                // var1 too low to subtract
+          if (*pv1==v2) {                    // var1 == var2
+            // reach here if var1 and var2 are identical; subtraction
+            // would increase digit by one, and the residue will be 0 so
+            // the calculation is done; leave the loop with residue=0.
+            thisunit++;                      // as though subtracted
+            *var1=0;                         // set var1 to 0
+            var1units=1;                     // ..
+            break;  // from inner
+            } // var1 == var2
+          // *pv1>v2.  Prepare for real subtraction; the lengths are equal
+          // Estimate the multiplier (there's always a msu1-1)...
+          // Bring in two units of var2 to provide a good estimate.
+          mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2pair);
+          } // lengths the same
+         else { // var1units > var2ulen, so subtraction is safe
+          // The var2 msu is one unit towards the lsu of the var1 msu,
+          // so only one unit for var2 can be used.
+          mult=(Int)(((eInt)*msu1*(DECDPUNMAX+1)+*(msu1-1))/msu2plus);
+          }
+        if (mult==0) mult=1;                 // must always be at least 1
+        // subtraction needed; var1 is > var2
+        thisunit=(Unit)(thisunit+mult);      // accumulate
+        // subtract var1-var2, into var1; only the overlap needs
+        // processing, as this is an in-place calculation
+        shift=var2ulen-var2units;
+        #if DECTRACE
+          decDumpAr('1', &var1[shift], var1units-shift);
+          decDumpAr('2', var2, var2units);
+          printf("m=%ld\n", -mult);
+        #endif
+        decUnitAddSub(&var1[shift], var1units-shift,
+                      var2, var2units, 0,
+                      &var1[shift], -mult);
+        #if DECTRACE
+          decDumpAr('#', &var1[shift], var1units-shift);
+        #endif
+        // var1 now probably has leading zeros; these are removed at the
+        // top of the inner loop.
+        } // inner loop
+
+      // The next unit has been calculated in full; unless it's a
+      // leading zero, add to acc
+      if (accunits!=0 || thisunit!=0) {      // is first or non-zero
+        *accnext=thisunit;                   // store in accumulator
+        // account exactly for the new digits
+        if (accunits==0) {
+          accdigits++;                       // at least one
+          for (pow=&powers[1]; thisunit>=*pow; pow++) accdigits++;
+          }
+         else accdigits+=DECDPUN;
+        accunits++;                          // update count
+        accnext--;                           // ready for next
+        if (accdigits>reqdigits) break;      // have enough digits
+        }
+
+      // if the residue is zero, the operation is done (unless divide
+      // or divideInteger and still not enough digits yet)
+      if (*var1==0 && var1units==1) {        // residue is 0
+        if (op&(REMAINDER|REMNEAR)) break;
+        if ((op&DIVIDE) && (exponent<=maxexponent)) break;
+        // [drop through if divideInteger]
+        }
+      // also done enough if calculating remainder or integer
+      // divide and just did the last ('units') unit
+      if (exponent==0 && !(op&DIVIDE)) break;
+
+      // to get here, var1 is less than var2, so divide var2 by the per-
+      // Unit power of ten and go for the next digit
+      var2ulen--;                            // shift down
+      exponent-=DECDPUN;                     // update the exponent
+      } // outer loop
+
+    // ---- division is complete ---------------------------------------
+    // here: acc      has at least reqdigits+1 of good results (or fewer
+    //                if early stop), starting at accnext+1 (its lsu)
+    //       var1     has any residue at the stopping point
+    //       accunits is the number of digits collected in acc
+    if (accunits==0) {             // acc is 0
+      accunits=1;                  // show have a unit ..
+      accdigits=1;                 // ..
+      *accnext=0;                  // .. whose value is 0
+      }
+     else accnext++;               // back to last placed
+    // accnext now -> lowest unit of result
+
+    residue=0;                     // assume no residue
+    if (op&DIVIDE) {
+      // record the presence of any residue, for rounding
+      if (*var1!=0 || var1units>1) residue=1;
+       else { // no residue
+        // Had an exact division; clean up spurious trailing 0s.
+        // There will be at most DECDPUN-1, from the final multiply,
+        // and then only if the result is non-0 (and even) and the
+        // exponent is 'loose'.
+        #if DECDPUN>1
+        Unit lsu=*accnext;
+        if (!(lsu&0x01) && (lsu!=0)) {
+          // count the trailing zeros
+          Int drop=0;
+          for (;; drop++) {    // [will terminate because lsu!=0]
+            if (exponent>=maxexponent) break;     // don't chop real 0s
+            #if DECDPUN<=4
+              if ((lsu-QUOT10(lsu, drop+1)
+                  *powers[drop+1])!=0) break;     // found non-0 digit
+            #else
+              if (lsu%powers[drop+1]!=0) break;   // found non-0 digit
+            #endif
+            exponent++;
+            }
+          if (drop>0) {
+            accunits=decShiftToLeast(accnext, accunits, drop);
+            accdigits=decGetDigits(accnext, accunits);
+            accunits=D2U(accdigits);
+            // [exponent was adjusted in the loop]
+            }
+          } // neither odd nor 0
+        #endif
+        } // exact divide
+      } // divide
+     else /* op!=DIVIDE */ {
+      // check for coefficient overflow
+      if (accdigits+exponent>reqdigits) {
+        *status|=DEC_Division_impossible;
+        break;
+        }
+      if (op & (REMAINDER|REMNEAR)) {
+        // [Here, the exponent will be 0, because var1 was adjusted
+        // appropriately.]
+        Int postshift;                       // work
+        Flag wasodd=0;                       // integer was odd
+        Unit *quotlsu;                       // for save
+        Int  quotdigits;                     // ..
+
+        bits=lhs->bits;                      // remainder sign is always as lhs
+
+        // Fastpath when residue is truly 0 is worthwhile [and
+        // simplifies the code below]
+        if (*var1==0 && var1units==1) {      // residue is 0
+          Int exp=lhs->exponent;             // save min(exponents)
+          if (rhs->exponent<exp) exp=rhs->exponent;
+          decNumberZero(res);                // 0 coefficient
+          #if DECSUBSET
+          if (set->extended)
+          #endif
+          res->exponent=exp;                 // .. with proper exponent
+          res->bits=(uByte)(bits&DECNEG);          // [cleaned]
+          decFinish(res, set, &residue, status);   // might clamp
+          break;
+          }
+        // note if the quotient was odd
+        if (*accnext & 0x01) wasodd=1;       // acc is odd
+        quotlsu=accnext;                     // save in case need to reinspect
+        quotdigits=accdigits;                // ..
+
+        // treat the residue, in var1, as the value to return, via acc
+        // calculate the unused zero digits.  This is the smaller of:
+        //   var1 initial padding (saved above)
+        //   var2 residual padding, which happens to be given by:
+        postshift=var1initpad+exponent-lhs->exponent+rhs->exponent;
+        // [the 'exponent' term accounts for the shifts during divide]
+        if (var1initpad<postshift) postshift=var1initpad;
+
+        // shift var1 the requested amount, and adjust its digits
+        var1units=decShiftToLeast(var1, var1units, postshift);
+        accnext=var1;
+        accdigits=decGetDigits(var1, var1units);
+        accunits=D2U(accdigits);
+
+        exponent=lhs->exponent;         // exponent is smaller of lhs & rhs
+        if (rhs->exponent<exponent) exponent=rhs->exponent;
+
+        // Now correct the result if doing remainderNear; if it
+        // (looking just at coefficients) is > rhs/2, or == rhs/2 and
+        // the integer was odd then the result should be rem-rhs.
+        if (op&REMNEAR) {
+          Int compare, tarunits;        // work
+          Unit *up;                     // ..
+          // calculate remainder*2 into the var1 buffer (which has
+          // 'headroom' of an extra unit and hence enough space)
+          // [a dedicated 'double' loop would be faster, here]
+          tarunits=decUnitAddSub(accnext, accunits, accnext, accunits,
+                                 0, accnext, 1);
+          // decDumpAr('r', accnext, tarunits);
+
+          // Here, accnext (var1) holds tarunits Units with twice the
+          // remainder's coefficient, which must now be compared to the
+          // RHS.  The remainder's exponent may be smaller than the RHS's.
+          compare=decUnitCompare(accnext, tarunits, rhs->lsu, D2U(rhs->digits),
+                                 rhs->exponent-exponent);
+          if (compare==BADINT) {             // deep trouble
+            *status|=DEC_Insufficient_storage;
+            break;}
+
+          // now restore the remainder by dividing by two; the lsu
+          // is known to be even.
+          for (up=accnext; up<accnext+tarunits; up++) {
+            Int half;              // half to add to lower unit
+            half=*up & 0x01;
+            *up/=2;                // [shift]
+            if (!half) continue;
+            *(up-1)+=(DECDPUNMAX+1)/2;
+            }
+          // [accunits still describes the original remainder length]
+
+          if (compare>0 || (compare==0 && wasodd)) { // adjustment needed
+            Int exp, expunits, exprem;       // work
+            // This is effectively causing round-up of the quotient,
+            // so if it was the rare case where it was full and all
+            // nines, it would overflow and hence division-impossible
+            // should be raised
+            Flag allnines=0;                 // 1 if quotient all nines
+            if (quotdigits==reqdigits) {     // could be borderline
+              for (up=quotlsu; ; up++) {
+                if (quotdigits>DECDPUN) {
+                  if (*up!=DECDPUNMAX) break;// non-nines
+                  }
+                 else {                      // this is the last Unit
+                  if (*up==powers[quotdigits]-1) allnines=1;
+                  break;
+                  }
+                quotdigits-=DECDPUN;         // checked those digits
+                } // up
+              } // borderline check
+            if (allnines) {
+              *status|=DEC_Division_impossible;
+              break;}
+
+            // rem-rhs is needed; the sign will invert.  Again, var1
+            // can safely be used for the working Units array.
+            exp=rhs->exponent-exponent;      // RHS padding needed
+            // Calculate units and remainder from exponent.
+            expunits=exp/DECDPUN;
+            exprem=exp%DECDPUN;
+            // subtract [A+B*(-m)]; the result will always be negative
+            accunits=-decUnitAddSub(accnext, accunits,
+                                    rhs->lsu, D2U(rhs->digits),
+                                    expunits, accnext, -(Int)powers[exprem]);
+            accdigits=decGetDigits(accnext, accunits); // count digits exactly
+            accunits=D2U(accdigits);    // and recalculate the units for copy
+            // [exponent is as for original remainder]
+            bits^=DECNEG;               // flip the sign
+            }
+          } // REMNEAR
+        } // REMAINDER or REMNEAR
+      } // not DIVIDE
+
+    // Set exponent and bits
+    res->exponent=exponent;
+    res->bits=(uByte)(bits&DECNEG);          // [cleaned]
+
+    // Now the coefficient.
+    decSetCoeff(res, set, accnext, accdigits, &residue, status);
+
+    decFinish(res, set, &residue, status);   // final cleanup
+
+    #if DECSUBSET
+    // If a divide then strip trailing zeros if subset [after round]
+    if (!set->extended && (op==DIVIDE)) decTrim(res, set, 0, 1, &dropped);
+    #endif
+    } while(0);                              // end protected
+
+  if (varalloc!=NULL) free(varalloc);   // drop any storage used
+  if (allocacc!=NULL) free(allocacc);   // ..
+  #if DECSUBSET
+  if (allocrhs!=NULL) free(allocrhs);   // ..
+  if (alloclhs!=NULL) free(alloclhs);   // ..
+  #endif
+  return res;
+  } // decDivideOp
+
+/* ------------------------------------------------------------------ */
+/* decMultiplyOp -- multiplication operation                          */
+/*                                                                    */
+/*  This routine performs the multiplication C=A x B.                 */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X*X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*   status is the usual accumulator                                  */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* ------------------------------------------------------------------ */
+/* 'Classic' multiplication is used rather than Karatsuba, as the     */
+/* latter would give only a minor improvement for the short numbers   */
+/* expected to be handled most (and uses much more memory).           */
+/*                                                                    */
+/* There are two major paths here: the general-purpose ('old code')   */
+/* path which handles all DECDPUN values, and a fastpath version      */
+/* which is used if 64-bit ints are available, DECDPUN<=4, and more   */
+/* than two calls to decUnitAddSub would be made.                     */
+/*                                                                    */
+/* The fastpath version lumps units together into 8-digit or 9-digit  */
+/* chunks, and also uses a lazy carry strategy to minimise expensive  */
+/* 64-bit divisions.  The chunks are then broken apart again into     */
+/* units for continuing processing.  Despite this overhead, the       */
+/* fastpath can speed up some 16-digit operations by 10x (and much    */
+/* more for higher-precision calculations).                           */
+/*                                                                    */
+/* A buffer always has to be used for the accumulator; in the         */
+/* fastpath, buffers are also always needed for the chunked copies of */
+/* of the operand coefficients.                                       */
+/* Static buffers are larger than needed just for multiply, to allow  */
+/* for calls from other operations (notably exp).                     */
+/* ------------------------------------------------------------------ */
+#define FASTMUL (DECUSE64 && DECDPUN<5)
+static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs,
+                                 const decNumber *rhs, decContext *set,
+                                 uInt *status) {
+  Int    accunits;                 // Units of accumulator in use
+  Int    exponent;                 // work
+  Int    residue=0;                // rounding residue
+  uByte  bits;                     // result sign
+  Unit  *acc;                      // -> accumulator Unit array
+  Int    needbytes;                // size calculator
+  void  *allocacc=NULL;            // -> allocated accumulator, iff allocated
+  Unit  accbuff[SD2U(DECBUFFER*4+1)]; // buffer (+1 for DECBUFFER==0,
+                                   // *4 for calls from other operations)
+  const Unit *mer, *mermsup;       // work
+  Int   madlength;                 // Units in multiplicand
+  Int   shift;                     // Units to shift multiplicand by
+
+  #if FASTMUL
+    // if DECDPUN is 1 or 3 work in base 10**9, otherwise
+    // (DECDPUN is 2 or 4) then work in base 10**8
+    #if DECDPUN & 1                // odd
+      #define FASTBASE 1000000000  // base
+      #define FASTDIGS          9  // digits in base
+      #define FASTLAZY         18  // carry resolution point [1->18]
+    #else
+      #define FASTBASE  100000000
+      #define FASTDIGS          8
+      #define FASTLAZY       1844  // carry resolution point [1->1844]
+    #endif
+    // three buffers are used, two for chunked copies of the operands
+    // (base 10**8 or base 10**9) and one base 2**64 accumulator with
+    // lazy carry evaluation
+    uInt   zlhibuff[(DECBUFFER*2+1)/8+1]; // buffer (+1 for DECBUFFER==0)
+    uInt  *zlhi=zlhibuff;                 // -> lhs array
+    uInt  *alloclhi=NULL;                 // -> allocated buffer, iff allocated
+    uInt   zrhibuff[(DECBUFFER*2+1)/8+1]; // buffer (+1 for DECBUFFER==0)
+    uInt  *zrhi=zrhibuff;                 // -> rhs array
+    uInt  *allocrhi=NULL;                 // -> allocated buffer, iff allocated
+    uLong  zaccbuff[(DECBUFFER*2+1)/4+2]; // buffer (+1 for DECBUFFER==0)
+    // [allocacc is shared for both paths, as only one will run]
+    uLong *zacc=zaccbuff;          // -> accumulator array for exact result
+    #if DECDPUN==1
+    Int    zoff;                   // accumulator offset
+    #endif
+    uInt  *lip, *rip;              // item pointers
+    uInt  *lmsi, *rmsi;            // most significant items
+    Int    ilhs, irhs, iacc;       // item counts in the arrays
+    Int    lazy;                   // lazy carry counter
+    uLong  lcarry;                 // uLong carry
+    uInt   carry;                  // carry (NB not uLong)
+    Int    count;                  // work
+    const  Unit *cup;              // ..
+    Unit  *up;                     // ..
+    uLong *lp;                     // ..
+    Int    p;                      // ..
+  #endif
+
+  #if DECSUBSET
+    decNumber *alloclhs=NULL;      // -> allocated buffer, iff allocated
+    decNumber *allocrhs=NULL;      // -> allocated buffer, iff allocated
+  #endif
+
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  #endif
+
+  // precalculate result sign
+  bits=(uByte)((lhs->bits^rhs->bits)&DECNEG);
+
+  // handle infinities and NaNs
+  if (SPECIALARGS) {               // a special bit set
+    if (SPECIALARGS & (DECSNAN | DECNAN)) { // one or two NaNs
+      decNaNs(res, lhs, rhs, set, status);
+      return res;}
+    // one or two infinities; Infinity * 0 is invalid
+    if (((lhs->bits & DECINF)==0 && ISZERO(lhs))
+      ||((rhs->bits & DECINF)==0 && ISZERO(rhs))) {
+      *status|=DEC_Invalid_operation;
+      return res;}
+    decNumberZero(res);
+    res->bits=bits|DECINF;         // infinity
+    return res;}
+
+  // For best speed, as in DMSRCN [the original Rexx numerics
+  // module], use the shorter number as the multiplier (rhs) and
+  // the longer as the multiplicand (lhs) to minimise the number of
+  // adds (partial products)
+  if (lhs->digits<rhs->digits) {   // swap...
+    const decNumber *hold=lhs;
+    lhs=rhs;
+    rhs=hold;
+    }
+
+  do {                             // protect allocated storage
+    #if DECSUBSET
+    if (!set->extended) {
+      // reduce operands and set lostDigits status, as needed
+      if (lhs->digits>set->digits) {
+        alloclhs=decRoundOperand(lhs, set, status);
+        if (alloclhs==NULL) break;
+        lhs=alloclhs;
+        }
+      if (rhs->digits>set->digits) {
+        allocrhs=decRoundOperand(rhs, set, status);
+        if (allocrhs==NULL) break;
+        rhs=allocrhs;
+        }
+      }
+    #endif
+    // [following code does not require input rounding]
+
+    #if FASTMUL                    // fastpath can be used
+    // use the fast path if there are enough digits in the shorter
+    // operand to make the setup and takedown worthwhile
+    #define NEEDTWO (DECDPUN*2)    // within two decUnitAddSub calls
+    if (rhs->digits>NEEDTWO) {     // use fastpath...
+      // calculate the number of elements in each array
+      ilhs=(lhs->digits+FASTDIGS-1)/FASTDIGS; // [ceiling]
+      irhs=(rhs->digits+FASTDIGS-1)/FASTDIGS; // ..
+      iacc=ilhs+irhs;
+
+      // allocate buffers if required, as usual
+      needbytes=ilhs*sizeof(uInt);
+      if (needbytes>(Int)sizeof(zlhibuff)) {
+        alloclhi=(uInt *)malloc(needbytes);
+        zlhi=alloclhi;}
+      needbytes=irhs*sizeof(uInt);
+      if (needbytes>(Int)sizeof(zrhibuff)) {
+        allocrhi=(uInt *)malloc(needbytes);
+        zrhi=allocrhi;}
+
+      // Allocating the accumulator space needs a special case when
+      // DECDPUN=1 because when converting the accumulator to Units
+      // after the multiplication each 8-byte item becomes 9 1-byte
+      // units.  Therefore iacc extra bytes are needed at the front
+      // (rounded up to a multiple of 8 bytes), and the uLong
+      // accumulator starts offset the appropriate number of units
+      // to the right to avoid overwrite during the unchunking.
+      needbytes=iacc*sizeof(uLong);
+      #if DECDPUN==1
+      zoff=(iacc+7)/8;        // items to offset by
+      needbytes+=zoff*8;
+      #endif
+      if (needbytes>(Int)sizeof(zaccbuff)) {
+        allocacc=(uLong *)malloc(needbytes);
+        zacc=(uLong *)allocacc;}
+      if (zlhi==NULL||zrhi==NULL||zacc==NULL) {
+        *status|=DEC_Insufficient_storage;
+        break;}
+
+      acc=(Unit *)zacc;       // -> target Unit array
+      #if DECDPUN==1
+      zacc+=zoff;             // start uLong accumulator to right
+      #endif
+
+      // assemble the chunked copies of the left and right sides
+      for (count=lhs->digits, cup=lhs->lsu, lip=zlhi; count>0; lip++)
+        for (p=0, *lip=0; p<FASTDIGS && count>0;
+             p+=DECDPUN, cup++, count-=DECDPUN)
+          *lip+=*cup*powers[p];
+      lmsi=lip-1;     // save -> msi
+      for (count=rhs->digits, cup=rhs->lsu, rip=zrhi; count>0; rip++)
+        for (p=0, *rip=0; p<FASTDIGS && count>0;
+             p+=DECDPUN, cup++, count-=DECDPUN)
+          *rip+=*cup*powers[p];
+      rmsi=rip-1;     // save -> msi
+
+      // zero the accumulator
+      for (lp=zacc; lp<zacc+iacc; lp++) *lp=0;
+
+      /* Start the multiplication */
+      // Resolving carries can dominate the cost of accumulating the
+      // partial products, so this is only done when necessary.
+      // Each uLong item in the accumulator can hold values up to
+      // 2**64-1, and each partial product can be as large as
+      // (10**FASTDIGS-1)**2.  When FASTDIGS=9, this can be added to
+      // itself 18.4 times in a uLong without overflowing, so during
+      // the main calculation resolution is carried out every 18th
+      // add -- every 162 digits.  Similarly, when FASTDIGS=8, the
+      // partial products can be added to themselves 1844.6 times in
+      // a uLong without overflowing, so intermediate carry
+      // resolution occurs only every 14752 digits.  Hence for common
+      // short numbers usually only the one final carry resolution
+      // occurs.
+      // (The count is set via FASTLAZY to simplify experiments to
+      // measure the value of this approach: a 35% improvement on a
+      // [34x34] multiply.)
+      lazy=FASTLAZY;                         // carry delay count
+      for (rip=zrhi; rip<=rmsi; rip++) {     // over each item in rhs
+        lp=zacc+(rip-zrhi);                  // where to add the lhs
+        for (lip=zlhi; lip<=lmsi; lip++, lp++) { // over each item in lhs
+          *lp+=(uLong)(*lip)*(*rip);         // [this should in-line]
+          } // lip loop
+        lazy--;
+        if (lazy>0 && rip!=rmsi) continue;
+        lazy=FASTLAZY;                       // reset delay count
+        // spin up the accumulator resolving overflows
+        for (lp=zacc; lp<zacc+iacc; lp++) {
+          if (*lp<FASTBASE) continue;        // it fits
+          lcarry=*lp/FASTBASE;               // top part [slow divide]
+          // lcarry can exceed 2**32-1, so check again; this check
+          // and occasional extra divide (slow) is well worth it, as
+          // it allows FASTLAZY to be increased to 18 rather than 4
+          // in the FASTDIGS=9 case
+          if (lcarry<FASTBASE) carry=(uInt)lcarry;  // [usual]
+           else { // two-place carry [fairly rare]
+            uInt carry2=(uInt)(lcarry/FASTBASE);    // top top part
+            *(lp+2)+=carry2;                        // add to item+2
+            *lp-=((uLong)FASTBASE*FASTBASE*carry2); // [slow]
+            carry=(uInt)(lcarry-((uLong)FASTBASE*carry2)); // [inline]
+            }
+          *(lp+1)+=carry;                    // add to item above [inline]
+          *lp-=((uLong)FASTBASE*carry);      // [inline]
+          } // carry resolution
+        } // rip loop
+
+      // The multiplication is complete; time to convert back into
+      // units.  This can be done in-place in the accumulator and in
+      // 32-bit operations, because carries were resolved after the
+      // final add.  This needs N-1 divides and multiplies for
+      // each item in the accumulator (which will become up to N
+      // units, where 2<=N<=9).
+      for (lp=zacc, up=acc; lp<zacc+iacc; lp++) {
+        uInt item=(uInt)*lp;                 // decapitate to uInt
+        for (p=0; p<FASTDIGS-DECDPUN; p+=DECDPUN, up++) {
+          uInt part=item/(DECDPUNMAX+1);
+          *up=(Unit)(item-(part*(DECDPUNMAX+1)));
+          item=part;
+          } // p
+        *up=(Unit)item; up++;                // [final needs no division]
+        } // lp
+      accunits=up-acc;                       // count of units
+      }
+     else { // here to use units directly, without chunking ['old code']
+    #endif
+
+      // if accumulator will be too long for local storage, then allocate
+      acc=accbuff;                 // -> assume buffer for accumulator
+      needbytes=(D2U(lhs->digits)+D2U(rhs->digits))*sizeof(Unit);
+      if (needbytes>(Int)sizeof(accbuff)) {
+        allocacc=(Unit *)malloc(needbytes);
+        if (allocacc==NULL) {*status|=DEC_Insufficient_storage; break;}
+        acc=(Unit *)allocacc;                // use the allocated space
+        }
+
+      /* Now the main long multiplication loop */
+      // Unlike the equivalent in the IBM Java implementation, there
+      // is no advantage in calculating from msu to lsu.  So, do it
+      // by the book, as it were.
+      // Each iteration calculates ACC=ACC+MULTAND*MULT
+      accunits=1;                  // accumulator starts at '0'
+      *acc=0;                      // .. (lsu=0)
+      shift=0;                     // no multiplicand shift at first
+      madlength=D2U(lhs->digits);  // this won't change
+      mermsup=rhs->lsu+D2U(rhs->digits); // -> msu+1 of multiplier
+
+      for (mer=rhs->lsu; mer<mermsup; mer++) {
+        // Here, *mer is the next Unit in the multiplier to use
+        // If non-zero [optimization] add it...
+        if (*mer!=0) accunits=decUnitAddSub(&acc[shift], accunits-shift,
+                                            lhs->lsu, madlength, 0,
+                                            &acc[shift], *mer)
+                                            + shift;
+         else { // extend acc with a 0; it will be used shortly
+          *(acc+accunits)=0;       // [this avoids length of <=0 later]
+          accunits++;
+          }
+        // multiply multiplicand by 10**DECDPUN for next Unit to left
+        shift++;                   // add this for 'logical length'
+        } // n
+    #if FASTMUL
+      } // unchunked units
+    #endif
+    // common end-path
+    #if DECTRACE
+      decDumpAr('*', acc, accunits);         // Show exact result
+    #endif
+
+    // acc now contains the exact result of the multiplication,
+    // possibly with a leading zero unit; build the decNumber from
+    // it, noting if any residue
+    res->bits=bits;                          // set sign
+    res->digits=decGetDigits(acc, accunits); // count digits exactly
+
+    // There can be a 31-bit wrap in calculating the exponent.
+    // This can only happen if both input exponents are negative and
+    // both their magnitudes are large.  If there was a wrap, set a
+    // safe very negative exponent, from which decFinalize() will
+    // raise a hard underflow shortly.
+    exponent=lhs->exponent+rhs->exponent;    // calculate exponent
+    if (lhs->exponent<0 && rhs->exponent<0 && exponent>0)
+      exponent=-2*DECNUMMAXE;                // force underflow
+    res->exponent=exponent;                  // OK to overwrite now
+
+
+    // Set the coefficient.  If any rounding, residue records
+    decSetCoeff(res, set, acc, res->digits, &residue, status);
+    decFinish(res, set, &residue, status);   // final cleanup
+    } while(0);                         // end protected
+
+  if (allocacc!=NULL) free(allocacc);   // drop any storage used
+  #if DECSUBSET
+  if (allocrhs!=NULL) free(allocrhs);   // ..
+  if (alloclhs!=NULL) free(alloclhs);   // ..
+  #endif
+  #if FASTMUL
+  if (allocrhi!=NULL) free(allocrhi);   // ..
+  if (alloclhi!=NULL) free(alloclhi);   // ..
+  #endif
+  return res;
+  } // decMultiplyOp
+
+/* ------------------------------------------------------------------ */
+/* decExpOp -- effect exponentiation                                  */
+/*                                                                    */
+/*   This computes C = exp(A)                                         */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*   set is the context; note that rounding mode has no effect        */
+/*                                                                    */
+/* C must have space for set->digits digits. status is updated but    */
+/* not set.                                                           */
+/*                                                                    */
+/* Restrictions:                                                      */
+/*                                                                    */
+/*   digits, emax, and -emin in the context must be less than         */
+/*   2*DEC_MAX_MATH (1999998), and the rhs must be within these       */
+/*   bounds or a zero.  This is an internal routine, so these         */
+/*   restrictions are contractual and not enforced.                   */
+/*                                                                    */
+/* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will      */
+/* almost always be correctly rounded, but may be up to 1 ulp in      */
+/* error in rare cases.                                               */
+/*                                                                    */
+/* Finite results will always be full precision and Inexact, except   */
+/* when A is a zero or -Infinity (giving 1 or 0 respectively).        */
+/* ------------------------------------------------------------------ */
+/* This approach used here is similar to the algorithm described in   */
+/*                                                                    */
+/*   Variable Precision Exponential Function, T. E. Hull and          */
+/*   A. Abrham, ACM Transactions on Mathematical Software, Vol 12 #2, */
+/*   pp79-91, ACM, June 1986.                                         */
+/*                                                                    */
+/* with the main difference being that the iterations in the series   */
+/* evaluation are terminated dynamically (which does not require the  */
+/* extra variable-precision variables which are expensive in this     */
+/* context).                                                          */
+/*                                                                    */
+/* The error analysis in Hull & Abrham's paper applies except for the */
+/* round-off error accumulation during the series evaluation.  This   */
+/* code does not precalculate the number of iterations and so cannot  */
+/* use Horner's scheme.  Instead, the accumulation is done at double- */
+/* precision, which ensures that the additions of the terms are exact */
+/* and do not accumulate round-off (and any round-off errors in the   */
+/* terms themselves move 'to the right' faster than they can          */
+/* accumulate).  This code also extends the calculation by allowing,  */
+/* in the spirit of other decNumber operators, the input to be more   */
+/* precise than the result (the precision used is based on the more   */
+/* precise of the input or requested result).                         */
+/*                                                                    */
+/* Implementation notes:                                              */
+/*                                                                    */
+/* 1. This is separated out as decExpOp so it can be called from      */
+/*    other Mathematical functions (notably Ln) with a wider range    */
+/*    than normal.  In particular, it can handle the slightly wider   */
+/*    (double) range needed by Ln (which has to be able to calculate  */
+/*    exp(-x) where x can be the tiniest number (Ntiny).              */
+/*                                                                    */
+/* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop         */
+/*    iterations by appoximately a third with additional (although    */
+/*    diminishing) returns as the range is reduced to even smaller    */
+/*    fractions.  However, h (the power of 10 used to correct the     */
+/*    result at the end, see below) must be kept <=8 as otherwise     */
+/*    the final result cannot be computed.  Hence the leverage is a   */
+/*    sliding value (8-h), where potentially the range is reduced     */
+/*    more for smaller values.                                        */
+/*                                                                    */
+/*    The leverage that can be applied in this way is severely        */
+/*    limited by the cost of the raise-to-the power at the end,       */
+/*    which dominates when the number of iterations is small (less    */
+/*    than ten) or when rhs is short.  As an example, the adjustment  */
+/*    x**10,000,000 needs 31 multiplications, all but one full-width. */
+/*                                                                    */
+/* 3. The restrictions (especially precision) could be raised with    */
+/*    care, but the full decNumber range seems very hard within the   */
+/*    32-bit limits.                                                  */
+/*                                                                    */
+/* 4. The working precisions for the static buffers are twice the     */
+/*    obvious size to allow for calls from decNumberPower.            */
+/* ------------------------------------------------------------------ */
+decNumber * decExpOp(decNumber *res, const decNumber *rhs,
+                         decContext *set, uInt *status) {
+  uInt ignore=0;                   // working status
+  Int h;                           // adjusted exponent for 0.xxxx
+  Int p;                           // working precision
+  Int residue;                     // rounding residue
+  uInt needbytes;                  // for space calculations
+  const decNumber *x=rhs;          // (may point to safe copy later)
+  decContext aset, tset, dset;     // working contexts
+  Int comp;                        // work
+
+  // the argument is often copied to normalize it, so (unusually) it
+  // is treated like other buffers, using DECBUFFER, +1 in case
+  // DECBUFFER is 0
+  decNumber bufr[D2N(DECBUFFER*2+1)];
+  decNumber *allocrhs=NULL;        // non-NULL if rhs buffer allocated
+
+  // the working precision will be no more than set->digits+8+1
+  // so for on-stack buffers DECBUFFER+9 is used, +1 in case DECBUFFER
+  // is 0 (and twice that for the accumulator)
+
+  // buffer for t, term (working precision plus)
+  decNumber buft[D2N(DECBUFFER*2+9+1)];
+  decNumber *allocbuft=NULL;       // -> allocated buft, iff allocated
+  decNumber *t=buft;               // term
+  // buffer for a, accumulator (working precision * 2), at least 9
+  decNumber bufa[D2N(DECBUFFER*4+18+1)];
+  decNumber *allocbufa=NULL;       // -> allocated bufa, iff allocated
+  decNumber *a=bufa;               // accumulator
+  // decNumber for the divisor term; this needs at most 9 digits
+  // and so can be fixed size [16 so can use standard context]
+  decNumber bufd[D2N(16)];
+  decNumber *d=bufd;               // divisor
+  decNumber numone;                // constant 1
+
+  #if DECCHECK
+  Int iterations=0;                // for later sanity check
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  do {                                  // protect allocated storage
+    if (SPECIALARG) {                   // handle infinities and NaNs
+      if (decNumberIsInfinite(rhs)) {   // an infinity
+        if (decNumberIsNegative(rhs))   // -Infinity -> +0
+          decNumberZero(res);
+         else decNumberCopy(res, rhs);  // +Infinity -> self
+        }
+       else decNaNs(res, rhs, NULL, set, status); // a NaN
+      break;}
+
+    if (ISZERO(rhs)) {                  // zeros -> exact 1
+      decNumberZero(res);               // make clean 1
+      *res->lsu=1;                      // ..
+      break;}                           // [no status to set]
+
+    // e**x when 0 < x < 0.66 is < 1+3x/2, hence can fast-path
+    // positive and negative tiny cases which will result in inexact
+    // 1.  This also allows the later add-accumulate to always be
+    // exact (because its length will never be more than twice the
+    // working precision).
+    // The comparator (tiny) needs just one digit, so use the
+    // decNumber d for it (reused as the divisor, etc., below); its
+    // exponent is such that if x is positive it will have
+    // set->digits-1 zeros between the decimal point and the digit,
+    // which is 4, and if x is negative one more zero there as the
+    // more precise result will be of the form 0.9999999 rather than
+    // 1.0000001.  Hence, tiny will be 0.0000004  if digits=7 and x>0
+    // or 0.00000004 if digits=7 and x<0.  If RHS not larger than
+    // this then the result will be 1.000000
+    decNumberZero(d);                   // clean
+    *d->lsu=4;                          // set 4 ..
+    d->exponent=-set->digits;           // * 10**(-d)
+    if (decNumberIsNegative(rhs)) d->exponent--;  // negative case
+    comp=decCompare(d, rhs, 1);         // signless compare
+    if (comp==BADINT) {
+      *status|=DEC_Insufficient_storage;
+      break;}
+    if (comp>=0) {                      // rhs < d
+      Int shift=set->digits-1;
+      decNumberZero(res);               // set 1
+      *res->lsu=1;                      // ..
+      res->digits=decShiftToMost(res->lsu, 1, shift);
+      res->exponent=-shift;                  // make 1.0000...
+      *status|=DEC_Inexact | DEC_Rounded;    // .. inexactly
+      break;} // tiny
+
+    // set up the context to be used for calculating a, as this is
+    // used on both paths below
+    decContextDefault(&aset, DEC_INIT_DECIMAL64);
+    // accumulator bounds are as requested (could underflow)
+    aset.emax=set->emax;                // usual bounds
+    aset.emin=set->emin;                // ..
+    aset.clamp=0;                       // and no concrete format
+
+    // calculate the adjusted (Hull & Abrham) exponent (where the
+    // decimal point is just to the left of the coefficient msd)
+    h=rhs->exponent+rhs->digits;
+    // if h>8 then 10**h cannot be calculated safely; however, when
+    // h=8 then exp(|rhs|) will be at least exp(1E+7) which is at
+    // least 6.59E+4342944, so (due to the restriction on Emax/Emin)
+    // overflow (or underflow to 0) is guaranteed -- so this case can
+    // be handled by simply forcing the appropriate excess
+    if (h>8) {                          // overflow/underflow
+      // set up here so Power call below will over or underflow to
+      // zero; set accumulator to either 2 or 0.02
+      // [stack buffer for a is always big enough for this]
+      decNumberZero(a);
+      *a->lsu=2;                        // not 1 but < exp(1)
+      if (decNumberIsNegative(rhs)) a->exponent=-2; // make 0.02
+      h=8;                              // clamp so 10**h computable
+      p=9;                              // set a working precision
+      }
+     else {                             // h<=8
+      Int maxlever=(rhs->digits>8?1:0);
+      // [could/should increase this for precisions >40 or so, too]
+
+      // if h is 8, cannot normalize to a lower upper limit because
+      // the final result will not be computable (see notes above),
+      // but leverage can be applied whenever h is less than 8.
+      // Apply as much as possible, up to a MAXLEVER digits, which
+      // sets the tradeoff against the cost of the later a**(10**h).
+      // As h is increased, the working precision below also
+      // increases to compensate for the "constant digits at the
+      // front" effect.
+      Int lever=MINI(8-h, maxlever);    // leverage attainable
+      Int use=-rhs->digits-lever;       // exponent to use for RHS
+      h+=lever;                         // apply leverage selected
+      if (h<0) {                        // clamp
+        use+=h;                         // [may end up subnormal]
+        h=0;
+        }
+      // Take a copy of RHS if it needs normalization (true whenever x>=1)
+      if (rhs->exponent!=use) {
+        decNumber *newrhs=bufr;         // assume will fit on stack
+        needbytes=sizeof(decNumber)+(D2U(rhs->digits)-1)*sizeof(Unit);
+        if (needbytes>sizeof(bufr)) {   // need malloc space
+          allocrhs=(decNumber *)malloc(needbytes);
+          if (allocrhs==NULL) {         // hopeless -- abandon
+            *status|=DEC_Insufficient_storage;
+            break;}
+          newrhs=allocrhs;              // use the allocated space
+          }
+        decNumberCopy(newrhs, rhs);     // copy to safe space
+        newrhs->exponent=use;           // normalize; now <1
+        x=newrhs;                       // ready for use
+        // decNumberShow(x);
+        }
+
+      // Now use the usual power series to evaluate exp(x).  The
+      // series starts as 1 + x + x^2/2 ... so prime ready for the
+      // third term by setting the term variable t=x, the accumulator
+      // a=1, and the divisor d=2.
+
+      // First determine the working precision.  From Hull & Abrham
+      // this is set->digits+h+2.  However, if x is 'over-precise' we
+      // need to allow for all its digits to potentially participate
+      // (consider an x where all the excess digits are 9s) so in
+      // this case use x->digits+h+2
+      p=MAXI(x->digits, set->digits)+h+2;    // [h<=8]
+
+      // a and t are variable precision, and depend on p, so space
+      // must be allocated for them if necessary
+
+      // the accumulator needs to be able to hold 2p digits so that
+      // the additions on the second and subsequent iterations are
+      // sufficiently exact.
+      needbytes=sizeof(decNumber)+(D2U(p*2)-1)*sizeof(Unit);
+      if (needbytes>sizeof(bufa)) {     // need malloc space
+        allocbufa=(decNumber *)malloc(needbytes);
+        if (allocbufa==NULL) {          // hopeless -- abandon
+          *status|=DEC_Insufficient_storage;
+          break;}
+        a=allocbufa;                    // use the allocated space
+        }
+      // the term needs to be able to hold p digits (which is
+      // guaranteed to be larger than x->digits, so the initial copy
+      // is safe); it may also be used for the raise-to-power
+      // calculation below, which needs an extra two digits
+      needbytes=sizeof(decNumber)+(D2U(p+2)-1)*sizeof(Unit);
+      if (needbytes>sizeof(buft)) {     // need malloc space
+        allocbuft=(decNumber *)malloc(needbytes);
+        if (allocbuft==NULL) {          // hopeless -- abandon
+          *status|=DEC_Insufficient_storage;
+          break;}
+        t=allocbuft;                    // use the allocated space
+        }
+
+      decNumberCopy(t, x);              // term=x
+      decNumberZero(a); *a->lsu=1;      // accumulator=1
+      decNumberZero(d); *d->lsu=2;      // divisor=2
+      decNumberZero(&numone); *numone.lsu=1; // constant 1 for increment
+
+      // set up the contexts for calculating a, t, and d
+      decContextDefault(&tset, DEC_INIT_DECIMAL64);
+      dset=tset;
+      // accumulator bounds are set above, set precision now
+      aset.digits=p*2;                  // double
+      // term bounds avoid any underflow or overflow
+      tset.digits=p;
+      tset.emin=DEC_MIN_EMIN;           // [emax is plenty]
+      // [dset.digits=16, etc., are sufficient]
+
+      // finally ready to roll
+      for (;;) {
+        #if DECCHECK
+        iterations++;
+        #endif
+        // only the status from the accumulation is interesting
+        // [but it should remain unchanged after first add]
+        decAddOp(a, a, t, &aset, 0, status);           // a=a+t
+        decMultiplyOp(t, t, x, &tset, &ignore);        // t=t*x
+        decDivideOp(t, t, d, &tset, DIVIDE, &ignore);  // t=t/d
+        // the iteration ends when the term cannot affect the result,
+        // if rounded to p digits, which is when its value is smaller
+        // than the accumulator by p+1 digits.  There must also be
+        // full precision in a.
+        if (((a->digits+a->exponent)>=(t->digits+t->exponent+p+1))
+            && (a->digits>=p)) break;
+        decAddOp(d, d, &numone, &dset, 0, &ignore);    // d=d+1
+        } // iterate
+
+      #if DECCHECK
+      // just a sanity check; comment out test to show always
+      if (iterations>p+3)
+        printf("Exp iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
+               (LI)iterations, (LI)*status, (LI)p, (LI)x->digits);
+      #endif
+      } // h<=8
+
+    // apply postconditioning: a=a**(10**h) -- this is calculated
+    // at a slightly higher precision than Hull & Abrham suggest
+    if (h>0) {
+      Int seenbit=0;               // set once a 1-bit is seen
+      Int i;                       // counter
+      Int n=powers[h];             // always positive
+      aset.digits=p+2;             // sufficient precision
+      // avoid the overhead and many extra digits of decNumberPower
+      // as all that is needed is the short 'multipliers' loop; here
+      // accumulate the answer into t
+      decNumberZero(t); *t->lsu=1; // acc=1
+      for (i=1;;i++){              // for each bit [top bit ignored]
+        // abandon if have had overflow or terminal underflow
+        if (*status & (DEC_Overflow|DEC_Underflow)) { // interesting?
+          if (*status&DEC_Overflow || ISZERO(t)) break;}
+        n=n<<1;                    // move next bit to testable position
+        if (n<0) {                 // top bit is set
+          seenbit=1;               // OK, have a significant bit
+          decMultiplyOp(t, t, a, &aset, status); // acc=acc*x
+          }
+        if (i==31) break;          // that was the last bit
+        if (!seenbit) continue;    // no need to square 1
+        decMultiplyOp(t, t, t, &aset, status); // acc=acc*acc [square]
+        } /*i*/ // 32 bits
+      // decNumberShow(t);
+      a=t;                         // and carry on using t instead of a
+      }
+
+    // Copy and round the result to res
+    residue=1;                          // indicate dirt to right ..
+    if (ISZERO(a)) residue=0;           // .. unless underflowed to 0
+    aset.digits=set->digits;            // [use default rounding]
+    decCopyFit(res, a, &aset, &residue, status); // copy & shorten
+    decFinish(res, set, &residue, status);       // cleanup/set flags
+    } while(0);                         // end protected
+
+  if (allocrhs !=NULL) free(allocrhs);  // drop any storage used
+  if (allocbufa!=NULL) free(allocbufa); // ..
+  if (allocbuft!=NULL) free(allocbuft); // ..
+  // [status is handled by caller]
+  return res;
+  } // decExpOp
+
+/* ------------------------------------------------------------------ */
+/* Initial-estimate natural logarithm table                           */
+/*                                                                    */
+/*   LNnn -- 90-entry 16-bit table for values from .10 through .99.   */
+/*           The result is a 4-digit encode of the coefficient (c=the */
+/*           top 14 bits encoding 0-9999) and a 2-digit encode of the */
+/*           exponent (e=the bottom 2 bits encoding 0-3)              */
+/*                                                                    */
+/*           The resulting value is given by:                         */
+/*                                                                    */
+/*             v = -c * 10**(-e-3)                                    */
+/*                                                                    */
+/*           where e and c are extracted from entry k = LNnn[x-10]    */
+/*           where x is truncated (NB) into the range 10 through 99,  */
+/*           and then c = k>>2 and e = k&3.                           */
+/* ------------------------------------------------------------------ */
+const uShort LNnn[90]={9016,  8652,  8316,  8008,  7724,  7456,  7208,
+  6972,  6748,  6540,  6340,  6148,  5968,  5792,  5628,  5464,  5312,
+  5164,  5020,  4884,  4748,  4620,  4496,  4376,  4256,  4144,  4032,
+ 39233, 38181, 37157, 36157, 35181, 34229, 33297, 32389, 31501, 30629,
+ 29777, 28945, 28129, 27329, 26545, 25777, 25021, 24281, 23553, 22837,
+ 22137, 21445, 20769, 20101, 19445, 18801, 18165, 17541, 16925, 16321,
+ 15721, 15133, 14553, 13985, 13421, 12865, 12317, 11777, 11241, 10717,
+ 10197,  9685,  9177,  8677,  8185,  7697,  7213,  6737,  6269,  5801,
+  5341,  4889,  4437, 39930, 35534, 31186, 26886, 22630, 18418, 14254,
+ 10130,  6046, 20055};
+
+/* ------------------------------------------------------------------ */
+/* decLnOp -- effect natural logarithm                                */
+/*                                                                    */
+/*   This computes C = ln(A)                                          */
+/*                                                                    */
+/*   res is C, the result.  C may be A                                */
+/*   rhs is A                                                         */
+/*   set is the context; note that rounding mode has no effect        */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* Notable cases:                                                     */
+/*   A<0 -> Invalid                                                   */
+/*   A=0 -> -Infinity (Exact)                                         */
+/*   A=+Infinity -> +Infinity (Exact)                                 */
+/*   A=1 exactly -> 0 (Exact)                                         */
+/*                                                                    */
+/* Restrictions (as for Exp):                                         */
+/*                                                                    */
+/*   digits, emax, and -emin in the context must be less than         */
+/*   DEC_MAX_MATH+11 (1000010), and the rhs must be within these      */
+/*   bounds or a zero.  This is an internal routine, so these         */
+/*   restrictions are contractual and not enforced.                   */
+/*                                                                    */
+/* A finite result is rounded using DEC_ROUND_HALF_EVEN; it will      */
+/* almost always be correctly rounded, but may be up to 1 ulp in      */
+/* error in rare cases.                                               */
+/* ------------------------------------------------------------------ */
+/* The result is calculated using Newton's method, with each          */
+/* iteration calculating a' = a + x * exp(-a) - 1.  See, for example, */
+/* Epperson 1989.                                                     */
+/*                                                                    */
+/* The iteration ends when the adjustment x*exp(-a)-1 is tiny enough. */
+/* This has to be calculated at the sum of the precision of x and the */
+/* working precision.                                                 */
+/*                                                                    */
+/* Implementation notes:                                              */
+/*                                                                    */
+/* 1. This is separated out as decLnOp so it can be called from       */
+/*    other Mathematical functions (e.g., Log 10) with a wider range  */
+/*    than normal.  In particular, it can handle the slightly wider   */
+/*    (+9+2) range needed by a power function.                        */
+/*                                                                    */
+/* 2. The speed of this function is about 10x slower than exp, as     */
+/*    it typically needs 4-6 iterations for short numbers, and the    */
+/*    extra precision needed adds a squaring effect, twice.           */
+/*                                                                    */
+/* 3. Fastpaths are included for ln(10) and ln(2), up to length 40,   */
+/*    as these are common requests.  ln(10) is used by log10(x).      */
+/*                                                                    */
+/* 4. An iteration might be saved by widening the LNnn table, and     */
+/*    would certainly save at least one if it were made ten times     */
+/*    bigger, too (for truncated fractions 0.100 through 0.999).      */
+/*    However, for most practical evaluations, at least four or five  */
+/*    iterations will be neede -- so this would only speed up by      */
+/*    20-25% and that probably does not justify increasing the table  */
+/*    size.                                                           */
+/*                                                                    */
+/* 5. The static buffers are larger than might be expected to allow   */
+/*    for calls from decNumberPower.                                  */
+/* ------------------------------------------------------------------ */
+decNumber * decLnOp(decNumber *res, const decNumber *rhs,
+                    decContext *set, uInt *status) {
+  uInt ignore=0;                   // working status accumulator
+  uInt needbytes;                  // for space calculations
+  Int residue;                     // rounding residue
+  Int r;                           // rhs=f*10**r [see below]
+  Int p;                           // working precision
+  Int pp;                          // precision for iteration
+  Int t;                           // work
+
+  // buffers for a (accumulator, typically precision+2) and b
+  // (adjustment calculator, same size)
+  decNumber bufa[D2N(DECBUFFER+12)];
+  decNumber *allocbufa=NULL;       // -> allocated bufa, iff allocated
+  decNumber *a=bufa;               // accumulator/work
+  decNumber bufb[D2N(DECBUFFER*2+2)];
+  decNumber *allocbufb=NULL;       // -> allocated bufa, iff allocated
+  decNumber *b=bufb;               // adjustment/work
+
+  decNumber  numone;               // constant 1
+  decNumber  cmp;                  // work
+  decContext aset, bset;           // working contexts
+
+  #if DECCHECK
+  Int iterations=0;                // for later sanity check
+  if (decCheckOperands(res, DECUNUSED, rhs, set)) return res;
+  #endif
+
+  do {                                  // protect allocated storage
+    if (SPECIALARG) {                   // handle infinities and NaNs
+      if (decNumberIsInfinite(rhs)) {   // an infinity
+        if (decNumberIsNegative(rhs))   // -Infinity -> error
+          *status|=DEC_Invalid_operation;
+         else decNumberCopy(res, rhs);  // +Infinity -> self
+        }
+       else decNaNs(res, rhs, NULL, set, status); // a NaN
+      break;}
+
+    if (ISZERO(rhs)) {                  // +/- zeros -> -Infinity
+      decNumberZero(res);               // make clean
+      res->bits=DECINF|DECNEG;          // set - infinity
+      break;}                           // [no status to set]
+
+    // Non-zero negatives are bad...
+    if (decNumberIsNegative(rhs)) {     // -x -> error
+      *status|=DEC_Invalid_operation;
+      break;}
+
+    // Here, rhs is positive, finite, and in range
+
+    // lookaside fastpath code for ln(2) and ln(10) at common lengths
+    if (rhs->exponent==0 && set->digits<=40) {
+      #if DECDPUN==1
+      if (rhs->lsu[0]==0 && rhs->lsu[1]==1 && rhs->digits==2) { // ln(10)
+      #else
+      if (rhs->lsu[0]==10 && rhs->digits==2) {                  // ln(10)
+      #endif
+        aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
+        #define LN10 "2.302585092994045684017991454684364207601"
+        decNumberFromString(res, LN10, &aset);
+        *status|=(DEC_Inexact | DEC_Rounded); // is inexact
+        break;}
+      if (rhs->lsu[0]==2 && rhs->digits==1) { // ln(2)
+        aset=*set; aset.round=DEC_ROUND_HALF_EVEN;
+        #define LN2 "0.6931471805599453094172321214581765680755"
+        decNumberFromString(res, LN2, &aset);
+        *status|=(DEC_Inexact | DEC_Rounded);
+        break;}
+      } // integer and short
+
+    // Determine the working precision.  This is normally the
+    // requested precision + 2, with a minimum of 9.  However, if
+    // the rhs is 'over-precise' then allow for all its digits to
+    // potentially participate (consider an rhs where all the excess
+    // digits are 9s) so in this case use rhs->digits+2.
+    p=MAXI(rhs->digits, MAXI(set->digits, 7))+2;
+
+    // Allocate space for the accumulator and the high-precision
+    // adjustment calculator, if necessary.  The accumulator must
+    // be able to hold p digits, and the adjustment up to
+    // rhs->digits+p digits.  They are also made big enough for 16
+    // digits so that they can be used for calculating the initial
+    // estimate.
+    needbytes=sizeof(decNumber)+(D2U(MAXI(p,16))-1)*sizeof(Unit);
+    if (needbytes>sizeof(bufa)) {     // need malloc space
+      allocbufa=(decNumber *)malloc(needbytes);
+      if (allocbufa==NULL) {          // hopeless -- abandon
+        *status|=DEC_Insufficient_storage;
+        break;}
+      a=allocbufa;                    // use the allocated space
+      }
+    pp=p+rhs->digits;
+    needbytes=sizeof(decNumber)+(D2U(MAXI(pp,16))-1)*sizeof(Unit);
+    if (needbytes>sizeof(bufb)) {     // need malloc space
+      allocbufb=(decNumber *)malloc(needbytes);
+      if (allocbufb==NULL) {          // hopeless -- abandon
+        *status|=DEC_Insufficient_storage;
+        break;}
+      b=allocbufb;                    // use the allocated space
+      }
+
+    // Prepare an initial estimate in acc. Calculate this by
+    // considering the coefficient of x to be a normalized fraction,
+    // f, with the decimal point at far left and multiplied by
+    // 10**r.  Then, rhs=f*10**r and 0.1<=f<1, and
+    //   ln(x) = ln(f) + ln(10)*r
+    // Get the initial estimate for ln(f) from a small lookup
+    // table (see above) indexed by the first two digits of f,
+    // truncated.
+
+    decContextDefault(&aset, DEC_INIT_DECIMAL64); // 16-digit extended
+    r=rhs->exponent+rhs->digits;        // 'normalised' exponent
+    decNumberFromInt32(a, r);           // a=r
+    decNumberFromInt32(b, 2302585);     // b=ln(10) (2.302585)
+    b->exponent=-6;                     //  ..
+    decMultiplyOp(a, a, b, &aset, &ignore);  // a=a*b
+    // now get top two digits of rhs into b by simple truncate and
+    // force to integer
+    residue=0;                          // (no residue)
+    aset.digits=2; aset.round=DEC_ROUND_DOWN;
+    decCopyFit(b, rhs, &aset, &residue, &ignore); // copy & shorten
+    b->exponent=0;                      // make integer
+    t=decGetInt(b);                     // [cannot fail]
+    if (t<10) t=X10(t);                 // adjust single-digit b
+    t=LNnn[t-10];                       // look up ln(b)
+    decNumberFromInt32(b, t>>2);        // b=ln(b) coefficient
+    b->exponent=-(t&3)-3;               // set exponent
+    b->bits=DECNEG;                     // ln(0.10)->ln(0.99) always -ve
+    aset.digits=16; aset.round=DEC_ROUND_HALF_EVEN; // restore
+    decAddOp(a, a, b, &aset, 0, &ignore); // acc=a+b
+    // the initial estimate is now in a, with up to 4 digits correct.
+    // When rhs is at or near Nmax the estimate will be low, so we
+    // will approach it from below, avoiding overflow when calling exp.
+
+    decNumberZero(&numone); *numone.lsu=1;   // constant 1 for adjustment
+
+    // accumulator bounds are as requested (could underflow, but
+    // cannot overflow)
+    aset.emax=set->emax;
+    aset.emin=set->emin;
+    aset.clamp=0;                       // no concrete format
+    // set up a context to be used for the multiply and subtract
+    bset=aset;
+    bset.emax=DEC_MAX_MATH*2;           // use double bounds for the
+    bset.emin=-DEC_MAX_MATH*2;          // adjustment calculation
+                                        // [see decExpOp call below]
+    // for each iteration double the number of digits to calculate,
+    // up to a maximum of p
+    pp=9;                               // initial precision
+    // [initially 9 as then the sequence starts 7+2, 16+2, and
+    // 34+2, which is ideal for standard-sized numbers]
+    aset.digits=pp;                     // working context
+    bset.digits=pp+rhs->digits;         // wider context
+    for (;;) {                          // iterate
+      #if DECCHECK
+      iterations++;
+      if (iterations>24) break;         // consider 9 * 2**24
+      #endif
+      // calculate the adjustment (exp(-a)*x-1) into b.  This is a
+      // catastrophic subtraction but it really is the difference
+      // from 1 that is of interest.
+      // Use the internal entry point to Exp as it allows the double
+      // range for calculating exp(-a) when a is the tiniest subnormal.
+      a->bits^=DECNEG;                  // make -a
+      decExpOp(b, a, &bset, &ignore);   // b=exp(-a)
+      a->bits^=DECNEG;                  // restore sign of a
+      // now multiply by rhs and subtract 1, at the wider precision
+      decMultiplyOp(b, b, rhs, &bset, &ignore);        // b=b*rhs
+      decAddOp(b, b, &numone, &bset, DECNEG, &ignore); // b=b-1
+
+      // the iteration ends when the adjustment cannot affect the
+      // result by >=0.5 ulp (at the requested digits), which
+      // is when its value is smaller than the accumulator by
+      // set->digits+1 digits (or it is zero) -- this is a looser
+      // requirement than for Exp because all that happens to the
+      // accumulator after this is the final rounding (but note that
+      // there must also be full precision in a, or a=0).
+
+      if (decNumberIsZero(b) ||
+          (a->digits+a->exponent)>=(b->digits+b->exponent+set->digits+1)) {
+        if (a->digits==p) break;
+        if (decNumberIsZero(a)) {
+          decCompareOp(&cmp, rhs, &numone, &aset, COMPARE, &ignore); // rhs=1 ?
+          if (cmp.lsu[0]==0) a->exponent=0;            // yes, exact 0
+           else *status|=(DEC_Inexact | DEC_Rounded);  // no, inexact
+          break;
+          }
+        // force padding if adjustment has gone to 0 before full length
+        if (decNumberIsZero(b)) b->exponent=a->exponent-p;
+        }
+
+      // not done yet ...
+      decAddOp(a, a, b, &aset, 0, &ignore);  // a=a+b for next estimate
+      if (pp==p) continue;                   // precision is at maximum
+      // lengthen the next calculation
+      pp=pp*2;                               // double precision
+      if (pp>p) pp=p;                        // clamp to maximum
+      aset.digits=pp;                        // working context
+      bset.digits=pp+rhs->digits;            // wider context
+      } // Newton's iteration
+
+    #if DECCHECK
+    // just a sanity check; remove the test to show always
+    if (iterations>24)
+      printf("Ln iterations=%ld, status=%08lx, p=%ld, d=%ld\n",
+            (LI)iterations, (LI)*status, (LI)p, (LI)rhs->digits);
+    #endif
+
+    // Copy and round the result to res
+    residue=1;                          // indicate dirt to right
+    if (ISZERO(a)) residue=0;           // .. unless underflowed to 0
+    aset.digits=set->digits;            // [use default rounding]
+    decCopyFit(res, a, &aset, &residue, status); // copy & shorten
+    decFinish(res, set, &residue, status);       // cleanup/set flags
+    } while(0);                         // end protected
+
+  if (allocbufa!=NULL) free(allocbufa); // drop any storage used
+  if (allocbufb!=NULL) free(allocbufb); // ..
+  // [status is handled by caller]
+  return res;
+  } // decLnOp
+
+/* ------------------------------------------------------------------ */
+/* decQuantizeOp  -- force exponent to requested value                */
+/*                                                                    */
+/*   This computes C = op(A, B), where op adjusts the coefficient     */
+/*   of C (by rounding or shifting) such that the exponent (-scale)   */
+/*   of C has the value B or matches the exponent of B.               */
+/*   The numerical value of C will equal A, except for the effects of */
+/*   any rounding that occurred.                                      */
+/*                                                                    */
+/*   res is C, the result.  C may be A or B                           */
+/*   lhs is A, the number to adjust                                   */
+/*   rhs is B, the requested exponent                                 */
+/*   set is the context                                               */
+/*   quant is 1 for quantize or 0 for rescale                         */
+/*   status is the status accumulator (this can be called without     */
+/*          risk of control loss)                                     */
+/*                                                                    */
+/* C must have space for set->digits digits.                          */
+/*                                                                    */
+/* Unless there is an error or the result is infinite, the exponent   */
+/* after the operation is guaranteed to be that requested.            */
+/* ------------------------------------------------------------------ */
+static decNumber * decQuantizeOp(decNumber *res, const decNumber *lhs,
+                                 const decNumber *rhs, decContext *set,
+                                 Flag quant, uInt *status) {
+  #if DECSUBSET
+  decNumber *alloclhs=NULL;        // non-NULL if rounded lhs allocated
+  decNumber *allocrhs=NULL;        // .., rhs
+  #endif
+  const decNumber *inrhs=rhs;      // save original rhs
+  Int   reqdigits=set->digits;     // requested DIGITS
+  Int   reqexp;                    // requested exponent [-scale]
+  Int   residue=0;                 // rounding residue
+  Int   etiny=set->emin-(reqdigits-1);
+
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  #endif
+
+  do {                             // protect allocated storage
+    #if DECSUBSET
+    if (!set->extended) {
+      // reduce operands and set lostDigits status, as needed
+      if (lhs->digits>reqdigits) {
+        alloclhs=decRoundOperand(lhs, set, status);
+        if (alloclhs==NULL) break;
+        lhs=alloclhs;
+        }
+      if (rhs->digits>reqdigits) { // [this only checks lostDigits]
+        allocrhs=decRoundOperand(rhs, set, status);
+        if (allocrhs==NULL) break;
+        rhs=allocrhs;
+        }
+      }
+    #endif
+    // [following code does not require input rounding]
+
+    // Handle special values
+    if (SPECIALARGS) {
+      // NaNs get usual processing
+      if (SPECIALARGS & (DECSNAN | DECNAN))
+        decNaNs(res, lhs, rhs, set, status);
+      // one infinity but not both is bad
+      else if ((lhs->bits ^ rhs->bits) & DECINF)
+        *status|=DEC_Invalid_operation;
+      // both infinity: return lhs
+      else decNumberCopy(res, lhs);          // [nop if in place]
+      break;
+      }
+
+    // set requested exponent
+    if (quant) reqexp=inrhs->exponent;  // quantize -- match exponents
+     else {                             // rescale -- use value of rhs
+      // Original rhs must be an integer that fits and is in range,
+      // which could be from -1999999997 to +999999999, thanks to
+      // subnormals
+      reqexp=decGetInt(inrhs);               // [cannot fail]
+      }
+
+    #if DECSUBSET
+    if (!set->extended) etiny=set->emin;     // no subnormals
+    #endif
+
+    if (reqexp==BADINT                       // bad (rescale only) or ..
+     || reqexp==BIGODD || reqexp==BIGEVEN    // very big (ditto) or ..
+     || (reqexp<etiny)                       // < lowest
+     || (reqexp>set->emax)) {                // > emax
+      *status|=DEC_Invalid_operation;
+      break;}
+
+    // the RHS has been processed, so it can be overwritten now if necessary
+    if (ISZERO(lhs)) {                       // zero coefficient unchanged
+      decNumberCopy(res, lhs);               // [nop if in place]
+      res->exponent=reqexp;                  // .. just set exponent
+      #if DECSUBSET
+      if (!set->extended) res->bits=0;       // subset specification; no -0
+      #endif
+      }
+     else {                                  // non-zero lhs
+      Int adjust=reqexp-lhs->exponent;       // digit adjustment needed
+      // if adjusted coefficient will definitely not fit, give up now
+      if ((lhs->digits-adjust)>reqdigits) {
+        *status|=DEC_Invalid_operation;
+        break;
+        }
+
+      if (adjust>0) {                        // increasing exponent
+        // this will decrease the length of the coefficient by adjust
+        // digits, and must round as it does so
+        decContext workset;                  // work
+        workset=*set;                        // clone rounding, etc.
+        workset.digits=lhs->digits-adjust;   // set requested length
+        // [note that the latter can be <1, here]
+        decCopyFit(res, lhs, &workset, &residue, status); // fit to result
+        decApplyRound(res, &workset, residue, status);    // .. and round
+        residue=0;                                        // [used]
+        // If just rounded a 999s case, exponent will be off by one;
+        // adjust back (after checking space), if so.
+        if (res->exponent>reqexp) {
+          // re-check needed, e.g., for quantize(0.9999, 0.001) under
+          // set->digits==3
+          if (res->digits==reqdigits) {      // cannot shift by 1
+            *status&=~(DEC_Inexact | DEC_Rounded); // [clean these]
+            *status|=DEC_Invalid_operation;
+            break;
+            }
+          res->digits=decShiftToMost(res->lsu, res->digits, 1); // shift
+          res->exponent--;                   // (re)adjust the exponent.
+          }
+        #if DECSUBSET
+        if (ISZERO(res) && !set->extended) res->bits=0; // subset; no -0
+        #endif
+        } // increase
+       else /* adjust<=0 */ {                // decreasing or = exponent
+        // this will increase the length of the coefficient by -adjust
+        // digits, by adding zero or more trailing zeros; this is
+        // already checked for fit, above
+        decNumberCopy(res, lhs);             // [it will fit]
+        // if padding needed (adjust<0), add it now...
+        if (adjust<0) {
+          res->digits=decShiftToMost(res->lsu, res->digits, -adjust);
+          res->exponent+=adjust;             // adjust the exponent
+          }
+        } // decrease
+      } // non-zero
+
+    // Check for overflow [do not use Finalize in this case, as an
+    // overflow here is a "don't fit" situation]
+    if (res->exponent>set->emax-res->digits+1) {  // too big
+      *status|=DEC_Invalid_operation;
+      break;
+      }
+     else {
+      decFinalize(res, set, &residue, status);    // set subnormal flags
+      *status&=~DEC_Underflow;          // suppress Underflow [as per 754]
+      }
+    } while(0);                         // end protected
+
+  #if DECSUBSET
+  if (allocrhs!=NULL) free(allocrhs);   // drop any storage used
+  if (alloclhs!=NULL) free(alloclhs);   // ..
+  #endif
+  return res;
+  } // decQuantizeOp
+
+/* ------------------------------------------------------------------ */
+/* decCompareOp -- compare, min, or max two Numbers                   */
+/*                                                                    */
+/*   This computes C = A ? B and carries out one of four operations:  */
+/*     COMPARE    -- returns the signum (as a number) giving the      */
+/*                   result of a comparison unless one or both        */
+/*                   operands is a NaN (in which case a NaN results)  */
+/*     COMPSIG    -- as COMPARE except that a quiet NaN raises        */
+/*                   Invalid operation.                               */
+/*     COMPMAX    -- returns the larger of the operands, using the    */
+/*                   754 maxnum operation                             */
+/*     COMPMAXMAG -- ditto, comparing absolute values                 */
+/*     COMPMIN    -- the 754 minnum operation                         */
+/*     COMPMINMAG -- ditto, comparing absolute values                 */
+/*     COMTOTAL   -- returns the signum (as a number) giving the      */
+/*                   result of a comparison using 754 total ordering  */
+/*                                                                    */
+/*   res is C, the result.  C may be A and/or B (e.g., X=X?X)         */
+/*   lhs is A                                                         */
+/*   rhs is B                                                         */
+/*   set is the context                                               */
+/*   op  is the operation flag                                        */
+/*   status is the usual accumulator                                  */
+/*                                                                    */
+/* C must have space for one digit for COMPARE or set->digits for     */
+/* COMPMAX, COMPMIN, COMPMAXMAG, or COMPMINMAG.                       */
+/* ------------------------------------------------------------------ */
+/* The emphasis here is on speed for common cases, and avoiding       */
+/* coefficient comparison if possible.                                */
+/* ------------------------------------------------------------------ */
+decNumber * decCompareOp(decNumber *res, const decNumber *lhs,
+                         const decNumber *rhs, decContext *set,
+                         Flag op, uInt *status) {
+  #if DECSUBSET
+  decNumber *alloclhs=NULL;        // non-NULL if rounded lhs allocated
+  decNumber *allocrhs=NULL;        // .., rhs
+  #endif
+  Int   result=0;                  // default result value
+  uByte merged;                    // work
+
+  #if DECCHECK
+  if (decCheckOperands(res, lhs, rhs, set)) return res;
+  #endif
+
+  do {                             // protect allocated storage
+    #if DECSUBSET
+    if (!set->extended) {
+      // reduce operands and set lostDigits status, as needed
+      if (lhs->digits>set->digits) {
+        alloclhs=decRoundOperand(lhs, set, status);
+        if (alloclhs==NULL) {result=BADINT; break;}
+        lhs=alloclhs;
+        }
+      if (rhs->digits>set->digits) {
+        allocrhs=decRoundOperand(rhs, set, status);
+        if (allocrhs==NULL) {result=BADINT; break;}
+        rhs=allocrhs;
+        }
+      }
+    #endif
+    // [following code does not require input rounding]
+
+    // If total ordering then handle differing signs 'up front'
+    if (op==COMPTOTAL) {                // total ordering
+      if (decNumberIsNegative(lhs) & !decNumberIsNegative(rhs)) {
+        result=-1;
+        break;
+        }
+      if (!decNumberIsNegative(lhs) & decNumberIsNegative(rhs)) {
+        result=+1;
+        break;
+        }
+      }
+
+    // handle NaNs specially; let infinities drop through
+    // This assumes sNaN (even just one) leads to NaN.
+    merged=(lhs->bits | rhs->bits) & (DECSNAN | DECNAN);
+    if (merged) {                       // a NaN bit set
+      if (op==COMPARE);                 // result will be NaN
+       else if (op==COMPSIG)            // treat qNaN as sNaN
+        *status|=DEC_Invalid_operation | DEC_sNaN;
+       else if (op==COMPTOTAL) {        // total ordering, always finite
+        // signs are known to be the same; compute the ordering here
+        // as if the signs are both positive, then invert for negatives
+        if (!decNumberIsNaN(lhs)) result=-1;
+         else if (!decNumberIsNaN(rhs)) result=+1;
+         // here if both NaNs
+         else if (decNumberIsSNaN(lhs) && decNumberIsQNaN(rhs)) result=-1;
+         else if (decNumberIsQNaN(lhs) && decNumberIsSNaN(rhs)) result=+1;
+         else { // both NaN or both sNaN
+          // now it just depends on the payload
+          result=decUnitCompare(lhs->lsu, D2U(lhs->digits),
+                                rhs->lsu, D2U(rhs->digits), 0);
+          // [Error not possible, as these are 'aligned']
+          } // both same NaNs
+        if (decNumberIsNegative(lhs)) result=-result;
+        break;
+        } // total order
+
+       else if (merged & DECSNAN);           // sNaN -> qNaN
+       else { // here if MIN or MAX and one or two quiet NaNs
+        // min or max -- 754 rules ignore single NaN
+        if (!decNumberIsNaN(lhs) || !decNumberIsNaN(rhs)) {
+          // just one NaN; force choice to be the non-NaN operand
+          op=COMPMAX;
+          if (lhs->bits & DECNAN) result=-1; // pick rhs
+                             else result=+1; // pick lhs
+          break;
+          }
+        } // max or min
+      op=COMPNAN;                            // use special path
+      decNaNs(res, lhs, rhs, set, status);   // propagate NaN
+      break;
+      }
+    // have numbers
+    if (op==COMPMAXMAG || op==COMPMINMAG) result=decCompare(lhs, rhs, 1);
+     else result=decCompare(lhs, rhs, 0);    // sign matters
+    } while(0);                              // end protected
+
+  if (result==BADINT) *status|=DEC_Insufficient_storage; // rare
+   else {
+    if (op==COMPARE || op==COMPSIG ||op==COMPTOTAL) { // returning signum
+      if (op==COMPTOTAL && result==0) {
+        // operands are numerically equal or same NaN (and same sign,
+        // tested first); if identical, leave result 0
+        if (lhs->exponent!=rhs->exponent) {
+          if (lhs->exponent<rhs->exponent) result=-1;
+           else result=+1;
+          if (decNumberIsNegative(lhs)) result=-result;
+          } // lexp!=rexp
+        } // total-order by exponent
+      decNumberZero(res);               // [always a valid result]
+      if (result!=0) {                  // must be -1 or +1
+        *res->lsu=1;
+        if (result<0) res->bits=DECNEG;
+        }
+      }
+     else if (op==COMPNAN);             // special, drop through
+     else {                             // MAX or MIN, non-NaN result
+      Int residue=0;                    // rounding accumulator
+      // choose the operand for the result
+      const decNumber *choice;
+      if (result==0) { // operands are numerically equal
+        // choose according to sign then exponent (see 754)
+        uByte slhs=(lhs->bits & DECNEG);
+        uByte srhs=(rhs->bits & DECNEG);
+        #if DECSUBSET
+        if (!set->extended) {           // subset: force left-hand
+          op=COMPMAX;
+          result=+1;
+          }
+        else
+        #endif
+        if (slhs!=srhs) {          // signs differ
+          if (slhs) result=-1;     // rhs is max
+               else result=+1;     // lhs is max
+          }
+         else if (slhs && srhs) {  // both negative
+          if (lhs->exponent<rhs->exponent) result=+1;
+                                      else result=-1;
+          // [if equal, use lhs, technically identical]
+          }
+         else {                    // both positive
+          if (lhs->exponent>rhs->exponent) result=+1;
+                                      else result=-1;
+          // [ditto]
+          }
+        } // numerically equal
+      // here result will be non-0; reverse if looking for MIN
+      if (op==COMPMIN || op==COMPMINMAG) result=-result;
+      choice=(result>0 ? lhs : rhs);    // choose
+      // copy chosen to result, rounding if need be
+      decCopyFit(res, choice, set, &residue, status);
+      decFinish(res, set, &residue, status);
+      }
+    }
+  #if DECSUBSET
+  if (allocrhs!=NULL) free(allocrhs);   // free any storage used
+  if (alloclhs!=NULL) free(alloclhs);   // ..
+  #endif
+  return res;
+  } // decCompareOp
+
+/* ------------------------------------------------------------------ */
+/* decCompare -- compare two decNumbers by numerical value            */
+/*                                                                    */
+/*  This routine compares A ? B without altering them.                */
+/*                                                                    */
+/*  Arg1 is A, a decNumber which is not a NaN                         */
+/*  Arg2 is B, a decNumber which is not a NaN                         */
+/*  Arg3 is 1 for a sign-independent compare, 0 otherwise             */
+/*                                                                    */
+/*  returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure   */
+/*  (the only possible failure is an allocation error)                */
+/* ------------------------------------------------------------------ */
+static Int decCompare(const decNumber *lhs, const decNumber *rhs,
+                      Flag abs) {
+  Int   result;                    // result value
+  Int   sigr;                      // rhs signum
+  Int   compare;                   // work
+
+  result=1;                                  // assume signum(lhs)
+  if (ISZERO(lhs)) result=0;
+  if (abs) {
+    if (ISZERO(rhs)) return result;          // LHS wins or both 0
+    // RHS is non-zero
+    if (result==0) return -1;                // LHS is 0; RHS wins
+    // [here, both non-zero, result=1]
+    }
+   else {                                    // signs matter
+    if (result && decNumberIsNegative(lhs)) result=-1;
+    sigr=1;                                  // compute signum(rhs)
+    if (ISZERO(rhs)) sigr=0;
+     else if (decNumberIsNegative(rhs)) sigr=-1;
+    if (result > sigr) return +1;            // L > R, return 1
+    if (result < sigr) return -1;            // L < R, return -1
+    if (result==0) return 0;                   // both 0
+    }
+
+  // signums are the same; both are non-zero
+  if ((lhs->bits | rhs->bits) & DECINF) {    // one or more infinities
+    if (decNumberIsInfinite(rhs)) {
+      if (decNumberIsInfinite(lhs)) result=0;// both infinite
+       else result=-result;                  // only rhs infinite
+      }
+    return result;
+    }
+  // must compare the coefficients, allowing for exponents
+  if (lhs->exponent>rhs->exponent) {         // LHS exponent larger
+    // swap sides, and sign
+    const decNumber *temp=lhs;
+    lhs=rhs;
+    rhs=temp;
+    result=-result;
+    }
+  compare=decUnitCompare(lhs->lsu, D2U(lhs->digits),
+                         rhs->lsu, D2U(rhs->digits),
+                         rhs->exponent-lhs->exponent);
+  if (compare!=BADINT) compare*=result;      // comparison succeeded
+  return compare;
+  } // decCompare
+
+/* ------------------------------------------------------------------ */
+/* decUnitCompare -- compare two >=0 integers in Unit arrays          */
+/*                                                                    */
+/*  This routine compares A ? B*10**E where A and B are unit arrays   */
+/*  A is a plain integer                                              */
+/*  B has an exponent of E (which must be non-negative)               */
+/*                                                                    */
+/*  Arg1 is A first Unit (lsu)                                        */
+/*  Arg2 is A length in Units                                         */
+/*  Arg3 is B first Unit (lsu)                                        */
+/*  Arg4 is B length in Units                                         */
+/*  Arg5 is E (0 if the units are aligned)                            */
+/*                                                                    */
+/*  returns -1, 0, or 1 for A<B, A==B, or A>B, or BADINT if failure   */
+/*  (the only possible failure is an allocation error, which can      */
+/*  only occur if E!=0)                                               */
+/* ------------------------------------------------------------------ */
+static Int decUnitCompare(const Unit *a, Int alength,
+                          const Unit *b, Int blength, Int exp) {
+  Unit  *acc;                      // accumulator for result
+  Unit  accbuff[SD2U(DECBUFFER*2+1)]; // local buffer
+  Unit  *allocacc=NULL;            // -> allocated acc buffer, iff allocated
+  Int   accunits, need;            // units in use or needed for acc
+  const Unit *l, *r, *u;           // work
+  Int   expunits, exprem, result;  // ..
+
+  if (exp==0) {                    // aligned; fastpath
+    if (alength>blength) return 1;
+    if (alength<blength) return -1;
+    // same number of units in both -- need unit-by-unit compare
+    l=a+alength-1;
+    r=b+alength-1;
+    for (;l>=a; l--, r--) {
+      if (*l>*r) return 1;
+      if (*l<*r) return -1;
+      }
+    return 0;                      // all units match
+    } // aligned
+
+  // Unaligned.  If one is >1 unit longer than the other, padded
+  // approximately, then can return easily
+  if (alength>blength+(Int)D2U(exp)) return 1;
+  if (alength+1<blength+(Int)D2U(exp)) return -1;
+
+  // Need to do a real subtract.  For this, a result buffer is needed
+  // even though only the sign is of interest.  Its length needs
+  // to be the larger of alength and padded blength, +2
+  need=blength+D2U(exp);                // maximum real length of B
+  if (need<alength) need=alength;
+  need+=2;
+  acc=accbuff;                          // assume use local buffer
+  if (need*sizeof(Unit)>sizeof(accbuff)) {
+    allocacc=(Unit *)malloc(need*sizeof(Unit));
+    if (allocacc==NULL) return BADINT;  // hopeless -- abandon
+    acc=allocacc;
+    }
+  // Calculate units and remainder from exponent.
+  expunits=exp/DECDPUN;
+  exprem=exp%DECDPUN;
+  // subtract [A+B*(-m)]
+  accunits=decUnitAddSub(a, alength, b, blength, expunits, acc,
+                         -(Int)powers[exprem]);
+  // [UnitAddSub result may have leading zeros, even on zero]
+  if (accunits<0) result=-1;            // negative result
+   else {                               // non-negative result
+    // check units of the result before freeing any storage
+    for (u=acc; u<acc+accunits-1 && *u==0;) u++;
+    result=(*u==0 ? 0 : +1);
+    }
+  // clean up and return the result
+  if (allocacc!=NULL) free(allocacc);   // drop any storage used
+  return result;
+  } // decUnitCompare
+
+/* ------------------------------------------------------------------ */
+/* decUnitAddSub -- add or subtract two >=0 integers in Unit arrays   */
+/*                                                                    */
+/*  This routine performs the calculation:                            */
+/*                                                                    */
+/*  C=A+(B*M)                                                         */
+/*                                                                    */
+/*  Where M is in the range -DECDPUNMAX through +DECDPUNMAX.          */
+/*                                                                    */
+/*  A may be shorter or longer than B.                                */
+/*                                                                    */
+/*  Leading zeros are not removed after a calculation.  The result is */
+/*  either the same length as the longer of A and B (adding any       */
+/*  shift), or one Unit longer than that (if a Unit carry occurred).  */
+/*                                                                    */
+/*  A and B content are not altered unless C is also A or B.          */
+/*  C may be the same array as A or B, but only if no zero padding is */
+/*  requested (that is, C may be B only if bshift==0).                */
+/*  C is filled from the lsu; only those units necessary to complete  */
+/*  the calculation are referenced.                                   */
+/*                                                                    */
+/*  Arg1 is A first Unit (lsu)                                        */
+/*  Arg2 is A length in Units                                         */
+/*  Arg3 is B first Unit (lsu)                                        */
+/*  Arg4 is B length in Units                                         */
+/*  Arg5 is B shift in Units  (>=0; pads with 0 units if positive)    */
+/*  Arg6 is C first Unit (lsu)                                        */
+/*  Arg7 is M, the multiplier                                         */
+/*                                                                    */
+/*  returns the count of Units written to C, which will be non-zero   */
+/*  and negated if the result is negative.  That is, the sign of the  */
+/*  returned Int is the sign of the result (positive for zero) and    */
+/*  the absolute value of the Int is the count of Units.              */
+/*                                                                    */
+/*  It is the caller's responsibility to make sure that C size is     */
+/*  safe, allowing space if necessary for a one-Unit carry.           */
+/*                                                                    */
+/*  This routine is severely performance-critical; *any* change here  */
+/*  must be measured (timed) to assure no performance degradation.    */
+/*  In particular, trickery here tends to be counter-productive, as   */
+/*  increased complexity of code hurts register optimizations on      */
+/*  register-poor architectures.  Avoiding divisions is nearly        */
+/*  always a Good Idea, however.                                      */
+/*                                                                    */
+/* Special thanks to Rick McGuire (IBM Cambridge, MA) and Dave Clark  */
+/* (IBM Warwick, UK) for some of the ideas used in this routine.      */
+/* ------------------------------------------------------------------ */
+static Int decUnitAddSub(const Unit *a, Int alength,
+                         const Unit *b, Int blength, Int bshift,
+                         Unit *c, Int m) {
+  const Unit *alsu=a;              // A lsu [need to remember it]
+  Unit *clsu=c;                    // C ditto
+  Unit *minC;                      // low water mark for C
+  Unit *maxC;                      // high water mark for C
+  eInt carry=0;                    // carry integer (could be Long)
+  Int  add;                        // work
+  #if DECDPUN<=4                   // myriadal, millenary, etc.
+  Int  est;                        // estimated quotient
+  #endif
+
+  #if DECTRACE
+  if (alength<1 || blength<1)
+    printf("decUnitAddSub: alen blen m %ld %ld [%ld]\n", alength, blength, m);
+  #endif
+
+  maxC=c+alength;                  // A is usually the longer
+  minC=c+blength;                  // .. and B the shorter
+  if (bshift!=0) {                 // B is shifted; low As copy across
+    minC+=bshift;
+    // if in place [common], skip copy unless there's a gap [rare]
+    if (a==c && bshift<=alength) {
+      c+=bshift;
+      a+=bshift;
+      }
+     else for (; c<clsu+bshift; a++, c++) {  // copy needed
+      if (a<alsu+alength) *c=*a;
+       else *c=0;
+      }
+    }
+  if (minC>maxC) { // swap
+    Unit *hold=minC;
+    minC=maxC;
+    maxC=hold;
+    }
+
+  // For speed, do the addition as two loops; the first where both A
+  // and B contribute, and the second (if necessary) where only one or
+  // other of the numbers contribute.
+  // Carry handling is the same (i.e., duplicated) in each case.
+  for (; c<minC; c++) {
+    carry+=*a;
+    a++;
+    carry+=((eInt)*b)*m;                // [special-casing m=1/-1
+    b++;                                // here is not a win]
+    // here carry is new Unit of digits; it could be +ve or -ve
+    if ((ueInt)carry<=DECDPUNMAX) {     // fastpath 0-DECDPUNMAX
+      *c=(Unit)carry;
+      carry=0;
+      continue;
+      }
+    #if DECDPUN==4                           // use divide-by-multiply
+      if (carry>=0) {
+        est=(((ueInt)carry>>11)*53687)>>18;
+        *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder
+        carry=est;                           // likely quotient [89%]
+        if (*c<DECDPUNMAX+1) continue;       // estimate was correct
+        carry++;
+        *c-=DECDPUNMAX+1;
+        continue;
+        }
+      // negative case
+      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
+      est=(((ueInt)carry>>11)*53687)>>18;
+      *c=(Unit)(carry-est*(DECDPUNMAX+1));
+      carry=est-(DECDPUNMAX+1);              // correctly negative
+      if (*c<DECDPUNMAX+1) continue;         // was OK
+      carry++;
+      *c-=DECDPUNMAX+1;
+    #elif DECDPUN==3
+      if (carry>=0) {
+        est=(((ueInt)carry>>3)*16777)>>21;
+        *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder
+        carry=est;                           // likely quotient [99%]
+        if (*c<DECDPUNMAX+1) continue;       // estimate was correct
+        carry++;
+        *c-=DECDPUNMAX+1;
+        continue;
+        }
+      // negative case
+      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
+      est=(((ueInt)carry>>3)*16777)>>21;
+      *c=(Unit)(carry-est*(DECDPUNMAX+1));
+      carry=est-(DECDPUNMAX+1);              // correctly negative
+      if (*c<DECDPUNMAX+1) continue;         // was OK
+      carry++;
+      *c-=DECDPUNMAX+1;
+    #elif DECDPUN<=2
+      // Can use QUOT10 as carry <= 4 digits
+      if (carry>=0) {
+        est=QUOT10(carry, DECDPUN);
+        *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder
+        carry=est;                           // quotient
+        continue;
+        }
+      // negative case
+      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
+      est=QUOT10(carry, DECDPUN);
+      *c=(Unit)(carry-est*(DECDPUNMAX+1));
+      carry=est-(DECDPUNMAX+1);              // correctly negative
+    #else
+      // remainder operator is undefined if negative, so must test
+      if ((ueInt)carry<(DECDPUNMAX+1)*2) {   // fastpath carry +1
+        *c=(Unit)(carry-(DECDPUNMAX+1));     // [helps additions]
+        carry=1;
+        continue;
+        }
+      if (carry>=0) {
+        *c=(Unit)(carry%(DECDPUNMAX+1));
+        carry=carry/(DECDPUNMAX+1);
+        continue;
+        }
+      // negative case
+      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
+      *c=(Unit)(carry%(DECDPUNMAX+1));
+      carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
+    #endif
+    } // c
+
+  // now may have one or other to complete
+  // [pretest to avoid loop setup/shutdown]
+  if (c<maxC) for (; c<maxC; c++) {
+    if (a<alsu+alength) {               // still in A
+      carry+=*a;
+      a++;
+      }
+     else {                             // inside B
+      carry+=((eInt)*b)*m;
+      b++;
+      }
+    // here carry is new Unit of digits; it could be +ve or -ve and
+    // magnitude up to DECDPUNMAX squared
+    if ((ueInt)carry<=DECDPUNMAX) {     // fastpath 0-DECDPUNMAX
+      *c=(Unit)carry;
+      carry=0;
+      continue;
+      }
+    // result for this unit is negative or >DECDPUNMAX
+    #if DECDPUN==4                           // use divide-by-multiply
+      if (carry>=0) {
+        est=(((ueInt)carry>>11)*53687)>>18;
+        *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder
+        carry=est;                           // likely quotient [79.7%]
+        if (*c<DECDPUNMAX+1) continue;       // estimate was correct
+        carry++;
+        *c-=DECDPUNMAX+1;
+        continue;
+        }
+      // negative case
+      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
+      est=(((ueInt)carry>>11)*53687)>>18;
+      *c=(Unit)(carry-est*(DECDPUNMAX+1));
+      carry=est-(DECDPUNMAX+1);              // correctly negative
+      if (*c<DECDPUNMAX+1) continue;         // was OK
+      carry++;
+      *c-=DECDPUNMAX+1;
+    #elif DECDPUN==3
+      if (carry>=0) {
+        est=(((ueInt)carry>>3)*16777)>>21;
+        *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder
+        carry=est;                           // likely quotient [99%]
+        if (*c<DECDPUNMAX+1) continue;       // estimate was correct
+        carry++;
+        *c-=DECDPUNMAX+1;
+        continue;
+        }
+      // negative case
+      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
+      est=(((ueInt)carry>>3)*16777)>>21;
+      *c=(Unit)(carry-est*(DECDPUNMAX+1));
+      carry=est-(DECDPUNMAX+1);              // correctly negative
+      if (*c<DECDPUNMAX+1) continue;         // was OK
+      carry++;
+      *c-=DECDPUNMAX+1;
+    #elif DECDPUN<=2
+      if (carry>=0) {
+        est=QUOT10(carry, DECDPUN);
+        *c=(Unit)(carry-est*(DECDPUNMAX+1)); // remainder
+        carry=est;                           // quotient
+        continue;
+        }
+      // negative case
+      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
+      est=QUOT10(carry, DECDPUN);
+      *c=(Unit)(carry-est*(DECDPUNMAX+1));
+      carry=est-(DECDPUNMAX+1);              // correctly negative
+    #else
+      if ((ueInt)carry<(DECDPUNMAX+1)*2){    // fastpath carry 1
+        *c=(Unit)(carry-(DECDPUNMAX+1));
+        carry=1;
+        continue;
+        }
+      // remainder operator is undefined if negative, so must test
+      if (carry>=0) {
+        *c=(Unit)(carry%(DECDPUNMAX+1));
+        carry=carry/(DECDPUNMAX+1);
+        continue;
+        }
+      // negative case
+      carry=carry+(eInt)(DECDPUNMAX+1)*(DECDPUNMAX+1); // make positive
+      *c=(Unit)(carry%(DECDPUNMAX+1));
+      carry=carry/(DECDPUNMAX+1)-(DECDPUNMAX+1);
+    #endif
+    } // c
+
+  // OK, all A and B processed; might still have carry or borrow
+  // return number of Units in the result, negated if a borrow
+  if (carry==0) return c-clsu;     // no carry, so no more to do
+  if (carry>0) {                   // positive carry
+    *c=(Unit)carry;                // place as new unit
+    c++;                           // ..
+    return c-clsu;
+    }
+  // -ve carry: it's a borrow; complement needed
+  add=1;                           // temporary carry...
+  for (c=clsu; c<maxC; c++) {
+    add=DECDPUNMAX+add-*c;
+    if (add<=DECDPUNMAX) {
+      *c=(Unit)add;
+      add=0;
+      }
+     else {
+      *c=0;
+      add=1;
+      }
+    }
+  // add an extra unit iff it would be non-zero
+  #if DECTRACE
+    printf("UAS borrow: add %ld, carry %ld\n", add, carry);
+  #endif
+  if ((add-carry-1)!=0) {
+    *c=(Unit)(add-carry-1);
+    c++;                      // interesting, include it
+    }
+  return clsu-c;              // -ve result indicates borrowed
+  } // decUnitAddSub
+
+/* ------------------------------------------------------------------ */
+/* decTrim -- trim trailing zeros or normalize                        */
+/*                                                                    */
+/*   dn is the number to trim or normalize                            */
+/*   set is the context to use to check for clamp                     */
+/*   all is 1 to remove all trailing zeros, 0 for just fraction ones  */
+/*   noclamp is 1 to unconditional (unclamped) trim                   */
+/*   dropped returns the number of discarded trailing zeros           */
+/*   returns dn                                                       */
+/*                                                                    */
+/* If clamp is set in the context then the number of zeros trimmed    */
+/* may be limited if the exponent is high.                            */
+/* All fields are updated as required.  This is a utility operation,  */
+/* so special values are unchanged and no error is possible.          */
+/* ------------------------------------------------------------------ */
+static decNumber * decTrim(decNumber *dn, decContext *set, Flag all,
+                           Flag noclamp, Int *dropped) {
+  Int   d, exp;                    // work
+  uInt  cut;                       // ..
+  Unit  *up;                       // -> current Unit
+
+  #if DECCHECK
+  if (decCheckOperands(dn, DECUNUSED, DECUNUSED, DECUNCONT)) return dn;
+  #endif
+
+  *dropped=0;                           // assume no zeros dropped
+  if ((dn->bits & DECSPECIAL)           // fast exit if special ..
+    || (*dn->lsu & 0x01)) return dn;    // .. or odd
+  if (ISZERO(dn)) {                     // .. or 0
+    dn->exponent=0;                     // (sign is preserved)
+    return dn;
+    }
+
+  // have a finite number which is even
+  exp=dn->exponent;
+  cut=1;                           // digit (1-DECDPUN) in Unit
+  up=dn->lsu;                      // -> current Unit
+  for (d=0; d<dn->digits-1; d++) { // [don't strip the final digit]
+    // slice by powers
+    #if DECDPUN<=4
+      uInt quot=QUOT10(*up, cut);
+      if ((*up-quot*powers[cut])!=0) break;  // found non-0 digit
+    #else
+      if (*up%powers[cut]!=0) break;         // found non-0 digit
+    #endif
+    // have a trailing 0
+    if (!all) {                    // trimming
+      // [if exp>0 then all trailing 0s are significant for trim]
+      if (exp<=0) {                // if digit might be significant
+        if (exp==0) break;         // then quit
+        exp++;                     // next digit might be significant
+        }
+      }
+    cut++;                         // next power
+    if (cut>DECDPUN) {             // need new Unit
+      up++;
+      cut=1;
+      }
+    } // d
+  if (d==0) return dn;             // none to drop
+
+  // may need to limit drop if clamping
+  if (set->clamp && !noclamp) {
+    Int maxd=set->emax-set->digits+1-dn->exponent;
+    if (maxd<=0) return dn;        // nothing possible
+    if (d>maxd) d=maxd;
+    }
+
+  // effect the drop
+  decShiftToLeast(dn->lsu, D2U(dn->digits), d);
+  dn->exponent+=d;                 // maintain numerical value
+  dn->digits-=d;                   // new length
+  *dropped=d;                      // report the count
+  return dn;
+  } // decTrim
+
+/* ------------------------------------------------------------------ */
+/* decReverse -- reverse a Unit array in place                        */
+/*                                                                    */
+/*   ulo    is the start of the array                                 */
+/*   uhi    is the end of the array (highest Unit to include)         */
+/*                                                                    */
+/* The units ulo through uhi are reversed in place (if the number     */
+/* of units is odd, the middle one is untouched).  Note that the      */
+/* digit(s) in each unit are unaffected.                              */
+/* ------------------------------------------------------------------ */
+static void decReverse(Unit *ulo, Unit *uhi) {
+  Unit temp;
+  for (; ulo<uhi; ulo++, uhi--) {
+    temp=*ulo;
+    *ulo=*uhi;
+    *uhi=temp;
+    }
+  return;
+  } // decReverse
+
+/* ------------------------------------------------------------------ */
+/* decShiftToMost -- shift digits in array towards most significant   */
+/*                                                                    */
+/*   uar    is the array                                              */
+/*   digits is the count of digits in use in the array                */
+/*   shift  is the number of zeros to pad with (least significant);   */
+/*     it must be zero or positive                                    */
+/*                                                                    */
+/*   returns the new length of the integer in the array, in digits    */
+/*                                                                    */
+/* No overflow is permitted (that is, the uar array must be known to  */
+/* be large enough to hold the result, after shifting).               */
+/* ------------------------------------------------------------------ */
+static Int decShiftToMost(Unit *uar, Int digits, Int shift) {
+  Unit  *target, *source, *first;  // work
+  Int   cut;                       // odd 0's to add
+  uInt  next;                      // work
+
+  if (shift==0) return digits;     // [fastpath] nothing to do
+  if ((digits+shift)<=DECDPUN) {   // [fastpath] single-unit case
+    *uar=(Unit)(*uar*powers[shift]);
+    return digits+shift;
+    }
+
+  next=0;                          // all paths
+  source=uar+D2U(digits)-1;        // where msu comes from
+  target=source+D2U(shift);        // where upper part of first cut goes
+  cut=DECDPUN-MSUDIGITS(shift);    // where to slice
+  if (cut==0) {                    // unit-boundary case
+    for (; source>=uar; source--, target--) *target=*source;
+    }
+   else {
+    first=uar+D2U(digits+shift)-1; // where msu of source will end up
+    for (; source>=uar; source--, target--) {
+      // split the source Unit and accumulate remainder for next
+      #if DECDPUN<=4
+        uInt quot=QUOT10(*source, cut);
+        uInt rem=*source-quot*powers[cut];
+        next+=quot;
+      #else
+        uInt rem=*source%powers[cut];
+        next+=*source/powers[cut];
+      #endif
+      if (target<=first) *target=(Unit)next;   // write to target iff valid
+      next=rem*powers[DECDPUN-cut];            // save remainder for next Unit
+      }
+    } // shift-move
+
+  // propagate any partial unit to one below and clear the rest
+  for (; target>=uar; target--) {
+    *target=(Unit)next;
+    next=0;
+    }
+  return digits+shift;
+  } // decShiftToMost
+
+/* ------------------------------------------------------------------ */
+/* decShiftToLeast -- shift digits in array towards least significant */
+/*                                                                    */
+/*   uar   is the array                                               */
+/*   units is length of the array, in units                           */
+/*   shift is the number of digits to remove from the lsu end; it     */
+/*     must be zero or positive and <= than units*DECDPUN.            */
+/*                                                                    */
+/*   returns the new length of the integer in the array, in units     */
+/*                                                                    */
+/* Removed digits are discarded (lost).  Units not required to hold   */
+/* the final result are unchanged.                                    */
+/* ------------------------------------------------------------------ */
+static Int decShiftToLeast(Unit *uar, Int units, Int shift) {
+  Unit  *target, *up;              // work
+  Int   cut, count;                // work
+  Int   quot, rem;                 // for division
+
+  if (shift==0) return units;      // [fastpath] nothing to do
+  if (shift==units*DECDPUN) {      // [fastpath] little to do
+    *uar=0;                        // all digits cleared gives zero
+    return 1;                      // leaves just the one
+    }
+
+  target=uar;                      // both paths
+  cut=MSUDIGITS(shift);
+  if (cut==DECDPUN) {              // unit-boundary case; easy
+    up=uar+D2U(shift);
+    for (; up<uar+units; target++, up++) *target=*up;
+    return target-uar;
+    }
+
+  // messier
+  up=uar+D2U(shift-cut);           // source; correct to whole Units
+  count=units*DECDPUN-shift;       // the maximum new length
+  #if DECDPUN<=4
+    quot=QUOT10(*up, cut);
+  #else
+    quot=*up/powers[cut];
+  #endif
+  for (; ; target++) {
+    *target=(Unit)quot;
+    count-=(DECDPUN-cut);
+    if (count<=0) break;
+    up++;
+    quot=*up;
+    #if DECDPUN<=4
+      quot=QUOT10(quot, cut);
+      rem=*up-quot*powers[cut];
+    #else
+      rem=quot%powers[cut];
+      quot=quot/powers[cut];
+    #endif
+    *target=(Unit)(*target+rem*powers[DECDPUN-cut]);
+    count-=cut;
+    if (count<=0) break;
+    }
+  return target-uar+1;
+  } // decShiftToLeast
+
+#if DECSUBSET
+/* ------------------------------------------------------------------ */
+/* decRoundOperand -- round an operand  [used for subset only]        */
+/*                                                                    */
+/*   dn is the number to round (dn->digits is > set->digits)          */
+/*   set is the relevant context                                      */
+/*   status is the status accumulator                                 */
+/*                                                                    */
+/*   returns an allocated decNumber with the rounded result.          */
+/*                                                                    */
+/* lostDigits and other status may be set by this.                    */
+/*                                                                    */
+/* Since the input is an operand, it must not be modified.            */
+/* Instead, return an allocated decNumber, rounded as required.       */
+/* It is the caller's responsibility to free the allocated storage.   */
+/*                                                                    */
+/* If no storage is available then the result cannot be used, so NULL */
+/* is returned.                                                       */
+/* ------------------------------------------------------------------ */
+static decNumber *decRoundOperand(const decNumber *dn, decContext *set,
+                                  uInt *status) {
+  decNumber *res;                       // result structure
+  uInt newstatus=0;                     // status from round
+  Int  residue=0;                       // rounding accumulator
+
+  // Allocate storage for the returned decNumber, big enough for the
+  // length specified by the context
+  res=(decNumber *)malloc(sizeof(decNumber)
+                          +(D2U(set->digits)-1)*sizeof(Unit));
+  if (res==NULL) {
+    *status|=DEC_Insufficient_storage;
+    return NULL;
+    }
+  decCopyFit(res, dn, set, &residue, &newstatus);
+  decApplyRound(res, set, residue, &newstatus);
+
+  // If that set Inexact then "lost digits" is raised...
+  if (newstatus & DEC_Inexact) newstatus|=DEC_Lost_digits;
+  *status|=newstatus;
+  return res;
+  } // decRoundOperand
+#endif
+
+/* ------------------------------------------------------------------ */
+/* decCopyFit -- copy a number, truncating the coefficient if needed  */
+/*                                                                    */
+/*   dest is the target decNumber                                     */
+/*   src  is the source decNumber                                     */
+/*   set is the context [used for length (digits) and rounding mode]  */
+/*   residue is the residue accumulator                               */
+/*   status contains the current status to be updated                 */
+/*                                                                    */
+/* (dest==src is allowed and will be a no-op if fits)                 */
+/* All fields are updated as required.                                */
+/* ------------------------------------------------------------------ */
+static void decCopyFit(decNumber *dest, const decNumber *src,
+                       decContext *set, Int *residue, uInt *status) {
+  dest->bits=src->bits;
+  dest->exponent=src->exponent;
+  decSetCoeff(dest, set, src->lsu, src->digits, residue, status);
+  } // decCopyFit
+
+/* ------------------------------------------------------------------ */
+/* decSetCoeff -- set the coefficient of a number                     */
+/*                                                                    */
+/*   dn    is the number whose coefficient array is to be set.        */
+/*         It must have space for set->digits digits                  */
+/*   set   is the context [for size]                                  */
+/*   lsu   -> lsu of the source coefficient [may be dn->lsu]          */
+/*   len   is digits in the source coefficient [may be dn->digits]    */
+/*   residue is the residue accumulator.  This has values as in       */
+/*         decApplyRound, and will be unchanged unless the            */
+/*         target size is less than len.  In this case, the           */
+/*         coefficient is truncated and the residue is updated to     */
+/*         reflect the previous residue and the dropped digits.       */
+/*   status is the status accumulator, as usual                       */
+/*                                                                    */
+/* The coefficient may already be in the number, or it can be an      */
+/* external intermediate array.  If it is in the number, lsu must ==  */
+/* dn->lsu and len must == dn->digits.                                */
+/*                                                                    */
+/* Note that the coefficient length (len) may be < set->digits, and   */
+/* in this case this merely copies the coefficient (or is a no-op     */
+/* if dn->lsu==lsu).                                                  */
+/*                                                                    */
+/* Note also that (only internally, from decQuantizeOp and            */
+/* decSetSubnormal) the value of set->digits may be less than one,    */
+/* indicating a round to left.  This routine handles that case        */
+/* correctly; caller ensures space.                                   */
+/*                                                                    */
+/* dn->digits, dn->lsu (and as required), and dn->exponent are        */
+/* updated as necessary.   dn->bits (sign) is unchanged.              */
+/*                                                                    */
+/* DEC_Rounded status is set if any digits are discarded.             */
+/* DEC_Inexact status is set if any non-zero digits are discarded, or */
+/*                       incoming residue was non-0 (implies rounded) */
+/* ------------------------------------------------------------------ */
+// mapping array: maps 0-9 to canonical residues, so that a residue
+// can be adjusted in the range [-1, +1] and achieve correct rounding
+//                             0  1  2  3  4  5  6  7  8  9
+static const uByte resmap[10]={0, 3, 3, 3, 3, 5, 7, 7, 7, 7};
+static void decSetCoeff(decNumber *dn, decContext *set, const Unit *lsu,
+                        Int len, Int *residue, uInt *status) {
+  Int   discard;              // number of digits to discard
+  uInt  cut;                  // cut point in Unit
+  const Unit *up;             // work
+  Unit  *target;              // ..
+  Int   count;                // ..
+  #if DECDPUN<=4
+  uInt  temp;                 // ..
+  #endif
+
+  discard=len-set->digits;    // digits to discard
+  if (discard<=0) {           // no digits are being discarded
+    if (dn->lsu!=lsu) {       // copy needed
+      // copy the coefficient array to the result number; no shift needed
+      count=len;              // avoids D2U
+      up=lsu;
+      for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
+        *target=*up;
+      dn->digits=len;         // set the new length
+      }
+    // dn->exponent and residue are unchanged, record any inexactitude
+    if (*residue!=0) *status|=(DEC_Inexact | DEC_Rounded);
+    return;
+    }
+
+  // some digits must be discarded ...
+  dn->exponent+=discard;      // maintain numerical value
+  *status|=DEC_Rounded;       // accumulate Rounded status
+  if (*residue>1) *residue=1; // previous residue now to right, so reduce
+
+  if (discard>len) {          // everything, +1, is being discarded
+    // guard digit is 0
+    // residue is all the number [NB could be all 0s]
+    if (*residue<=0) {        // not already positive
+      count=len;              // avoids D2U
+      for (up=lsu; count>0; up++, count-=DECDPUN) if (*up!=0) { // found non-0
+        *residue=1;
+        break;                // no need to check any others
+        }
+      }
+    if (*residue!=0) *status|=DEC_Inexact; // record inexactitude
+    *dn->lsu=0;               // coefficient will now be 0
+    dn->digits=1;             // ..
+    return;
+    } // total discard
+
+  // partial discard [most common case]
+  // here, at least the first (most significant) discarded digit exists
+
+  // spin up the number, noting residue during the spin, until get to
+  // the Unit with the first discarded digit.  When reach it, extract
+  // it and remember its position
+  count=0;
+  for (up=lsu;; up++) {
+    count+=DECDPUN;
+    if (count>=discard) break; // full ones all checked
+    if (*up!=0) *residue=1;
+    } // up
+
+  // here up -> Unit with first discarded digit
+  cut=discard-(count-DECDPUN)-1;
+  if (cut==DECDPUN-1) {       // unit-boundary case (fast)
+    Unit half=(Unit)powers[DECDPUN]>>1;
+    // set residue directly
+    if (*up>=half) {
+      if (*up>half) *residue=7;
+      else *residue+=5;       // add sticky bit
+      }
+     else { // <half
+      if (*up!=0) *residue=3; // [else is 0, leave as sticky bit]
+      }
+    if (set->digits<=0) {     // special for Quantize/Subnormal :-(
+      *dn->lsu=0;             // .. result is 0
+      dn->digits=1;           // ..
+      }
+     else {                   // shift to least
+      count=set->digits;      // now digits to end up with
+      dn->digits=count;       // set the new length
+      up++;                   // move to next
+      // on unit boundary, so shift-down copy loop is simple
+      for (target=dn->lsu; count>0; target++, up++, count-=DECDPUN)
+        *target=*up;
+      }
+    } // unit-boundary case
+
+   else { // discard digit is in low digit(s), and not top digit
+    uInt  discard1;                // first discarded digit
+    uInt  quot, rem;               // for divisions
+    if (cut==0) quot=*up;          // is at bottom of unit
+     else /* cut>0 */ {            // it's not at bottom of unit
+      #if DECDPUN<=4
+        quot=QUOT10(*up, cut);
+        rem=*up-quot*powers[cut];
+      #else
+        rem=*up%powers[cut];
+        quot=*up/powers[cut];
+      #endif
+      if (rem!=0) *residue=1;
+      }
+    // discard digit is now at bottom of quot
+    #if DECDPUN<=4
+      temp=(quot*6554)>>16;        // fast /10
+      // Vowels algorithm here not a win (9 instructions)
+      discard1=quot-X10(temp);
+      quot=temp;
+    #else
+      discard1=quot%10;
+      quot=quot/10;
+    #endif
+    // here, discard1 is the guard digit, and residue is everything
+    // else [use mapping array to accumulate residue safely]
+    *residue+=resmap[discard1];
+    cut++;                         // update cut
+    // here: up -> Unit of the array with bottom digit
+    //       cut is the division point for each Unit
+    //       quot holds the uncut high-order digits for the current unit
+    if (set->digits<=0) {          // special for Quantize/Subnormal :-(
+      *dn->lsu=0;                  // .. result is 0
+      dn->digits=1;                // ..
+      }
+     else {                        // shift to least needed
+      count=set->digits;           // now digits to end up with
+      dn->digits=count;            // set the new length
+      // shift-copy the coefficient array to the result number
+      for (target=dn->lsu; ; target++) {
+        *target=(Unit)quot;
+        count-=(DECDPUN-cut);
+        if (count<=0) break;
+        up++;
+        quot=*up;
+        #if DECDPUN<=4
+          quot=QUOT10(quot, cut);
+          rem=*up-quot*powers[cut];
+        #else
+          rem=quot%powers[cut];
+          quot=quot/powers[cut];
+        #endif
+        *target=(Unit)(*target+rem*powers[DECDPUN-cut]);
+        count-=cut;
+        if (count<=0) break;
+        } // shift-copy loop
+      } // shift to least
+    } // not unit boundary
+
+  if (*residue!=0) *status|=DEC_Inexact; // record inexactitude
+  return;
+  } // decSetCoeff
+
+/* ------------------------------------------------------------------ */
+/* decApplyRound -- apply pending rounding to a number                */
+/*                                                                    */
+/*   dn    is the number, with space for set->digits digits           */
+/*   set   is the context [for size and rounding mode]                */
+/*   residue indicates pending rounding, being any accumulated        */
+/*         guard and sticky information.  It may be:                  */
+/*         6-9: rounding digit is >5                                  */
+/*         5:   rounding digit is exactly half-way                    */
+/*         1-4: rounding digit is <5 and >0                           */
+/*         0:   the coefficient is exact                              */
+/*        -1:   as 1, but the hidden digits are subtractive, that     */
+/*              is, of the opposite sign to dn.  In this case the     */
+/*              coefficient must be non-0.  This case occurs when     */
+/*              subtracting a small number (which can be reduced to   */
+/*              a sticky bit); see decAddOp.                          */
+/*   status is the status accumulator, as usual                       */
+/*                                                                    */
+/* This routine applies rounding while keeping the length of the      */
+/* coefficient constant.  The exponent and status are unchanged       */
+/* except if:                                                         */
+/*                                                                    */
+/*   -- the coefficient was increased and is all nines (in which      */
+/*      case Overflow could occur, and is handled directly here so    */
+/*      the caller does not need to re-test for overflow)             */
+/*                                                                    */
+/*   -- the coefficient was decreased and becomes all nines (in which */
+/*      case Underflow could occur, and is also handled directly).    */
+/*                                                                    */
+/* All fields in dn are updated as required.                          */
+/*                                                                    */
+/* ------------------------------------------------------------------ */
+static void decApplyRound(decNumber *dn, decContext *set, Int residue,
+                          uInt *status) {
+  Int  bump;                  // 1 if coefficient needs to be incremented
+                              // -1 if coefficient needs to be decremented
+
+  if (residue==0) return;     // nothing to apply
+
+  bump=0;                     // assume a smooth ride
+
+  // now decide whether, and how, to round, depending on mode
+  switch (set->round) {
+    case DEC_ROUND_05UP: {    // round zero or five up (for reround)
+      // This is the same as DEC_ROUND_DOWN unless there is a
+      // positive residue and the lsd of dn is 0 or 5, in which case
+      // it is bumped; when residue is <0, the number is therefore
+      // bumped down unless the final digit was 1 or 6 (in which
+      // case it is bumped down and then up -- a no-op)
+      Int lsd5=*dn->lsu%5;     // get lsd and quintate
+      if (residue<0 && lsd5!=1) bump=-1;
+       else if (residue>0 && lsd5==0) bump=1;
+      // [bump==1 could be applied directly; use common path for clarity]
+      break;} // r-05
+
+    case DEC_ROUND_DOWN: {
+      // no change, except if negative residue
+      if (residue<0) bump=-1;
+      break;} // r-d
+
+    case DEC_ROUND_HALF_DOWN: {
+      if (residue>5) bump=1;
+      break;} // r-h-d
+
+    case DEC_ROUND_HALF_EVEN: {
+      if (residue>5) bump=1;            // >0.5 goes up
+       else if (residue==5) {           // exactly 0.5000...
+        // 0.5 goes up iff [new] lsd is odd
+        if (*dn->lsu & 0x01) bump=1;
+        }
+      break;} // r-h-e
+
+    case DEC_ROUND_HALF_UP: {
+      if (residue>=5) bump=1;
+      break;} // r-h-u
+
+    case DEC_ROUND_UP: {
+      if (residue>0) bump=1;
+      break;} // r-u
+
+    case DEC_ROUND_CEILING: {
+      // same as _UP for positive numbers, and as _DOWN for negatives
+      // [negative residue cannot occur on 0]
+      if (decNumberIsNegative(dn)) {
+        if (residue<0) bump=-1;
+        }
+       else {
+        if (residue>0) bump=1;
+        }
+      break;} // r-c
+
+    case DEC_ROUND_FLOOR: {
+      // same as _UP for negative numbers, and as _DOWN for positive
+      // [negative residue cannot occur on 0]
+      if (!decNumberIsNegative(dn)) {
+        if (residue<0) bump=-1;
+        }
+       else {
+        if (residue>0) bump=1;
+        }
+      break;} // r-f
+
+    default: {      // e.g., DEC_ROUND_MAX
+      *status|=DEC_Invalid_context;
+      #if DECTRACE || (DECCHECK && DECVERB)
+      printf("Unknown rounding mode: %d\n", set->round);
+      #endif
+      break;}
+    } // switch
+
+  // now bump the number, up or down, if need be
+  if (bump==0) return;                       // no action required
+
+  // Simply use decUnitAddSub unless bumping up and the number is
+  // all nines.  In this special case set to 100... explicitly
+  // and adjust the exponent by one (as otherwise could overflow
+  // the array)
+  // Similarly handle all-nines result if bumping down.
+  if (bump>0) {
+    Unit *up;                                // work
+    uInt count=dn->digits;                   // digits to be checked
+    for (up=dn->lsu; ; up++) {
+      if (count<=DECDPUN) {
+        // this is the last Unit (the msu)
+        if (*up!=powers[count]-1) break;     // not still 9s
+        // here if it, too, is all nines
+        *up=(Unit)powers[count-1];           // here 999 -> 100 etc.
+        for (up=up-1; up>=dn->lsu; up--) *up=0; // others all to 0
+        dn->exponent++;                      // and bump exponent
+        // [which, very rarely, could cause Overflow...]
+        if ((dn->exponent+dn->digits)>set->emax+1) {
+          decSetOverflow(dn, set, status);
+          }
+        return;                              // done
+        }
+      // a full unit to check, with more to come
+      if (*up!=DECDPUNMAX) break;            // not still 9s
+      count-=DECDPUN;
+      } // up
+    } // bump>0
+   else {                                    // -1
+    // here checking for a pre-bump of 1000... (leading 1, all
+    // other digits zero)
+    Unit *up, *sup;                          // work
+    uInt count=dn->digits;                   // digits to be checked
+    for (up=dn->lsu; ; up++) {
+      if (count<=DECDPUN) {
+        // this is the last Unit (the msu)
+        if (*up!=powers[count-1]) break;     // not 100..
+        // here if have the 1000... case
+        sup=up;                              // save msu pointer
+        *up=(Unit)powers[count]-1;           // here 100 in msu -> 999
+        // others all to all-nines, too
+        for (up=up-1; up>=dn->lsu; up--) *up=(Unit)powers[DECDPUN]-1;
+        dn->exponent--;                      // and bump exponent
+
+        // iff the number was at the subnormal boundary (exponent=etiny)
+        // then the exponent is now out of range, so it will in fact get
+        // clamped to etiny and the final 9 dropped.
+        // printf(">> emin=%d exp=%d sdig=%d\n", set->emin,
+        //        dn->exponent, set->digits);
+        if (dn->exponent+1==set->emin-set->digits+1) {
+          if (count==1 && dn->digits==1) *sup=0;  // here 9 -> 0[.9]
+           else {
+            *sup=(Unit)powers[count-1]-1;    // here 999.. in msu -> 99..
+            dn->digits--;
+            }
+          dn->exponent++;
+          *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
+          }
+        return;                              // done
+        }
+
+      // a full unit to check, with more to come
+      if (*up!=0) break;                     // not still 0s
+      count-=DECDPUN;
+      } // up
+
+    } // bump<0
+
+  // Actual bump needed.  Do it.
+  decUnitAddSub(dn->lsu, D2U(dn->digits), uarrone, 1, 0, dn->lsu, bump);
+  } // decApplyRound
+
+#if DECSUBSET
+/* ------------------------------------------------------------------ */
+/* decFinish -- finish processing a number                            */
+/*                                                                    */
+/*   dn is the number                                                 */
+/*   set is the context                                               */
+/*   residue is the rounding accumulator (as in decApplyRound)        */
+/*   status is the accumulator                                        */
+/*                                                                    */
+/* This finishes off the current number by:                           */
+/*    1. If not extended:                                             */
+/*       a. Converting a zero result to clean '0'                     */
+/*       b. Reducing positive exponents to 0, if would fit in digits  */
+/*    2. Checking for overflow and subnormals (always)                */
+/* Note this is just Finalize when no subset arithmetic.              */
+/* All fields are updated as required.                                */
+/* ------------------------------------------------------------------ */
+static void decFinish(decNumber *dn, decContext *set, Int *residue,
+                      uInt *status) {
+  if (!set->extended) {
+    if ISZERO(dn) {                // value is zero
+      dn->exponent=0;              // clean exponent ..
+      dn->bits=0;                  // .. and sign
+      return;                      // no error possible
+      }
+    if (dn->exponent>=0) {         // non-negative exponent
+      // >0; reduce to integer if possible
+      if (set->digits >= (dn->exponent+dn->digits)) {
+        dn->digits=decShiftToMost(dn->lsu, dn->digits, dn->exponent);
+        dn->exponent=0;
+        }
+      }
+    } // !extended
+
+  decFinalize(dn, set, residue, status);
+  } // decFinish
+#endif
+
+/* ------------------------------------------------------------------ */
+/* decFinalize -- final check, clamp, and round of a number           */
+/*                                                                    */
+/*   dn is the number                                                 */
+/*   set is the context                                               */
+/*   residue is the rounding accumulator (as in decApplyRound)        */
+/*   status is the status accumulator                                 */
+/*                                                                    */
+/* This finishes off the current number by checking for subnormal     */
+/* results, applying any pending rounding, checking for overflow,     */
+/* and applying any clamping.                                         */
+/* Underflow and overflow conditions are raised as appropriate.       */
+/* All fields are updated as required.                                */
+/* ------------------------------------------------------------------ */
+static void decFinalize(decNumber *dn, decContext *set, Int *residue,
+                        uInt *status) {
+  Int shift;                            // shift needed if clamping
+  Int tinyexp=set->emin-dn->digits+1;   // precalculate subnormal boundary
+
+  // Must be careful, here, when checking the exponent as the
+  // adjusted exponent could overflow 31 bits [because it may already
+  // be up to twice the expected].
+
+  // First test for subnormal.  This must be done before any final
+  // round as the result could be rounded to Nmin or 0.
+  if (dn->exponent<=tinyexp) {          // prefilter
+    Int comp;
+    decNumber nmin;
+    // A very nasty case here is dn == Nmin and residue<0
+    if (dn->exponent<tinyexp) {
+      // Go handle subnormals; this will apply round if needed.
+      decSetSubnormal(dn, set, residue, status);
+      return;
+      }
+    // Equals case: only subnormal if dn=Nmin and negative residue
+    decNumberZero(&nmin);
+    nmin.lsu[0]=1;
+    nmin.exponent=set->emin;
+    comp=decCompare(dn, &nmin, 1);                // (signless compare)
+    if (comp==BADINT) {                           // oops
+      *status|=DEC_Insufficient_storage;          // abandon...
+      return;
+      }
+    if (*residue<0 && comp==0) {                  // neg residue and dn==Nmin
+      decApplyRound(dn, set, *residue, status);   // might force down
+      decSetSubnormal(dn, set, residue, status);
+      return;
+      }
+    }
+
+  // now apply any pending round (this could raise overflow).
+  if (*residue!=0) decApplyRound(dn, set, *residue, status);
+
+  // Check for overflow [redundant in the 'rare' case] or clamp
+  if (dn->exponent<=set->emax-set->digits+1) return;   // neither needed
+
+
+  // here when might have an overflow or clamp to do
+  if (dn->exponent>set->emax-dn->digits+1) {           // too big
+    decSetOverflow(dn, set, status);
+    return;
+    }
+  // here when the result is normal but in clamp range
+  if (!set->clamp) return;
+
+  // here when need to apply the IEEE exponent clamp (fold-down)
+  shift=dn->exponent-(set->emax-set->digits+1);
+
+  // shift coefficient (if non-zero)
+  if (!ISZERO(dn)) {
+    dn->digits=decShiftToMost(dn->lsu, dn->digits, shift);
+    }
+  dn->exponent-=shift;   // adjust the exponent to match
+  *status|=DEC_Clamped;  // and record the dirty deed
+  return;
+  } // decFinalize
+
+/* ------------------------------------------------------------------ */
+/* decSetOverflow -- set number to proper overflow value              */
+/*                                                                    */
+/*   dn is the number (used for sign [only] and result)               */
+/*   set is the context [used for the rounding mode, etc.]            */
+/*   status contains the current status to be updated                 */
+/*                                                                    */
+/* This sets the sign of a number and sets its value to either        */
+/* Infinity or the maximum finite value, depending on the sign of     */
+/* dn and the rounding mode, following IEEE 754 rules.                */
+/* ------------------------------------------------------------------ */
+static void decSetOverflow(decNumber *dn, decContext *set, uInt *status) {
+  Flag needmax=0;                  // result is maximum finite value
+  uByte sign=dn->bits&DECNEG;      // clean and save sign bit
+
+  if (ISZERO(dn)) {                // zero does not overflow magnitude
+    Int emax=set->emax;                      // limit value
+    if (set->clamp) emax-=set->digits-1;     // lower if clamping
+    if (dn->exponent>emax) {                 // clamp required
+      dn->exponent=emax;
+      *status|=DEC_Clamped;
+      }
+    return;
+    }
+
+  decNumberZero(dn);
+  switch (set->round) {
+    case DEC_ROUND_DOWN: {
+      needmax=1;                   // never Infinity
+      break;} // r-d
+    case DEC_ROUND_05UP: {
+      needmax=1;                   // never Infinity
+      break;} // r-05
+    case DEC_ROUND_CEILING: {
+      if (sign) needmax=1;         // Infinity if non-negative
+      break;} // r-c
+    case DEC_ROUND_FLOOR: {
+      if (!sign) needmax=1;        // Infinity if negative
+      break;} // r-f
+    default: break;                // Infinity in all other cases
+    }
+  if (needmax) {
+    decSetMaxValue(dn, set);
+    dn->bits=sign;                 // set sign
+    }
+   else dn->bits=sign|DECINF;      // Value is +/-Infinity
+  *status|=DEC_Overflow | DEC_Inexact | DEC_Rounded;
+  } // decSetOverflow
+
+/* ------------------------------------------------------------------ */
+/* decSetMaxValue -- set number to +Nmax (maximum normal value)       */
+/*                                                                    */
+/*   dn is the number to set                                          */
+/*   set is the context [used for digits and emax]                    */
+/*                                                                    */
+/* This sets the number to the maximum positive value.                */
+/* ------------------------------------------------------------------ */
+static void decSetMaxValue(decNumber *dn, decContext *set) {
+  Unit *up;                        // work
+  Int count=set->digits;           // nines to add
+  dn->digits=count;
+  // fill in all nines to set maximum value
+  for (up=dn->lsu; ; up++) {
+    if (count>DECDPUN) *up=DECDPUNMAX;  // unit full o'nines
+     else {                             // this is the msu
+      *up=(Unit)(powers[count]-1);
+      break;
+      }
+    count-=DECDPUN;                // filled those digits
+    } // up
+  dn->bits=0;                      // + sign
+  dn->exponent=set->emax-set->digits+1;
+  } // decSetMaxValue
+
+/* ------------------------------------------------------------------ */
+/* decSetSubnormal -- process value whose exponent is <Emin           */
+/*                                                                    */
+/*   dn is the number (used as input as well as output; it may have   */
+/*         an allowed subnormal value, which may need to be rounded)  */
+/*   set is the context [used for the rounding mode]                  */
+/*   residue is any pending residue                                   */
+/*   status contains the current status to be updated                 */
+/*                                                                    */
+/* If subset mode, set result to zero and set Underflow flags.        */
+/*                                                                    */
+/* Value may be zero with a low exponent; this does not set Subnormal */
+/* but the exponent will be clamped to Etiny.                         */
+/*                                                                    */
+/* Otherwise ensure exponent is not out of range, and round as        */
+/* necessary.  Underflow is set if the result is Inexact.             */
+/* ------------------------------------------------------------------ */
+static void decSetSubnormal(decNumber *dn, decContext *set, Int *residue,
+                            uInt *status) {
+  decContext workset;         // work
+  Int        etiny, adjust;   // ..
+
+  #if DECSUBSET
+  // simple set to zero and 'hard underflow' for subset
+  if (!set->extended) {
+    decNumberZero(dn);
+    // always full overflow
+    *status|=DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded;
+    return;
+    }
+  #endif
+
+  // Full arithmetic -- allow subnormals, rounded to minimum exponent
+  // (Etiny) if needed
+  etiny=set->emin-(set->digits-1);      // smallest allowed exponent
+
+  if ISZERO(dn) {                       // value is zero
+    // residue can never be non-zero here
+    #if DECCHECK
+      if (*residue!=0) {
+        printf("++ Subnormal 0 residue %ld\n", (LI)*residue);
+        *status|=DEC_Invalid_operation;
+        }
+    #endif
+    if (dn->exponent<etiny) {           // clamp required
+      dn->exponent=etiny;
+      *status|=DEC_Clamped;
+      }
+    return;
+    }
+
+  *status|=DEC_Subnormal;               // have a non-zero subnormal
+  adjust=etiny-dn->exponent;            // calculate digits to remove
+  if (adjust<=0) {                      // not out of range; unrounded
+    // residue can never be non-zero here, except in the Nmin-residue
+    // case (which is a subnormal result), so can take fast-path here
+    // it may already be inexact (from setting the coefficient)
+    if (*status&DEC_Inexact) *status|=DEC_Underflow;
+    return;
+    }
+
+  // adjust>0, so need to rescale the result so exponent becomes Etiny
+  // [this code is similar to that in rescale]
+  workset=*set;                         // clone rounding, etc.
+  workset.digits=dn->digits-adjust;     // set requested length
+  workset.emin-=adjust;                 // and adjust emin to match
+  // [note that the latter can be <1, here, similar to Rescale case]
+  decSetCoeff(dn, &workset, dn->lsu, dn->digits, residue, status);
+  decApplyRound(dn, &workset, *residue, status);
+
+  // Use 754 default rule: Underflow is set iff Inexact
+  // [independent of whether trapped]
+  if (*status&DEC_Inexact) *status|=DEC_Underflow;
+
+  // if rounded up a 999s case, exponent will be off by one; adjust
+  // back if so [it will fit, because it was shortened earlier]
+  if (dn->exponent>etiny) {
+    dn->digits=decShiftToMost(dn->lsu, dn->digits, 1);
+    dn->exponent--;                     // (re)adjust the exponent.
+    }
+
+  // if rounded to zero, it is by definition clamped...
+  if (ISZERO(dn)) *status|=DEC_Clamped;
+  } // decSetSubnormal
+
+/* ------------------------------------------------------------------ */
+/* decCheckMath - check entry conditions for a math function          */
+/*                                                                    */
+/*   This checks the context and the operand                          */
+/*                                                                    */
+/*   rhs is the operand to check                                      */
+/*   set is the context to check                                      */
+/*   status is unchanged if both are good                             */
+/*                                                                    */
+/* returns non-zero if status is changed, 0 otherwise                 */
+/*                                                                    */
+/* Restrictions enforced:                                             */
+/*                                                                    */
+/*   digits, emax, and -emin in the context must be less than         */
+/*   DEC_MAX_MATH (999999), and A must be within these bounds if      */
+/*   non-zero.  Invalid_operation is set in the status if a           */
+/*   restriction is violated.                                         */
+/* ------------------------------------------------------------------ */
+static uInt decCheckMath(const decNumber *rhs, decContext *set,
+                         uInt *status) {
+  uInt save=*status;                         // record
+  if (set->digits>DEC_MAX_MATH
+   || set->emax>DEC_MAX_MATH
+   || -set->emin>DEC_MAX_MATH) *status|=DEC_Invalid_context;
+   else if ((rhs->digits>DEC_MAX_MATH
+     || rhs->exponent+rhs->digits>DEC_MAX_MATH+1
+     || rhs->exponent+rhs->digits<2*(1-DEC_MAX_MATH))
+     && !ISZERO(rhs)) *status|=DEC_Invalid_operation;
+  return (*status!=save);
+  } // decCheckMath
+
+/* ------------------------------------------------------------------ */
+/* decGetInt -- get integer from a number                             */
+/*                                                                    */
+/*   dn is the number [which will not be altered]                     */
+/*                                                                    */
+/*   returns one of:                                                  */
+/*     BADINT if there is a non-zero fraction                         */
+/*     the converted integer                                          */
+/*     BIGEVEN if the integer is even and magnitude > 2*10**9         */
+/*     BIGODD  if the integer is odd  and magnitude > 2*10**9         */
+/*                                                                    */
+/* This checks and gets a whole number from the input decNumber.      */
+/* The sign can be determined from dn by the caller when BIGEVEN or   */
+/* BIGODD is returned.                                                */
+/* ------------------------------------------------------------------ */
+static Int decGetInt(const decNumber *dn) {
+  Int  theInt;                          // result accumulator
+  const Unit *up;                       // work
+  Int  got;                             // digits (real or not) processed
+  Int  ilength=dn->digits+dn->exponent; // integral length
+  Flag neg=decNumberIsNegative(dn);     // 1 if -ve
+
+  // The number must be an integer that fits in 10 digits
+  // Assert, here, that 10 is enough for any rescale Etiny
+  #if DEC_MAX_EMAX > 999999999
+    #error GetInt may need updating [for Emax]
+  #endif
+  #if DEC_MIN_EMIN < -999999999
+    #error GetInt may need updating [for Emin]
+  #endif
+  if (ISZERO(dn)) return 0;             // zeros are OK, with any exponent
+
+  up=dn->lsu;                           // ready for lsu
+  theInt=0;                             // ready to accumulate
+  if (dn->exponent>=0) {                // relatively easy
+    // no fractional part [usual]; allow for positive exponent
+    got=dn->exponent;
+    }
+   else { // -ve exponent; some fractional part to check and discard
+    Int count=-dn->exponent;            // digits to discard
+    // spin up whole units until reach the Unit with the unit digit
+    for (; count>=DECDPUN; up++) {
+      if (*up!=0) return BADINT;        // non-zero Unit to discard
+      count-=DECDPUN;
+      }
+    if (count==0) got=0;                // [a multiple of DECDPUN]
+     else {                             // [not multiple of DECDPUN]
+      Int rem;                          // work
+      // slice off fraction digits and check for non-zero
+      #if DECDPUN<=4
+        theInt=QUOT10(*up, count);
+        rem=*up-theInt*powers[count];
+      #else
+        rem=*up%powers[count];          // slice off discards
+        theInt=*up/powers[count];
+      #endif
+      if (rem!=0) return BADINT;        // non-zero fraction
+      // it looks good
+      got=DECDPUN-count;                // number of digits so far
+      up++;                             // ready for next
+      }
+    }
+  // now it's known there's no fractional part
+
+  // tricky code now, to accumulate up to 9.3 digits
+  if (got==0) {theInt=*up; got+=DECDPUN; up++;} // ensure lsu is there
+
+  if (ilength<11) {
+    Int save=theInt;
+    // collect any remaining unit(s)
+    for (; got<ilength; up++) {
+      theInt+=*up*powers[got];
+      got+=DECDPUN;
+      }
+    if (ilength==10) {                  // need to check for wrap
+      if (theInt/(Int)powers[got-DECDPUN]!=(Int)*(up-1)) ilength=11;
+         // [that test also disallows the BADINT result case]
+       else if (neg && theInt>1999999997) ilength=11;
+       else if (!neg && theInt>999999999) ilength=11;
+      if (ilength==11) theInt=save;     // restore correct low bit
+      }
+    }
+
+  if (ilength>10) {                     // too big
+    if (theInt&1) return BIGODD;        // bottom bit 1
+    return BIGEVEN;                     // bottom bit 0
+    }
+
+  if (neg) theInt=-theInt;              // apply sign
+  return theInt;
+  } // decGetInt
+
+/* ------------------------------------------------------------------ */
+/* decDecap -- decapitate the coefficient of a number                 */
+/*                                                                    */
+/*   dn   is the number to be decapitated                             */
+/*   drop is the number of digits to be removed from the left of dn;  */
+/*     this must be <= dn->digits (if equal, the coefficient is       */
+/*     set to 0)                                                      */
+/*                                                                    */
+/* Returns dn; dn->digits will be <= the initial digits less drop     */
+/* (after removing drop digits there may be leading zero digits       */
+/* which will also be removed).  Only dn->lsu and dn->digits change.  */
+/* ------------------------------------------------------------------ */
+static decNumber *decDecap(decNumber *dn, Int drop) {
+  Unit *msu;                            // -> target cut point
+  Int cut;                              // work
+  if (drop>=dn->digits) {               // losing the whole thing
+    #if DECCHECK
+    if (drop>dn->digits)
+      printf("decDecap called with drop>digits [%ld>%ld]\n",
+             (LI)drop, (LI)dn->digits);
+    #endif
+    dn->lsu[0]=0;
+    dn->digits=1;
+    return dn;
+    }
+  msu=dn->lsu+D2U(dn->digits-drop)-1;   // -> likely msu
+  cut=MSUDIGITS(dn->digits-drop);       // digits to be in use in msu
+  if (cut!=DECDPUN) *msu%=powers[cut];  // clear left digits
+  // that may have left leading zero digits, so do a proper count...
+  dn->digits=decGetDigits(dn->lsu, msu-dn->lsu+1);
+  return dn;
+  } // decDecap
+
+/* ------------------------------------------------------------------ */
+/* decBiStr -- compare string with pairwise options                   */
+/*                                                                    */
+/*   targ is the string to compare                                    */
+/*   str1 is one of the strings to compare against (length may be 0)  */
+/*   str2 is the other; it must be the same length as str1            */
+/*                                                                    */
+/*   returns 1 if strings compare equal, (that is, it is the same     */
+/*   length as str1 and str2, and each character of targ is in either */
+/*   str1 or str2 in the corresponding position), or 0 otherwise      */
+/*                                                                    */
+/* This is used for generic caseless compare, including the awkward   */
+/* case of the Turkish dotted and dotless Is.  Use as (for example):  */
+/*   if (decBiStr(test, "mike", "MIKE")) ...                          */
+/* ------------------------------------------------------------------ */
+static Flag decBiStr(const char *targ, const char *str1, const char *str2) {
+  for (;;targ++, str1++, str2++) {
+    if (*targ!=*str1 && *targ!=*str2) return 0;
+    // *targ has a match in one (or both, if terminator)
+    if (*targ=='\0') break;
+    } // forever
+  return 1;
+  } // decBiStr
+
+/* ------------------------------------------------------------------ */
+/* decNaNs -- handle NaN operand or operands                          */
+/*                                                                    */
+/*   res     is the result number                                     */
+/*   lhs     is the first operand                                     */
+/*   rhs     is the second operand, or NULL if none                   */
+/*   context is used to limit payload length                          */
+/*   status  contains the current status                              */
+/*   returns res in case convenient                                   */
+/*                                                                    */
+/* Called when one or both operands is a NaN, and propagates the      */
+/* appropriate result to res.  When an sNaN is found, it is changed   */
+/* to a qNaN and Invalid operation is set.                            */
+/* ------------------------------------------------------------------ */
+static decNumber * decNaNs(decNumber *res, const decNumber *lhs,
+                           const decNumber *rhs, decContext *set,
+                           uInt *status) {
+  // This decision tree ends up with LHS being the source pointer,
+  // and status updated if need be
+  if (lhs->bits & DECSNAN)
+    *status|=DEC_Invalid_operation | DEC_sNaN;
+   else if (rhs==NULL);
+   else if (rhs->bits & DECSNAN) {
+    lhs=rhs;
+    *status|=DEC_Invalid_operation | DEC_sNaN;
+    }
+   else if (lhs->bits & DECNAN);
+   else lhs=rhs;
+
+  // propagate the payload
+  if (lhs->digits<=set->digits) decNumberCopy(res, lhs); // easy
+   else { // too long
+    const Unit *ul;
+    Unit *ur, *uresp1;
+    // copy safe number of units, then decapitate
+    res->bits=lhs->bits;                // need sign etc.
+    uresp1=res->lsu+D2U(set->digits);
+    for (ur=res->lsu, ul=lhs->lsu; ur<uresp1; ur++, ul++) *ur=*ul;
+    res->digits=D2U(set->digits)*DECDPUN;
+    // maybe still too long
+    if (res->digits>set->digits) decDecap(res, res->digits-set->digits);
+    }
+
+  res->bits&=~DECSNAN;        // convert any sNaN to NaN, while
+  res->bits|=DECNAN;          // .. preserving sign
+  res->exponent=0;            // clean exponent
+                              // [coefficient was copied/decapitated]
+  return res;
+  } // decNaNs
+
+/* ------------------------------------------------------------------ */
+/* decStatus -- apply non-zero status                                 */
+/*                                                                    */
+/*   dn     is the number to set if error                             */
+/*   status contains the current status (not yet in context)          */
+/*   set    is the context                                            */
+/*                                                                    */
+/* If the status is an error status, the number is set to a NaN,      */
+/* unless the error was an overflow, divide-by-zero, or underflow,    */
+/* in which case the number will have already been set.               */
+/*                                                                    */
+/* The context status is then updated with the new status.  Note that */
+/* this may raise a signal, so control may never return from this     */
+/* routine (hence resources must be recovered before it is called).   */
+/* ------------------------------------------------------------------ */
+static void decStatus(decNumber *dn, uInt status, decContext *set) {
+  if (status & DEC_NaNs) {              // error status -> NaN
+    // if cause was an sNaN, clear and propagate [NaN is already set up]
+    if (status & DEC_sNaN) status&=~DEC_sNaN;
+     else {
+      decNumberZero(dn);                // other error: clean throughout
+      dn->bits=DECNAN;                  // and make a quiet NaN
+      }
+    }
+  decContextSetStatus(set, status);     // [may not return]
+  return;
+  } // decStatus
+
+/* ------------------------------------------------------------------ */
+/* decGetDigits -- count digits in a Units array                      */
+/*                                                                    */
+/*   uar is the Unit array holding the number (this is often an       */
+/*          accumulator of some sort)                                 */
+/*   len is the length of the array in units [>=1]                    */
+/*                                                                    */
+/*   returns the number of (significant) digits in the array          */
+/*                                                                    */
+/* All leading zeros are excluded, except the last if the array has   */
+/* only zero Units.                                                   */
+/* ------------------------------------------------------------------ */
+// This may be called twice during some operations.
+static Int decGetDigits(Unit *uar, Int len) {
+  Unit *up=uar+(len-1);            // -> msu
+  Int  digits=(len-1)*DECDPUN+1;   // possible digits excluding msu
+  #if DECDPUN>4
+  uInt const *pow;                 // work
+  #endif
+                                   // (at least 1 in final msu)
+  #if DECCHECK
+  if (len<1) printf("decGetDigits called with len<1 [%ld]\n", (LI)len);
+  #endif
+
+  for (; up>=uar; up--) {
+    if (*up==0) {                  // unit is all 0s
+      if (digits==1) break;        // a zero has one digit
+      digits-=DECDPUN;             // adjust for 0 unit
+      continue;}
+    // found the first (most significant) non-zero Unit
+    #if DECDPUN>1                  // not done yet
+    if (*up<10) break;             // is 1-9
+    digits++;
+    #if DECDPUN>2                  // not done yet
+    if (*up<100) break;            // is 10-99
+    digits++;
+    #if DECDPUN>3                  // not done yet
+    if (*up<1000) break;           // is 100-999
+    digits++;
+    #if DECDPUN>4                  // count the rest ...
+    for (pow=&powers[4]; *up>=*pow; pow++) digits++;
+    #endif
+    #endif
+    #endif
+    #endif
+    break;
+    } // up
+  return digits;
+  } // decGetDigits
+
+#if DECTRACE | DECCHECK
+/* ------------------------------------------------------------------ */
+/* decNumberShow -- display a number [debug aid]                      */
+/*   dn is the number to show                                         */
+/*                                                                    */
+/* Shows: sign, exponent, coefficient (msu first), digits             */
+/*    or: sign, special-value                                         */
+/* ------------------------------------------------------------------ */
+// this is public so other modules can use it
+void decNumberShow(const decNumber *dn) {
+  const Unit *up;                  // work
+  uInt u, d;                       // ..
+  Int cut;                         // ..
+  char isign='+';                  // main sign
+  if (dn==NULL) {
+    printf("NULL\n");
+    return;}
+  if (decNumberIsNegative(dn)) isign='-';
+  printf(" >> %c ", isign);
+  if (dn->bits&DECSPECIAL) {       // Is a special value
+    if (decNumberIsInfinite(dn)) printf("Infinity");
+     else {                                  // a NaN
+      if (dn->bits&DECSNAN) printf("sNaN");  // signalling NaN
+       else printf("NaN");
+      }
+    // if coefficient and exponent are 0, no more to do
+    if (dn->exponent==0 && dn->digits==1 && *dn->lsu==0) {
+      printf("\n");
+      return;}
+    // drop through to report other information
+    printf(" ");
+    }
+
+  // now carefully display the coefficient
+  up=dn->lsu+D2U(dn->digits)-1;         // msu
+  printf("%ld", (LI)*up);
+  for (up=up-1; up>=dn->lsu; up--) {
+    u=*up;
+    printf(":");
+    for (cut=DECDPUN-1; cut>=0; cut--) {
+      d=u/powers[cut];
+      u-=d*powers[cut];
+      printf("%ld", (LI)d);
+      } // cut
+    } // up
+  if (dn->exponent!=0) {
+    char esign='+';
+    if (dn->exponent<0) esign='-';
+    printf(" E%c%ld", esign, (LI)abs(dn->exponent));
+    }
+  printf(" [%ld]\n", (LI)dn->digits);
+  } // decNumberShow
+#endif
+
+#if DECTRACE || DECCHECK
+/* ------------------------------------------------------------------ */
+/* decDumpAr -- display a unit array [debug/check aid]                */
+/*   name is a single-character tag name                              */
+/*   ar   is the array to display                                     */
+/*   len  is the length of the array in Units                         */
+/* ------------------------------------------------------------------ */
+static void decDumpAr(char name, const Unit *ar, Int len) {
+  Int i;
+  const char *spec;
+  #if DECDPUN==9
+    spec="%09d ";
+  #elif DECDPUN==8
+    spec="%08d ";
+  #elif DECDPUN==7
+    spec="%07d ";
+  #elif DECDPUN==6
+    spec="%06d ";
+  #elif DECDPUN==5
+    spec="%05d ";
+  #elif DECDPUN==4
+    spec="%04d ";
+  #elif DECDPUN==3
+    spec="%03d ";
+  #elif DECDPUN==2
+    spec="%02d ";
+  #else
+    spec="%d ";
+  #endif
+  printf("  :%c: ", name);
+  for (i=len-1; i>=0; i--) {
+    if (i==len-1) printf("%ld ", (LI)ar[i]);
+     else printf(spec, ar[i]);
+    }
+  printf("\n");
+  return;}
+#endif
+
+#if DECCHECK
+/* ------------------------------------------------------------------ */
+/* decCheckOperands -- check operand(s) to a routine                  */
+/*   res is the result structure (not checked; it will be set to      */
+/*          quiet NaN if error found (and it is not NULL))            */
+/*   lhs is the first operand (may be DECUNRESU)                      */
+/*   rhs is the second (may be DECUNUSED)                             */
+/*   set is the context (may be DECUNCONT)                            */
+/*   returns 0 if both operands, and the context are clean, or 1      */
+/*     otherwise (in which case the context will show an error,       */
+/*     unless NULL).  Note that res is not cleaned; caller should     */
+/*     handle this so res=NULL case is safe.                          */
+/* The caller is expected to abandon immediately if 1 is returned.    */
+/* ------------------------------------------------------------------ */
+static Flag decCheckOperands(decNumber *res, const decNumber *lhs,
+                             const decNumber *rhs, decContext *set) {
+  Flag bad=0;
+  if (set==NULL) {                 // oops; hopeless
+    #if DECTRACE || DECVERB
+    printf("Reference to context is NULL.\n");
+    #endif
+    bad=1;
+    return 1;}
+   else if (set!=DECUNCONT
+     && (set->digits<1 || set->round>=DEC_ROUND_MAX)) {
+    bad=1;
+    #if DECTRACE || DECVERB
+    printf("Bad context [digits=%ld round=%ld].\n",
+           (LI)set->digits, (LI)set->round);
+    #endif
+    }
+   else {
+    if (res==NULL) {
+      bad=1;
+      #if DECTRACE
+      // this one not DECVERB as standard tests include NULL
+      printf("Reference to result is NULL.\n");
+      #endif
+      }
+    if (!bad && lhs!=DECUNUSED) bad=(decCheckNumber(lhs));
+    if (!bad && rhs!=DECUNUSED) bad=(decCheckNumber(rhs));
+    }
+  if (bad) {
+    if (set!=DECUNCONT) decContextSetStatus(set, DEC_Invalid_operation);
+    if (res!=DECUNRESU && res!=NULL) {
+      decNumberZero(res);
+      res->bits=DECNAN;       // qNaN
+      }
+    }
+  return bad;
+  } // decCheckOperands
+
+/* ------------------------------------------------------------------ */
+/* decCheckNumber -- check a number                                   */
+/*   dn is the number to check                                        */
+/*   returns 0 if the number is clean, or 1 otherwise                 */
+/*                                                                    */
+/* The number is considered valid if it could be a result from some   */
+/* operation in some valid context.                                   */
+/* ------------------------------------------------------------------ */
+static Flag decCheckNumber(const decNumber *dn) {
+  const Unit *up;             // work
+  uInt maxuint;               // ..
+  Int ae, d, digits;          // ..
+  Int emin, emax;             // ..
+
+  if (dn==NULL) {             // hopeless
+    #if DECTRACE
+    // this one not DECVERB as standard tests include NULL
+    printf("Reference to decNumber is NULL.\n");
+    #endif
+    return 1;}
+
+  // check special values
+  if (dn->bits & DECSPECIAL) {
+    if (dn->exponent!=0) {
+      #if DECTRACE || DECVERB
+      printf("Exponent %ld (not 0) for a special value [%02x].\n",
+             (LI)dn->exponent, dn->bits);
+      #endif
+      return 1;}
+
+    // 2003.09.08: NaNs may now have coefficients, so next tests Inf only
+    if (decNumberIsInfinite(dn)) {
+      if (dn->digits!=1) {
+        #if DECTRACE || DECVERB
+        printf("Digits %ld (not 1) for an infinity.\n", (LI)dn->digits);
+        #endif
+        return 1;}
+      if (*dn->lsu!=0) {
+        #if DECTRACE || DECVERB
+        printf("LSU %ld (not 0) for an infinity.\n", (LI)*dn->lsu);
+        #endif
+        decDumpAr('I', dn->lsu, D2U(dn->digits));
+        return 1;}
+      } // Inf
+    // 2002.12.26: negative NaNs can now appear through proposed IEEE
+    //             concrete formats (decimal64, etc.).
+    return 0;
+    }
+
+  // check the coefficient
+  if (dn->digits<1 || dn->digits>DECNUMMAXP) {
+    #if DECTRACE || DECVERB
+    printf("Digits %ld in number.\n", (LI)dn->digits);
+    #endif
+    return 1;}
+
+  d=dn->digits;
+
+  for (up=dn->lsu; d>0; up++) {
+    if (d>DECDPUN) maxuint=DECDPUNMAX;
+     else {                   // reached the msu
+      maxuint=powers[d]-1;
+      if (dn->digits>1 && *up<powers[d-1]) {
+        #if DECTRACE || DECVERB
+        printf("Leading 0 in number.\n");
+        decNumberShow(dn);
+        #endif
+        return 1;}
+      }
+    if (*up>maxuint) {
+      #if DECTRACE || DECVERB
+      printf("Bad Unit [%08lx] in %ld-digit number at offset %ld [maxuint %ld].\n",
+              (LI)*up, (LI)dn->digits, (LI)(up-dn->lsu), (LI)maxuint);
+      #endif
+      return 1;}
+    d-=DECDPUN;
+    }
+
+  // check the exponent.  Note that input operands can have exponents
+  // which are out of the set->emin/set->emax and set->digits range
+  // (just as they can have more digits than set->digits).
+  ae=dn->exponent+dn->digits-1;    // adjusted exponent
+  emax=DECNUMMAXE;
+  emin=DECNUMMINE;
+  digits=DECNUMMAXP;
+  if (ae<emin-(digits-1)) {
+    #if DECTRACE || DECVERB
+    printf("Adjusted exponent underflow [%ld].\n", (LI)ae);
+    decNumberShow(dn);
+    #endif
+    return 1;}
+  if (ae>+emax) {
+    #if DECTRACE || DECVERB
+    printf("Adjusted exponent overflow [%ld].\n", (LI)ae);
+    decNumberShow(dn);
+    #endif
+    return 1;}
+
+  return 0;              // it's OK
+  } // decCheckNumber
+
+/* ------------------------------------------------------------------ */
+/* decCheckInexact -- check a normal finite inexact result has digits */
+/*   dn is the number to check                                        */
+/*   set is the context (for status and precision)                    */
+/*   sets Invalid operation, etc., if some digits are missing         */
+/* [this check is not made for DECSUBSET compilation or when          */
+/* subnormal is not set]                                              */
+/* ------------------------------------------------------------------ */
+static void decCheckInexact(const decNumber *dn, decContext *set) {
+  #if !DECSUBSET && DECEXTFLAG
+    if ((set->status & (DEC_Inexact|DEC_Subnormal))==DEC_Inexact
+     && (set->digits!=dn->digits) && !(dn->bits & DECSPECIAL)) {
+      #if DECTRACE || DECVERB
+      printf("Insufficient digits [%ld] on normal Inexact result.\n",
+             (LI)dn->digits);
+      decNumberShow(dn);
+      #endif
+      decContextSetStatus(set, DEC_Invalid_operation);
+      }
+  #else
+    // next is a noop for quiet compiler
+    if (dn!=NULL && dn->digits==0) set->status|=DEC_Invalid_operation;
+  #endif
+  return;
+  } // decCheckInexact
+#endif
+
+#if DECALLOC
+#undef malloc
+#undef free
+/* ------------------------------------------------------------------ */
+/* decMalloc -- accountable allocation routine                        */
+/*   n is the number of bytes to allocate                             */
+/*                                                                    */
+/* Semantics is the same as the stdlib malloc routine, but bytes      */
+/* allocated are accounted for globally, and corruption fences are    */
+/* added before and after the 'actual' storage.                       */
+/* ------------------------------------------------------------------ */
+/* This routine allocates storage with an extra twelve bytes; 8 are   */
+/* at the start and hold:                                             */
+/*   0-3 the original length requested                                */
+/*   4-7 buffer corruption detection fence (DECFENCE, x4)             */
+/* The 4 bytes at the end also hold a corruption fence (DECFENCE, x4) */
+/* ------------------------------------------------------------------ */
+static void *decMalloc(size_t n) {
+  uInt  size=n+12;                 // true size
+  void  *alloc;                    // -> allocated storage
+  uByte *b, *b0;                   // work
+  uInt  uiwork;                    // for macros
+
+  alloc=malloc(size);              // -> allocated storage
+  if (alloc==NULL) return NULL;    // out of strorage
+  b0=(uByte *)alloc;               // as bytes
+  decAllocBytes+=n;                // account for storage
+  UBFROMUI(alloc, n);              // save n
+  // printf(" alloc ++ dAB: %ld (%ld)\n", (LI)decAllocBytes, (LI)n);
+  for (b=b0+4; b<b0+8; b++) *b=DECFENCE;
+  for (b=b0+n+8; b<b0+n+12; b++) *b=DECFENCE;
+  return b0+8;                     // -> play area
+  } // decMalloc
+
+/* ------------------------------------------------------------------ */
+/* decFree -- accountable free routine                                */
+/*   alloc is the storage to free                                     */
+/*                                                                    */
+/* Semantics is the same as the stdlib malloc routine, except that    */
+/* the global storage accounting is updated and the fences are        */
+/* checked to ensure that no routine has written 'out of bounds'.     */
+/* ------------------------------------------------------------------ */
+/* This routine first checks that the fences have not been corrupted. */
+/* It then frees the storage using the 'truw' storage address (that   */
+/* is, offset by 8).                                                  */
+/* ------------------------------------------------------------------ */
+static void decFree(void *alloc) {
+  uInt  n;                         // original length
+  uByte *b, *b0;                   // work
+  uInt  uiwork;                    // for macros
+
+  if (alloc==NULL) return;         // allowed; it's a nop
+  b0=(uByte *)alloc;               // as bytes
+  b0-=8;                           // -> true start of storage
+  n=UBTOUI(b0);                    // lift length
+  for (b=b0+4; b<b0+8; b++) if (*b!=DECFENCE)
+    printf("=== Corrupt byte [%02x] at offset %d from %ld ===\n", *b,
+           b-b0-8, (LI)b0);
+  for (b=b0+n+8; b<b0+n+12; b++) if (*b!=DECFENCE)
+    printf("=== Corrupt byte [%02x] at offset +%d from %ld, n=%ld ===\n", *b,
+           b-b0-8, (LI)b0, (LI)n);
+  free(b0);                        // drop the storage
+  decAllocBytes-=n;                // account for storage
+  // printf(" free -- dAB: %d (%d)\n", decAllocBytes, -n);
+  } // decFree
+#define malloc(a) decMalloc(a)
+#define free(a) decFree(a)
+#endif
diff --git a/decNumber/decNumber.h b/decNumber/decNumber.h
index d2cd42ba..6f8a5a3e 100644
--- a/decNumber/decNumber.h
+++ b/decNumber/decNumber.h
@@ -1,144 +1,182 @@
-/* ------------------------------------------------------------------ */
-/* Decimal Number arithmetic module header                            */
-/* ------------------------------------------------------------------ */
-/* Copyright (c) IBM Corporation, 2000, 2006.  All rights reserved.   */
-/*                                                                    */
-/* This software is made available under the terms of the             */
-/* ICU License -- ICU 1.8.1 and later.                                */
-/*                                                                    */
-/* The description and User's Guide ("The decNumber C Library") for   */
-/* this software is called decNumber.pdf.  This document is           */
-/* available, together with arithmetic and format specifications,     */
-/* testcases, and Web links, at: http://www2.hursley.ibm.com/decimal  */
-/*                                                                    */
-/* Please send comments, suggestions, and corrections to the author:  */
-/*   mfc@uk.ibm.com                                                   */
-/*   Mike Cowlishaw, IBM Fellow                                       */
-/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
-/* ------------------------------------------------------------------ */
-
-#if !defined(DECNUMBER)
-  #define DECNUMBER
-  #define DECNAME     "decNumber"                       /* Short name */
-  #define DECVERSION  "decNumber 3.37"           /* Version [16 max.] */
-  #define DECFULLNAME "Decimal Number Module"         /* Verbose name */
-  #define DECAUTHOR   "Mike Cowlishaw"                /* Who to blame */
-
-  #if !defined(DECCONTEXT)
-    #include "decContext.h"
-  #endif
-
-  // Bit settings for decNumber.bits
-  #define DECNEG    0x80        // Sign; 1=negative, 0=positive or zero
-  #define DECINF    0x40        // 1=Infinity
-  #define DECNAN    0x20        // 1=NaN
-  #define DECSNAN   0x10        // 1=sNaN
-  // The remaining bits are reserved; they must be 0
-  #define DECSPECIAL (DECINF|DECNAN|DECSNAN) // any special value
-
-  // Define the decNumber data structure.  The size and shape of the
-  // units array in the structure is determined by the following
-  // constant.  This must not be changed without recompiling the
-  // decNumber library modules.
-  #define DECDPUN 3                // DECimal Digits Per UNit [must be in
-                                   // range 1-9; 3 or powers of 2 are best].
-
-  // DECNUMDIGITS is the default number of digits that can be held in
-  // the structure.  If undefined, 1 is assumed and it is assumed that
-  // the structure will be immediately followed by extra space, as
-  // required.  DECNUMDIGITS is always >0.
-  #if !defined(DECNUMDIGITS)
-    #define DECNUMDIGITS 1
-  #endif
-
-  // The size (integer data type) of each unit is determined by the
-  // number of digits it will hold.
-  #if   DECDPUN<=2
-    #define decNumberUnit uint8_t
-  #elif DECDPUN<=4
-    #define decNumberUnit uint16_t
-  #else
-    #define decNumberUnit uint32_t
-  #endif
-  // The number of decNumberUnits needed is ceil(DECNUMDIGITS/DECDPUN)
-  #define DECNUMUNITS ((DECNUMDIGITS+DECDPUN-1)/DECDPUN)
-
-  // The data structure...
-  typedef struct {
-    int32_t digits;                // Count of digits in the coefficient; >0
-    int32_t exponent;              // Unadjusted exponent, unbiased, in
-                                   // range: -1999999997 through 999999999
-    uint8_t bits;                  // Indicator bits (see above)
-    decNumberUnit lsu[DECNUMUNITS];// Coefficient, from least significant unit
-    } decNumber;
-
-  // Notes:
-  // 1. If digits is > DECDPUN then there will one or more
-  //    decNumberUnits immediately following the first element of lsu.
-  //    These contain the remaining (more significant) digits of the
-  //    number, and may be in the lsu array, or may be guaranteed by
-  //    some other mechanism (such as being contained in another
-  //    structure, or being overlaid on dynamically allocated storage).
-  //
-  //    Each integer of the coefficient (except potentially the last)
-  //    contains DECDPUN digits (e.g., a value in the range 0 through
-  //    99999999 if DECDPUN is 8, or 0 through 999 if DECDPUN is 3).
-  //
-  // 2. A decNumber converted to a string may need up to digits+14
-  //    characters.  The worst cases (non-exponential and exponential
-  //    formats) are: -0.00000{9...}#
-  //             and: -9.{9...}E+999999999#   (where # is '\0')
-
-
-  /* ------------------------------------------------------------------ */
-  /* decNumber public functions and macros                              */
-  /* ------------------------------------------------------------------ */
-  // Conversions
-  decNumber * decNumberFromString(decNumber *, const char *, decContext *);
-  char * decNumberToString(const decNumber *, char *);
-  char * decNumberToEngString(const decNumber *, char *);
-
-  // Operators and elementary functions
-  decNumber * decNumberAbs(decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberAdd(decNumber *, const decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberCompare(decNumber *, const decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberCompareTotal(decNumber *, const decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberDivide(decNumber *, const decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberDivideInteger(decNumber *, const decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberExp(decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberLn(decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberLog10(decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberMax(decNumber *, const decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberMin(decNumber *, const decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberMinus(decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberMultiply(decNumber *, const decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberNormalize(decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberPlus(decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberPower(decNumber *, const decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberQuantize(decNumber *, const decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberRemainder(decNumber *, const decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberRemainderNear(decNumber *, const decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberRescale(decNumber *, const decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberSameQuantum(decNumber *, const decNumber *, const decNumber *);
-  decNumber * decNumberSquareRoot(decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberSubtract(decNumber *, const decNumber *, const decNumber *, decContext *);
-  decNumber * decNumberToIntegralValue(decNumber *, const decNumber *, decContext *);
-
-  // Utilities
-  decNumber  * decNumberCopy(decNumber *, const decNumber *);
-  decNumber  * decNumberTrim(decNumber *);
-  const char * decNumberVersion(void);
-  decNumber  * decNumberZero(decNumber *);
-
-  // Macros for testing decNumbers
-  #define decNumberIsZero(dn)     (*(dn)->lsu==0 \
-                                   && (dn)->digits==1 \
-                                   && (((dn)->bits&DECSPECIAL)==0))
-  #define decNumberIsNegative(dn) (((dn)->bits&DECNEG)!=0)
-  #define decNumberIsNaN(dn)      (((dn)->bits&(DECNAN|DECSNAN))!=0)
-  #define decNumberIsQNaN(dn)     (((dn)->bits&(DECNAN))!=0)
-  #define decNumberIsSNaN(dn)     (((dn)->bits&(DECSNAN))!=0)
-  #define decNumberIsInfinite(dn) (((dn)->bits&DECINF)!=0)
-  #define decNumberIsSpecial(dn)  (((dn)->bits&DECSPECIAL)!=0)
-
-#endif
+/* ------------------------------------------------------------------ */
+/* Decimal Number arithmetic module header                            */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2010.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is called decNumber.pdf.  This document is           */
+/* available, together with arithmetic and format specifications,     */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+
+#if !defined(DECNUMBER)
+  #define DECNUMBER
+  #define DECNAME     "decNumber"                       /* Short name */
+  #define DECFULLNAME "Decimal Number Module"         /* Verbose name */
+  #define DECAUTHOR   "Mike Cowlishaw"                /* Who to blame */
+
+  #if !defined(DECCONTEXT)
+    #include "decContext.h"
+  #endif
+
+  /* Bit settings for decNumber.bits                                  */
+  #define DECNEG    0x80      /* Sign; 1=negative, 0=positive or zero */
+  #define DECINF    0x40      /* 1=Infinity                           */
+  #define DECNAN    0x20      /* 1=NaN                                */
+  #define DECSNAN   0x10      /* 1=sNaN                               */
+  /* The remaining bits are reserved; they must be 0                  */
+  #define DECSPECIAL (DECINF|DECNAN|DECSNAN) /* any special value     */
+
+  /* Define the decNumber data structure.  The size and shape of the  */
+  /* units array in the structure is determined by the following      */
+  /* constant.  This must not be changed without recompiling the      */
+  /* decNumber library modules. */
+
+  #define DECDPUN 3           /* DECimal Digits Per UNit [must be >0  */
+                              /* and <10; 3 or powers of 2 are best]. */
+
+  /* DECNUMDIGITS is the default number of digits that can be held in */
+  /* the structure.  If undefined, 1 is assumed and it is assumed     */
+  /* that the structure will be immediately followed by extra space,  */
+  /* as required.  DECNUMDIGITS is always >0.                         */
+  #if !defined(DECNUMDIGITS)
+    #define DECNUMDIGITS 1
+  #endif
+
+  /* The size (integer data type) of each unit is determined by the   */
+  /* number of digits it will hold.                                   */
+  #if   DECDPUN<=2
+    #define decNumberUnit uint8_t
+  #elif DECDPUN<=4
+    #define decNumberUnit uint16_t
+  #else
+    #define decNumberUnit uint32_t
+  #endif
+  /* The number of units needed is ceil(DECNUMDIGITS/DECDPUN)         */
+  #define DECNUMUNITS ((DECNUMDIGITS+DECDPUN-1)/DECDPUN)
+
+  /* The data structure... */
+  typedef struct {
+    int32_t digits;      /* Count of digits in the coefficient; >0    */
+    int32_t exponent;    /* Unadjusted exponent, unbiased, in         */
+                         /* range: -1999999997 through 999999999      */
+    uint8_t bits;        /* Indicator bits (see above)                */
+                         /* Coefficient, from least significant unit  */
+    decNumberUnit lsu[DECNUMUNITS];
+    } decNumber;
+
+  /* Notes:                                                           */
+  /* 1. If digits is > DECDPUN then there will one or more            */
+  /*    decNumberUnits immediately following the first element of lsu.*/
+  /*    These contain the remaining (more significant) digits of the  */
+  /*    number, and may be in the lsu array, or may be guaranteed by  */
+  /*    some other mechanism (such as being contained in another      */
+  /*    structure, or being overlaid on dynamically allocated         */
+  /*    storage).                                                     */
+  /*                                                                  */
+  /*    Each integer of the coefficient (except potentially the last) */
+  /*    contains DECDPUN digits (e.g., a value in the range 0 through */
+  /*    99999999 if DECDPUN is 8, or 0 through 999 if DECDPUN is 3).  */
+  /*                                                                  */
+  /* 2. A decNumber converted to a string may need up to digits+14    */
+  /*    characters.  The worst cases (non-exponential and exponential */
+  /*    formats) are -0.00000{9...}# and -9.{9...}E+999999999#        */
+  /*    (where # is '\0')                                             */
+
+
+  /* ---------------------------------------------------------------- */
+  /* decNumber public functions and macros                            */
+  /* ---------------------------------------------------------------- */
+  /* Conversions                                                      */
+  decNumber * decNumberFromInt32(decNumber *, int32_t);
+  decNumber * decNumberFromUInt32(decNumber *, uint32_t);
+  decNumber * decNumberFromString(decNumber *, const char *, decContext *);
+  char      * decNumberToString(const decNumber *, char *);
+  char      * decNumberToEngString(const decNumber *, char *);
+  uint32_t    decNumberToUInt32(const decNumber *, decContext *);
+  int32_t     decNumberToInt32(const decNumber *, decContext *);
+  uint8_t   * decNumberGetBCD(const decNumber *, uint8_t *);
+  decNumber * decNumberSetBCD(decNumber *, const uint8_t *, uint32_t);
+
+  /* Operators and elementary functions                               */
+  decNumber * decNumberAbs(decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberAdd(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberAnd(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberCompare(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberCompareSignal(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberCompareTotal(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberCompareTotalMag(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberDivide(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberDivideInteger(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberExp(decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberFMA(decNumber *, const decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberInvert(decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberLn(decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberLogB(decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberLog10(decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberMax(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberMaxMag(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberMin(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberMinMag(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberMinus(decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberMultiply(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberNormalize(decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberOr(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberPlus(decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberPower(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberQuantize(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberReduce(decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberRemainder(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberRemainderNear(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberRescale(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberRotate(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberSameQuantum(decNumber *, const decNumber *, const decNumber *);
+  decNumber * decNumberScaleB(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberShift(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberSquareRoot(decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberSubtract(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberToIntegralExact(decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberToIntegralValue(decNumber *, const decNumber *, decContext *);
+  decNumber * decNumberXor(decNumber *, const decNumber *, const decNumber *, decContext *);
+
+  /* Utilities                                                        */
+  enum decClass decNumberClass(const decNumber *, decContext *);
+  const char * decNumberClassToString(enum decClass);
+  decNumber  * decNumberCopy(decNumber *, const decNumber *);
+  decNumber  * decNumberCopyAbs(decNumber *, const decNumber *);
+  decNumber  * decNumberCopyNegate(decNumber *, const decNumber *);
+  decNumber  * decNumberCopySign(decNumber *, const decNumber *, const decNumber *);
+  decNumber  * decNumberNextMinus(decNumber *, const decNumber *, decContext *);
+  decNumber  * decNumberNextPlus(decNumber *, const decNumber *, decContext *);
+  decNumber  * decNumberNextToward(decNumber *, const decNumber *, const decNumber *, decContext *);
+  decNumber  * decNumberTrim(decNumber *);
+  const char * decNumberVersion(void);
+  decNumber  * decNumberZero(decNumber *);
+
+  /* Functions for testing decNumbers (normality depends on context)  */
+  int32_t decNumberIsNormal(const decNumber *, decContext *);
+  int32_t decNumberIsSubnormal(const decNumber *, decContext *);
+
+  /* Macros for testing decNumber *dn                                 */
+  #define decNumberIsCanonical(dn) (1)  /* All decNumbers are saintly */
+  #define decNumberIsFinite(dn)    (((dn)->bits&DECSPECIAL)==0)
+  #define decNumberIsInfinite(dn)  (((dn)->bits&DECINF)!=0)
+  #define decNumberIsNaN(dn)       (((dn)->bits&(DECNAN|DECSNAN))!=0)
+  #define decNumberIsNegative(dn)  (((dn)->bits&DECNEG)!=0)
+  #define decNumberIsQNaN(dn)      (((dn)->bits&(DECNAN))!=0)
+  #define decNumberIsSNaN(dn)      (((dn)->bits&(DECSNAN))!=0)
+  #define decNumberIsSpecial(dn)   (((dn)->bits&DECSPECIAL)!=0)
+  #define decNumberIsZero(dn)      (*(dn)->lsu==0 \
+                                    && (dn)->digits==1 \
+                                    && (((dn)->bits&DECSPECIAL)==0))
+  #define decNumberRadix(dn)       (10)
+
+#endif
diff --git a/decNumber/decNumber.rc b/decNumber/decNumber.rc
index ebeaabb9..c2c29381 100644
--- a/decNumber/decNumber.rc
+++ b/decNumber/decNumber.rc
@@ -6,19 +6,22 @@
  *
  * $Log$
  *
+ * the IBM copyright info was different in many modules
+ * here the most comprehensive one is used
+ *
  */
 
 #include <winver.h>
 
   #define DECNAME     "decNumber"                       /* Short name */
-  #define DECVERSION  "decNumber 3.37"           /* Version [16 max.] */
+  #define DECVERSION  "decNumber 3.68"           /* Version [16 max.] */
   #define DECFULLNAME "Decimal Number Module"         /* Verbose name */
   #define DECAUTHOR   "Mike Cowlishaw"                /* Who to blame */
 
-  #define DECCOPYRIGHT "Copyright (c) IBM Corporation, 2000, 2006"
+  #define DECCOPYRIGHT "Copyright (c) IBM Corporation, 2000, 2010"
   #define DECLICENSE   "ICU License -- ICU 1.8.1 and later"
   #define DECVERMAJOR 3                       /* Major version number */
-  #define DECVERMINOR 37                      /* Minor version number */
+  #define DECVERMINOR 68                      /* Minor version number */
 
   #define SPECIALINFO "Built for Hercules"
 
diff --git a/decNumber/decNumberLocal.h b/decNumber/decNumberLocal.h
index 7dcf0a12..5c88a5ea 100644
--- a/decNumber/decNumberLocal.h
+++ b/decNumber/decNumberLocal.h
@@ -1,200 +1,757 @@
-/* ------------------------------------------------------------------ */
-/* decNumber package local type, tuning, and macro definitions        */
-/* ------------------------------------------------------------------ */
-/* Copyright (c) IBM Corporation, 2000, 2005.  All rights reserved.   */
-/*                                                                    */
-/* This software is made available under the terms of the             */
-/* ICU License -- ICU 1.8.1 and later.                                */
-/*                                                                    */
-/* The description and User's Guide ("The decNumber C Library") for   */
-/* this software is called decNumber.pdf.  This document is           */
-/* available, together with arithmetic and format specifications,     */
-/* testcases, and Web links, at: http://www2.hursley.ibm.com/decimal  */
-/*                                                                    */
-/* Please send comments, suggestions, and corrections to the author:  */
-/*   mfc@uk.ibm.com                                                   */
-/*   Mike Cowlishaw, IBM Fellow                                       */
-/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
-/* ------------------------------------------------------------------ */
-/* This header file is included by all modules in the decNumber       */
-/* library, and contains local type definitions, tuning parameters,   */
-/* etc.  It must only be included once, and should not need to be     */
-/* used by application programs.  decNumber.h must be included first. */
-/* ------------------------------------------------------------------ */
-
-#if !defined(DECNUMBERLOC)
-  #define DECNUMBERLOC
-  #define DECNLAUTHOR   "Mike Cowlishaw"              /* Who to blame */
-
-  /* Tuning parameter */
-  #define DECBUFFER 36        // Maximum size basis for local buffers.
-                              // Should be a common maximum precision
-                              // rounded up to a multiple of 4; must
-                              // be zero or positive.
-
-  /* Conditional code flags -- set these to 1 for best performance */
-  #define DECENDIAN 1         // 1=concrete formats are endian
-  #define DECUSE64  1         // 1 to allow use of 64-bit integers
-
-  /* Conditional check flags -- set these to 0 for best performance */
-  #define DECCHECK  0         // 1 to enable robust checking
-  #define DECALLOC  0         // 1 to enable memory allocation accounting
-  #define DECTRACE  0         // 1 to trace critical intermediates, etc.
-
-  /* Local names for common types -- for safety, decNumber modules do
-     not use int or long directly */
-  #define Flag   uint8_t
-  #define Byte   int8_t
-  #define uByte  uint8_t
-  #define Short  int16_t
-  #define uShort uint16_t
-  #define Int    int32_t
-  #define uInt   uint32_t
-  #define Unit   decNumberUnit
-  #if DECUSE64
-  #define Long   int64_t
-  #define uLong  uint64_t
-  #endif
-
-  /* Development-use defines */
-  #if DECALLOC
-    // if these interfere with your C includes, just comment them out
-    #define  int ?            // enable to ensure that plain C 'int' or
-    #define  long ??          // .. 'long' types are not used
-  #endif
-
-  /* Limits and constants */
-  #define DECNUMMAXP 999999999  // maximum precision code can handle
-  #define DECNUMMAXE 999999999  // maximum adjusted exponent ditto
-  #define DECNUMMINE -999999999 // minimum adjusted exponent ditto
-  #if (DECNUMMAXP != DEC_MAX_DIGITS)
-    #error Maximum digits mismatch
-  #endif
-  #if (DECNUMMAXE != DEC_MAX_EMAX)
-    #error Maximum exponent mismatch
-  #endif
-  #if (DECNUMMINE != DEC_MIN_EMIN)
-    #error Minimum exponent mismatch
-  #endif
-
-  /* Set DECDPUNMAX -- the maximum integer that fits in DECDPUN    */
-  /* digits, and D2UTABLE -- the initializer for the D2U table     */
-  #if   DECDPUN==1
-    #define DECDPUNMAX 9
-    #define D2UTABLE {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,  \
-                      18,19,20,21,22,23,24,25,26,27,28,29,30,31,32, \
-                      33,34,35,36,37,38,39,40,41,42,43,44,45,46,47, \
-                      48,49}
-  #elif DECDPUN==2
-    #define DECDPUNMAX 99
-    #define D2UTABLE {0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,  \
-                      11,11,12,12,13,13,14,14,15,15,16,16,17,17,18, \
-                      18,19,19,20,20,21,21,22,22,23,23,24,24,25}
-  #elif DECDPUN==3
-    #define DECDPUNMAX 999
-    #define D2UTABLE {0,1,1,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7,7,  \
-                      8,8,8,9,9,9,10,10,10,11,11,11,12,12,12,13,13, \
-                      13,14,14,14,15,15,15,16,16,16,17}
-  #elif DECDPUN==4
-    #define DECDPUNMAX 9999
-    #define D2UTABLE {0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,  \
-                      6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11, \
-                      11,11,11,12,12,12,12,13}
-  #elif DECDPUN==5
-    #define DECDPUNMAX 99999
-    #define D2UTABLE {0,1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4,4,4,5,  \
-                      5,5,5,5,6,6,6,6,6,7,7,7,7,7,8,8,8,8,8,9,9,9,  \
-                      9,9,10,10,10,10}
-  #elif DECDPUN==6
-    #define DECDPUNMAX 999999
-    #define D2UTABLE {0,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,4,4,4,  \
-                      4,4,4,5,5,5,5,5,5,6,6,6,6,6,6,7,7,7,7,7,7,8,  \
-                      8,8,8,8,8,9}
-  #elif DECDPUN==7
-    #define DECDPUNMAX 9999999
-    #define D2UTABLE {0,1,1,1,1,1,1,1,2,2,2,2,2,2,2,3,3,3,3,3,3,3,  \
-                      4,4,4,4,4,4,4,5,5,5,5,5,5,5,6,6,6,6,6,6,6,7,  \
-                      7,7,7,7,7,7}
-  #elif DECDPUN==8
-    #define DECDPUNMAX 99999999
-    #define D2UTABLE {0,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3,  \
-                      3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,6,6,6,  \
-                      6,6,6,6,6,7}
-  #elif DECDPUN==9
-    #define DECDPUNMAX 999999999
-    #define D2UTABLE {0,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,3,3,3,  \
-                      3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,  \
-                      5,5,6,6,6,6}
-  #elif defined(DECDPUN)
-    #error DECDPUN must be in the range 1-9
-  #endif
-
-  /* ----- Shared data (in decNumber.c) ----- */
-  // Public powers of of ten array (powers[n]==10**n, 0<=n<=10)
-  extern const uInt powers[];
-  // Public lookup table used by the D2U macro (see below)
-  #define DECMAXD2U 49
-  extern const uByte d2utable[DECMAXD2U+1];
-
-  /* ----- Macros ----- */
-  // ISZERO -- return true if decNumber dn is a zero
-  // [performance-critical in some situations]
-  #define ISZERO(dn) decNumberIsZero(dn)     // now just a local name
-
-  // X10 and X100 -- multiply integer i by 10 or 100
-  // [shifts are usually faster than multiply; could be conditional]
-  #define X10(i)  (((i)<<1)+((i)<<3))
-  #define X100(i) (((i)<<2)+((i)<<5)+((i)<<6))
-
-  // D2U -- return the number of Units needed to hold d digits
-  // (runtime version, with table lookaside for small d)
-  #if DECDPUN==8
-    #define D2U(d) ((unsigned)((d)<=DECMAXD2U?d2utable[d]:((d)+7)>>3))
-  #elif DECDPUN==4
-    #define D2U(d) ((unsigned)((d)<=DECMAXD2U?d2utable[d]:((d)+3)>>2))
-  #else
-    #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN)
-  #endif
-  // SD2U -- static D2U macro (for compile-time calculation)
-  #define SD2U(d) (((d)+DECDPUN-1)/DECDPUN)
-
-  // MSUDIGITS -- returns digits in msu, calculated using D2U
-  #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN)
-
-  // D2N -- return the number of decNumber structs that would be
-  // needed to contain that number of digits (and the initial
-  // decNumber struct) safely.  Note that one Unit is included in the
-  // initial structure.  Used for allocating space that is aligned on
-  // a decNumber struct boundary.
-  #define D2N(d) \
-    ((((SD2U(d)-1)*sizeof(Unit))+sizeof(decNumber)*2-1)/sizeof(decNumber))
-
-  // TODIGIT -- macro to remove the leading digit from the unsigned
-  // integer u at column cut (counting from the right, LSD=0) and
-  // place it as an ASCII character into the character pointed to by
-  // c.  Note that cut must be <= 9, and the maximum value for u is
-  // 2,000,000,000 (as is needed for negative exponents of
-  // subnormals).  The unsigned integer pow is used as a temporary
-  // variable.
-  #define TODIGIT(u, cut, c, pow) {       \
-    *(c)='0';                             \
-    pow=powers[cut]*2;                    \
-    if ((u)>pow) {                        \
-      pow*=4;                             \
-      if ((u)>=pow) {(u)-=pow; *(c)+=8;}  \
-      pow/=2;                             \
-      if ((u)>=pow) {(u)-=pow; *(c)+=4;}  \
-      pow/=2;                             \
-      }                                   \
-    if ((u)>=pow) {(u)-=pow; *(c)+=2;}    \
-    pow/=2;                               \
-    if ((u)>=pow) {(u)-=pow; *(c)+=1;}    \
-    }
-
-  // MAX and MIN -- general max & min (not in ANSI)
-  #define MAX(x,y) ((x)<(y)?(y):(x))
-  #define MIN(x,y) ((x)>(y)?(y):(x))
-
-#else
-  #error decNumberLocal included more than once
-#endif
+/* ------------------------------------------------------------------ */
+/* decNumber package local type, tuning, and macro definitions        */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2010.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is called decNumber.pdf.  This document is           */
+/* available, together with arithmetic and format specifications,     */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+/* This header file is included by all modules in the decNumber       */
+/* library, and contains local type definitions, tuning parameters,   */
+/* etc.  It should not need to be used by application programs.       */
+/* decNumber.h or one of decDouble (etc.) must be included first.     */
+/* ------------------------------------------------------------------ */
+
+#if !defined(DECNUMBERLOC)
+  #define DECNUMBERLOC
+  #define DECVERSION    "decNumber 3.68" /* Package Version [16 max.] */
+  #define DECNLAUTHOR   "Mike Cowlishaw"              /* Who to blame */
+
+  #include <stdlib.h>         /* for abs                              */
+  #include <string.h>         /* for memset, strcpy                   */
+
+  /* Conditional code flag -- set this to match hardware platform     */
+  #if !defined(DECLITEND)
+  #define DECLITEND 1         /* 1=little-endian, 0=big-endian        */
+  #endif
+
+  /* Conditional code flag -- set this to 1 for best performance      */
+  #if !defined(DECUSE64)
+  #define DECUSE64  1         /* 1=use int64s, 0=int32 & smaller only */
+  #endif
+
+  /* Conditional code flag -- set this to 0 to exclude printf calls   */
+  #if !defined(DECPRINT)
+  #define DECPRINT  1         /* 1=allow printf calls; 0=no printf    */
+  #endif
+
+  /* Conditional check flags -- set these to 0 for best performance   */
+  #if !defined(DECCHECK)
+  #define DECCHECK  0         /* 1 to enable robust checking          */
+  #endif
+  #if !defined(DECALLOC)
+  #define DECALLOC  0         /* 1 to enable memory accounting        */
+  #endif
+  #if !defined(DECTRACE)
+  #define DECTRACE  0         /* 1 to trace certain internals, etc.   */
+  #endif
+
+  /* Tuning parameter for decNumber (arbitrary precision) module      */
+  #if !defined(DECBUFFER)
+  #define DECBUFFER 36        /* Size basis for local buffers.  This  */
+                              /* should be a common maximum precision */
+                              /* rounded up to a multiple of 4; must  */
+                              /* be zero or positive.                 */
+  #endif
+
+
+  /* ---------------------------------------------------------------- */
+  /* Check parameter dependencies                                     */
+  /* ---------------------------------------------------------------- */
+  #if DECCHECK & !DECPRINT
+    #error DECCHECK needs DECPRINT to be useful
+  #endif
+  #if DECALLOC & !DECPRINT
+    #error DECALLOC needs DECPRINT to be useful
+  #endif
+  #if DECTRACE & !DECPRINT
+    #error DECTRACE needs DECPRINT to be useful
+  #endif
+
+  /* ---------------------------------------------------------------- */
+  /* Definitions for all modules (general-purpose)                    */
+  /* ---------------------------------------------------------------- */
+
+  /* Local names for common types -- for safety, decNumber modules do */
+  /* not use int or long directly.                                    */
+  #define Flag   uint8_t
+  #define Byte   int8_t
+  #define uByte  uint8_t
+  #define Short  int16_t
+  #define uShort uint16_t
+  #define Int    int32_t
+  #define uInt   uint32_t
+  #define Unit   decNumberUnit
+  #if DECUSE64
+  #define Long   int64_t
+  #define uLong  uint64_t
+  #endif
+
+  /* Development-use definitions                                      */
+  typedef long int LI;        /* for printf arguments only            */
+  #define DECNOINT  0         /* 1 to check no internal use of 'int'  */
+                              /*   or stdint types                    */
+  #if DECNOINT
+    /* if these interfere with your C includes, do not set DECNOINT   */
+    #define int     ?         /* enable to ensure that plain C 'int'  */
+    #define long    ??        /* .. or 'long' types are not used      */
+  #endif
+
+  /* Shared lookup tables                                             */
+  extern const uByte  DECSTICKYTAB[10]; /* re-round digits if sticky  */
+  extern const uInt   DECPOWERS[10];    /* powers of ten table        */
+  /* The following are included from decDPD.h                         */
+  extern const uShort DPD2BIN[1024];    /* DPD -> 0-999               */
+  extern const uShort BIN2DPD[1000];    /* 0-999 -> DPD               */
+  extern const uInt   DPD2BINK[1024];   /* DPD -> 0-999000            */
+  extern const uInt   DPD2BINM[1024];   /* DPD -> 0-999000000         */
+  extern const uByte  DPD2BCD8[4096];   /* DPD -> ddd + len           */
+  extern const uByte  BIN2BCD8[4000];   /* 0-999 -> ddd + len         */
+  extern const uShort BCD2DPD[2458];    /* 0-0x999 -> DPD (0x999=2457)*/
+
+  /* LONGMUL32HI -- set w=(u*v)>>32, where w, u, and v are uInts      */
+  /* (that is, sets w to be the high-order word of the 64-bit result; */
+  /* the low-order word is simply u*v.)                               */
+  /* This version is derived from Knuth via Hacker's Delight;         */
+  /* it seems to optimize better than some others tried               */
+  #define LONGMUL32HI(w, u, v) {             \
+    uInt u0, u1, v0, v1, w0, w1, w2, t;      \
+    u0=u & 0xffff; u1=u>>16;                 \
+    v0=v & 0xffff; v1=v>>16;                 \
+    w0=u0*v0;                                \
+    t=u1*v0 + (w0>>16);                      \
+    w1=t & 0xffff; w2=t>>16;                 \
+    w1=u0*v1 + w1;                           \
+    (w)=u1*v1 + w2 + (w1>>16);}
+
+  /* ROUNDUP -- round an integer up to a multiple of n                */
+  #define ROUNDUP(i, n) ((((i)+(n)-1)/n)*n)
+  #define ROUNDUP4(i)   (((i)+3)&~3)    /* special for n=4            */
+
+  /* ROUNDDOWN -- round an integer down to a multiple of n            */
+  #define ROUNDDOWN(i, n) (((i)/n)*n)
+  #define ROUNDDOWN4(i)   ((i)&~3)      /* special for n=4            */
+
+  /* References to multi-byte sequences under different sizes; these  */
+  /* require locally declared variables, but do not violate strict    */
+  /* aliasing or alignment (as did the UINTAT simple cast to uInt).   */
+  /* Variables needed are uswork, uiwork, etc. [so do not use at same */
+  /* level in an expression, e.g., UBTOUI(x)==UBTOUI(y) may fail].    */
+
+  /* Return a uInt, etc., from bytes starting at a char* or uByte*    */
+  #define UBTOUS(b)  (memcpy((void *)&uswork, b, 2), uswork)
+  #define UBTOUI(b)  (memcpy((void *)&uiwork, b, 4), uiwork)
+
+  /* Store a uInt, etc., into bytes starting at a char* or uByte*.    */
+  /* Returns i, evaluated, for convenience; has to use uiwork because */
+  /* i may be an expression.                                          */
+  #define UBFROMUS(b, i)  (uswork=(i), memcpy(b, (void *)&uswork, 2), uswork)
+  #define UBFROMUI(b, i)  (uiwork=(i), memcpy(b, (void *)&uiwork, 4), uiwork)
+
+  /* X10 and X100 -- multiply integer i by 10 or 100                  */
+  /* [shifts are usually faster than multiply; could be conditional]  */
+  #define X10(i)  (((i)<<1)+((i)<<3))
+  #define X100(i) (((i)<<2)+((i)<<5)+((i)<<6))
+
+  /* MAXI and MINI -- general max & min (not in ANSI) for integers    */
+  #define MAXI(x,y) ((x)<(y)?(y):(x))
+  #define MINI(x,y) ((x)>(y)?(y):(x))
+
+  /* Useful constants                                                 */
+  #define BILLION      1000000000            /* 10**9                 */
+  /* CHARMASK: 0x30303030 for ASCII/UTF8; 0xF0F0F0F0 for EBCDIC       */
+  #define CHARMASK ((((((((uInt)'0')<<8)+'0')<<8)+'0')<<8)+'0')
+
+
+  /* ---------------------------------------------------------------- */
+  /* Definitions for arbitary-precision modules (only valid after     */
+  /* decNumber.h has been included)                                   */
+  /* ---------------------------------------------------------------- */
+
+  /* Limits and constants                                             */
+  #define DECNUMMAXP 999999999  /* maximum precision code can handle  */
+  #define DECNUMMAXE 999999999  /* maximum adjusted exponent ditto    */
+  #define DECNUMMINE -999999999 /* minimum adjusted exponent ditto    */
+  #if (DECNUMMAXP != DEC_MAX_DIGITS)
+    #error Maximum digits mismatch
+  #endif
+  #if (DECNUMMAXE != DEC_MAX_EMAX)
+    #error Maximum exponent mismatch
+  #endif
+  #if (DECNUMMINE != DEC_MIN_EMIN)
+    #error Minimum exponent mismatch
+  #endif
+
+  /* Set DECDPUNMAX -- the maximum integer that fits in DECDPUN       */
+  /* digits, and D2UTABLE -- the initializer for the D2U table        */
+  #if   DECDPUN==1
+    #define DECDPUNMAX 9
+    #define D2UTABLE {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,  \
+                      18,19,20,21,22,23,24,25,26,27,28,29,30,31,32, \
+                      33,34,35,36,37,38,39,40,41,42,43,44,45,46,47, \
+                      48,49}
+  #elif DECDPUN==2
+    #define DECDPUNMAX 99
+    #define D2UTABLE {0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,  \
+                      11,11,12,12,13,13,14,14,15,15,16,16,17,17,18, \
+                      18,19,19,20,20,21,21,22,22,23,23,24,24,25}
+  #elif DECDPUN==3
+    #define DECDPUNMAX 999
+    #define D2UTABLE {0,1,1,1,2,2,2,3,3,3,4,4,4,5,5,5,6,6,6,7,7,7,  \
+                      8,8,8,9,9,9,10,10,10,11,11,11,12,12,12,13,13, \
+                      13,14,14,14,15,15,15,16,16,16,17}
+  #elif DECDPUN==4
+    #define DECDPUNMAX 9999
+    #define D2UTABLE {0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,6,  \
+                      6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,11, \
+                      11,11,11,12,12,12,12,13}
+  #elif DECDPUN==5
+    #define DECDPUNMAX 99999
+    #define D2UTABLE {0,1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4,4,4,5,  \
+                      5,5,5,5,6,6,6,6,6,7,7,7,7,7,8,8,8,8,8,9,9,9,  \
+                      9,9,10,10,10,10}
+  #elif DECDPUN==6
+    #define DECDPUNMAX 999999
+    #define D2UTABLE {0,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,4,4,4,  \
+                      4,4,4,5,5,5,5,5,5,6,6,6,6,6,6,7,7,7,7,7,7,8,  \
+                      8,8,8,8,8,9}
+  #elif DECDPUN==7
+    #define DECDPUNMAX 9999999
+    #define D2UTABLE {0,1,1,1,1,1,1,1,2,2,2,2,2,2,2,3,3,3,3,3,3,3,  \
+                      4,4,4,4,4,4,4,5,5,5,5,5,5,5,6,6,6,6,6,6,6,7,  \
+                      7,7,7,7,7,7}
+  #elif DECDPUN==8
+    #define DECDPUNMAX 99999999
+    #define D2UTABLE {0,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3,  \
+                      3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,6,6,6,  \
+                      6,6,6,6,6,7}
+  #elif DECDPUN==9
+    #define DECDPUNMAX 999999999
+    #define D2UTABLE {0,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,3,3,3,  \
+                      3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,  \
+                      5,5,6,6,6,6}
+  #elif defined(DECDPUN)
+    #error DECDPUN must be in the range 1-9
+  #endif
+
+  /* ----- Shared data (in decNumber.c) ----- */
+  /* Public lookup table used by the D2U macro (see below)            */
+  #define DECMAXD2U 49
+  extern const uByte d2utable[DECMAXD2U+1];
+
+  /* ----- Macros ----- */
+  /* ISZERO -- return true if decNumber dn is a zero                  */
+  /* [performance-critical in some situations]                        */
+  #define ISZERO(dn) decNumberIsZero(dn)     /* now just a local name */
+
+  /* D2U -- return the number of Units needed to hold d digits        */
+  /* (runtime version, with table lookaside for small d)              */
+  #if DECDPUN==8
+    #define D2U(d) ((unsigned)((d)<=DECMAXD2U?d2utable[d]:((d)+7)>>3))
+  #elif DECDPUN==4
+    #define D2U(d) ((unsigned)((d)<=DECMAXD2U?d2utable[d]:((d)+3)>>2))
+  #else
+    #define D2U(d) ((d)<=DECMAXD2U?d2utable[d]:((d)+DECDPUN-1)/DECDPUN)
+  #endif
+  /* SD2U -- static D2U macro (for compile-time calculation)          */
+  #define SD2U(d) (((d)+DECDPUN-1)/DECDPUN)
+
+  /* MSUDIGITS -- returns digits in msu, from digits, calculated      */
+  /* using D2U                                                        */
+  #define MSUDIGITS(d) ((d)-(D2U(d)-1)*DECDPUN)
+
+  /* D2N -- return the number of decNumber structs that would be      */
+  /* needed to contain that number of digits (and the initial         */
+  /* decNumber struct) safely.  Note that one Unit is included in the */
+  /* initial structure.  Used for allocating space that is aligned on */
+  /* a decNumber struct boundary. */
+  #define D2N(d) \
+    ((((SD2U(d)-1)*sizeof(Unit))+sizeof(decNumber)*2-1)/sizeof(decNumber))
+
+  /* TODIGIT -- macro to remove the leading digit from the unsigned   */
+  /* integer u at column cut (counting from the right, LSD=0) and     */
+  /* place it as an ASCII character into the character pointed to by  */
+  /* c.  Note that cut must be <= 9, and the maximum value for u is   */
+  /* 2,000,000,000 (as is needed for negative exponents of            */
+  /* subnormals).  The unsigned integer pow is used as a temporary    */
+  /* variable. */
+  #define TODIGIT(u, cut, c, pow) {       \
+    *(c)='0';                             \
+    pow=DECPOWERS[cut]*2;                 \
+    if ((u)>pow) {                        \
+      pow*=4;                             \
+      if ((u)>=pow) {(u)-=pow; *(c)+=8;}  \
+      pow/=2;                             \
+      if ((u)>=pow) {(u)-=pow; *(c)+=4;}  \
+      pow/=2;                             \
+      }                                   \
+    if ((u)>=pow) {(u)-=pow; *(c)+=2;}    \
+    pow/=2;                               \
+    if ((u)>=pow) {(u)-=pow; *(c)+=1;}    \
+    }
+
+  /* ---------------------------------------------------------------- */
+  /* Definitions for fixed-precision modules (only valid after        */
+  /* decSingle.h, decDouble.h, or decQuad.h has been included)        */
+  /* ---------------------------------------------------------------- */
+
+  /* bcdnum -- a structure describing a format-independent finite     */
+  /* number, whose coefficient is a string of bcd8 uBytes             */
+  typedef struct {
+    uByte   *msd;             /* -> most significant digit            */
+    uByte   *lsd;             /* -> least ditto                       */
+    uInt     sign;            /* 0=positive, DECFLOAT_Sign=negative   */
+    Int      exponent;        /* Unadjusted signed exponent (q), or   */
+                              /* DECFLOAT_NaN etc. for a special      */
+    } bcdnum;
+
+  /* Test if exponent or bcdnum exponent must be a special, etc.      */
+  #define EXPISSPECIAL(exp) ((exp)>=DECFLOAT_MinSp)
+  #define EXPISINF(exp) (exp==DECFLOAT_Inf)
+  #define EXPISNAN(exp) (exp==DECFLOAT_qNaN || exp==DECFLOAT_sNaN)
+  #define NUMISSPECIAL(num) (EXPISSPECIAL((num)->exponent))
+
+  /* Refer to a 32-bit word or byte in a decFloat (df) by big-endian  */
+  /* (array) notation (the 0 word or byte contains the sign bit),     */
+  /* automatically adjusting for endianness; similarly address a word */
+  /* in the next-wider format (decFloatWider, or dfw)                 */
+  #define DECWORDS  (DECBYTES/4)
+  #define DECWWORDS (DECWBYTES/4)
+  #if DECLITEND
+    #define DFBYTE(df, off)   ((df)->bytes[DECBYTES-1-(off)])
+    #define DFWORD(df, off)   ((df)->words[DECWORDS-1-(off)])
+    #define DFWWORD(dfw, off) ((dfw)->words[DECWWORDS-1-(off)])
+  #else
+    #define DFBYTE(df, off)   ((df)->bytes[off])
+    #define DFWORD(df, off)   ((df)->words[off])
+    #define DFWWORD(dfw, off) ((dfw)->words[off])
+  #endif
+
+  /* Tests for sign or specials, directly on DECFLOATs                */
+  #define DFISSIGNED(df)  ((DFWORD(df, 0)&0x80000000)!=0)
+  #define DFISSPECIAL(df) ((DFWORD(df, 0)&0x78000000)==0x78000000)
+  #define DFISINF(df)     ((DFWORD(df, 0)&0x7c000000)==0x78000000)
+  #define DFISNAN(df)     ((DFWORD(df, 0)&0x7c000000)==0x7c000000)
+  #define DFISQNAN(df)    ((DFWORD(df, 0)&0x7e000000)==0x7c000000)
+  #define DFISSNAN(df)    ((DFWORD(df, 0)&0x7e000000)==0x7e000000)
+
+  /* Shared lookup tables                                             */
+  extern const uInt   DECCOMBMSD[64];   /* Combination field -> MSD   */
+  extern const uInt   DECCOMBFROM[48];  /* exp+msd -> Combination     */
+
+  /* Private generic (utility) routine                                */
+  #if DECCHECK || DECTRACE
+    extern void decShowNum(const bcdnum *, const char *);
+  #endif
+
+  /* Format-dependent macros and constants                            */
+  #if defined(DECPMAX)
+
+    /* Useful constants                                               */
+    #define DECPMAX9  (ROUNDUP(DECPMAX, 9)/9)  /* 'Pmax' in 10**9s    */
+    /* Top words for a zero                                           */
+    #define SINGLEZERO   0x22500000
+    #define DOUBLEZERO   0x22380000
+    #define QUADZERO     0x22080000
+    /* [ZEROWORD is defined to be one of these in the DFISZERO macro] */
+
+    /* Format-dependent common tests:                                 */
+    /*   DFISZERO   -- test for (any) zero                            */
+    /*   DFISCCZERO -- test for coefficient continuation being zero   */
+    /*   DFISCC01   -- test for coefficient contains only 0s and 1s   */
+    /*   DFISINT    -- test for finite and exponent q=0               */
+    /*   DFISUINT01 -- test for sign=0, finite, exponent q=0, and     */
+    /*                 MSD=0 or 1                                     */
+    /*   ZEROWORD is also defined here.                               */
+    /*                                                                */
+    /* In DFISZERO the first test checks the least-significant word   */
+    /* (most likely to be non-zero); the penultimate tests MSD and    */
+    /* DPDs in the signword, and the final test excludes specials and */
+    /* MSD>7.  DFISINT similarly has to allow for the two forms of    */
+    /* MSD codes.  DFISUINT01 only has to allow for one form of MSD   */
+    /* code.                                                          */
+    #if DECPMAX==7
+      #define ZEROWORD SINGLEZERO
+      /* [test macros not needed except for Zero]                     */
+      #define DFISZERO(df)  ((DFWORD(df, 0)&0x1c0fffff)==0         \
+                          && (DFWORD(df, 0)&0x60000000)!=0x60000000)
+    #elif DECPMAX==16
+      #define ZEROWORD DOUBLEZERO
+      #define DFISZERO(df)  ((DFWORD(df, 1)==0                     \
+                          && (DFWORD(df, 0)&0x1c03ffff)==0         \
+                          && (DFWORD(df, 0)&0x60000000)!=0x60000000))
+      #define DFISINT(df) ((DFWORD(df, 0)&0x63fc0000)==0x22380000  \
+                         ||(DFWORD(df, 0)&0x7bfc0000)==0x6a380000)
+      #define DFISUINT01(df) ((DFWORD(df, 0)&0xfbfc0000)==0x22380000)
+      #define DFISCCZERO(df) (DFWORD(df, 1)==0                     \
+                          && (DFWORD(df, 0)&0x0003ffff)==0)
+      #define DFISCC01(df)  ((DFWORD(df, 0)&~0xfffc9124)==0        \
+                          && (DFWORD(df, 1)&~0x49124491)==0)
+    #elif DECPMAX==34
+      #define ZEROWORD QUADZERO
+      #define DFISZERO(df)  ((DFWORD(df, 3)==0                     \
+                          &&  DFWORD(df, 2)==0                     \
+                          &&  DFWORD(df, 1)==0                     \
+                          && (DFWORD(df, 0)&0x1c003fff)==0         \
+                          && (DFWORD(df, 0)&0x60000000)!=0x60000000))
+      #define DFISINT(df) ((DFWORD(df, 0)&0x63ffc000)==0x22080000  \
+                         ||(DFWORD(df, 0)&0x7bffc000)==0x6a080000)
+      #define DFISUINT01(df) ((DFWORD(df, 0)&0xfbffc000)==0x22080000)
+      #define DFISCCZERO(df) (DFWORD(df, 3)==0                     \
+                          &&  DFWORD(df, 2)==0                     \
+                          &&  DFWORD(df, 1)==0                     \
+                          && (DFWORD(df, 0)&0x00003fff)==0)
+
+      #define DFISCC01(df)   ((DFWORD(df, 0)&~0xffffc912)==0       \
+                          &&  (DFWORD(df, 1)&~0x44912449)==0       \
+                          &&  (DFWORD(df, 2)&~0x12449124)==0       \
+                          &&  (DFWORD(df, 3)&~0x49124491)==0)
+    #endif
+
+    /* Macros to test if a certain 10 bits of a uInt or pair of uInts */
+    /* are a canonical declet [higher or lower bits are ignored].     */
+    /* declet is at offset 0 (from the right) in a uInt:              */
+    #define CANONDPD(dpd) (((dpd)&0x300)==0 || ((dpd)&0x6e)!=0x6e)
+    /* declet is at offset k (a multiple of 2) in a uInt:             */
+    #define CANONDPDOFF(dpd, k) (((dpd)&(0x300<<(k)))==0            \
+      || ((dpd)&(((uInt)0x6e)<<(k)))!=(((uInt)0x6e)<<(k)))
+    /* declet is at offset k (a multiple of 2) in a pair of uInts:    */
+    /* [the top 2 bits will always be in the more-significant uInt]   */
+    #define CANONDPDTWO(hi, lo, k) (((hi)&(0x300>>(32-(k))))==0     \
+      || ((hi)&(0x6e>>(32-(k))))!=(0x6e>>(32-(k)))                  \
+      || ((lo)&(((uInt)0x6e)<<(k)))!=(((uInt)0x6e)<<(k)))
+
+    /* Macro to test whether a full-length (length DECPMAX) BCD8      */
+    /* coefficient, starting at uByte u, is all zeros                 */
+    /* Test just the LSWord first, then the remainder as a sequence   */
+    /* of tests in order to avoid same-level use of UBTOUI            */
+    #if DECPMAX==7
+      #define ISCOEFFZERO(u) (                                      \
+           UBTOUI((u)+DECPMAX-4)==0                                 \
+        && UBTOUS((u)+DECPMAX-6)==0                                 \
+        && *(u)==0)
+    #elif DECPMAX==16
+      #define ISCOEFFZERO(u) (                                      \
+           UBTOUI((u)+DECPMAX-4)==0                                 \
+        && UBTOUI((u)+DECPMAX-8)==0                                 \
+        && UBTOUI((u)+DECPMAX-12)==0                                \
+        && UBTOUI(u)==0)
+    #elif DECPMAX==34
+      #define ISCOEFFZERO(u) (                                      \
+           UBTOUI((u)+DECPMAX-4)==0                                 \
+        && UBTOUI((u)+DECPMAX-8)==0                                 \
+        && UBTOUI((u)+DECPMAX-12)==0                                \
+        && UBTOUI((u)+DECPMAX-16)==0                                \
+        && UBTOUI((u)+DECPMAX-20)==0                                \
+        && UBTOUI((u)+DECPMAX-24)==0                                \
+        && UBTOUI((u)+DECPMAX-28)==0                                \
+        && UBTOUI((u)+DECPMAX-32)==0                                \
+        && UBTOUS(u)==0)
+    #endif
+
+    /* Macros and masks for the sign, exponent continuation, and MSD  */
+    /* Get the sign as DECFLOAT_Sign or 0                             */
+    #define GETSIGN(df) (DFWORD(df, 0)&0x80000000)
+    /* Get the exponent continuation from a decFloat *df as an Int    */
+    #define GETECON(df) ((Int)((DFWORD((df), 0)&0x03ffffff)>>(32-6-DECECONL)))
+    /* Ditto, from the next-wider format                              */
+    #define GETWECON(df) ((Int)((DFWWORD((df), 0)&0x03ffffff)>>(32-6-DECWECONL)))
+    /* Get the biased exponent similarly                              */
+    #define GETEXP(df)  ((Int)(DECCOMBEXP[DFWORD((df), 0)>>26]+GETECON(df)))
+    /* Get the unbiased exponent similarly                            */
+    #define GETEXPUN(df) ((Int)GETEXP(df)-DECBIAS)
+    /* Get the MSD similarly (as uInt)                                */
+    #define GETMSD(df)   (DECCOMBMSD[DFWORD((df), 0)>>26])
+
+    /* Compile-time computes of the exponent continuation field masks */
+    /* full exponent continuation field:                              */
+    #define ECONMASK ((0x03ffffff>>(32-6-DECECONL))<<(32-6-DECECONL))
+    /* same, not including its first digit (the qNaN/sNaN selector):  */
+    #define ECONNANMASK ((0x01ffffff>>(32-6-DECECONL))<<(32-6-DECECONL))
+
+    /* Macros to decode the coefficient in a finite decFloat *df into */
+    /* a BCD string (uByte *bcdin) of length DECPMAX uBytes.          */
+
+    /* In-line sequence to convert least significant 10 bits of uInt  */
+    /* dpd to three BCD8 digits starting at uByte u.  Note that an    */
+    /* extra byte is written to the right of the three digits because */
+    /* four bytes are moved at a time for speed; the alternative      */
+    /* macro moves exactly three bytes (usually slower).              */
+    #define dpd2bcd8(u, dpd)  memcpy(u, &DPD2BCD8[((dpd)&0x3ff)*4], 4)
+    #define dpd2bcd83(u, dpd) memcpy(u, &DPD2BCD8[((dpd)&0x3ff)*4], 3)
+
+    /* Decode the declets.  After extracting each one, it is decoded  */
+    /* to BCD8 using a table lookup (also used for variable-length    */
+    /* decode).  Each DPD decode is 3 bytes BCD8 plus a one-byte      */
+    /* length which is not used, here).  Fixed-length 4-byte moves    */
+    /* are fast, however, almost everywhere, and so are used except   */
+    /* for the final three bytes (to avoid overrun).  The code below  */
+    /* is 36 instructions for Doubles and about 70 for Quads, even    */
+    /* on IA32.                                                       */
+
+    /* Two macros are defined for each format:                        */
+    /*   GETCOEFF extracts the coefficient of the current format      */
+    /*   GETWCOEFF extracts the coefficient of the next-wider format. */
+    /* The latter is a copy of the next-wider GETCOEFF using DFWWORD. */
+
+    #if DECPMAX==7
+    #define GETCOEFF(df, bcd) {                          \
+      uInt sourhi=DFWORD(df, 0);                         \
+      *(bcd)=(uByte)DECCOMBMSD[sourhi>>26];              \
+      dpd2bcd8(bcd+1, sourhi>>10);                       \
+      dpd2bcd83(bcd+4, sourhi);}
+    #define GETWCOEFF(df, bcd) {                         \
+      uInt sourhi=DFWWORD(df, 0);                        \
+      uInt sourlo=DFWWORD(df, 1);                        \
+      *(bcd)=(uByte)DECCOMBMSD[sourhi>>26];              \
+      dpd2bcd8(bcd+1, sourhi>>8);                        \
+      dpd2bcd8(bcd+4, (sourhi<<2) | (sourlo>>30));       \
+      dpd2bcd8(bcd+7, sourlo>>20);                       \
+      dpd2bcd8(bcd+10, sourlo>>10);                      \
+      dpd2bcd83(bcd+13, sourlo);}
+
+    #elif DECPMAX==16
+    #define GETCOEFF(df, bcd) {                          \
+      uInt sourhi=DFWORD(df, 0);                         \
+      uInt sourlo=DFWORD(df, 1);                         \
+      *(bcd)=(uByte)DECCOMBMSD[sourhi>>26];              \
+      dpd2bcd8(bcd+1, sourhi>>8);                        \
+      dpd2bcd8(bcd+4, (sourhi<<2) | (sourlo>>30));       \
+      dpd2bcd8(bcd+7, sourlo>>20);                       \
+      dpd2bcd8(bcd+10, sourlo>>10);                      \
+      dpd2bcd83(bcd+13, sourlo);}
+    #define GETWCOEFF(df, bcd) {                         \
+      uInt sourhi=DFWWORD(df, 0);                        \
+      uInt sourmh=DFWWORD(df, 1);                        \
+      uInt sourml=DFWWORD(df, 2);                        \
+      uInt sourlo=DFWWORD(df, 3);                        \
+      *(bcd)=(uByte)DECCOMBMSD[sourhi>>26];              \
+      dpd2bcd8(bcd+1, sourhi>>4);                        \
+      dpd2bcd8(bcd+4, ((sourhi)<<6) | (sourmh>>26));     \
+      dpd2bcd8(bcd+7, sourmh>>16);                       \
+      dpd2bcd8(bcd+10, sourmh>>6);                       \
+      dpd2bcd8(bcd+13, ((sourmh)<<4) | (sourml>>28));    \
+      dpd2bcd8(bcd+16, sourml>>18);                      \
+      dpd2bcd8(bcd+19, sourml>>8);                       \
+      dpd2bcd8(bcd+22, ((sourml)<<2) | (sourlo>>30));    \
+      dpd2bcd8(bcd+25, sourlo>>20);                      \
+      dpd2bcd8(bcd+28, sourlo>>10);                      \
+      dpd2bcd83(bcd+31, sourlo);}
+
+    #elif DECPMAX==34
+    #define GETCOEFF(df, bcd) {                          \
+      uInt sourhi=DFWORD(df, 0);                         \
+      uInt sourmh=DFWORD(df, 1);                         \
+      uInt sourml=DFWORD(df, 2);                         \
+      uInt sourlo=DFWORD(df, 3);                         \
+      *(bcd)=(uByte)DECCOMBMSD[sourhi>>26];              \
+      dpd2bcd8(bcd+1, sourhi>>4);                        \
+      dpd2bcd8(bcd+4, ((sourhi)<<6) | (sourmh>>26));     \
+      dpd2bcd8(bcd+7, sourmh>>16);                       \
+      dpd2bcd8(bcd+10, sourmh>>6);                       \
+      dpd2bcd8(bcd+13, ((sourmh)<<4) | (sourml>>28));    \
+      dpd2bcd8(bcd+16, sourml>>18);                      \
+      dpd2bcd8(bcd+19, sourml>>8);                       \
+      dpd2bcd8(bcd+22, ((sourml)<<2) | (sourlo>>30));    \
+      dpd2bcd8(bcd+25, sourlo>>20);                      \
+      dpd2bcd8(bcd+28, sourlo>>10);                      \
+      dpd2bcd83(bcd+31, sourlo);}
+
+      #define GETWCOEFF(df, bcd) {??} /* [should never be used]       */
+    #endif
+
+    /* Macros to decode the coefficient in a finite decFloat *df into */
+    /* a base-billion uInt array, with the least-significant          */
+    /* 0-999999999 'digit' at offset 0.                               */
+
+    /* Decode the declets.  After extracting each one, it is decoded  */
+    /* to binary using a table lookup.  Three tables are used; one    */
+    /* the usual DPD to binary, the other two pre-multiplied by 1000  */
+    /* and 1000000 to avoid multiplication during decode.  These      */
+    /* tables can also be used for multiplying up the MSD as the DPD  */
+    /* code for 0 through 9 is the identity.                          */
+    #define DPD2BIN0 DPD2BIN         /* for prettier code             */
+
+    #if DECPMAX==7
+    #define GETCOEFFBILL(df, buf) {                           \
+      uInt sourhi=DFWORD(df, 0);                              \
+      (buf)[0]=DPD2BIN0[sourhi&0x3ff]                         \
+              +DPD2BINK[(sourhi>>10)&0x3ff]                   \
+              +DPD2BINM[DECCOMBMSD[sourhi>>26]];}
+
+    #elif DECPMAX==16
+    #define GETCOEFFBILL(df, buf) {                           \
+      uInt sourhi, sourlo;                                    \
+      sourlo=DFWORD(df, 1);                                   \
+      (buf)[0]=DPD2BIN0[sourlo&0x3ff]                         \
+              +DPD2BINK[(sourlo>>10)&0x3ff]                   \
+              +DPD2BINM[(sourlo>>20)&0x3ff];                  \
+      sourhi=DFWORD(df, 0);                                   \
+      (buf)[1]=DPD2BIN0[((sourhi<<2) | (sourlo>>30))&0x3ff]   \
+              +DPD2BINK[(sourhi>>8)&0x3ff]                    \
+              +DPD2BINM[DECCOMBMSD[sourhi>>26]];}
+
+    #elif DECPMAX==34
+    #define GETCOEFFBILL(df, buf) {                           \
+      uInt sourhi, sourmh, sourml, sourlo;                    \
+      sourlo=DFWORD(df, 3);                                   \
+      (buf)[0]=DPD2BIN0[sourlo&0x3ff]                         \
+              +DPD2BINK[(sourlo>>10)&0x3ff]                   \
+              +DPD2BINM[(sourlo>>20)&0x3ff];                  \
+      sourml=DFWORD(df, 2);                                   \
+      (buf)[1]=DPD2BIN0[((sourml<<2) | (sourlo>>30))&0x3ff]   \
+              +DPD2BINK[(sourml>>8)&0x3ff]                    \
+              +DPD2BINM[(sourml>>18)&0x3ff];                  \
+      sourmh=DFWORD(df, 1);                                   \
+      (buf)[2]=DPD2BIN0[((sourmh<<4) | (sourml>>28))&0x3ff]   \
+              +DPD2BINK[(sourmh>>6)&0x3ff]                    \
+              +DPD2BINM[(sourmh>>16)&0x3ff];                  \
+      sourhi=DFWORD(df, 0);                                   \
+      (buf)[3]=DPD2BIN0[((sourhi<<6) | (sourmh>>26))&0x3ff]   \
+              +DPD2BINK[(sourhi>>4)&0x3ff]                    \
+              +DPD2BINM[DECCOMBMSD[sourhi>>26]];}
+
+    #endif
+
+    /* Macros to decode the coefficient in a finite decFloat *df into */
+    /* a base-thousand uInt array (of size DECLETS+1, to allow for    */
+    /* the MSD), with the least-significant 0-999 'digit' at offset 0.*/
+
+    /* Decode the declets.  After extracting each one, it is decoded  */
+    /* to binary using a table lookup.                                */
+    #if DECPMAX==7
+    #define GETCOEFFTHOU(df, buf) {                           \
+      uInt sourhi=DFWORD(df, 0);                              \
+      (buf)[0]=DPD2BIN[sourhi&0x3ff];                         \
+      (buf)[1]=DPD2BIN[(sourhi>>10)&0x3ff];                   \
+      (buf)[2]=DECCOMBMSD[sourhi>>26];}
+
+    #elif DECPMAX==16
+    #define GETCOEFFTHOU(df, buf) {                           \
+      uInt sourhi, sourlo;                                    \
+      sourlo=DFWORD(df, 1);                                   \
+      (buf)[0]=DPD2BIN[sourlo&0x3ff];                         \
+      (buf)[1]=DPD2BIN[(sourlo>>10)&0x3ff];                   \
+      (buf)[2]=DPD2BIN[(sourlo>>20)&0x3ff];                   \
+      sourhi=DFWORD(df, 0);                                   \
+      (buf)[3]=DPD2BIN[((sourhi<<2) | (sourlo>>30))&0x3ff];   \
+      (buf)[4]=DPD2BIN[(sourhi>>8)&0x3ff];                    \
+      (buf)[5]=DECCOMBMSD[sourhi>>26];}
+
+    #elif DECPMAX==34
+    #define GETCOEFFTHOU(df, buf) {                           \
+      uInt sourhi, sourmh, sourml, sourlo;                    \
+      sourlo=DFWORD(df, 3);                                   \
+      (buf)[0]=DPD2BIN[sourlo&0x3ff];                         \
+      (buf)[1]=DPD2BIN[(sourlo>>10)&0x3ff];                   \
+      (buf)[2]=DPD2BIN[(sourlo>>20)&0x3ff];                   \
+      sourml=DFWORD(df, 2);                                   \
+      (buf)[3]=DPD2BIN[((sourml<<2) | (sourlo>>30))&0x3ff];   \
+      (buf)[4]=DPD2BIN[(sourml>>8)&0x3ff];                    \
+      (buf)[5]=DPD2BIN[(sourml>>18)&0x3ff];                   \
+      sourmh=DFWORD(df, 1);                                   \
+      (buf)[6]=DPD2BIN[((sourmh<<4) | (sourml>>28))&0x3ff];   \
+      (buf)[7]=DPD2BIN[(sourmh>>6)&0x3ff];                    \
+      (buf)[8]=DPD2BIN[(sourmh>>16)&0x3ff];                   \
+      sourhi=DFWORD(df, 0);                                   \
+      (buf)[9]=DPD2BIN[((sourhi<<6) | (sourmh>>26))&0x3ff];   \
+      (buf)[10]=DPD2BIN[(sourhi>>4)&0x3ff];                   \
+      (buf)[11]=DECCOMBMSD[sourhi>>26];}
+    #endif
+
+
+    /* Macros to decode the coefficient in a finite decFloat *df and  */
+    /* add to a base-thousand uInt array (as for GETCOEFFTHOU).       */
+    /* After the addition then most significant 'digit' in the array  */
+    /* might have a value larger then 10 (with a maximum of 19).      */
+    #if DECPMAX==7
+    #define ADDCOEFFTHOU(df, buf) {                           \
+      uInt sourhi=DFWORD(df, 0);                              \
+      (buf)[0]+=DPD2BIN[sourhi&0x3ff];                        \
+      if (buf[0]>999) {buf[0]-=1000; buf[1]++;}               \
+      (buf)[1]+=DPD2BIN[(sourhi>>10)&0x3ff];                  \
+      if (buf[1]>999) {buf[1]-=1000; buf[2]++;}               \
+      (buf)[2]+=DECCOMBMSD[sourhi>>26];}
+
+    #elif DECPMAX==16
+    #define ADDCOEFFTHOU(df, buf) {                           \
+      uInt sourhi, sourlo;                                    \
+      sourlo=DFWORD(df, 1);                                   \
+      (buf)[0]+=DPD2BIN[sourlo&0x3ff];                        \
+      if (buf[0]>999) {buf[0]-=1000; buf[1]++;}               \
+      (buf)[1]+=DPD2BIN[(sourlo>>10)&0x3ff];                  \
+      if (buf[1]>999) {buf[1]-=1000; buf[2]++;}               \
+      (buf)[2]+=DPD2BIN[(sourlo>>20)&0x3ff];                  \
+      if (buf[2]>999) {buf[2]-=1000; buf[3]++;}               \
+      sourhi=DFWORD(df, 0);                                   \
+      (buf)[3]+=DPD2BIN[((sourhi<<2) | (sourlo>>30))&0x3ff];  \
+      if (buf[3]>999) {buf[3]-=1000; buf[4]++;}               \
+      (buf)[4]+=DPD2BIN[(sourhi>>8)&0x3ff];                   \
+      if (buf[4]>999) {buf[4]-=1000; buf[5]++;}               \
+      (buf)[5]+=DECCOMBMSD[sourhi>>26];}
+
+    #elif DECPMAX==34
+    #define ADDCOEFFTHOU(df, buf) {                           \
+      uInt sourhi, sourmh, sourml, sourlo;                    \
+      sourlo=DFWORD(df, 3);                                   \
+      (buf)[0]+=DPD2BIN[sourlo&0x3ff];                        \
+      if (buf[0]>999) {buf[0]-=1000; buf[1]++;}               \
+      (buf)[1]+=DPD2BIN[(sourlo>>10)&0x3ff];                  \
+      if (buf[1]>999) {buf[1]-=1000; buf[2]++;}               \
+      (buf)[2]+=DPD2BIN[(sourlo>>20)&0x3ff];                  \
+      if (buf[2]>999) {buf[2]-=1000; buf[3]++;}               \
+      sourml=DFWORD(df, 2);                                   \
+      (buf)[3]+=DPD2BIN[((sourml<<2) | (sourlo>>30))&0x3ff];  \
+      if (buf[3]>999) {buf[3]-=1000; buf[4]++;}               \
+      (buf)[4]+=DPD2BIN[(sourml>>8)&0x3ff];                   \
+      if (buf[4]>999) {buf[4]-=1000; buf[5]++;}               \
+      (buf)[5]+=DPD2BIN[(sourml>>18)&0x3ff];                  \
+      if (buf[5]>999) {buf[5]-=1000; buf[6]++;}               \
+      sourmh=DFWORD(df, 1);                                   \
+      (buf)[6]+=DPD2BIN[((sourmh<<4) | (sourml>>28))&0x3ff];  \
+      if (buf[6]>999) {buf[6]-=1000; buf[7]++;}               \
+      (buf)[7]+=DPD2BIN[(sourmh>>6)&0x3ff];                   \
+      if (buf[7]>999) {buf[7]-=1000; buf[8]++;}               \
+      (buf)[8]+=DPD2BIN[(sourmh>>16)&0x3ff];                  \
+      if (buf[8]>999) {buf[8]-=1000; buf[9]++;}               \
+      sourhi=DFWORD(df, 0);                                   \
+      (buf)[9]+=DPD2BIN[((sourhi<<6) | (sourmh>>26))&0x3ff];  \
+      if (buf[9]>999) {buf[9]-=1000; buf[10]++;}              \
+      (buf)[10]+=DPD2BIN[(sourhi>>4)&0x3ff];                  \
+      if (buf[10]>999) {buf[10]-=1000; buf[11]++;}            \
+      (buf)[11]+=DECCOMBMSD[sourhi>>26];}
+    #endif
+
+
+    /* Set a decFloat to the maximum positive finite number (Nmax)    */
+    #if DECPMAX==7
+    #define DFSETNMAX(df)            \
+      {DFWORD(df, 0)=0x77f3fcff;}
+    #elif DECPMAX==16
+    #define DFSETNMAX(df)            \
+      {DFWORD(df, 0)=0x77fcff3f;     \
+       DFWORD(df, 1)=0xcff3fcff;}
+    #elif DECPMAX==34
+    #define DFSETNMAX(df)            \
+      {DFWORD(df, 0)=0x77ffcff3;     \
+       DFWORD(df, 1)=0xfcff3fcf;     \
+       DFWORD(df, 2)=0xf3fcff3f;     \
+       DFWORD(df, 3)=0xcff3fcff;}
+    #endif
+
+  /* [end of format-dependent macros and constants]                   */
+  #endif
+
+#else
+  #error decNumberLocal included more than once
+#endif
diff --git a/decNumber/decPacked.c b/decNumber/decPacked.c
index 7e50a917..9881139d 100644
--- a/decNumber/decPacked.c
+++ b/decNumber/decPacked.c
@@ -1,223 +1,220 @@
-/* ------------------------------------------------------------------ */
-/* Packed Decimal conversion module                                   */
-/* ------------------------------------------------------------------ */
-/* Copyright (c) IBM Corporation, 2000, 2002.  All rights reserved.   */
-/*                                                                    */
-/* This software is made available under the terms of the             */
-/* ICU License -- ICU 1.8.1 and later.                                */
-/*                                                                    */
-/* The description and User's Guide ("The decNumber C Library") for   */
-/* this software is called decNumber.pdf.  This document is           */
-/* available, together with arithmetic and format specifications,     */
-/* testcases, and Web links, at: http://www2.hursley.ibm.com/decimal  */
-/*                                                                    */
-/* Please send comments, suggestions, and corrections to the author:  */
-/*   mfc@uk.ibm.com                                                   */
-/*   Mike Cowlishaw, IBM Fellow                                       */
-/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
-/* ------------------------------------------------------------------ */
-/* This module comprises the routines for Packed Decimal format       */
-/* numbers.  Conversions are supplied to and from decNumber, which in */
-/* turn supports:                                                     */
-/*   conversions to and from string                                   */
-/*   arithmetic routines                                              */
-/*   utilities.                                                       */
-/* Conversions from decNumber to and from densely packed decimal      */
-/* formats are provided by the decimal32 through decimal128 modules.  */
-/* ------------------------------------------------------------------ */
-
-#include <string.h>           // for NULL
-#if defined(_MSVC_)
-#pragma warning(disable:4244) // (floating-point only?) "conversion from 'x' to 'y', possible loss of data"
-#endif /*defined(_MSVC_)*/
-#include "decNumber.h"        // base number library
-#include "decPacked.h"        // packed decimal
-#include "decNumberLocal.h"   // decNumber local types, etc.
-
-/* ------------------------------------------------------------------ */
-/* decPackedFromNumber -- convert decNumber to BCD Packed Decimal     */
-/*                                                                    */
-/*   bcd    is the BCD bytes                                          */
-/*   length is the length of the BCD array                            */
-/*   scale  is the scale result                                       */
-/*   dn     is the decNumber                                          */
-/*   returns bcd, or NULL if error                                    */
-/*                                                                    */
-/* The number is converted to a BCD packed decimal byte array,        */
-/* right aligned in the bcd array, whose length is indicated by the   */
-/* second parameter.  The final 4-bit nibble in the array will be a   */
-/* sign nibble, C (1100) for + and D (1101) for -.  Unused bytes and  */
-/* nibbles to the left of the number are set to 0.                    */
-/*                                                                    */
-/* scale is set to the scale of the number (this is the exponent,     */
-/* negated).  To force the number to a specified scale, first use the */
-/* decNumberRescale routine, which will round and change the exponent */
-/* as necessary.                                                      */
-/*                                                                    */
-/* If there is an error (that is, the decNumber has too many digits   */
-/* to fit in length bytes, or it is a NaN or Infinity), NULL is       */
-/* returned and the bcd and scale results are unchanged.  Otherwise   */
-/* bcd is returned.                                                   */
-/* ------------------------------------------------------------------ */
-uByte * decPackedFromNumber(uByte *bcd, Int length, Int *scale,
-                            const decNumber *dn) {
-  const Unit *up=dn->lsu;     // Unit array pointer
-  uByte obyte, *out;          // current output byte, and where it goes
-  Int indigs=dn->digits;      // digits processed
-  uInt cut=DECDPUN;           // downcounter per Unit
-  uInt u=*up;                 // work
-  uInt nib;                   // ..
-  #if DECDPUN<=4
-  uInt temp;                  // ..
-  #endif
-
-  if (dn->digits>length*2-1                  // too long ..
-   ||(dn->bits & DECSPECIAL)) return NULL;   // .. or special -- hopeless
-
-  if (dn->bits&DECNEG) obyte=DECPMINUS;      // set the sign ..
-   else                obyte=DECPPLUS;
-  *scale=-dn->exponent;                      // .. and scale
-
-  // loop from lowest (rightmost) byte
-  out=bcd+length-1;                          // -> final byte
-  for (; out>=bcd; out--) {
-    if (indigs>0) {
-      if (cut==0) {
-        up++;
-        u=*up;
-        cut=DECDPUN;
-        }
-      #if DECDPUN<=4
-        temp=(u*6554)>>16;         // fast /10
-        nib=u-X10(temp);
-        u=temp;
-      #else
-        nib=u%10;                  // cannot use *6554 trick :-(
-        u=u/10;
-      #endif
-      obyte|=(nib<<4);
-      indigs--;
-      cut--;
-      }
-    *out=obyte;
-    obyte=0;                       // assume 0
-    if (indigs>0) {
-      if (cut==0) {
-        up++;
-        u=*up;
-        cut=DECDPUN;
-        }
-      #if DECDPUN<=4
-        temp=(u*6554)>>16;         // as above
-        obyte=(uByte)(u-X10(temp));
-        u=temp;
-      #else
-        obyte=(uByte)(u%10);
-        u=u/10;
-      #endif
-      indigs--;
-      cut--;
-      }
-    } // loop
-
-  return bcd;
-  } // decPackedFromNumber
-
-/* ------------------------------------------------------------------ */
-/* decPackedToNumber -- convert BCD Packed Decimal to a decNumber     */
-/*                                                                    */
-/*   bcd    is the BCD bytes                                          */
-/*   length is the length of the BCD array                            */
-/*   scale  is the scale associated with the BCD integer              */
-/*   dn     is the decNumber [with space for length*2 digits]         */
-/*   returns dn, or NULL if error                                     */
-/*                                                                    */
-/* The BCD packed decimal byte array, together with an associated     */
-/* scale, is converted to a decNumber.  The BCD array is assumed full */
-/* of digits, and must be ended by a 4-bit sign nibble in the least   */
-/* significant four bits of the final byte.                           */
-/*                                                                    */
-/* The scale is used (negated) as the exponent of the decNumber.      */
-/* Note that zeros may have a sign and/or a scale.                    */
-/*                                                                    */
-/* The decNumber structure is assumed to have sufficient space to     */
-/* hold the converted number (that is, up to length*2-1 digits), so   */
-/* no error is possible unless the adjusted exponent is out of range, */
-/* no sign nibble was found, or a sign nibble was found before the    */
-/* final nibble.  In these error cases, NULL is returned and the      */
-/* decNumber will be 0.                                               */
-/* ------------------------------------------------------------------ */
-decNumber * decPackedToNumber(const uByte *bcd, Int length,
-                              const Int *scale, decNumber *dn) {
-  const uByte *last=bcd+length-1;  // -> last byte
-  const uByte *first;              // -> first non-zero byte
-  uInt  nib;                       // work nibble
-  Unit  *up=dn->lsu;               // output pointer
-  Int   digits;                    // digits count
-  Int   cut=0;                     // phase of output
-
-  decNumberZero(dn);               // default result
-  last=&bcd[length-1];
-  nib=*last & 0x0f;                // get the sign
-  if (nib==DECPMINUS || nib==DECPMINUSALT) dn->bits=DECNEG;
-   else if (nib<=9) return NULL;   // not a sign nibble
-
-  // skip leading zero bytes [final byte is always non-zero, due to sign]
-  for (first=bcd; *first==0;) first++;
-  digits=(last-first)*2+1;              // calculate digits ..
-  if ((*first & 0xf0)==0) digits--;     // adjust for leading zero nibble
-  if (digits!=0) dn->digits=digits;     // count of actual digits [if 0,
-                                        // leave as 1]
-
-  // check the adjusted exponent; note that scale could be unbounded
-  dn->exponent=-*scale;                 // set the exponent
-  if (*scale>=0) {                      // usual case
-    if ((dn->digits-*scale-1)<-DECNUMMAXE) {      // underflow
-      decNumberZero(dn);
-      return NULL;}
-    }
-   else { // -ve scale; +ve exponent
-    // need to be careful to avoid wrap, here, also BADINT case
-    if ((*scale<-DECNUMMAXE)            // overflow even without digits
-         || ((dn->digits-*scale-1)>DECNUMMAXE)) { // overflow
-      decNumberZero(dn);
-      return NULL;}
-    }
-  if (digits==0) return dn;             // result was zero
-
-  // copy the digits to the number's units, starting at the lsu
-  // [unrolled]
-  for (;;) {                            // forever
-    // left nibble first
-    nib=(unsigned)(*last & 0xf0)>>4;
-    // got a digit, in nib
-    if (nib>9) {decNumberZero(dn); return NULL;}
-
-    if (cut==0) *up=(Unit)nib;
-     else *up=(Unit)(*up+nib*powers[cut]);
-    digits--;
-    if (digits==0) break;               // got them all
-    cut++;
-    if (cut==DECDPUN) {
-      up++;
-      cut=0;
-      }
-    last--;                             // ready for next
-    nib=*last & 0x0f;                   // get right nibble
-    if (nib>9) {decNumberZero(dn); return NULL;}
-
-    // got a digit, in nib
-    if (cut==0) *up=(Unit)nib;
-     else *up=(Unit)(*up+nib*powers[cut]);
-    digits--;
-    if (digits==0) break;               // got them all
-    cut++;
-    if (cut==DECDPUN) {
-      up++;
-      cut=0;
-      }
-    } // forever
-
-  return dn;
-  } // decPackedToNumber
-
+/* ------------------------------------------------------------------ */
+/* Packed Decimal conversion module                                   */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2002.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is called decNumber.pdf.  This document is           */
+/* available, together with arithmetic and format specifications,     */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+/* This module comprises the routines for Packed Decimal format       */
+/* numbers.  Conversions are supplied to and from decNumber, which in */
+/* turn supports:                                                     */
+/*   conversions to and from string                                   */
+/*   arithmetic routines                                              */
+/*   utilities.                                                       */
+/* Conversions from decNumber to and from densely packed decimal      */
+/* formats are provided by the decimal32 through decimal128 modules.  */
+/* ------------------------------------------------------------------ */
+
+#include <string.h>           // for NULL
+#include "decNumber.h"        // base number library
+#include "decPacked.h"        // packed decimal
+#include "decNumberLocal.h"   // decNumber local types, etc.
+
+/* ------------------------------------------------------------------ */
+/* decPackedFromNumber -- convert decNumber to BCD Packed Decimal     */
+/*                                                                    */
+/*   bcd    is the BCD bytes                                          */
+/*   length is the length of the BCD array                            */
+/*   scale  is the scale result                                       */
+/*   dn     is the decNumber                                          */
+/*   returns bcd, or NULL if error                                    */
+/*                                                                    */
+/* The number is converted to a BCD packed decimal byte array,        */
+/* right aligned in the bcd array, whose length is indicated by the   */
+/* second parameter.  The final 4-bit nibble in the array will be a   */
+/* sign nibble, C (1100) for + and D (1101) for -.  Unused bytes and  */
+/* nibbles to the left of the number are set to 0.                    */
+/*                                                                    */
+/* scale is set to the scale of the number (this is the exponent,     */
+/* negated).  To force the number to a specified scale, first use the */
+/* decNumberRescale routine, which will round and change the exponent */
+/* as necessary.                                                      */
+/*                                                                    */
+/* If there is an error (that is, the decNumber has too many digits   */
+/* to fit in length bytes, or it is a NaN or Infinity), NULL is       */
+/* returned and the bcd and scale results are unchanged.  Otherwise   */
+/* bcd is returned.                                                   */
+/* ------------------------------------------------------------------ */
+uByte * decPackedFromNumber(uByte *bcd, Int length, Int *scale,
+                            const decNumber *dn) {
+  const Unit *up=dn->lsu;     // Unit array pointer
+  uByte obyte, *out;          // current output byte, and where it goes
+  Int indigs=dn->digits;      // digits processed
+  uInt cut=DECDPUN;           // downcounter per Unit
+  uInt u=*up;                 // work
+  uInt nib;                   // ..
+  #if DECDPUN<=4
+  uInt temp;                  // ..
+  #endif
+
+  if (dn->digits>length*2-1                  // too long ..
+   ||(dn->bits & DECSPECIAL)) return NULL;   // .. or special -- hopeless
+
+  if (dn->bits&DECNEG) obyte=DECPMINUS;      // set the sign ..
+   else                obyte=DECPPLUS;
+  *scale=-dn->exponent;                      // .. and scale
+
+  // loop from lowest (rightmost) byte
+  out=bcd+length-1;                          // -> final byte
+  for (; out>=bcd; out--) {
+    if (indigs>0) {
+      if (cut==0) {
+        up++;
+        u=*up;
+        cut=DECDPUN;
+        }
+      #if DECDPUN<=4
+        temp=(u*6554)>>16;         // fast /10
+        nib=u-X10(temp);
+        u=temp;
+      #else
+        nib=u%10;                  // cannot use *6554 trick :-(
+        u=u/10;
+      #endif
+      obyte|=(nib<<4);
+      indigs--;
+      cut--;
+      }
+    *out=obyte;
+    obyte=0;                       // assume 0
+    if (indigs>0) {
+      if (cut==0) {
+        up++;
+        u=*up;
+        cut=DECDPUN;
+        }
+      #if DECDPUN<=4
+        temp=(u*6554)>>16;         // as above
+        obyte=(uByte)(u-X10(temp));
+        u=temp;
+      #else
+        obyte=(uByte)(u%10);
+        u=u/10;
+      #endif
+      indigs--;
+      cut--;
+      }
+    } // loop
+
+  return bcd;
+  } // decPackedFromNumber
+
+/* ------------------------------------------------------------------ */
+/* decPackedToNumber -- convert BCD Packed Decimal to a decNumber     */
+/*                                                                    */
+/*   bcd    is the BCD bytes                                          */
+/*   length is the length of the BCD array                            */
+/*   scale  is the scale associated with the BCD integer              */
+/*   dn     is the decNumber [with space for length*2 digits]         */
+/*   returns dn, or NULL if error                                     */
+/*                                                                    */
+/* The BCD packed decimal byte array, together with an associated     */
+/* scale, is converted to a decNumber.  The BCD array is assumed full */
+/* of digits, and must be ended by a 4-bit sign nibble in the least   */
+/* significant four bits of the final byte.                           */
+/*                                                                    */
+/* The scale is used (negated) as the exponent of the decNumber.      */
+/* Note that zeros may have a sign and/or a scale.                    */
+/*                                                                    */
+/* The decNumber structure is assumed to have sufficient space to     */
+/* hold the converted number (that is, up to length*2-1 digits), so   */
+/* no error is possible unless the adjusted exponent is out of range, */
+/* no sign nibble was found, or a sign nibble was found before the    */
+/* final nibble.  In these error cases, NULL is returned and the      */
+/* decNumber will be 0.                                               */
+/* ------------------------------------------------------------------ */
+decNumber * decPackedToNumber(const uByte *bcd, Int length,
+                              const Int *scale, decNumber *dn) {
+  const uByte *last=bcd+length-1;  // -> last byte
+  const uByte *first;              // -> first non-zero byte
+  uInt  nib;                       // work nibble
+  Unit  *up=dn->lsu;               // output pointer
+  Int   digits;                    // digits count
+  Int   cut=0;                     // phase of output
+
+  decNumberZero(dn);               // default result
+  last=&bcd[length-1];
+  nib=*last & 0x0f;                // get the sign
+  if (nib==DECPMINUS || nib==DECPMINUSALT) dn->bits=DECNEG;
+   else if (nib<=9) return NULL;   // not a sign nibble
+
+  // skip leading zero bytes [final byte is always non-zero, due to sign]
+  for (first=bcd; *first==0;) first++;
+  digits=(last-first)*2+1;              // calculate digits ..
+  if ((*first & 0xf0)==0) digits--;     // adjust for leading zero nibble
+  if (digits!=0) dn->digits=digits;     // count of actual digits [if 0,
+                                        // leave as 1]
+
+  // check the adjusted exponent; note that scale could be unbounded
+  dn->exponent=-*scale;                 // set the exponent
+  if (*scale>=0) {                      // usual case
+    if ((dn->digits-*scale-1)<-DECNUMMAXE) {      // underflow
+      decNumberZero(dn);
+      return NULL;}
+    }
+   else { // -ve scale; +ve exponent
+    // need to be careful to avoid wrap, here, also BADINT case
+    if ((*scale<-DECNUMMAXE)            // overflow even without digits
+         || ((dn->digits-*scale-1)>DECNUMMAXE)) { // overflow
+      decNumberZero(dn);
+      return NULL;}
+    }
+  if (digits==0) return dn;             // result was zero
+
+  // copy the digits to the number's units, starting at the lsu
+  // [unrolled]
+  for (;;) {                            // forever
+    // left nibble first
+    nib=(unsigned)(*last & 0xf0)>>4;
+    // got a digit, in nib
+    if (nib>9) {decNumberZero(dn); return NULL;}
+
+    if (cut==0) *up=(Unit)nib;
+     else *up=(Unit)(*up+nib*DECPOWERS[cut]);
+    digits--;
+    if (digits==0) break;               // got them all
+    cut++;
+    if (cut==DECDPUN) {
+      up++;
+      cut=0;
+      }
+    last--;                             // ready for next
+    nib=*last & 0x0f;                   // get right nibble
+    if (nib>9) {decNumberZero(dn); return NULL;}
+
+    // got a digit, in nib
+    if (cut==0) *up=(Unit)nib;
+     else *up=(Unit)(*up+nib*DECPOWERS[cut]);
+    digits--;
+    if (digits==0) break;               // got them all
+    cut++;
+    if (cut==DECDPUN) {
+      up++;
+      cut=0;
+      }
+    } // forever
+
+  return dn;
+  } // decPackedToNumber
+
diff --git a/decNumber/decPacked.h b/decNumber/decPacked.h
index 5669edf0..320d53fa 100644
--- a/decNumber/decPacked.h
+++ b/decNumber/decPacked.h
@@ -1,50 +1,52 @@
-/* ------------------------------------------------------------------ */
-/* Packed Decimal conversion module header                            */
-/* ------------------------------------------------------------------ */
-/* Copyright (c) IBM Corporation, 2000, 2005.  All rights reserved.   */
-/*                                                                    */
-/* This software is made available under the terms of the             */
-/* ICU License -- ICU 1.8.1 and later.                                */
-/*                                                                    */
-/* The description and User's Guide ("The decNumber C Library") for   */
-/* this software is called decNumber.pdf.  This document is           */
-/* available, together with arithmetic and format specifications,     */
-/* testcases, and Web links, at: http://www2.hursley.ibm.com/decimal  */
-/*                                                                    */
-/* Please send comments, suggestions, and corrections to the author:  */
-/*   mfc@uk.ibm.com                                                   */
-/*   Mike Cowlishaw, IBM Fellow                                       */
-/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
-/* ------------------------------------------------------------------ */
-
-#if !defined(DECPACKED)
-  #define DECPACKED
-  #define DECPNAME     "decPacked"                      /* Short name */
-  #define DECPFULLNAME "Packed Decimal conversions"   /* Verbose name */
-  #define DECPAUTHOR   "Mike Cowlishaw"               /* Who to blame */
-
-  #define DECPACKED_DefP 32             // default precision
-
-  #ifndef  DECNUMDIGITS
-    #define DECNUMDIGITS DECPACKED_DefP // size if not already defined
-  #endif
-  #include "decNumber.h"                // context and number library
-
-  /* Sign nibble constants */
-  #define DECPPLUSALT  0x0A   // alternate plus nibble
-  #define DECPMINUSALT 0x0B   // alternate minus nibble
-  #define DECPPLUS     0x0C   // preferred plus nibble
-  #define DECPMINUS    0x0D   // preferred minus nibble
-  #define DECPPLUSALT2 0x0E   // alternate plus nibble
-  #define DECPUNSIGNED 0x0F   // alternate plus nibble (unsigned)
-
-  /* ---------------------------------------------------------------- */
-  /* decPacked public routines                                        */
-  /* ---------------------------------------------------------------- */
-  // Conversions
-  uint8_t * decPackedFromNumber(uint8_t *, int32_t, int32_t *,
-                                const decNumber *);
-  decNumber * decPackedToNumber(const uint8_t *, int32_t, const int32_t *,
-                                decNumber *);
-
-#endif
+/* ------------------------------------------------------------------ */
+/* Packed Decimal conversion module header                            */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2005.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is called decNumber.pdf.  This document is           */
+/* available, together with arithmetic and format specifications,     */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+
+#if !defined(DECPACKED)
+  #define DECPACKED
+  #define DECPNAME     "decPacked"                      /* Short name */
+  #define DECPFULLNAME "Packed Decimal conversions"   /* Verbose name */
+  #define DECPAUTHOR   "Mike Cowlishaw"               /* Who to blame */
+
+  #define DECPACKED_DefP 32             /* default precision          */
+
+  #ifndef  DECNUMDIGITS
+    #define DECNUMDIGITS DECPACKED_DefP /* size if not already defined*/
+  #endif
+  #include "decNumber.h"                /* context and number library */
+
+  /* Sign nibble constants                                            */
+  #if !defined(DECPPLUSALT)
+    #define DECPPLUSALT  0x0A /* alternate plus  nibble               */
+    #define DECPMINUSALT 0x0B /* alternate minus nibble               */
+    #define DECPPLUS     0x0C /* preferred plus  nibble               */
+    #define DECPMINUS    0x0D /* preferred minus nibble               */
+    #define DECPPLUSALT2 0x0E /* alternate plus  nibble               */
+    #define DECPUNSIGNED 0x0F /* alternate plus  nibble (unsigned)    */
+  #endif
+
+  /* ---------------------------------------------------------------- */
+  /* decPacked public routines                                        */
+  /* ---------------------------------------------------------------- */
+  /* Conversions                                                      */
+  uint8_t * decPackedFromNumber(uint8_t *, int32_t, int32_t *,
+                                const decNumber *);
+  decNumber * decPackedToNumber(const uint8_t *, int32_t, const int32_t *,
+                                decNumber *);
+
+#endif
diff --git a/decNumber/decQuad.c b/decNumber/decQuad.c
new file mode 100644
index 00000000..6394da8a
--- /dev/null
+++ b/decNumber/decQuad.c
@@ -0,0 +1,135 @@
+/* ------------------------------------------------------------------ */
+/* decQuad.c -- decQuad operations module                             */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2010.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is included in the package as decNumber.pdf.  This   */
+/* document is also available in HTML, together with specifications,  */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+/* This module comprises decQuad operations (including conversions)   */
+/* ------------------------------------------------------------------ */
+
+
+/* Constant mappings for shared code */
+#define DECPMAX     DECQUAD_Pmax
+#define DECEMIN     DECQUAD_Emin
+#define DECEMAX     DECQUAD_Emax
+#define DECEMAXD    DECQUAD_EmaxD
+#define DECBYTES    DECQUAD_Bytes
+#define DECSTRING   DECQUAD_String
+#define DECECONL    DECQUAD_EconL
+#define DECBIAS     DECQUAD_Bias
+#define DECLETS     DECQUAD_Declets
+#define DECQTINY   (-DECQUAD_Bias)
+
+/* Type and function mappings for shared code */
+#define decFloat                   decQuad        // Type name
+
+// Utilities and conversions (binary results, extractors, etc.)
+#define decFloatFromBCD            decQuadFromBCD
+#define decFloatFromInt32          decQuadFromInt32
+#define decFloatFromPacked         decQuadFromPacked
+#define decFloatFromPackedChecked  decQuadFromPackedChecked
+#define decFloatFromString         decQuadFromString
+#define decFloatFromUInt32         decQuadFromUInt32
+#define decFloatFromWider          decQuadFromWider
+#define decFloatGetCoefficient     decQuadGetCoefficient
+#define decFloatGetExponent        decQuadGetExponent
+#define decFloatSetCoefficient     decQuadSetCoefficient
+#define decFloatSetExponent        decQuadSetExponent
+#define decFloatShow               decQuadShow
+#define decFloatToBCD              decQuadToBCD
+#define decFloatToEngString        decQuadToEngString
+#define decFloatToInt32            decQuadToInt32
+#define decFloatToInt32Exact       decQuadToInt32Exact
+#define decFloatToPacked           decQuadToPacked
+#define decFloatToString           decQuadToString
+#define decFloatToUInt32           decQuadToUInt32
+#define decFloatToUInt32Exact      decQuadToUInt32Exact
+#define decFloatToWider            decQuadToWider
+#define decFloatZero               decQuadZero
+
+// Computational (result is a decFloat)
+#define decFloatAbs                decQuadAbs
+#define decFloatAdd                decQuadAdd
+#define decFloatAnd                decQuadAnd
+#define decFloatDivide             decQuadDivide
+#define decFloatDivideInteger      decQuadDivideInteger
+#define decFloatFMA                decQuadFMA
+#define decFloatInvert             decQuadInvert
+#define decFloatLogB               decQuadLogB
+#define decFloatMax                decQuadMax
+#define decFloatMaxMag             decQuadMaxMag
+#define decFloatMin                decQuadMin
+#define decFloatMinMag             decQuadMinMag
+#define decFloatMinus              decQuadMinus
+#define decFloatMultiply           decQuadMultiply
+#define decFloatNextMinus          decQuadNextMinus
+#define decFloatNextPlus           decQuadNextPlus
+#define decFloatNextToward         decQuadNextToward
+#define decFloatOr                 decQuadOr
+#define decFloatPlus               decQuadPlus
+#define decFloatQuantize           decQuadQuantize
+#define decFloatReduce             decQuadReduce
+#define decFloatRemainder          decQuadRemainder
+#define decFloatRemainderNear      decQuadRemainderNear
+#define decFloatRotate             decQuadRotate
+#define decFloatScaleB             decQuadScaleB
+#define decFloatShift              decQuadShift
+#define decFloatSubtract           decQuadSubtract
+#define decFloatToIntegralValue    decQuadToIntegralValue
+#define decFloatToIntegralExact    decQuadToIntegralExact
+#define decFloatXor                decQuadXor
+
+// Comparisons
+#define decFloatCompare            decQuadCompare
+#define decFloatCompareSignal      decQuadCompareSignal
+#define decFloatCompareTotal       decQuadCompareTotal
+#define decFloatCompareTotalMag    decQuadCompareTotalMag
+
+// Copies
+#define decFloatCanonical          decQuadCanonical
+#define decFloatCopy               decQuadCopy
+#define decFloatCopyAbs            decQuadCopyAbs
+#define decFloatCopyNegate         decQuadCopyNegate
+#define decFloatCopySign           decQuadCopySign
+
+// Non-computational
+#define decFloatClass              decQuadClass
+#define decFloatClassString        decQuadClassString
+#define decFloatDigits             decQuadDigits
+#define decFloatIsCanonical        decQuadIsCanonical
+#define decFloatIsFinite           decQuadIsFinite
+#define decFloatIsInfinite         decQuadIsInfinite
+#define decFloatIsInteger          decQuadIsInteger
+#define decFloatIsLogical          decQuadIsLogical
+#define decFloatIsNaN              decQuadIsNaN
+#define decFloatIsNegative         decQuadIsNegative
+#define decFloatIsNormal           decQuadIsNormal
+#define decFloatIsPositive         decQuadIsPositive
+#define decFloatIsSignaling        decQuadIsSignaling
+#define decFloatIsSignalling       decQuadIsSignalling
+#define decFloatIsSigned           decQuadIsSigned
+#define decFloatIsSubnormal        decQuadIsSubnormal
+#define decFloatIsZero             decQuadIsZero
+#define decFloatRadix              decQuadRadix
+#define decFloatSameQuantum        decQuadSameQuantum
+#define decFloatVersion            decQuadVersion
+
+/* And now the code itself */
+#include "decContext.h"       // public includes
+#include "decQuad.h"          // ..
+#include "decNumberLocal.h"   // local includes (need DECPMAX)
+#include "decCommon.h"        // non-arithmetic decFloat routines
+#include "decBasic.h"         // basic formats routines
+
diff --git a/decNumber/decQuad.h b/decNumber/decQuad.h
new file mode 100644
index 00000000..4eb7017b
--- /dev/null
+++ b/decNumber/decQuad.h
@@ -0,0 +1,177 @@
+/* ------------------------------------------------------------------ */
+/* decQuad.h -- Decimal 128-bit format module header                  */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2010.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is included in the package as decNumber.pdf.  This   */
+/* document is also available in HTML, together with specifications,  */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+/* This include file is always included by decSingle and decDouble,   */
+/* and therefore also holds useful constants used by all three.       */
+
+#if !defined(DECQUAD)
+  #define DECQUAD
+
+  #define DECQUADNAME         "decimalQuad"           /* Short name   */
+  #define DECQUADTITLE        "Decimal 128-bit datum" /* Verbose name */
+  #define DECQUADAUTHOR       "Mike Cowlishaw"        /* Who to blame */
+
+  /* parameters for decQuads */
+  #define DECQUAD_Bytes    16      /* length                          */
+  #define DECQUAD_Pmax     34      /* maximum precision (digits)      */
+  #define DECQUAD_Emin  -6143      /* minimum adjusted exponent       */
+  #define DECQUAD_Emax   6144      /* maximum adjusted exponent       */
+  #define DECQUAD_EmaxD     4      /* maximum exponent digits         */
+  #define DECQUAD_Bias   6176      /* bias for the exponent           */
+  #define DECQUAD_String   43      /* maximum string length, +1       */
+  #define DECQUAD_EconL    12      /* exponent continuation length    */
+  #define DECQUAD_Declets  11      /* count of declets                */
+  /* highest biased exponent (Elimit-1) */
+  #define DECQUAD_Ehigh (DECQUAD_Emax + DECQUAD_Bias - (DECQUAD_Pmax-1))
+
+  /* Required include                                                 */
+  #include "decContext.h"
+
+  /* The decQuad decimal 128-bit type, accessible by all sizes */
+  typedef union {
+    uint8_t   bytes[DECQUAD_Bytes];     /* fields: 1, 5, 12, 110 bits */
+    uint16_t shorts[DECQUAD_Bytes/2];
+    uint32_t  words[DECQUAD_Bytes/4];
+    #if DECUSE64
+    uint64_t  longs[DECQUAD_Bytes/8];
+    #endif
+    } decQuad;
+
+  /* ---------------------------------------------------------------- */
+  /* Shared constants                                                 */
+  /* ---------------------------------------------------------------- */
+
+  /* sign and special values [top 32-bits; last two bits are don't-care
+     for Infinity on input, last bit don't-care for NaNs] */
+  #define DECFLOAT_Sign  0x80000000     /* 1 00000 00 Sign */
+  #define DECFLOAT_NaN   0x7c000000     /* 0 11111 00 NaN generic */
+  #define DECFLOAT_qNaN  0x7c000000     /* 0 11111 00 qNaN */
+  #define DECFLOAT_sNaN  0x7e000000     /* 0 11111 10 sNaN */
+  #define DECFLOAT_Inf   0x78000000     /* 0 11110 00 Infinity */
+  #define DECFLOAT_MinSp 0x78000000     /* minimum special value */
+                                        /* [specials are all >=MinSp] */
+  /* Sign nibble constants                                            */
+  #if !defined(DECPPLUSALT)
+    #define DECPPLUSALT  0x0A /* alternate plus  nibble               */
+    #define DECPMINUSALT 0x0B /* alternate minus nibble               */
+    #define DECPPLUS     0x0C /* preferred plus  nibble               */
+    #define DECPMINUS    0x0D /* preferred minus nibble               */
+    #define DECPPLUSALT2 0x0E /* alternate plus  nibble               */
+    #define DECPUNSIGNED 0x0F /* alternate plus  nibble (unsigned)    */
+  #endif
+
+  /* ---------------------------------------------------------------- */
+  /* Routines -- implemented as decFloat routines in common files     */
+  /* ---------------------------------------------------------------- */
+
+  /* Utilities and conversions, extractors, etc.) */
+  extern decQuad * decQuadFromBCD(decQuad *, int32_t, const uint8_t *, int32_t);
+  extern decQuad * decQuadFromInt32(decQuad *, int32_t);
+  extern decQuad * decQuadFromPacked(decQuad *, int32_t, const uint8_t *);
+  extern decQuad * decQuadFromPackedChecked(decQuad *, int32_t, const uint8_t *);
+  extern decQuad * decQuadFromString(decQuad *, const char *, decContext *);
+  extern decQuad * decQuadFromUInt32(decQuad *, uint32_t);
+  extern int32_t   decQuadGetCoefficient(const decQuad *, uint8_t *);
+  extern int32_t   decQuadGetExponent(const decQuad *);
+  extern decQuad * decQuadSetCoefficient(decQuad *, const uint8_t *, int32_t);
+  extern decQuad * decQuadSetExponent(decQuad *, decContext *, int32_t);
+  extern void      decQuadShow(const decQuad *, const char *);
+  extern int32_t   decQuadToBCD(const decQuad *, int32_t *, uint8_t *);
+  extern char    * decQuadToEngString(const decQuad *, char *);
+  extern int32_t   decQuadToInt32(const decQuad *, decContext *, enum rounding);
+  extern int32_t   decQuadToInt32Exact(const decQuad *, decContext *, enum rounding);
+  extern int32_t   decQuadToPacked(const decQuad *, int32_t *, uint8_t *);
+  extern char    * decQuadToString(const decQuad *, char *);
+  extern uint32_t  decQuadToUInt32(const decQuad *, decContext *, enum rounding);
+  extern uint32_t  decQuadToUInt32Exact(const decQuad *, decContext *, enum rounding);
+  extern decQuad * decQuadZero(decQuad *);
+
+  /* Computational (result is a decQuad) */
+  extern decQuad * decQuadAbs(decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadAdd(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadAnd(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadDivide(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadDivideInteger(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadFMA(decQuad *, const decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadInvert(decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadLogB(decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadMax(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadMaxMag(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadMin(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadMinMag(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadMinus(decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadMultiply(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadNextMinus(decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadNextPlus(decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadNextToward(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadOr(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadPlus(decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadQuantize(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadReduce(decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadRemainder(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadRemainderNear(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadRotate(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadScaleB(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadShift(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadSubtract(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadToIntegralValue(decQuad *, const decQuad *, decContext *, enum rounding);
+  extern decQuad * decQuadToIntegralExact(decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadXor(decQuad *, const decQuad *, const decQuad *, decContext *);
+
+  /* Comparisons */
+  extern decQuad * decQuadCompare(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadCompareSignal(decQuad *, const decQuad *, const decQuad *, decContext *);
+  extern decQuad * decQuadCompareTotal(decQuad *, const decQuad *, const decQuad *);
+  extern decQuad * decQuadCompareTotalMag(decQuad *, const decQuad *, const decQuad *);
+
+  /* Copies */
+  extern decQuad * decQuadCanonical(decQuad *, const decQuad *);
+  extern decQuad * decQuadCopy(decQuad *, const decQuad *);
+  extern decQuad * decQuadCopyAbs(decQuad *, const decQuad *);
+  extern decQuad * decQuadCopyNegate(decQuad *, const decQuad *);
+  extern decQuad * decQuadCopySign(decQuad *, const decQuad *, const decQuad *);
+
+  /* Non-computational */
+  extern enum decClass decQuadClass(const decQuad *);
+  extern const char *  decQuadClassString(const decQuad *);
+  extern uint32_t      decQuadDigits(const decQuad *);
+  extern uint32_t      decQuadIsCanonical(const decQuad *);
+  extern uint32_t      decQuadIsFinite(const decQuad *);
+  extern uint32_t      decQuadIsInteger(const decQuad *);
+  extern uint32_t      decQuadIsLogical(const decQuad *);
+  extern uint32_t      decQuadIsInfinite(const decQuad *);
+  extern uint32_t      decQuadIsNaN(const decQuad *);
+  extern uint32_t      decQuadIsNegative(const decQuad *);
+  extern uint32_t      decQuadIsNormal(const decQuad *);
+  extern uint32_t      decQuadIsPositive(const decQuad *);
+  extern uint32_t      decQuadIsSignaling(const decQuad *);
+  extern uint32_t      decQuadIsSignalling(const decQuad *);
+  extern uint32_t      decQuadIsSigned(const decQuad *);
+  extern uint32_t      decQuadIsSubnormal(const decQuad *);
+  extern uint32_t      decQuadIsZero(const decQuad *);
+  extern uint32_t      decQuadRadix(const decQuad *);
+  extern uint32_t      decQuadSameQuantum(const decQuad *, const decQuad *);
+  extern const char *  decQuadVersion(void);
+
+  /* decNumber conversions; these are implemented as macros so as not  */
+  /* to force a dependency on decimal128 and decNumber in decQuad.     */
+  /* decQuadFromNumber returns a decimal128 * to avoid warnings.       */
+  #define decQuadToNumber(dq, dn) decimal128ToNumber((decimal128 *)(dq), dn)
+  #define decQuadFromNumber(dq, dn, set) decimal128FromNumber((decimal128 *)(dq), dn, set)
+
+#endif
diff --git a/decNumber/decSingle.c b/decNumber/decSingle.c
new file mode 100644
index 00000000..b455a75d
--- /dev/null
+++ b/decNumber/decSingle.c
@@ -0,0 +1,71 @@
+/* ------------------------------------------------------------------ */
+/* decSingle.c -- decSingle operations module                         */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2008.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is included in the package as decNumber.pdf.  This   */
+/* document is also available in HTML, together with specifications,  */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+/* This module comprises decSingle operations (including conversions) */
+/* ------------------------------------------------------------------ */
+
+#include "decContext.h"       // public includes
+#include "decSingle.h"        // public includes
+
+/* Constant mappings for shared code */
+#define DECPMAX     DECSINGLE_Pmax
+#define DECEMIN     DECSINGLE_Emin
+#define DECEMAX     DECSINGLE_Emax
+#define DECEMAXD    DECSINGLE_EmaxD
+#define DECBYTES    DECSINGLE_Bytes
+#define DECSTRING   DECSINGLE_String
+#define DECECONL    DECSINGLE_EconL
+#define DECBIAS     DECSINGLE_Bias
+#define DECLETS     DECSINGLE_Declets
+#define DECQTINY    (-DECSINGLE_Bias)
+// parameters of next-wider format
+#define DECWBYTES   DECDOUBLE_Bytes
+#define DECWPMAX    DECDOUBLE_Pmax
+#define DECWECONL   DECDOUBLE_EconL
+#define DECWBIAS    DECDOUBLE_Bias
+
+/* Type and function mappings for shared code */
+#define decFloat                   decSingle      // Type name
+#define decFloatWider              decDouble      // Type name
+
+// Utility (binary results, extractors, etc.)
+#define decFloatFromBCD            decSingleFromBCD
+#define decFloatFromPacked         decSingleFromPacked
+#define decFloatFromPackedChecked  decSingleFromPackedChecked
+#define decFloatFromString         decSingleFromString
+#define decFloatFromWider          decSingleFromWider
+#define decFloatGetCoefficient     decSingleGetCoefficient
+#define decFloatGetExponent        decSingleGetExponent
+#define decFloatSetCoefficient     decSingleSetCoefficient
+#define decFloatSetExponent        decSingleSetExponent
+#define decFloatShow               decSingleShow
+#define decFloatToBCD              decSingleToBCD
+#define decFloatToEngString        decSingleToEngString
+#define decFloatToPacked           decSingleToPacked
+#define decFloatToString           decSingleToString
+#define decFloatToWider            decSingleToWider
+#define decFloatZero               decSingleZero
+
+// Non-computational
+#define decFloatRadix              decSingleRadix
+#define decFloatVersion            decSingleVersion
+
+#include "decNumberLocal.h"   // local includes (need DECPMAX)
+#include "decCommon.h"        // non-basic decFloat routines
+// [Do not include decBasic.h for decimal32]
+
diff --git a/decNumber/decSingle.h b/decNumber/decSingle.h
new file mode 100644
index 00000000..0691f7af
--- /dev/null
+++ b/decNumber/decSingle.h
@@ -0,0 +1,86 @@
+/* ------------------------------------------------------------------ */
+/* decSingle.h -- Decimal 32-bit format module header                 */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2008.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is included in the package as decNumber.pdf.  This   */
+/* document is also available in HTML, together with specifications,  */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+
+#if !defined(DECSINGLE)
+  #define DECSINGLE
+
+  #define DECSINGLENAME       "decSingle"             /* Short name   */
+  #define DECSINGLETITLE      "Decimal 32-bit datum"  /* Verbose name */
+  #define DECSINGLEAUTHOR     "Mike Cowlishaw"        /* Who to blame */
+
+  /* parameters for decSingles */
+  #define DECSINGLE_Bytes    4     /* length                          */
+  #define DECSINGLE_Pmax     7     /* maximum precision (digits)      */
+  #define DECSINGLE_Emin   -95     /* minimum adjusted exponent       */
+  #define DECSINGLE_Emax    96     /* maximum adjusted exponent       */
+  #define DECSINGLE_EmaxD    3     /* maximum exponent digits         */
+  #define DECSINGLE_Bias   101     /* bias for the exponent           */
+  #define DECSINGLE_String  16     /* maximum string length, +1       */
+  #define DECSINGLE_EconL    6     /* exponent continuation length    */
+  #define DECSINGLE_Declets  2     /* count of declets                */
+  /* highest biased exponent (Elimit-1) */
+  #define DECSINGLE_Ehigh (DECSINGLE_Emax + DECSINGLE_Bias - (DECSINGLE_Pmax-1))
+
+  /* Required includes                                                */
+  #include "decContext.h"
+  #include "decQuad.h"
+  #include "decDouble.h"
+
+  /* The decSingle decimal 32-bit type, accessible by all sizes */
+  typedef union {
+    uint8_t   bytes[DECSINGLE_Bytes];   /* fields: 1, 5, 6, 20 bits */
+    uint16_t shorts[DECSINGLE_Bytes/2];
+    uint32_t  words[DECSINGLE_Bytes/4];
+    } decSingle;
+
+  /* ---------------------------------------------------------------- */
+  /* Routines -- implemented as decFloat routines in common files     */
+  /* ---------------------------------------------------------------- */
+
+  /* Utilities (binary argument(s) or result, extractors, etc.) */
+  extern decSingle * decSingleFromBCD(decSingle *, int32_t, const uint8_t *, int32_t);
+  extern decSingle * decSingleFromPacked(decSingle *, int32_t, const uint8_t *);
+  extern decSingle * decSingleFromPackedChecked(decSingle *, int32_t, const uint8_t *);
+  extern decSingle * decSingleFromString(decSingle *, const char *, decContext *);
+  extern decSingle * decSingleFromWider(decSingle *, const decDouble *, decContext *);
+  extern int32_t     decSingleGetCoefficient(const decSingle *, uint8_t *);
+  extern int32_t     decSingleGetExponent(const decSingle *);
+  extern decSingle * decSingleSetCoefficient(decSingle *, const uint8_t *, int32_t);
+  extern decSingle * decSingleSetExponent(decSingle *, decContext *, int32_t);
+  extern void        decSingleShow(const decSingle *, const char *);
+  extern int32_t     decSingleToBCD(const decSingle *, int32_t *, uint8_t *);
+  extern char      * decSingleToEngString(const decSingle *, char *);
+  extern int32_t     decSingleToPacked(const decSingle *, int32_t *, uint8_t *);
+  extern char      * decSingleToString(const decSingle *, char *);
+  extern decDouble * decSingleToWider(const decSingle *, decDouble *);
+  extern decSingle * decSingleZero(decSingle *);
+
+  /* (No Arithmetic routines for decSingle) */
+
+  /* Non-computational */
+  extern uint32_t     decSingleRadix(const decSingle *);
+  extern const char * decSingleVersion(void);
+
+  /* decNumber conversions; these are implemented as macros so as not  */
+  /* to force a dependency on decimal32 and decNumber in decSingle.    */
+  /* decSingleFromNumber returns a decimal32 * to avoid warnings.      */
+  #define decSingleToNumber(dq, dn) decimal32ToNumber((decimal32 *)(dq), dn)
+  #define decSingleFromNumber(dq, dn, set) decimal32FromNumber((decimal32 *)(dq), dn, set)
+
+#endif
diff --git a/decNumber/decimal128.c b/decNumber/decimal128.c
index 013294ce..e5fa45b9 100644
--- a/decNumber/decimal128.c
+++ b/decNumber/decimal128.c
@@ -1,565 +1,553 @@
-/* ------------------------------------------------------------------ */
-/* Decimal 128-bit format module                                      */
-/* ------------------------------------------------------------------ */
-/* Copyright (c) IBM Corporation, 2000, 2006.  All rights reserved.   */
-/*                                                                    */
-/* This software is made available under the terms of the             */
-/* ICU License -- ICU 1.8.1 and later.                                */
-/*                                                                    */
-/* The description and User's Guide ("The decNumber C Library") for   */
-/* this software is called decNumber.pdf.  This document is           */
-/* available, together with arithmetic and format specifications,     */
-/* testcases, and Web links, at: http://www2.hursley.ibm.com/decimal  */
-/*                                                                    */
-/* Please send comments, suggestions, and corrections to the author:  */
-/*   mfc@uk.ibm.com                                                   */
-/*   Mike Cowlishaw, IBM Fellow                                       */
-/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
-/* ------------------------------------------------------------------ */
-/* This module comprises the routines for decimal128 format numbers.  */
-/* Conversions are supplied to and from decNumber and String.         */
-/*                                                                    */
-/* No arithmetic routines are included; decNumber provides these.     */
-/*                                                                    */
-/* Error handling is the same as decNumber (qv.).                     */
-/* ------------------------------------------------------------------ */
-#include <string.h>           // [for memset/memcpy]
-#include <stdio.h>            // [for printf]
-#if defined(_MSVC_)
-#pragma warning(disable:4244) // (floating-point only?) "conversion from 'x' to 'y', possible loss of data"
-#endif /*defined(_MSVC_)*/
-
-#define  DECNUMDIGITS 34      // make decNumbers with space for 34
-#include "decNumber.h"        // base number library
-#include "decNumberLocal.h"   // decNumber local types, etc.
-#include "decimal128.h"       // our primary include
-
-/* Utility routines and tables [in decimal64.c] */
-extern const uInt   COMBEXP[32], COMBMSD[32];
-extern const uShort DPD2BIN[1024];
-extern const uShort BIN2DPD[1000];      // [not used]
-extern const uByte  BIN2CHAR[4001];
-
-extern void decDigitsFromDPD(decNumber *, const uInt *, Int);
-extern void decDigitsToDPD(const decNumber *, uInt *, Int);
-
-#if DECTRACE || DECCHECK
-void decimal128Show(const decimal128 *);          // for debug
-extern void decNumberShow(const decNumber *);     // ..
-#endif
-
-/* compile-time endian tester [assumes sizeof(int)>1] */
-static  const  Int mfcone=1;                 // constant 1
-static  const  Flag *mfctop=(Flag *)&mfcone; // -> top byte
-#define LITEND mfctop[0]           // named flag; 1=little-endian
-
-/* Useful macro */
-// Clear a structure (e.g., a decNumber)
-#define DEC_clear(d) memset(d, 0, sizeof(*d))
-
-/* ------------------------------------------------------------------ */
-/* decimal128FromNumber -- convert decNumber to decimal128            */
-/*                                                                    */
-/*   ds is the target decimal128                                      */
-/*   dn is the source number (assumed valid)                          */
-/*   set is the context, used only for reporting errors               */
-/*                                                                    */
-/* The set argument is used only for status reporting and for the     */
-/* rounding mode (used if the coefficient is more than DECIMAL128_Pmax*/
-/* digits or an overflow is detected).  If the exponent is out of the */
-/* valid range then Overflow or Underflow will be raised.             */
-/* After Underflow a subnormal result is possible.                    */
-/*                                                                    */
-/* DEC_Clamped is set if the number has to be 'folded down' to fit,   */
-/* by reducing its exponent and multiplying the coefficient by a      */
-/* power of ten, or if the exponent on a zero had to be clamped.      */
-/* ------------------------------------------------------------------ */
-decimal128 * decimal128FromNumber(decimal128 *d128, const decNumber *dn,
-                                  decContext *set) {
-  uInt status=0;                   // status accumulator
-  Int ae;                          // adjusted exponent
-  decNumber  dw;                   // work
-  decContext dc;                   // ..
-  uInt *pu;                        // ..
-  uInt comb, exp;                  // ..
-  uInt targar[4]={0,0,0,0};        // target 128-bit
-  #define targhi targar[3]         // name the word with the sign
-  #define targmh targar[2]         // name the words
-  #define targml targar[1]         // ..
-  #define targlo targar[0]         // ..
-
-  // If the number has too many digits, or the exponent could be
-  // out of range then reduce the number under the appropriate
-  // constraints.  This could push the number to Infinity or zero,
-  // so this check and rounding must be done before generating the
-  // decimal128]
-  ae=dn->exponent+dn->digits-1;              // [0 if special]
-  if (dn->digits>DECIMAL128_Pmax             // too many digits
-   || ae>DECIMAL128_Emax                     // likely overflow
-   || ae<DECIMAL128_Emin) {                  // likely underflow
-    decContextDefault(&dc, DEC_INIT_DECIMAL128); // [no traps]
-    dc.round=set->round;                     // use supplied rounding
-    decNumberPlus(&dw, dn, &dc);             // (round and check)
-    // [this changes -0 to 0, so enforce the sign...]
-    dw.bits|=dn->bits&DECNEG;
-    status=dc.status;                        // save status
-    dn=&dw;                                  // use the work number
-    } // maybe out of range
-
-  if (dn->bits&DECSPECIAL) {                      // a special value
-    if (dn->bits&DECINF) targhi=DECIMAL_Inf<<24;
-     else {                                       // sNaN or qNaN
-      if ((*dn->lsu!=0 || dn->digits>1)           // non-zero coefficient
-       && (dn->digits<DECIMAL128_Pmax)) {         // coefficient fits
-        decDigitsToDPD(dn, targar, 0);
-        }
-      if (dn->bits&DECNAN) targhi|=DECIMAL_NaN<<24;
-       else targhi|=DECIMAL_sNaN<<24;
-      } // a NaN
-    } // special
-
-   else { // is finite
-    if (decNumberIsZero(dn)) {               // is a zero
-      // set and clamp exponent
-      if (dn->exponent<-DECIMAL128_Bias) {
-        exp=0;                               // low clamp
-        status|=DEC_Clamped;
-        }
-       else {
-        exp=dn->exponent+DECIMAL128_Bias;    // bias exponent
-        if (exp>DECIMAL128_Ehigh) {          // top clamp
-          exp=DECIMAL128_Ehigh;
-          status|=DEC_Clamped;
-          }
-        }
-      comb=(exp>>9) & 0x18;             // msd=0, exp top 2 bits ..
-      }
-     else {                             // non-zero finite number
-      uInt msd;                         // work
-      Int pad=0;                        // coefficient pad digits
-
-      // the dn is known to fit, but it may need to be padded
-      exp=(uInt)(dn->exponent+DECIMAL128_Bias);    // bias exponent
-      if (exp>DECIMAL128_Ehigh) {                  // fold-down case
-        pad=exp-DECIMAL128_Ehigh;
-        exp=DECIMAL128_Ehigh;                      // [to maximum]
-        status|=DEC_Clamped;
-        }
-
-      // [fastpath for common case is not a win, here]
-      decDigitsToDPD(dn, targar, pad);
-      // save and clear the top digit
-      msd=targhi>>14;
-      targhi&=0x00003fff;
-
-      // create the combination field
-      if (msd>=8) comb=0x18 | ((exp>>11) & 0x06) | (msd & 0x01);
-             else comb=((exp>>9) & 0x18) | msd;
-      }
-    targhi|=comb<<26;              // add combination field ..
-    targhi|=(exp&0xfff)<<14;       // .. and exponent continuation
-    } // finite
-
-  if (dn->bits&DECNEG) targhi|=0x80000000; // add sign bit
-
-  // now write to storage; this may be endian, or not
-  #if DECENDIAN
-  // DECENDIAN -- direct store, in the right order
-  pu=(uInt *)d128->bytes;          // overlay
-  if (LITEND) {
-    pu[0]=targlo;                  // directly store the low int
-    pu[1]=targml;                  // then the mid-low
-    pu[2]=targmh;                  // then the mid-high
-    pu[3]=targhi;                  // then the high int
-    }
-   else {
-    pu[0]=targhi;                  // directly store the high int
-    pu[1]=targmh;                  // then the mid-high
-    pu[2]=targml;                  // then the mid-low
-    pu[3]=targlo;                  // then the low int
-    }
-  #else
-  // not DECENDIAN -- use network byte order
-  if (LITEND) {                    // little-endian needs reversal
-    uByte *pb;                     // work
-    Int off;                       // ..
-    for (pb=&d128->bytes[15]; pb>=d128->bytes; pb--) {
-      off=3-((pb-d128->bytes)>>2); // 0, then 1, 2, 3
-      *pb=(uByte)(targar[off]&0xff);
-      targar[off]>>=8;
-      } // i
-    }
-   else { // big-endian; it's the right way round already
-    pu=(uInt *)d128->bytes;        // overlay
-    pu[0]=targhi;                  // directly store the high int
-    pu[1]=targmh;                  // then the mid-high
-    pu[2]=targml;                  // then the mid-low
-    pu[3]=targlo;                  // then the low int
-    }
-  #endif
-
-  if (status!=0) decContextSetStatus(set, status); // pass on status
-  // decimal128Show(d128);
-  return d128;
-  } // decimal128FromNumber
-
-/* ------------------------------------------------------------------ */
-/* decimal128ToNumber -- convert decimal128 to decNumber              */
-/*   d128 is the source decimal128                                    */
-/*   dn is the target number, with appropriate space                  */
-/* No error is possible.                                              */
-/* ------------------------------------------------------------------ */
-decNumber * decimal128ToNumber(const decimal128 *d128, decNumber *dn) {
-  uInt msd;                        // coefficient MSD
-  uInt exp;                        // exponent top two bits
-  uInt comb;                       // combination field
-  uInt *pu;                        // work
-  Int  need;                       // ..
-  uInt sourar[4];                  // source 128-bit
-  #define sourhi sourar[3]         // name the word with the sign
-  #define sourmh sourar[2]         // and the mid-high word
-  #define sourml sourar[1]         // and the mod-low word
-  #define sourlo sourar[0]         // and the lowest word
-
-  // load source from storage; this may be endian, or not
-  #if DECENDIAN
-  // DECENDIAN -- direct load, in the right order
-  pu=(uInt *)d128->bytes;          // overlay
-  if (LITEND) {
-    sourlo=pu[0];                  // directly load the low int
-    sourml=pu[1];                  // then the mid-low
-    sourmh=pu[2];                  // then the mid-high
-    sourhi=pu[3];                  // then the high int
-    }
-   else {
-    sourhi=pu[0];                  // directly load the high int
-    sourmh=pu[1];                  // then the mid-high
-    sourml=pu[2];                  // then the mid-low
-    sourlo=pu[3];                  // then the low int
-    }
-  #else
-  // not DECENDIAN -- use network byte order
-  if (LITEND) {                    // little-endian needs reversal
-    const uByte *pb;               // work
-    Int off;                       // ..
-    for (pb=d128->bytes; pb<=&d128->bytes[15]; pb++) {
-      off=3-((pb-d128->bytes)>>2); // 3, then 2, 1, 0
-      sourar[off]<<=8;
-      sourar[off]|=*pb;
-      } // i
-    }
-   else { // big-endian; it's the right way round already
-    pu=(uInt *)d128->bytes;        // overlay
-    sourhi=pu[0];                  // directly load the high int
-    sourmh=pu[1];                  // then the mid-high
-    sourml=pu[2];                  // then the mid-low
-    sourlo=pu[3];                  // then the low int
-    }
-  #endif
-
-  comb=(sourhi>>26)&0x1f;          // combination field
-
-  decNumberZero(dn);               // clean number
-  if (sourhi&0x80000000) dn->bits=DECNEG; // set sign if negative
-
-  msd=COMBMSD[comb];               // decode the combination field
-  exp=COMBEXP[comb];               // ..
-
-  if (exp==3) {                    // is a special
-    if (msd==0) {
-      dn->bits|=DECINF;
-      return dn;                   // no coefficient needed
-      }
-    else if (sourhi&0x02000000) dn->bits|=DECSNAN;
-    else dn->bits|=DECNAN;
-    msd=0;                         // no top digit
-    }
-   else {                          // is a finite number
-    dn->exponent=(exp<<12)+((sourhi>>14)&0xfff)-DECIMAL128_Bias; // unbiased
-    }
-
-  // get the coefficient
-  sourhi&=0x00003fff;              // clean coefficient continuation
-  if (msd) {                       // non-zero msd
-    sourhi|=msd<<14;               // prefix to coefficient
-    need=12;                       // process 12 declets
-    }
-   else { // msd=0
-    if (sourhi) need=11;           // declets to process
-     else if (sourmh) need=10;
-     else if (sourml) need=7;
-     else if (sourlo) need=4;
-     else return dn;               // easy: coefficient is 0
-    } //msd=0
-
-  decDigitsFromDPD(dn, sourar, need);   // process declets
-  // decNumberShow(dn);
-  return dn;
-  } // decimal128ToNumber
-
-/* ------------------------------------------------------------------ */
-/* to-scientific-string -- conversion to numeric string               */
-/* to-engineering-string -- conversion to numeric string              */
-/*                                                                    */
-/*   decimal128ToString(d128, string);                                */
-/*   decimal128ToEngString(d128, string);                             */
-/*                                                                    */
-/*  d128 is the decimal128 format number to convert                   */
-/*  string is the string where the result will be laid out            */
-/*                                                                    */
-/*  string must be at least 24 characters                             */
-/*                                                                    */
-/*  No error is possible, and no status can be set.                   */
-/* ------------------------------------------------------------------ */
-char * decimal128ToEngString(const decimal128 *d128, char *string){
-  decNumber dn;                         // work
-  decimal128ToNumber(d128, &dn);
-  decNumberToEngString(&dn, string);
-  return string;
-  } // decimal128ToEngString
-
-char * decimal128ToString(const decimal128 *d128, char *string){
-  uInt msd;                        // coefficient MSD
-  Int  exp;                        // exponent top two bits or full
-  uInt comb;                       // combination field
-  char *cstart;                    // coefficient start
-  char *c;                         // output pointer in string
-  uInt *pu;                        // work
-  char *s, *t;                     // .. (source, target)
-  Int  dpd;                        // ..
-  Int  pre, e;                     // ..
-  const uByte *u;                  // ..
-
-  uInt sourar[4];                  // source 128-bit
-  #define sourhi sourar[3]         // name the word with the sign
-  #define sourmh sourar[2]         // and the mid-high word
-  #define sourml sourar[1]         // and the mod-low word
-  #define sourlo sourar[0]         // and the lowest word
-
-  // load source from storage; this may be endian, or not
-  #if DECENDIAN
-  // DECENDIAN -- direct load, in the right order
-  pu=(uInt *)d128->bytes;          // overlay
-  if (LITEND) {
-    sourlo=pu[0];                  // directly load the low int
-    sourml=pu[1];                  // then the mid-low
-    sourmh=pu[2];                  // then the mid-high
-    sourhi=pu[3];                  // then the high int
-    }
-   else {
-    sourhi=pu[0];                  // directly load the high int
-    sourmh=pu[1];                  // then the mid-high
-    sourml=pu[2];                  // then the mid-low
-    sourlo=pu[3];                  // then the low int
-    }
-  #else
-  // not DECENDIAN -- use network byte order
-  if (LITEND) {                    // little-endian needs reversal
-    const uByte *pb;               // work
-    Int off;                       // ..
-    for (pb=d128->bytes; pb<=&d128->bytes[15]; pb++) {
-      off=3-((pb-d128->bytes)>>2); // 3, then 2, 1, 0
-      sourar[off]<<=8;
-      sourar[off]|=*pb;
-      } // i
-    }
-   else { // big-endian; it's the right way round already
-    pu=(uInt *)d128->bytes;        // overlay
-    sourhi=pu[0];                  // directly load the high int
-    sourmh=pu[1];                  // then the mid-high
-    sourml=pu[2];                  // then the mid-low
-    sourlo=pu[3];                  // then the low int
-    }
-  #endif
-
-  c=string;                        // where result will go
-  if (((Int)sourhi)<0) *c++='-';   // handle sign
-
-  comb=(sourhi>>26)&0x1f;          // combination field
-  msd=COMBMSD[comb];               // decode the combination field
-  exp=COMBEXP[comb];               // ..
-
-  if (exp==3) {
-    if (msd==0) {                  // infinity
-      strcpy(c, "Infinity");
-      return string;               // easy
-      }
-    if (sourhi&0x02000000) *c++='s'; // sNaN
-    strcpy(c, "NaN");              // complete word
-    c+=3;                          // step past
-    if (sourlo==0 && sourml==0 && sourmh==0
-     && (sourhi&0x0003ffff)==0) return string; // zero payload
-    // otherwise drop through to add integer; set correct exp
-    exp=0; msd=0;                  // setup for following code
-    }
-   else exp=(exp<<12)+((sourhi>>14)&0xfff)-DECIMAL128_Bias; // unbiased
-
-  // convert 34 digits of significand to characters
-  cstart=c;                        // save start of coefficient
-  if (msd) *c++='0'+(char)msd;     // non-zero most significant digit
-
-  // Now decode the declets.  After extracting each one, it is
-  // decoded to binary and then to a 4-char sequence by table lookup;
-  // the 4-chars are a 1-char length (significant digits, except 000
-  // has length 0).  This allows us to left-align the first declet
-  // with non-zero content, then remaining ones are full 3-char
-  // length.  We use fixed-length memcpys because variable-length
-  // causes a subroutine call in GCC.  (These are length 4 for speed
-  // and are safe because the array has an extra terminator byte.)
-  #define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4];                   \
-                   if (c!=cstart) {memcpy(c, u+1, 4); c+=3;}      \
-                    else if (*u)  {memcpy(c, u+4-*u, 4); c+=*u;}
-  dpd=(sourhi>>4)&0x3ff;                     // declet 1
-  dpd2char;
-  dpd=((sourhi&0xf)<<6) | (sourmh>>26);      // declet 2
-  dpd2char;
-  dpd=(sourmh>>16)&0x3ff;                    // declet 3
-  dpd2char;
-  dpd=(sourmh>>6)&0x3ff;                     // declet 4
-  dpd2char;
-  dpd=((sourmh&0x3f)<<4) | (sourml>>28);     // declet 5
-  dpd2char;
-  dpd=(sourml>>18)&0x3ff;                    // declet 6
-  dpd2char;
-  dpd=(sourml>>8)&0x3ff;                     // declet 7
-  dpd2char;
-  dpd=((sourml&0xff)<<2) | (sourlo>>30);     // declet 8
-  dpd2char;
-  dpd=(sourlo>>20)&0x3ff;                    // declet 9
-  dpd2char;
-  dpd=(sourlo>>10)&0x3ff;                    // declet 10
-  dpd2char;
-  dpd=(sourlo)&0x3ff;                        // declet 11
-  dpd2char;
-
-  if (c==cstart) *c++='0';         // all zeros -- make 0
-
-  if (exp==0) {                    // integer or NaN case -- easy
-    *c='\0';                       // terminate
-    return string;
-    }
-
-  /* non-0 exponent */
-  e=0;                             // assume no E
-  pre=c-cstart+exp;
-  // [here, pre-exp is the digits count (==1 for zero)]
-  if (exp>0 || pre<-5) {           // need exponential form
-    e=pre-1;                       // calculate E value
-    pre=1;                         // assume one digit before '.'
-    } // exponential form
-
-  /* modify the coefficient, adding 0s, '.', and E+nn as needed */
-  s=c-1;                           // source (LSD)
-  if (pre>0) {                     // ddd.ddd (plain), perhaps with E
-    char *dotat=cstart+pre;
-    if (dotat<c) {                 // if embedded dot needed...
-      t=c;                              // target
-      for (; s>=dotat; s--, t--) *t=*s; // open the gap; leave t at gap
-      *t='.';                           // insert the dot
-      c++;                              // length increased by one
-      }
-
-    // finally add the E-part, if needed; it will never be 0, and has
-    // a maximum length of 4 digits
-    if (e!=0) {
-      *c++='E';                    // starts with E
-      *c++='+';                    // assume positive
-      if (e<0) {
-        *(c-1)='-';                // oops, need '-'
-        e=-e;                      // uInt, please
-        }
-      if (e<1000) {                // 3 (or fewer) digits case
-        u=&BIN2CHAR[e*4];          // -> length byte
-        memcpy(c, u+4-*u, 4);      // copy fixed 4 characters [is safe]
-        c+=*u;                     // bump pointer appropriately
-        }
-       else {                      // 4-digits
-        Int thou=((e>>3)*1049)>>17; // e/1000
-        Int rem=e-(1000*thou);      // e%1000
-        *c++='0'+(char)thou;
-        u=&BIN2CHAR[rem*4];        // -> length byte
-        memcpy(c, u+1, 4);         // copy fixed 3+1 characters [is safe]
-        c+=3;                      // bump pointer, always 3 digits
-        }
-      }
-    *c='\0';                       // add terminator
-    //printf("res %s\n", string);
-    return string;
-    } // pre>0
-
-  /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
-  t=c+1-pre;
-  *(t+1)='\0';                          // can add terminator now
-  for (; s>=cstart; s--, t--) *t=*s;    // shift whole coefficient right
-  c=cstart;
-  *c++='0';                             // always starts with 0.
-  *c++='.';
-  for (; pre<0; pre++) *c++='0';        // add any 0's after '.'
-  //printf("res %s\n", string);
-  return string;
-  } // decimal128ToString
-
-/* ------------------------------------------------------------------ */
-/* to-number -- conversion from numeric string                        */
-/*                                                                    */
-/*   decimal128FromString(result, string, set);                       */
-/*                                                                    */
-/*  result  is the decimal128 format number which gets the result of  */
-/*          the conversion                                            */
-/*  *string is the character string which should contain a valid      */
-/*          number (which may be a special value)                     */
-/*  set     is the context                                            */
-/*                                                                    */
-/* The context is supplied to this routine is used for error handling */
-/* (setting of status and traps) and for the rounding mode, only.     */
-/* If an error occurs, the result will be a valid decimal128 NaN.     */
-/* ------------------------------------------------------------------ */
-decimal128 * decimal128FromString(decimal128 *result, const char *string,
-                                  decContext *set) {
-  decContext dc;                             // work
-  decNumber dn;                              // ..
-
-  decContextDefault(&dc, DEC_INIT_DECIMAL128); // no traps, please
-  dc.round=set->round;                         // use supplied rounding
-
-  decNumberFromString(&dn, string, &dc);     // will round if needed
-  decimal128FromNumber(result, &dn, &dc);
-  if (dc.status!=0) {                        // something happened
-    decContextSetStatus(set, dc.status);     // .. pass it on
-    }
-  return result;
-  } // decimal128FromString
-
-#if DECTRACE || DECCHECK
-/* ------------------------------------------------------------------ */
-/* decimal128Show -- display a decimal128 in hexadecimal [debug aid]  */
-/*   d128 -- the number to show                                       */
-/* ------------------------------------------------------------------ */
-// Also shows sign/cob/expconfields extracted
-void decimal128Show(const decimal128 *d128) {
-  char buf[DECIMAL128_Bytes*2+1];
-  Int i, j=0;
-
-  #if DECENDIAN
-  if (LITEND) {
-    for (i=0; i<DECIMAL128_Bytes; i++, j+=2) {
-      sprintf(&buf[j], "%02x", d128->bytes[15-i]);
-      }
-    printf(" D128> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
-           d128->bytes[15]>>7, (d128->bytes[15]>>2)&0x1f,
-           ((d128->bytes[15]&0x3)<<10)|(d128->bytes[14]<<2)|
-           (d128->bytes[13]>>6));
-    }
-   else {
-  #endif
-    for (i=0; i<DECIMAL128_Bytes; i++, j+=2) {
-      sprintf(&buf[j], "%02x", d128->bytes[i]);
-      }
-    printf(" D128> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
-           decimal128Sign(d128), decimal128Comb(d128),
-           decimal128ExpCon(d128));
-  #if DECENDIAN
-    }
-  #endif
-  } // decimal128Show
-#endif
+/* ------------------------------------------------------------------ */
+/* Decimal 128-bit format module                                      */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2008.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is called decNumber.pdf.  This document is           */
+/* available, together with arithmetic and format specifications,     */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+/* This module comprises the routines for decimal128 format numbers.  */
+/* Conversions are supplied to and from decNumber and String.         */
+/*                                                                    */
+/* This is used when decNumber provides operations, either for all    */
+/* operations or as a proxy between decNumber and decSingle.          */
+/*                                                                    */
+/* Error handling is the same as decNumber (qv.).                     */
+/* ------------------------------------------------------------------ */
+#include <string.h>           // [for memset/memcpy]
+#include <stdio.h>            // [for printf]
+
+#define  DECNUMDIGITS 34      // make decNumbers with space for 34
+#include "decNumber.h"        // base number library
+#include "decNumberLocal.h"   // decNumber local types, etc.
+#include "decimal128.h"       // our primary include
+
+/* Utility routines and tables [in decimal64.c] */
+// DPD2BIN and the reverse are renamed to prevent link-time conflict
+// if decQuad is also built in the same executable
+#define DPD2BIN DPD2BINx
+#define BIN2DPD BIN2DPDx
+extern const uInt   COMBEXP[32], COMBMSD[32];
+extern const uShort DPD2BIN[1024];
+extern const uShort BIN2DPD[1000];      // [not used]
+extern const uByte  BIN2CHAR[4001];
+
+extern void decDigitsFromDPD(decNumber *, const uInt *, Int);
+extern void decDigitsToDPD(const decNumber *, uInt *, Int);
+
+#if DECTRACE || DECCHECK
+void decimal128Show(const decimal128 *);          // for debug
+extern void decNumberShow(const decNumber *);     // ..
+#endif
+
+/* Useful macro */
+// Clear a structure (e.g., a decNumber)
+#define DEC_clear(d) memset(d, 0, sizeof(*d))
+
+/* ------------------------------------------------------------------ */
+/* decimal128FromNumber -- convert decNumber to decimal128            */
+/*                                                                    */
+/*   ds is the target decimal128                                      */
+/*   dn is the source number (assumed valid)                          */
+/*   set is the context, used only for reporting errors               */
+/*                                                                    */
+/* The set argument is used only for status reporting and for the     */
+/* rounding mode (used if the coefficient is more than DECIMAL128_Pmax*/
+/* digits or an overflow is detected).  If the exponent is out of the */
+/* valid range then Overflow or Underflow will be raised.             */
+/* After Underflow a subnormal result is possible.                    */
+/*                                                                    */
+/* DEC_Clamped is set if the number has to be 'folded down' to fit,   */
+/* by reducing its exponent and multiplying the coefficient by a      */
+/* power of ten, or if the exponent on a zero had to be clamped.      */
+/* ------------------------------------------------------------------ */
+decimal128 * decimal128FromNumber(decimal128 *d128, const decNumber *dn,
+                                  decContext *set) {
+  uInt status=0;                   // status accumulator
+  Int ae;                          // adjusted exponent
+  decNumber  dw;                   // work
+  decContext dc;                   // ..
+  uInt comb, exp;                  // ..
+  uInt uiwork;                     // for macros
+  uInt targar[4]={0,0,0,0};        // target 128-bit
+  #define targhi targar[3]         // name the word with the sign
+  #define targmh targar[2]         // name the words
+  #define targml targar[1]         // ..
+  #define targlo targar[0]         // ..
+
+  // If the number has too many digits, or the exponent could be
+  // out of range then reduce the number under the appropriate
+  // constraints.  This could push the number to Infinity or zero,
+  // so this check and rounding must be done before generating the
+  // decimal128]
+  ae=dn->exponent+dn->digits-1;              // [0 if special]
+  if (dn->digits>DECIMAL128_Pmax             // too many digits
+   || ae>DECIMAL128_Emax                     // likely overflow
+   || ae<DECIMAL128_Emin) {                  // likely underflow
+    decContextDefault(&dc, DEC_INIT_DECIMAL128); // [no traps]
+    dc.round=set->round;                     // use supplied rounding
+    decNumberPlus(&dw, dn, &dc);             // (round and check)
+    // [this changes -0 to 0, so enforce the sign...]
+    dw.bits|=dn->bits&DECNEG;
+    status=dc.status;                        // save status
+    dn=&dw;                                  // use the work number
+    } // maybe out of range
+
+  if (dn->bits&DECSPECIAL) {                      // a special value
+    if (dn->bits&DECINF) targhi=DECIMAL_Inf<<24;
+     else {                                       // sNaN or qNaN
+      if ((*dn->lsu!=0 || dn->digits>1)           // non-zero coefficient
+       && (dn->digits<DECIMAL128_Pmax)) {         // coefficient fits
+        decDigitsToDPD(dn, targar, 0);
+        }
+      if (dn->bits&DECNAN) targhi|=DECIMAL_NaN<<24;
+       else targhi|=DECIMAL_sNaN<<24;
+      } // a NaN
+    } // special
+
+   else { // is finite
+    if (decNumberIsZero(dn)) {               // is a zero
+      // set and clamp exponent
+      if (dn->exponent<-DECIMAL128_Bias) {
+        exp=0;                               // low clamp
+        status|=DEC_Clamped;
+        }
+       else {
+        exp=dn->exponent+DECIMAL128_Bias;    // bias exponent
+        if (exp>DECIMAL128_Ehigh) {          // top clamp
+          exp=DECIMAL128_Ehigh;
+          status|=DEC_Clamped;
+          }
+        }
+      comb=(exp>>9) & 0x18;             // msd=0, exp top 2 bits ..
+      }
+     else {                             // non-zero finite number
+      uInt msd;                         // work
+      Int pad=0;                        // coefficient pad digits
+
+      // the dn is known to fit, but it may need to be padded
+      exp=(uInt)(dn->exponent+DECIMAL128_Bias);    // bias exponent
+      if (exp>DECIMAL128_Ehigh) {                  // fold-down case
+        pad=exp-DECIMAL128_Ehigh;
+        exp=DECIMAL128_Ehigh;                      // [to maximum]
+        status|=DEC_Clamped;
+        }
+
+      // [fastpath for common case is not a win, here]
+      decDigitsToDPD(dn, targar, pad);
+      // save and clear the top digit
+      msd=targhi>>14;
+      targhi&=0x00003fff;
+
+      // create the combination field
+      if (msd>=8) comb=0x18 | ((exp>>11) & 0x06) | (msd & 0x01);
+             else comb=((exp>>9) & 0x18) | msd;
+      }
+    targhi|=comb<<26;              // add combination field ..
+    targhi|=(exp&0xfff)<<14;       // .. and exponent continuation
+    } // finite
+
+  if (dn->bits&DECNEG) targhi|=0x80000000; // add sign bit
+
+  // now write to storage; this is endian
+  if (DECLITEND) {
+    // lo -> hi
+    UBFROMUI(d128->bytes,    targlo);
+    UBFROMUI(d128->bytes+4,  targml);
+    UBFROMUI(d128->bytes+8,  targmh);
+    UBFROMUI(d128->bytes+12, targhi);
+    }
+   else {
+    // hi -> lo
+    UBFROMUI(d128->bytes,    targhi);
+    UBFROMUI(d128->bytes+4,  targmh);
+    UBFROMUI(d128->bytes+8,  targml);
+    UBFROMUI(d128->bytes+12, targlo);
+    }
+
+  if (status!=0) decContextSetStatus(set, status); // pass on status
+  // decimal128Show(d128);
+  return d128;
+  } // decimal128FromNumber
+
+/* ------------------------------------------------------------------ */
+/* decimal128ToNumber -- convert decimal128 to decNumber              */
+/*   d128 is the source decimal128                                    */
+/*   dn is the target number, with appropriate space                  */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+decNumber * decimal128ToNumber(const decimal128 *d128, decNumber *dn) {
+  uInt msd;                        // coefficient MSD
+  uInt exp;                        // exponent top two bits
+  uInt comb;                       // combination field
+  Int  need;                       // work
+  uInt uiwork;                     // for macros
+  uInt sourar[4];                  // source 128-bit
+  #define sourhi sourar[3]         // name the word with the sign
+  #define sourmh sourar[2]         // and the mid-high word
+  #define sourml sourar[1]         // and the mod-low word
+  #define sourlo sourar[0]         // and the lowest word
+
+  // load source from storage; this is endian
+  if (DECLITEND) {
+    sourlo=UBTOUI(d128->bytes   ); // directly load the low int
+    sourml=UBTOUI(d128->bytes+4 ); // then the mid-low
+    sourmh=UBTOUI(d128->bytes+8 ); // then the mid-high
+    sourhi=UBTOUI(d128->bytes+12); // then the high int
+    }
+   else {
+    sourhi=UBTOUI(d128->bytes   ); // directly load the high int
+    sourmh=UBTOUI(d128->bytes+4 ); // then the mid-high
+    sourml=UBTOUI(d128->bytes+8 ); // then the mid-low
+    sourlo=UBTOUI(d128->bytes+12); // then the low int
+    }
+
+  comb=(sourhi>>26)&0x1f;          // combination field
+
+  decNumberZero(dn);               // clean number
+  if (sourhi&0x80000000) dn->bits=DECNEG; // set sign if negative
+
+  msd=COMBMSD[comb];               // decode the combination field
+  exp=COMBEXP[comb];               // ..
+
+  if (exp==3) {                    // is a special
+    if (msd==0) {
+      dn->bits|=DECINF;
+      return dn;                   // no coefficient needed
+      }
+    else if (sourhi&0x02000000) dn->bits|=DECSNAN;
+    else dn->bits|=DECNAN;
+    msd=0;                         // no top digit
+    }
+   else {                          // is a finite number
+    dn->exponent=(exp<<12)+((sourhi>>14)&0xfff)-DECIMAL128_Bias; // unbiased
+    }
+
+  // get the coefficient
+  sourhi&=0x00003fff;              // clean coefficient continuation
+  if (msd) {                       // non-zero msd
+    sourhi|=msd<<14;               // prefix to coefficient
+    need=12;                       // process 12 declets
+    }
+   else { // msd=0
+    if (sourhi) need=11;           // declets to process
+     else if (sourmh) need=10;
+     else if (sourml) need=7;
+     else if (sourlo) need=4;
+     else return dn;               // easy: coefficient is 0
+    } //msd=0
+
+  decDigitsFromDPD(dn, sourar, need);   // process declets
+  // decNumberShow(dn);
+  return dn;
+  } // decimal128ToNumber
+
+/* ------------------------------------------------------------------ */
+/* to-scientific-string -- conversion to numeric string               */
+/* to-engineering-string -- conversion to numeric string              */
+/*                                                                    */
+/*   decimal128ToString(d128, string);                                */
+/*   decimal128ToEngString(d128, string);                             */
+/*                                                                    */
+/*  d128 is the decimal128 format number to convert                   */
+/*  string is the string where the result will be laid out            */
+/*                                                                    */
+/*  string must be at least 24 characters                             */
+/*                                                                    */
+/*  No error is possible, and no status can be set.                   */
+/* ------------------------------------------------------------------ */
+char * decimal128ToEngString(const decimal128 *d128, char *string){
+  decNumber dn;                         // work
+  decimal128ToNumber(d128, &dn);
+  decNumberToEngString(&dn, string);
+  return string;
+  } // decimal128ToEngString
+
+char * decimal128ToString(const decimal128 *d128, char *string){
+  uInt msd;                        // coefficient MSD
+  Int  exp;                        // exponent top two bits or full
+  uInt comb;                       // combination field
+  char *cstart;                    // coefficient start
+  char *c;                         // output pointer in string
+  const uByte *u;                  // work
+  char *s, *t;                     // .. (source, target)
+  Int  dpd;                        // ..
+  Int  pre, e;                     // ..
+  uInt uiwork;                     // for macros
+
+  uInt sourar[4];                  // source 128-bit
+  #define sourhi sourar[3]         // name the word with the sign
+  #define sourmh sourar[2]         // and the mid-high word
+  #define sourml sourar[1]         // and the mod-low word
+  #define sourlo sourar[0]         // and the lowest word
+
+  // load source from storage; this is endian
+  if (DECLITEND) {
+    sourlo=UBTOUI(d128->bytes   ); // directly load the low int
+    sourml=UBTOUI(d128->bytes+4 ); // then the mid-low
+    sourmh=UBTOUI(d128->bytes+8 ); // then the mid-high
+    sourhi=UBTOUI(d128->bytes+12); // then the high int
+    }
+   else {
+    sourhi=UBTOUI(d128->bytes   ); // directly load the high int
+    sourmh=UBTOUI(d128->bytes+4 ); // then the mid-high
+    sourml=UBTOUI(d128->bytes+8 ); // then the mid-low
+    sourlo=UBTOUI(d128->bytes+12); // then the low int
+    }
+
+  c=string;                        // where result will go
+  if (((Int)sourhi)<0) *c++='-';   // handle sign
+
+  comb=(sourhi>>26)&0x1f;          // combination field
+  msd=COMBMSD[comb];               // decode the combination field
+  exp=COMBEXP[comb];               // ..
+
+  if (exp==3) {
+    if (msd==0) {                  // infinity
+      strcpy(c,   "Inf");
+      strcpy(c+3, "inity");
+      return string;               // easy
+      }
+    if (sourhi&0x02000000) *c++='s'; // sNaN
+    strcpy(c, "NaN");              // complete word
+    c+=3;                          // step past
+    if (sourlo==0 && sourml==0 && sourmh==0
+     && (sourhi&0x0003ffff)==0) return string; // zero payload
+    // otherwise drop through to add integer; set correct exp
+    exp=0; msd=0;                  // setup for following code
+    }
+   else exp=(exp<<12)+((sourhi>>14)&0xfff)-DECIMAL128_Bias; // unbiased
+
+  // convert 34 digits of significand to characters
+  cstart=c;                        // save start of coefficient
+  if (msd) *c++='0'+(char)msd;     // non-zero most significant digit
+
+  // Now decode the declets.  After extracting each one, it is
+  // decoded to binary and then to a 4-char sequence by table lookup;
+  // the 4-chars are a 1-char length (significant digits, except 000
+  // has length 0).  This allows us to left-align the first declet
+  // with non-zero content, then remaining ones are full 3-char
+  // length.  We use fixed-length memcpys because variable-length
+  // causes a subroutine call in GCC.  (These are length 4 for speed
+  // and are safe because the array has an extra terminator byte.)
+  #define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4];                   \
+                   if (c!=cstart) {memcpy(c, u+1, 4); c+=3;}      \
+                    else if (*u)  {memcpy(c, u+4-*u, 4); c+=*u;}
+  dpd=(sourhi>>4)&0x3ff;                     // declet 1
+  dpd2char;
+  dpd=((sourhi&0xf)<<6) | (sourmh>>26);      // declet 2
+  dpd2char;
+  dpd=(sourmh>>16)&0x3ff;                    // declet 3
+  dpd2char;
+  dpd=(sourmh>>6)&0x3ff;                     // declet 4
+  dpd2char;
+  dpd=((sourmh&0x3f)<<4) | (sourml>>28);     // declet 5
+  dpd2char;
+  dpd=(sourml>>18)&0x3ff;                    // declet 6
+  dpd2char;
+  dpd=(sourml>>8)&0x3ff;                     // declet 7
+  dpd2char;
+  dpd=((sourml&0xff)<<2) | (sourlo>>30);     // declet 8
+  dpd2char;
+  dpd=(sourlo>>20)&0x3ff;                    // declet 9
+  dpd2char;
+  dpd=(sourlo>>10)&0x3ff;                    // declet 10
+  dpd2char;
+  dpd=(sourlo)&0x3ff;                        // declet 11
+  dpd2char;
+
+  if (c==cstart) *c++='0';         // all zeros -- make 0
+
+  if (exp==0) {                    // integer or NaN case -- easy
+    *c='\0';                       // terminate
+    return string;
+    }
+
+  /* non-0 exponent */
+  e=0;                             // assume no E
+  pre=c-cstart+exp;
+  // [here, pre-exp is the digits count (==1 for zero)]
+  if (exp>0 || pre<-5) {           // need exponential form
+    e=pre-1;                       // calculate E value
+    pre=1;                         // assume one digit before '.'
+    } // exponential form
+
+  /* modify the coefficient, adding 0s, '.', and E+nn as needed */
+  s=c-1;                           // source (LSD)
+  if (pre>0) {                     // ddd.ddd (plain), perhaps with E
+    char *dotat=cstart+pre;
+    if (dotat<c) {                 // if embedded dot needed...
+      t=c;                              // target
+      for (; s>=dotat; s--, t--) *t=*s; // open the gap; leave t at gap
+      *t='.';                           // insert the dot
+      c++;                              // length increased by one
+      }
+
+    // finally add the E-part, if needed; it will never be 0, and has
+    // a maximum length of 4 digits
+    if (e!=0) {
+      *c++='E';                    // starts with E
+      *c++='+';                    // assume positive
+      if (e<0) {
+        *(c-1)='-';                // oops, need '-'
+        e=-e;                      // uInt, please
+        }
+      if (e<1000) {                // 3 (or fewer) digits case
+        u=&BIN2CHAR[e*4];          // -> length byte
+        memcpy(c, u+4-*u, 4);      // copy fixed 4 characters [is safe]
+        c+=*u;                     // bump pointer appropriately
+        }
+       else {                      // 4-digits
+        Int thou=((e>>3)*1049)>>17; // e/1000
+        Int rem=e-(1000*thou);      // e%1000
+        *c++='0'+(char)thou;
+        u=&BIN2CHAR[rem*4];        // -> length byte
+        memcpy(c, u+1, 4);         // copy fixed 3+1 characters [is safe]
+        c+=3;                      // bump pointer, always 3 digits
+        }
+      }
+    *c='\0';                       // add terminator
+    //printf("res %s\n", string);
+    return string;
+    } // pre>0
+
+  /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
+  t=c+1-pre;
+  *(t+1)='\0';                          // can add terminator now
+  for (; s>=cstart; s--, t--) *t=*s;    // shift whole coefficient right
+  c=cstart;
+  *c++='0';                             // always starts with 0.
+  *c++='.';
+  for (; pre<0; pre++) *c++='0';        // add any 0's after '.'
+  //printf("res %s\n", string);
+  return string;
+  } // decimal128ToString
+
+/* ------------------------------------------------------------------ */
+/* to-number -- conversion from numeric string                        */
+/*                                                                    */
+/*   decimal128FromString(result, string, set);                       */
+/*                                                                    */
+/*  result  is the decimal128 format number which gets the result of  */
+/*          the conversion                                            */
+/*  *string is the character string which should contain a valid      */
+/*          number (which may be a special value)                     */
+/*  set     is the context                                            */
+/*                                                                    */
+/* The context is supplied to this routine is used for error handling */
+/* (setting of status and traps) and for the rounding mode, only.     */
+/* If an error occurs, the result will be a valid decimal128 NaN.     */
+/* ------------------------------------------------------------------ */
+decimal128 * decimal128FromString(decimal128 *result, const char *string,
+                                  decContext *set) {
+  decContext dc;                             // work
+  decNumber dn;                              // ..
+
+  decContextDefault(&dc, DEC_INIT_DECIMAL128); // no traps, please
+  dc.round=set->round;                         // use supplied rounding
+
+  decNumberFromString(&dn, string, &dc);     // will round if needed
+  decimal128FromNumber(result, &dn, &dc);
+  if (dc.status!=0) {                        // something happened
+    decContextSetStatus(set, dc.status);     // .. pass it on
+    }
+  return result;
+  } // decimal128FromString
+
+/* ------------------------------------------------------------------ */
+/* decimal128IsCanonical -- test whether encoding is canonical        */
+/*   d128 is the source decimal128                                    */
+/*   returns 1 if the encoding of d128 is canonical, 0 otherwise      */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+uInt decimal128IsCanonical(const decimal128 *d128) {
+  decNumber dn;                         // work
+  decimal128 canon;                      // ..
+  decContext dc;                        // ..
+  decContextDefault(&dc, DEC_INIT_DECIMAL128);
+  decimal128ToNumber(d128, &dn);
+  decimal128FromNumber(&canon, &dn, &dc);// canon will now be canonical
+  return memcmp(d128, &canon, DECIMAL128_Bytes)==0;
+  } // decimal128IsCanonical
+
+/* ------------------------------------------------------------------ */
+/* decimal128Canonical -- copy an encoding, ensuring it is canonical  */
+/*   d128 is the source decimal128                                    */
+/*   result is the target (may be the same decimal128)                */
+/*   returns result                                                   */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+decimal128 * decimal128Canonical(decimal128 *result, const decimal128 *d128) {
+  decNumber dn;                         // work
+  decContext dc;                        // ..
+  decContextDefault(&dc, DEC_INIT_DECIMAL128);
+  decimal128ToNumber(d128, &dn);
+  decimal128FromNumber(result, &dn, &dc);// result will now be canonical
+  return result;
+  } // decimal128Canonical
+
+#if DECTRACE || DECCHECK
+/* Macros for accessing decimal128 fields.  These assume the argument
+   is a reference (pointer) to the decimal128 structure, and the
+   decimal128 is in network byte order (big-endian) */
+// Get sign
+#define decimal128Sign(d)       ((unsigned)(d)->bytes[0]>>7)
+
+// Get combination field
+#define decimal128Comb(d)       (((d)->bytes[0] & 0x7c)>>2)
+
+// Get exponent continuation [does not remove bias]
+#define decimal128ExpCon(d)     ((((d)->bytes[0] & 0x03)<<10)         \
+                              | ((unsigned)(d)->bytes[1]<<2)          \
+                              | ((unsigned)(d)->bytes[2]>>6))
+
+// Set sign [this assumes sign previously 0]
+#define decimal128SetSign(d, b) {                                     \
+  (d)->bytes[0]|=((unsigned)(b)<<7);}
+
+// Set exponent continuation [does not apply bias]
+// This assumes range has been checked and exponent previously 0;
+// type of exponent must be unsigned
+#define decimal128SetExpCon(d, e) {                                   \
+  (d)->bytes[0]|=(uByte)((e)>>10);                                    \
+  (d)->bytes[1] =(uByte)(((e)&0x3fc)>>2);                             \
+  (d)->bytes[2]|=(uByte)(((e)&0x03)<<6);}
+
+/* ------------------------------------------------------------------ */
+/* decimal128Show -- display a decimal128 in hexadecimal [debug aid]  */
+/*   d128 -- the number to show                                       */
+/* ------------------------------------------------------------------ */
+// Also shows sign/cob/expconfields extracted
+void decimal128Show(const decimal128 *d128) {
+  char buf[DECIMAL128_Bytes*2+1];
+  Int i, j=0;
+
+  if (DECLITEND) {
+    for (i=0; i<DECIMAL128_Bytes; i++, j+=2) {
+      sprintf(&buf[j], "%02x", d128->bytes[15-i]);
+      }
+    printf(" D128> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
+           d128->bytes[15]>>7, (d128->bytes[15]>>2)&0x1f,
+           ((d128->bytes[15]&0x3)<<10)|(d128->bytes[14]<<2)|
+           (d128->bytes[13]>>6));
+    }
+   else {
+    for (i=0; i<DECIMAL128_Bytes; i++, j+=2) {
+      sprintf(&buf[j], "%02x", d128->bytes[i]);
+      }
+    printf(" D128> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
+           decimal128Sign(d128), decimal128Comb(d128),
+           decimal128ExpCon(d128));
+    }
+  } // decimal128Show
+#endif
diff --git a/decNumber/decimal128.h b/decNumber/decimal128.h
index 64faf3cb..47d2f8e6 100644
--- a/decNumber/decimal128.h
+++ b/decNumber/decimal128.h
@@ -1,103 +1,81 @@
-/* ------------------------------------------------------------------ */
-/* Decimal 128-bit format module header                               */
-/* ------------------------------------------------------------------ */
-/* Copyright (c) IBM Corporation, 2000, 2005.  All rights reserved.   */
-/*                                                                    */
-/* This software is made available under the terms of the             */
-/* ICU License -- ICU 1.8.1 and later.                                */
-/*                                                                    */
-/* The description and User's Guide ("The decNumber C Library") for   */
-/* this software is called decNumber.pdf.  This document is           */
-/* available, together with arithmetic and format specifications,     */
-/* testcases, and Web links, at: http://www2.hursley.ibm.com/decimal  */
-/*                                                                    */
-/* Please send comments, suggestions, and corrections to the author:  */
-/*   mfc@uk.ibm.com                                                   */
-/*   Mike Cowlishaw, IBM Fellow                                       */
-/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
-/* ------------------------------------------------------------------ */
-
-#if !defined(DECIMAL128)
-  #define DECIMAL128
-  #define DEC128NAME     "decimal128"                 /* Short name */
-  #define DEC128FULLNAME "Decimal 128-bit Number"     /* Verbose name */
-  #define DEC128AUTHOR   "Mike Cowlishaw"             /* Who to blame */
-
-  /* parameters for decimal128s */
-  #define DECIMAL128_Bytes  16          // length
-  #define DECIMAL128_Pmax   34          // maximum precision (digits)
-  #define DECIMAL128_Emax   6144        // maximum adjusted exponent
-  #define DECIMAL128_Emin  -6143        // minimum adjusted exponent
-  #define DECIMAL128_Bias   6176        // bias for the exponent
-  #define DECIMAL128_String 43          // maximum string length, +1
-  #define DECIMAL128_EconL  12          // exponent continuation length
-  // highest biased exponent (Elimit-1)
-  #define DECIMAL128_Ehigh  (DECIMAL128_Emax+DECIMAL128_Bias-DECIMAL128_Pmax+1)
-
-  // check enough digits, if pre-defined
-  #if defined(DECNUMDIGITS)
-    #if (DECNUMDIGITS<DECIMAL128_Pmax)
-      #error decimal128.h needs pre-defined DECNUMDIGITS>=34 for safe use
-    #endif
-  #endif
-
-  #ifndef DECNUMDIGITS
-    #define DECNUMDIGITS DECIMAL128_Pmax // size if not already defined
-  #endif
-  #ifndef DECNUMBER
-    #include "decNumber.h"              // context and number library
-  #endif
-
-  /* Decimal 128-bit type, accessible by bytes */
-  typedef struct {
-    uint8_t bytes[DECIMAL128_Bytes];    // decimal128: 1, 5, 12, 110 bits
-    } decimal128;
-
-  /* special values [top byte excluding sign bit; last two bits are
-     don't-care for Infinity on input, last bit don't-care for NaN] */
-  #if !defined(DECIMAL_NaN)
-    #define DECIMAL_NaN     0x7c        // 0 11111 00 NaN
-    #define DECIMAL_sNaN    0x7e        // 0 11111 10 sNaN
-    #define DECIMAL_Inf     0x78        // 0 11110 00 Infinity
-  #endif
-
-  /* Macros for accessing decimal128 fields.  These assume the argument
-     is a reference (pointer) to the decimal128 structure, and the
-     decimal128 is in network byte order (big-endian) */
-  // Get sign
-  #define decimal128Sign(d)       ((unsigned)(d)->bytes[0]>>7)
-
-  // Get combination field
-  #define decimal128Comb(d)       (((d)->bytes[0] & 0x7c)>>2)
-
-  // Get exponent continuation [does not remove bias]
-  #define decimal128ExpCon(d)     ((((d)->bytes[0] & 0x03)<<10)       \
-                                | ((unsigned)(d)->bytes[1]<<2)        \
-                                | ((unsigned)(d)->bytes[2]>>6))
-
-  // Set sign [this assumes sign previously 0]
-  #define decimal128SetSign(d, b) {                                   \
-    (d)->bytes[0]|=((unsigned)(b)<<7);}
-
-  // Set exponent continuation [does not apply bias]
-  // This assumes range has been checked and exponent previously 0;
-  // type of exponent must be unsigned
-  #define decimal128SetExpCon(d, e) {                                 \
-    (d)->bytes[0]|=(uint8_t)((e)>>10);                                \
-    (d)->bytes[1] =(uint8_t)(((e)&0x3fc)>>2);                         \
-    (d)->bytes[2]|=(uint8_t)(((e)&0x03)<<6);}
-
-  /* ------------------------------------------------------------------ */
-  /* Routines                                                           */
-  /* ------------------------------------------------------------------ */
-  // String conversions
-  decimal128 * decimal128FromString(decimal128 *, const char *, decContext *);
-  char * decimal128ToString(const decimal128 *, char *);
-  char * decimal128ToEngString(const decimal128 *, char *);
-
-  // decNumber conversions
-  decimal128 * decimal128FromNumber(decimal128 *, const decNumber *,
-                                    decContext *);
-  decNumber * decimal128ToNumber(const decimal128 *, decNumber *);
-
-#endif
+/* ------------------------------------------------------------------ */
+/* Decimal 128-bit format module header                               */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2005.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is called decNumber.pdf.  This document is           */
+/* available, together with arithmetic and format specifications,     */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+
+#if !defined(DECIMAL128)
+  #define DECIMAL128
+  #define DEC128NAME     "decimal128"                 /* Short name   */
+  #define DEC128FULLNAME "Decimal 128-bit Number"     /* Verbose name */
+  #define DEC128AUTHOR   "Mike Cowlishaw"             /* Who to blame */
+
+  /* parameters for decimal128s */
+  #define DECIMAL128_Bytes  16          /* length                     */
+  #define DECIMAL128_Pmax   34          /* maximum precision (digits) */
+  #define DECIMAL128_Emax   6144        /* maximum adjusted exponent  */
+  #define DECIMAL128_Emin  -6143        /* minimum adjusted exponent  */
+  #define DECIMAL128_Bias   6176        /* bias for the exponent      */
+  #define DECIMAL128_String 43          /* maximum string length, +1  */
+  #define DECIMAL128_EconL  12          /* exp. continuation length   */
+  /* highest biased exponent (Elimit-1)                               */
+  #define DECIMAL128_Ehigh  (DECIMAL128_Emax+DECIMAL128_Bias-DECIMAL128_Pmax+1)
+
+  /* check enough digits, if pre-defined                              */
+  #if defined(DECNUMDIGITS)
+    #if (DECNUMDIGITS<DECIMAL128_Pmax)
+      #error decimal128.h needs pre-defined DECNUMDIGITS>=34 for safe use
+    #endif
+  #endif
+
+  #ifndef DECNUMDIGITS
+    #define DECNUMDIGITS DECIMAL128_Pmax /* size if not already defined*/
+  #endif
+  #ifndef DECNUMBER
+    #include "decNumber.h"              /* context and number library */
+  #endif
+
+  /* Decimal 128-bit type, accessible by bytes                        */
+  typedef struct {
+    uint8_t bytes[DECIMAL128_Bytes]; /* decimal128: 1, 5, 12, 110 bits*/
+    } decimal128;
+
+  /* special values [top byte excluding sign bit; last two bits are   */
+  /* don't-care for Infinity on input, last bit don't-care for NaN]   */
+  #if !defined(DECIMAL_NaN)
+    #define DECIMAL_NaN     0x7c        /* 0 11111 00 NaN             */
+    #define DECIMAL_sNaN    0x7e        /* 0 11111 10 sNaN            */
+    #define DECIMAL_Inf     0x78        /* 0 11110 00 Infinity        */
+  #endif
+
+  /* ---------------------------------------------------------------- */
+  /* Routines                                                         */
+  /* ---------------------------------------------------------------- */
+  /* String conversions                                               */
+  decimal128 * decimal128FromString(decimal128 *, const char *, decContext *);
+  char * decimal128ToString(const decimal128 *, char *);
+  char * decimal128ToEngString(const decimal128 *, char *);
+
+  /* decNumber conversions                                            */
+  decimal128 * decimal128FromNumber(decimal128 *, const decNumber *,
+                                    decContext *);
+  decNumber * decimal128ToNumber(const decimal128 *, decNumber *);
+
+  /* Format-dependent utilities                                       */
+  uint32_t    decimal128IsCanonical(const decimal128 *);
+  decimal128 * decimal128Canonical(decimal128 *, const decimal128 *);
+
+#endif
diff --git a/decNumber/decimal32.c b/decNumber/decimal32.c
index fd2a22bc..775cffd2 100644
--- a/decNumber/decimal32.c
+++ b/decNumber/decimal32.c
@@ -1,481 +1,476 @@
-/* ------------------------------------------------------------------ */
-/* Decimal 32-bit format module                                       */
-/* ------------------------------------------------------------------ */
-/* Copyright (c) IBM Corporation, 2000, 2006.  All rights reserved.   */
-/*                                                                    */
-/* This software is made available under the terms of the             */
-/* ICU License -- ICU 1.8.1 and later.                                */
-/*                                                                    */
-/* The description and User's Guide ("The decNumber C Library") for   */
-/* this software is called decNumber.pdf.  This document is           */
-/* available, together with arithmetic and format specifications,     */
-/* testcases, and Web links, at: http://www2.hursley.ibm.com/decimal  */
-/*                                                                    */
-/* Please send comments, suggestions, and corrections to the author:  */
-/*   mfc@uk.ibm.com                                                   */
-/*   Mike Cowlishaw, IBM Fellow                                       */
-/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
-/* ------------------------------------------------------------------ */
-/* This module comprises the routines for decimal32 format numbers.   */
-/* Conversions are supplied to and from decNumber and String.         */
-/*                                                                    */
-/* No arithmetic routines are included; decNumber provides these.     */
-/*                                                                    */
-/* Error handling is the same as decNumber (qv.).                     */
-/* ------------------------------------------------------------------ */
-#include <string.h>           // [for memset/memcpy]
-#include <stdio.h>            // [for printf]
-#if defined(_MSVC_)
-#pragma warning(disable:4244) // (floating-point only?) "conversion from 'x' to 'y', possible loss of data"
-#endif /*defined(_MSVC_)*/
-
-#define  DECNUMDIGITS  7      // make decNumbers with space for 7
-#include "decNumber.h"        // base number library
-#include "decNumberLocal.h"   // decNumber local types, etc.
-#include "decimal32.h"        // our primary include
-
-/* Utility tables and routines [in decimal64.c] */
-extern const uInt   COMBEXP[32], COMBMSD[32];
-extern const uShort DPD2BIN[1024];
-extern const uShort BIN2DPD[1000];
-extern const uByte  BIN2CHAR[4001];
-
-extern void decDigitsToDPD(const decNumber *, uInt *, Int);
-extern void decDigitsFromDPD(decNumber *, const uInt *, Int);
-
-#if DECTRACE || DECCHECK
-void decimal32Show(const decimal32 *);            // for debug
-extern void decNumberShow(const decNumber *);     // ..
-#endif
-
-/* Useful macro */
-// Clear a structure (e.g., a decNumber)
-#define DEC_clear(d) memset(d, 0, sizeof(*d))
-
-#if !DECENDIAN || DECTRACE || DECCHECK
-/* compile-time endian tester [assumes sizeof(int)>1] */
-static  const  Int mfcone=1;                 // constant 1
-static  const  Flag *mfctop=(Flag *)&mfcone; // -> top byte
-#define LITEND mfctop[0]           // named flag; 1=little-endian
-#endif
-
-/* ------------------------------------------------------------------ */
-/* decimal32FromNumber -- convert decNumber to decimal32              */
-/*                                                                    */
-/*   ds is the target decimal32                                       */
-/*   dn is the source number (assumed valid)                          */
-/*   set is the context, used only for reporting errors               */
-/*                                                                    */
-/* The set argument is used only for status reporting and for the     */
-/* rounding mode (used if the coefficient is more than DECIMAL32_Pmax */
-/* digits or an overflow is detected).  If the exponent is out of the */
-/* valid range then Overflow or Underflow will be raised.             */
-/* After Underflow a subnormal result is possible.                    */
-/*                                                                    */
-/* DEC_Clamped is set if the number has to be 'folded down' to fit,   */
-/* by reducing its exponent and multiplying the coefficient by a      */
-/* power of ten, or if the exponent on a zero had to be clamped.      */
-/* ------------------------------------------------------------------ */
-decimal32 * decimal32FromNumber(decimal32 *d32, const decNumber *dn,
-                              decContext *set) {
-  uInt status=0;                   // status accumulator
-  Int ae;                          // adjusted exponent
-  decNumber  dw;                   // work
-  decContext dc;                   // ..
-  uInt *pu;                        // ..
-  uInt comb, exp;                  // ..
-  uInt targ=0;                     // target 32-bit
-
-  // If the number has too many digits, or the exponent could be
-  // out of range then reduce the number under the appropriate
-  // constraints.  This could push the number to Infinity or zero,
-  // so this check and rounding must be done before generating the
-  // decimal32]
-  ae=dn->exponent+dn->digits-1;              // [0 if special]
-  if (dn->digits>DECIMAL32_Pmax              // too many digits
-   || ae>DECIMAL32_Emax                      // likely overflow
-   || ae<DECIMAL32_Emin) {                   // likely underflow
-    decContextDefault(&dc, DEC_INIT_DECIMAL32); // [no traps]
-    dc.round=set->round;                     // use supplied rounding
-    decNumberPlus(&dw, dn, &dc);             // (round and check)
-    // [this changes -0 to 0, so enforce the sign...]
-    dw.bits|=dn->bits&DECNEG;
-    status=dc.status;                        // save status
-    dn=&dw;                                  // use the work number
-    } // maybe out of range
-
-  if (dn->bits&DECSPECIAL) {                      // a special value
-    if (dn->bits&DECINF) targ=DECIMAL_Inf<<24;
-     else {                                       // sNaN or qNaN
-      if ((*dn->lsu!=0 || dn->digits>1)           // non-zero coefficient
-       && (dn->digits<DECIMAL32_Pmax)) {          // coefficient fits
-        decDigitsToDPD(dn, &targ, 0);
-        }
-      if (dn->bits&DECNAN) targ|=DECIMAL_NaN<<24;
-       else targ|=DECIMAL_sNaN<<24;
-      } // a NaN
-    } // special
-
-   else { // is finite
-    if (decNumberIsZero(dn)) {               // is a zero
-      // set and clamp exponent
-      if (dn->exponent<-DECIMAL32_Bias) {
-        exp=0;                               // low clamp
-        status|=DEC_Clamped;
-        }
-       else {
-        exp=dn->exponent+DECIMAL32_Bias;     // bias exponent
-        if (exp>DECIMAL32_Ehigh) {           // top clamp
-          exp=DECIMAL32_Ehigh;
-          status|=DEC_Clamped;
-          }
-        }
-      comb=(exp>>3) & 0x18;             // msd=0, exp top 2 bits ..
-      }
-     else {                             // non-zero finite number
-      uInt msd;                         // work
-      Int pad=0;                        // coefficient pad digits
-
-      // the dn is known to fit, but it may need to be padded
-      exp=(uInt)(dn->exponent+DECIMAL32_Bias);    // bias exponent
-      if (exp>DECIMAL32_Ehigh) {                  // fold-down case
-        pad=exp-DECIMAL32_Ehigh;
-        exp=DECIMAL32_Ehigh;                      // [to maximum]
-        status|=DEC_Clamped;
-        }
-
-      // fastpath common case
-      if (DECDPUN==3 && pad==0) {
-        targ=BIN2DPD[dn->lsu[0]];
-        if (dn->digits>3) targ|=(uInt)(BIN2DPD[dn->lsu[1]])<<10;
-        msd=(dn->digits==7 ? dn->lsu[2] : 0);
-        }
-       else { // general case
-        decDigitsToDPD(dn, &targ, pad);
-        // save and clear the top digit
-        msd=targ>>20;
-        targ&=0x000fffff;
-        }
-
-      // create the combination field
-      if (msd>=8) comb=0x18 | ((exp>>5) & 0x06) | (msd & 0x01);
-             else comb=((exp>>3) & 0x18) | msd;
-      }
-    targ|=comb<<26;                // add combination field ..
-    targ|=(exp&0x3f)<<20;          // .. and exponent continuation
-    } // finite
-
-  if (dn->bits&DECNEG) targ|=0x80000000;  // add sign bit
-
-  // now write to storage; this may be endian, or not
-  #if DECENDIAN
-  // DECENDIAN -- direct store
-  pu=(uInt *)d32->bytes;           // overlay
-  *pu=targ;                        // directly store the int
-  #else
-  // not DECENDIAN -- use network byte order
-  if (LITEND) {                    // little-endian needs reversal
-    uByte *pb;                     // work
-    for (pb=&d32->bytes[3]; pb>=d32->bytes; pb--) {
-      *pb=(uByte)(targ&0xff);
-      targ>>=8;
-      } // i
-    }
-   else { // big-endian; it's the right way round already
-    pu=(uInt *)d32->bytes;         // overlay
-    *pu=targ;                      // directly store the int
-    }
-  #endif
-
-  if (status!=0) decContextSetStatus(set, status); // pass on status
-  // decimal32Show(d32);
-  return d32;
-  } // decimal32FromNumber
-
-/* ------------------------------------------------------------------ */
-/* decimal32ToNumber -- convert decimal32 to decNumber                */
-/*   d32 is the source decimal32                                      */
-/*   dn is the target number, with appropriate space                  */
-/* No error is possible.                                              */
-/* ------------------------------------------------------------------ */
-decNumber * decimal32ToNumber(const decimal32 *d32, decNumber *dn) {
-  uInt msd;                        // coefficient MSD
-  uInt exp;                        // exponent top two bits
-  uInt comb;                       // combination field
-  uInt *pu;                        // work
-  uInt sour;                       // source 32-bit
-
-  // load source from storage; this may be endian, or not
-  #if DECENDIAN
-  // DECENDIAN -- direct load
-  pu=(uInt *)d32->bytes;           // overlay
-  sour=*pu;                        // directly load the int
-  #else
-  // not DECENDIAN -- use network byte order
-  if (LITEND) {                    // little-endian needs reversal
-    const uByte *pb;               // work
-    sour=0;                        // [keep compiler quiet]
-    for (pb=d32->bytes; pb<=&d32->bytes[3]; pb++) {
-      sour<<=8;
-      sour|=*pb;
-      } // i
-    }
-   else { // big-endian; it's the right way round already
-    pu=(uInt *)d32->bytes;         // overlay
-    sour=*pu;                      // directly load the int
-    }
-  #endif
-
-  comb=(sour>>26)&0x1f;            // combination field
-
-  decNumberZero(dn);               // clean number
-  if (sour&0x80000000) dn->bits=DECNEG; // set sign if negative
-
-  msd=COMBMSD[comb];               // decode the combination field
-  exp=COMBEXP[comb];               // ..
-
-  if (exp==3) {                    // is a special
-    if (msd==0) {
-      dn->bits|=DECINF;
-      return dn;                   // no coefficient needed
-      }
-    else if (sour&0x02000000) dn->bits|=DECSNAN;
-    else dn->bits|=DECNAN;
-    msd=0;                         // no top digit
-    }
-   else {                          // is a finite number
-    dn->exponent=(exp<<6)+((sour>>20)&0x3f)-DECIMAL32_Bias; // unbiased
-    }
-
-  // get the coefficient
-  sour&=0x000fffff;                // clean coefficient continuation
-  if (msd) {                       // non-zero msd
-    sour|=msd<<20;                 // prefix to coefficient
-    decDigitsFromDPD(dn, &sour, 3); // process 3 declets
-    return dn;
-    }
-  // msd=0
-  if (!sour) return dn;            // easy: coefficient is 0
-  if (sour&0x000ffc00)             // need 2 declets?
-    decDigitsFromDPD(dn, &sour, 2); // process 2 declets
-   else
-    decDigitsFromDPD(dn, &sour, 1); // process 1 declet
-  return dn;
-  } // decimal32ToNumber
-
-/* ------------------------------------------------------------------ */
-/* to-scientific-string -- conversion to numeric string               */
-/* to-engineering-string -- conversion to numeric string              */
-/*                                                                    */
-/*   decimal32ToString(d32, string);                                  */
-/*   decimal32ToEngString(d32, string);                               */
-/*                                                                    */
-/*  d32 is the decimal32 format number to convert                     */
-/*  string is the string where the result will be laid out            */
-/*                                                                    */
-/*  string must be at least 24 characters                             */
-/*                                                                    */
-/*  No error is possible, and no status can be set.                   */
-/* ------------------------------------------------------------------ */
-char * decimal32ToEngString(const decimal32 *d32, char *string){
-  decNumber dn;                         // work
-  decimal32ToNumber(d32, &dn);
-  decNumberToEngString(&dn, string);
-  return string;
-  } // decimal32ToEngString
-
-char * decimal32ToString(const decimal32 *d32, char *string){
-  uInt msd;                        // coefficient MSD
-  Int  exp;                        // exponent top two bits or full
-  uInt comb;                       // combination field
-  char *cstart;                    // coefficient start
-  char *c;                         // output pointer in string
-  uInt *pu;                        // work
-  char *s, *t;                     // .. (source, target)
-  Int  dpd;                        // ..
-  Int  pre, e;                     // ..
-  const uByte *u;                  // ..
-  uInt sour;                       // source 32-bit
-
-  // load source from storage; this may be endian, or not
-  #if DECENDIAN
-  // DECENDIAN -- direct load
-  pu=(uInt *)d32->bytes;           // overlay
-  sour=*pu;                        // directly load the int
-  #else
-  // not DECENDIAN -- use network byte order
-  if (LITEND) {                    // little-endian needs reversal
-    const uByte *pb;               // work
-    sour=0;                        // [keep compiler quiet]
-    for (pb=d32->bytes; pb<=&d32->bytes[3]; pb++) {
-      sour<<=8;
-      sour|=*pb;
-      } // i
-    }
-   else { // big-endian; it's the right way round already
-    pu=(uInt *)d32->bytes;         // overlay
-    sour=*pu;                      // directly load the int
-    }
-  #endif
-
-  c=string;                        // where result will go
-  if (((Int)sour)<0) *c++='-';     // handle sign
-
-  comb=(sour>>26)&0x1f;            // combination field
-  msd=COMBMSD[comb];               // decode the combination field
-  exp=COMBEXP[comb];               // ..
-
-  if (exp==3) {
-    if (msd==0) {                  // infinity
-      strcpy(c, "Infinity");
-      return string;               // easy
-      }
-    if (sour&0x02000000) *c++='s'; // sNaN
-    strcpy(c, "NaN");              // complete word
-    c+=3;                          // step past
-    if ((sour&0x000fffff)==0) return string; // zero payload
-    // otherwise drop through to add integer; set correct exp
-    exp=0; msd=0;                  // setup for following code
-    }
-   else exp=(exp<<6)+((sour>>20)&0x3f)-DECIMAL32_Bias; // unbiased
-
-  // convert 7 digits of significand to characters
-  cstart=c;                        // save start of coefficient
-  if (msd) *c++='0'+(char)msd;     // non-zero most significant digit
-
-  // Now decode the declets.  After extracting each one, it is
-  // decoded to binary and then to a 4-char sequence by table lookup;
-  // the 4-chars are a 1-char length (significant digits, except 000
-  // has length 0).  This allows us to left-align the first declet
-  // with non-zero content, then remaining ones are full 3-char
-  // length.  We use fixed-length memcpys because variable-length
-  // causes a subroutine call in GCC.  (These are length 4 for speed
-  // and are safe because the array has an extra terminator byte.)
-  #define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4];                   \
-                   if (c!=cstart) {memcpy(c, u+1, 4); c+=3;}      \
-                    else if (*u)  {memcpy(c, u+4-*u, 4); c+=*u;}
-
-  dpd=(sour>>10)&0x3ff;            // declet 1
-  dpd2char;
-  dpd=(sour)&0x3ff;                // declet 2
-  dpd2char;
-
-  if (c==cstart) *c++='0';         // all zeros -- make 0
-
-  if (exp==0) {                    // integer or NaN case -- easy
-    *c='\0';                       // terminate
-    return string;
-    }
-
-  /* non-0 exponent */
-  e=0;                             // assume no E
-  pre=c-cstart+exp;
-  // [here, pre-exp is the digits count (==1 for zero)]
-  if (exp>0 || pre<-5) {           // need exponential form
-    e=pre-1;                       // calculate E value
-    pre=1;                         // assume one digit before '.'
-    } // exponential form
-
-  /* modify the coefficient, adding 0s, '.', and E+nn as needed */
-  s=c-1;                           // source (LSD)
-  if (pre>0) {                     // ddd.ddd (plain), perhaps with E
-    char *dotat=cstart+pre;
-    if (dotat<c) {                 // if embedded dot needed...
-      t=c;                              // target
-      for (; s>=dotat; s--, t--) *t=*s; // open the gap; leave t at gap
-      *t='.';                           // insert the dot
-      c++;                              // length increased by one
-      }
-
-    // finally add the E-part, if needed; it will never be 0, and has
-    // a maximum length of 3 digits (E-101 case)
-    if (e!=0) {
-      *c++='E';                    // starts with E
-      *c++='+';                    // assume positive
-      if (e<0) {
-        *(c-1)='-';                // oops, need '-'
-        e=-e;                      // uInt, please
-        }
-      u=&BIN2CHAR[e*4];            // -> length byte
-      memcpy(c, u+4-*u, 4);        // copy fixed 4 characters [is safe]
-      c+=*u;                       // bump pointer appropriately
-      }
-    *c='\0';                       // add terminator
-    //printf("res %s\n", string);
-    return string;
-    } // pre>0
-
-  /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
-  t=c+1-pre;
-  *(t+1)='\0';                          // can add terminator now
-  for (; s>=cstart; s--, t--) *t=*s;    // shift whole coefficient right
-  c=cstart;
-  *c++='0';                             // always starts with 0.
-  *c++='.';
-  for (; pre<0; pre++) *c++='0';        // add any 0's after '.'
-  //printf("res %s\n", string);
-  return string;
-  } // decimal32ToString
-
-/* ------------------------------------------------------------------ */
-/* to-number -- conversion from numeric string                        */
-/*                                                                    */
-/*   decimal32FromString(result, string, set);                        */
-/*                                                                    */
-/*  result  is the decimal32 format number which gets the result of   */
-/*          the conversion                                            */
-/*  *string is the character string which should contain a valid      */
-/*          number (which may be a special value)                     */
-/*  set     is the context                                            */
-/*                                                                    */
-/* The context is supplied to this routine is used for error handling */
-/* (setting of status and traps) and for the rounding mode, only.     */
-/* If an error occurs, the result will be a valid decimal32 NaN.      */
-/* ------------------------------------------------------------------ */
-decimal32 * decimal32FromString(decimal32 *result, const char *string,
-                                decContext *set) {
-  decContext dc;                             // work
-  decNumber dn;                              // ..
-
-  decContextDefault(&dc, DEC_INIT_DECIMAL32); // no traps, please
-  dc.round=set->round;                        // use supplied rounding
-
-  decNumberFromString(&dn, string, &dc);     // will round if needed
-  decimal32FromNumber(result, &dn, &dc);
-  if (dc.status!=0) {                        // something happened
-    decContextSetStatus(set, dc.status);     // .. pass it on
-    }
-  return result;
-  } // decimal32FromString
-
-#if DECTRACE || DECCHECK
-/* ------------------------------------------------------------------ */
-/* decimal32Show -- display a decimal32 in hexadecimal [debug aid]    */
-/*   d32 -- the number to show                                        */
-/* ------------------------------------------------------------------ */
-// Also shows sign/cob/expconfields extracted - valid bigendian only
-void decimal32Show(const decimal32 *d32) {
-  char buf[DECIMAL32_Bytes*2+1];
-  Int i, j=0;
-
-  #if DECENDIAN
-  if (LITEND) {
-    for (i=0; i<DECIMAL32_Bytes; i++, j+=2) {
-      sprintf(&buf[j], "%02x", d32->bytes[3-i]);
-      }
-    printf(" D32> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
-           d32->bytes[3]>>7, (d32->bytes[3]>>2)&0x1f,
-           ((d32->bytes[3]&0x3)<<4)| (d32->bytes[2]>>4));
-    }
-   else {
-  #endif
-    for (i=0; i<DECIMAL32_Bytes; i++, j+=2) {
-      sprintf(&buf[j], "%02x", d32->bytes[i]);
-      }
-    printf(" D32> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
-           decimal32Sign(d32), decimal32Comb(d32), decimal32ExpCon(d32));
-  #if DECENDIAN
-    }
-  #endif
-  } // decimal32Show
-#endif
+/* ------------------------------------------------------------------ */
+/* Decimal 32-bit format module                                       */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2008.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is called decNumber.pdf.  This document is           */
+/* available, together with arithmetic and format specifications,     */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+/* This module comprises the routines for decimal32 format numbers.   */
+/* Conversions are supplied to and from decNumber and String.         */
+/*                                                                    */
+/* This is used when decNumber provides operations, either for all    */
+/* operations or as a proxy between decNumber and decSingle.          */
+/*                                                                    */
+/* Error handling is the same as decNumber (qv.).                     */
+/* ------------------------------------------------------------------ */
+#include <string.h>           // [for memset/memcpy]
+#include <stdio.h>            // [for printf]
+
+#define  DECNUMDIGITS  7      // make decNumbers with space for 7
+#include "decNumber.h"        // base number library
+#include "decNumberLocal.h"   // decNumber local types, etc.
+#include "decimal32.h"        // our primary include
+
+/* Utility tables and routines [in decimal64.c] */
+// DPD2BIN and the reverse are renamed to prevent link-time conflict
+// if decQuad is also built in the same executable
+#define DPD2BIN DPD2BINx
+#define BIN2DPD BIN2DPDx
+extern const uInt   COMBEXP[32], COMBMSD[32];
+extern const uShort DPD2BIN[1024];
+extern const uShort BIN2DPD[1000];
+extern const uByte  BIN2CHAR[4001];
+
+extern void decDigitsToDPD(const decNumber *, uInt *, Int);
+extern void decDigitsFromDPD(decNumber *, const uInt *, Int);
+
+#if DECTRACE || DECCHECK
+void decimal32Show(const decimal32 *);            // for debug
+extern void decNumberShow(const decNumber *);     // ..
+#endif
+
+/* Useful macro */
+// Clear a structure (e.g., a decNumber)
+#define DEC_clear(d) memset(d, 0, sizeof(*d))
+
+/* ------------------------------------------------------------------ */
+/* decimal32FromNumber -- convert decNumber to decimal32              */
+/*                                                                    */
+/*   ds is the target decimal32                                       */
+/*   dn is the source number (assumed valid)                          */
+/*   set is the context, used only for reporting errors               */
+/*                                                                    */
+/* The set argument is used only for status reporting and for the     */
+/* rounding mode (used if the coefficient is more than DECIMAL32_Pmax */
+/* digits or an overflow is detected).  If the exponent is out of the */
+/* valid range then Overflow or Underflow will be raised.             */
+/* After Underflow a subnormal result is possible.                    */
+/*                                                                    */
+/* DEC_Clamped is set if the number has to be 'folded down' to fit,   */
+/* by reducing its exponent and multiplying the coefficient by a      */
+/* power of ten, or if the exponent on a zero had to be clamped.      */
+/* ------------------------------------------------------------------ */
+decimal32 * decimal32FromNumber(decimal32 *d32, const decNumber *dn,
+                              decContext *set) {
+  uInt status=0;                   // status accumulator
+  Int ae;                          // adjusted exponent
+  decNumber  dw;                   // work
+  decContext dc;                   // ..
+  uInt comb, exp;                  // ..
+  uInt uiwork;                     // for macros
+  uInt targ=0;                     // target 32-bit
+
+  // If the number has too many digits, or the exponent could be
+  // out of range then reduce the number under the appropriate
+  // constraints.  This could push the number to Infinity or zero,
+  // so this check and rounding must be done before generating the
+  // decimal32]
+  ae=dn->exponent+dn->digits-1;              // [0 if special]
+  if (dn->digits>DECIMAL32_Pmax              // too many digits
+   || ae>DECIMAL32_Emax                      // likely overflow
+   || ae<DECIMAL32_Emin) {                   // likely underflow
+    decContextDefault(&dc, DEC_INIT_DECIMAL32); // [no traps]
+    dc.round=set->round;                     // use supplied rounding
+    decNumberPlus(&dw, dn, &dc);             // (round and check)
+    // [this changes -0 to 0, so enforce the sign...]
+    dw.bits|=dn->bits&DECNEG;
+    status=dc.status;                        // save status
+    dn=&dw;                                  // use the work number
+    } // maybe out of range
+
+  if (dn->bits&DECSPECIAL) {                      // a special value
+    if (dn->bits&DECINF) targ=DECIMAL_Inf<<24;
+     else {                                       // sNaN or qNaN
+      if ((*dn->lsu!=0 || dn->digits>1)           // non-zero coefficient
+       && (dn->digits<DECIMAL32_Pmax)) {          // coefficient fits
+        decDigitsToDPD(dn, &targ, 0);
+        }
+      if (dn->bits&DECNAN) targ|=DECIMAL_NaN<<24;
+       else targ|=DECIMAL_sNaN<<24;
+      } // a NaN
+    } // special
+
+   else { // is finite
+    if (decNumberIsZero(dn)) {               // is a zero
+      // set and clamp exponent
+      if (dn->exponent<-DECIMAL32_Bias) {
+        exp=0;                               // low clamp
+        status|=DEC_Clamped;
+        }
+       else {
+        exp=dn->exponent+DECIMAL32_Bias;     // bias exponent
+        if (exp>DECIMAL32_Ehigh) {           // top clamp
+          exp=DECIMAL32_Ehigh;
+          status|=DEC_Clamped;
+          }
+        }
+      comb=(exp>>3) & 0x18;             // msd=0, exp top 2 bits ..
+      }
+     else {                             // non-zero finite number
+      uInt msd;                         // work
+      Int pad=0;                        // coefficient pad digits
+
+      // the dn is known to fit, but it may need to be padded
+      exp=(uInt)(dn->exponent+DECIMAL32_Bias);    // bias exponent
+      if (exp>DECIMAL32_Ehigh) {                  // fold-down case
+        pad=exp-DECIMAL32_Ehigh;
+        exp=DECIMAL32_Ehigh;                      // [to maximum]
+        status|=DEC_Clamped;
+        }
+
+      // fastpath common case
+      if (DECDPUN==3 && pad==0) {
+        targ=BIN2DPD[dn->lsu[0]];
+        if (dn->digits>3) targ|=(uInt)(BIN2DPD[dn->lsu[1]])<<10;
+        msd=(dn->digits==7 ? dn->lsu[2] : 0);
+        }
+       else { // general case
+        decDigitsToDPD(dn, &targ, pad);
+        // save and clear the top digit
+        msd=targ>>20;
+        targ&=0x000fffff;
+        }
+
+      // create the combination field
+      if (msd>=8) comb=0x18 | ((exp>>5) & 0x06) | (msd & 0x01);
+             else comb=((exp>>3) & 0x18) | msd;
+      }
+    targ|=comb<<26;                // add combination field ..
+    targ|=(exp&0x3f)<<20;          // .. and exponent continuation
+    } // finite
+
+  if (dn->bits&DECNEG) targ|=0x80000000;  // add sign bit
+
+  // now write to storage; this is endian
+  UBFROMUI(d32->bytes, targ);      // directly store the int
+
+  if (status!=0) decContextSetStatus(set, status); // pass on status
+  // decimal32Show(d32);
+  return d32;
+  } // decimal32FromNumber
+
+/* ------------------------------------------------------------------ */
+/* decimal32ToNumber -- convert decimal32 to decNumber                */
+/*   d32 is the source decimal32                                      */
+/*   dn is the target number, with appropriate space                  */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+decNumber * decimal32ToNumber(const decimal32 *d32, decNumber *dn) {
+  uInt msd;                        // coefficient MSD
+  uInt exp;                        // exponent top two bits
+  uInt comb;                       // combination field
+  uInt sour;                       // source 32-bit
+  uInt uiwork;                     // for macros
+
+  // load source from storage; this is endian
+  sour=UBTOUI(d32->bytes);         // directly load the int
+
+  comb=(sour>>26)&0x1f;            // combination field
+
+  decNumberZero(dn);               // clean number
+  if (sour&0x80000000) dn->bits=DECNEG; // set sign if negative
+
+  msd=COMBMSD[comb];               // decode the combination field
+  exp=COMBEXP[comb];               // ..
+
+  if (exp==3) {                    // is a special
+    if (msd==0) {
+      dn->bits|=DECINF;
+      return dn;                   // no coefficient needed
+      }
+    else if (sour&0x02000000) dn->bits|=DECSNAN;
+    else dn->bits|=DECNAN;
+    msd=0;                         // no top digit
+    }
+   else {                          // is a finite number
+    dn->exponent=(exp<<6)+((sour>>20)&0x3f)-DECIMAL32_Bias; // unbiased
+    }
+
+  // get the coefficient
+  sour&=0x000fffff;                // clean coefficient continuation
+  if (msd) {                       // non-zero msd
+    sour|=msd<<20;                 // prefix to coefficient
+    decDigitsFromDPD(dn, &sour, 3); // process 3 declets
+    return dn;
+    }
+  // msd=0
+  if (!sour) return dn;            // easy: coefficient is 0
+  if (sour&0x000ffc00)             // need 2 declets?
+    decDigitsFromDPD(dn, &sour, 2); // process 2 declets
+   else
+    decDigitsFromDPD(dn, &sour, 1); // process 1 declet
+  return dn;
+  } // decimal32ToNumber
+
+/* ------------------------------------------------------------------ */
+/* to-scientific-string -- conversion to numeric string               */
+/* to-engineering-string -- conversion to numeric string              */
+/*                                                                    */
+/*   decimal32ToString(d32, string);                                  */
+/*   decimal32ToEngString(d32, string);                               */
+/*                                                                    */
+/*  d32 is the decimal32 format number to convert                     */
+/*  string is the string where the result will be laid out            */
+/*                                                                    */
+/*  string must be at least 24 characters                             */
+/*                                                                    */
+/*  No error is possible, and no status can be set.                   */
+/* ------------------------------------------------------------------ */
+char * decimal32ToEngString(const decimal32 *d32, char *string){
+  decNumber dn;                         // work
+  decimal32ToNumber(d32, &dn);
+  decNumberToEngString(&dn, string);
+  return string;
+  } // decimal32ToEngString
+
+char * decimal32ToString(const decimal32 *d32, char *string){
+  uInt msd;                        // coefficient MSD
+  Int  exp;                        // exponent top two bits or full
+  uInt comb;                       // combination field
+  char *cstart;                    // coefficient start
+  char *c;                         // output pointer in string
+  const uByte *u;                  // work
+  char *s, *t;                     // .. (source, target)
+  Int  dpd;                        // ..
+  Int  pre, e;                     // ..
+  uInt uiwork;                     // for macros
+  uInt sour;                       // source 32-bit
+
+  // load source from storage; this is endian
+  sour=UBTOUI(d32->bytes);         // directly load the int
+
+  c=string;                        // where result will go
+  if (((Int)sour)<0) *c++='-';     // handle sign
+
+  comb=(sour>>26)&0x1f;            // combination field
+  msd=COMBMSD[comb];               // decode the combination field
+  exp=COMBEXP[comb];               // ..
+
+  if (exp==3) {
+    if (msd==0) {                  // infinity
+      strcpy(c,   "Inf");
+      strcpy(c+3, "inity");
+      return string;               // easy
+      }
+    if (sour&0x02000000) *c++='s'; // sNaN
+    strcpy(c, "NaN");              // complete word
+    c+=3;                          // step past
+    if ((sour&0x000fffff)==0) return string; // zero payload
+    // otherwise drop through to add integer; set correct exp
+    exp=0; msd=0;                  // setup for following code
+    }
+   else exp=(exp<<6)+((sour>>20)&0x3f)-DECIMAL32_Bias; // unbiased
+
+  // convert 7 digits of significand to characters
+  cstart=c;                        // save start of coefficient
+  if (msd) *c++='0'+(char)msd;     // non-zero most significant digit
+
+  // Now decode the declets.  After extracting each one, it is
+  // decoded to binary and then to a 4-char sequence by table lookup;
+  // the 4-chars are a 1-char length (significant digits, except 000
+  // has length 0).  This allows us to left-align the first declet
+  // with non-zero content, then remaining ones are full 3-char
+  // length.  We use fixed-length memcpys because variable-length
+  // causes a subroutine call in GCC.  (These are length 4 for speed
+  // and are safe because the array has an extra terminator byte.)
+  #define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4];                   \
+                   if (c!=cstart) {memcpy(c, u+1, 4); c+=3;}      \
+                    else if (*u)  {memcpy(c, u+4-*u, 4); c+=*u;}
+
+  dpd=(sour>>10)&0x3ff;            // declet 1
+  dpd2char;
+  dpd=(sour)&0x3ff;                // declet 2
+  dpd2char;
+
+  if (c==cstart) *c++='0';         // all zeros -- make 0
+
+  if (exp==0) {                    // integer or NaN case -- easy
+    *c='\0';                       // terminate
+    return string;
+    }
+
+  /* non-0 exponent */
+  e=0;                             // assume no E
+  pre=c-cstart+exp;
+  // [here, pre-exp is the digits count (==1 for zero)]
+  if (exp>0 || pre<-5) {           // need exponential form
+    e=pre-1;                       // calculate E value
+    pre=1;                         // assume one digit before '.'
+    } // exponential form
+
+  /* modify the coefficient, adding 0s, '.', and E+nn as needed */
+  s=c-1;                           // source (LSD)
+  if (pre>0) {                     // ddd.ddd (plain), perhaps with E
+    char *dotat=cstart+pre;
+    if (dotat<c) {                 // if embedded dot needed...
+      t=c;                              // target
+      for (; s>=dotat; s--, t--) *t=*s; // open the gap; leave t at gap
+      *t='.';                           // insert the dot
+      c++;                              // length increased by one
+      }
+
+    // finally add the E-part, if needed; it will never be 0, and has
+    // a maximum length of 3 digits (E-101 case)
+    if (e!=0) {
+      *c++='E';                    // starts with E
+      *c++='+';                    // assume positive
+      if (e<0) {
+        *(c-1)='-';                // oops, need '-'
+        e=-e;                      // uInt, please
+        }
+      u=&BIN2CHAR[e*4];            // -> length byte
+      memcpy(c, u+4-*u, 4);        // copy fixed 4 characters [is safe]
+      c+=*u;                       // bump pointer appropriately
+      }
+    *c='\0';                       // add terminator
+    //printf("res %s\n", string);
+    return string;
+    } // pre>0
+
+  /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
+  t=c+1-pre;
+  *(t+1)='\0';                          // can add terminator now
+  for (; s>=cstart; s--, t--) *t=*s;    // shift whole coefficient right
+  c=cstart;
+  *c++='0';                             // always starts with 0.
+  *c++='.';
+  for (; pre<0; pre++) *c++='0';        // add any 0's after '.'
+  //printf("res %s\n", string);
+  return string;
+  } // decimal32ToString
+
+/* ------------------------------------------------------------------ */
+/* to-number -- conversion from numeric string                        */
+/*                                                                    */
+/*   decimal32FromString(result, string, set);                        */
+/*                                                                    */
+/*  result  is the decimal32 format number which gets the result of   */
+/*          the conversion                                            */
+/*  *string is the character string which should contain a valid      */
+/*          number (which may be a special value)                     */
+/*  set     is the context                                            */
+/*                                                                    */
+/* The context is supplied to this routine is used for error handling */
+/* (setting of status and traps) and for the rounding mode, only.     */
+/* If an error occurs, the result will be a valid decimal32 NaN.      */
+/* ------------------------------------------------------------------ */
+decimal32 * decimal32FromString(decimal32 *result, const char *string,
+                                decContext *set) {
+  decContext dc;                             // work
+  decNumber dn;                              // ..
+
+  decContextDefault(&dc, DEC_INIT_DECIMAL32); // no traps, please
+  dc.round=set->round;                        // use supplied rounding
+
+  decNumberFromString(&dn, string, &dc);     // will round if needed
+  decimal32FromNumber(result, &dn, &dc);
+  if (dc.status!=0) {                        // something happened
+    decContextSetStatus(set, dc.status);     // .. pass it on
+    }
+  return result;
+  } // decimal32FromString
+
+/* ------------------------------------------------------------------ */
+/* decimal32IsCanonical -- test whether encoding is canonical         */
+/*   d32 is the source decimal32                                      */
+/*   returns 1 if the encoding of d32 is canonical, 0 otherwise       */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+uInt decimal32IsCanonical(const decimal32 *d32) {
+  decNumber dn;                         // work
+  decimal32 canon;                      // ..
+  decContext dc;                        // ..
+  decContextDefault(&dc, DEC_INIT_DECIMAL32);
+  decimal32ToNumber(d32, &dn);
+  decimal32FromNumber(&canon, &dn, &dc);// canon will now be canonical
+  return memcmp(d32, &canon, DECIMAL32_Bytes)==0;
+  } // decimal32IsCanonical
+
+/* ------------------------------------------------------------------ */
+/* decimal32Canonical -- copy an encoding, ensuring it is canonical   */
+/*   d32 is the source decimal32                                      */
+/*   result is the target (may be the same decimal32)                 */
+/*   returns result                                                   */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+decimal32 * decimal32Canonical(decimal32 *result, const decimal32 *d32) {
+  decNumber dn;                         // work
+  decContext dc;                        // ..
+  decContextDefault(&dc, DEC_INIT_DECIMAL32);
+  decimal32ToNumber(d32, &dn);
+  decimal32FromNumber(result, &dn, &dc);// result will now be canonical
+  return result;
+  } // decimal32Canonical
+
+#if DECTRACE || DECCHECK
+/* Macros for accessing decimal32 fields.  These assume the argument
+   is a reference (pointer) to the decimal32 structure, and the
+   decimal32 is in network byte order (big-endian) */
+// Get sign
+#define decimal32Sign(d)       ((unsigned)(d)->bytes[0]>>7)
+
+// Get combination field
+#define decimal32Comb(d)       (((d)->bytes[0] & 0x7c)>>2)
+
+// Get exponent continuation [does not remove bias]
+#define decimal32ExpCon(d)     ((((d)->bytes[0] & 0x03)<<4)           \
+                             | ((unsigned)(d)->bytes[1]>>4))
+
+// Set sign [this assumes sign previously 0]
+#define decimal32SetSign(d, b) {                                      \
+  (d)->bytes[0]|=((unsigned)(b)<<7);}
+
+// Set exponent continuation [does not apply bias]
+// This assumes range has been checked and exponent previously 0;
+// type of exponent must be unsigned
+#define decimal32SetExpCon(d, e) {                                    \
+  (d)->bytes[0]|=(uByte)((e)>>4);                                     \
+  (d)->bytes[1]|=(uByte)(((e)&0x0F)<<4);}
+
+/* ------------------------------------------------------------------ */
+/* decimal32Show -- display a decimal32 in hexadecimal [debug aid]    */
+/*   d32 -- the number to show                                        */
+/* ------------------------------------------------------------------ */
+// Also shows sign/cob/expconfields extracted - valid bigendian only
+void decimal32Show(const decimal32 *d32) {
+  char buf[DECIMAL32_Bytes*2+1];
+  Int i, j=0;
+
+  if (DECLITEND) {
+    for (i=0; i<DECIMAL32_Bytes; i++, j+=2) {
+      sprintf(&buf[j], "%02x", d32->bytes[3-i]);
+      }
+    printf(" D32> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
+           d32->bytes[3]>>7, (d32->bytes[3]>>2)&0x1f,
+           ((d32->bytes[3]&0x3)<<4)| (d32->bytes[2]>>4));
+    }
+   else {
+    for (i=0; i<DECIMAL32_Bytes; i++, j+=2) {
+      sprintf(&buf[j], "%02x", d32->bytes[i]);
+      }
+    printf(" D32> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
+           decimal32Sign(d32), decimal32Comb(d32), decimal32ExpCon(d32));
+    }
+  } // decimal32Show
+#endif
diff --git a/decNumber/decimal32.h b/decNumber/decimal32.h
index ed92001f..060640e6 100644
--- a/decNumber/decimal32.h
+++ b/decNumber/decimal32.h
@@ -1,101 +1,81 @@
-/* ------------------------------------------------------------------ */
-/* Decimal 32-bit format module header                                */
-/* ------------------------------------------------------------------ */
-/* Copyright (c) IBM Corporation, 2000, 2005.  All rights reserved.   */
-/*                                                                    */
-/* This software is made available under the terms of the             */
-/* ICU License -- ICU 1.8.1 and later.                                */
-/*                                                                    */
-/* The description and User's Guide ("The decNumber C Library") for   */
-/* this software is called decNumber.pdf.  This document is           */
-/* available, together with arithmetic and format specifications,     */
-/* testcases, and Web links, at: http://www2.hursley.ibm.com/decimal  */
-/*                                                                    */
-/* Please send comments, suggestions, and corrections to the author:  */
-/*   mfc@uk.ibm.com                                                   */
-/*   Mike Cowlishaw, IBM Fellow                                       */
-/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
-/* ------------------------------------------------------------------ */
-
-#if !defined(DECIMAL32)
-  #define DECIMAL32
-  #define DEC32NAME     "decimal32"                   /* Short name */
-  #define DEC32FULLNAME "Decimal 32-bit Number"       /* Verbose name */
-  #define DEC32AUTHOR   "Mike Cowlishaw"              /* Who to blame */
-
-  /* parameters for decimal32s */
-  #define DECIMAL32_Bytes  4            // length
-  #define DECIMAL32_Pmax   7            // maximum precision (digits)
-  #define DECIMAL32_Emax   96           // maximum adjusted exponent
-  #define DECIMAL32_Emin  -95           // minimum adjusted exponent
-  #define DECIMAL32_Bias   101          // bias for the exponent
-  #define DECIMAL32_String 15           // maximum string length, +1
-  #define DECIMAL32_EconL  6            // exponent continuation length
-  // highest biased exponent (Elimit-1)
-  #define DECIMAL32_Ehigh  (DECIMAL32_Emax+DECIMAL32_Bias-DECIMAL32_Pmax+1)
-
-  // check enough digits, if pre-defined
-  #if defined(DECNUMDIGITS)
-    #if (DECNUMDIGITS<DECIMAL32_Pmax)
-      #error decimal32.h needs pre-defined DECNUMDIGITS>=7 for safe use
-    #endif
-  #endif
-
-  #ifndef DECNUMDIGITS
-    #define DECNUMDIGITS DECIMAL32_Pmax // size if not already defined
-  #endif
-  #ifndef DECNUMBER
-    #include "decNumber.h"              // context and number library
-  #endif
-
-  /* Decimal 32-bit type, accessible by bytes */
-  typedef struct {
-    uint8_t bytes[DECIMAL32_Bytes];     // decimal32: 1, 5, 6, 20 bits
-    } decimal32;
-
-  /* special values [top byte excluding sign bit; last two bits are
-     don't-care for Infinity on input, last bit don't-care for NaN] */
-  #if !defined(DECIMAL_NaN)
-    #define DECIMAL_NaN     0x7c        // 0 11111 00 NaN
-    #define DECIMAL_sNaN    0x7e        // 0 11111 10 sNaN
-    #define DECIMAL_Inf     0x78        // 0 11110 00 Infinity
-  #endif
-
-  /* Macros for accessing decimal32 fields.  These assume the argument
-     is a reference (pointer) to the decimal32 structure, and the
-     decimal32 is in network byte order (big-endian) */
-  // Get sign
-  #define decimal32Sign(d)       ((unsigned)(d)->bytes[0]>>7)
-
-  // Get combination field
-  #define decimal32Comb(d)       (((d)->bytes[0] & 0x7c)>>2)
-
-  // Get exponent continuation [does not remove bias]
-  #define decimal32ExpCon(d)     ((((d)->bytes[0] & 0x03)<<4)         \
-                               | ((unsigned)(d)->bytes[1]>>4))
-
-  // Set sign [this assumes sign previously 0]
-  #define decimal32SetSign(d, b) {                                    \
-    (d)->bytes[0]|=((unsigned)(b)<<7);}
-
-  // Set exponent continuation [does not apply bias]
-  // This assumes range has been checked and exponent previously 0;
-  // type of exponent must be unsigned
-  #define decimal32SetExpCon(d, e) {                                  \
-    (d)->bytes[0]|=(uint8_t)((e)>>4);                                 \
-    (d)->bytes[1]|=(uint8_t)(((e)&0x0F)<<4);}
-
-  /* ------------------------------------------------------------------ */
-  /* Routines                                                           */
-  /* ------------------------------------------------------------------ */
-  // String conversions
-  decimal32 * decimal32FromString(decimal32 *, const char *, decContext *);
-  char * decimal32ToString(const decimal32 *, char *);
-  char * decimal32ToEngString(const decimal32 *, char *);
-
-  // decNumber conversions
-  decimal32 * decimal32FromNumber(decimal32 *, const decNumber *,
-                                  decContext *);
-  decNumber * decimal32ToNumber(const decimal32 *, decNumber *);
-
-#endif
+/* ------------------------------------------------------------------ */
+/* Decimal 32-bit format module header                                */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2006.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is called decNumber.pdf.  This document is           */
+/* available, together with arithmetic and format specifications,     */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+
+#if !defined(DECIMAL32)
+  #define DECIMAL32
+  #define DEC32NAME     "decimal32"                   /* Short name   */
+  #define DEC32FULLNAME "Decimal 32-bit Number"       /* Verbose name */
+  #define DEC32AUTHOR   "Mike Cowlishaw"              /* Who to blame */
+
+  /* parameters for decimal32s */
+  #define DECIMAL32_Bytes  4            /* length                     */
+  #define DECIMAL32_Pmax   7            /* maximum precision (digits) */
+  #define DECIMAL32_Emax   96           /* maximum adjusted exponent  */
+  #define DECIMAL32_Emin  -95           /* minimum adjusted exponent  */
+  #define DECIMAL32_Bias   101          /* bias for the exponent      */
+  #define DECIMAL32_String 15           /* maximum string length, +1  */
+  #define DECIMAL32_EconL  6            /* exp. continuation length   */
+  /* highest biased exponent (Elimit-1)                               */
+  #define DECIMAL32_Ehigh  (DECIMAL32_Emax+DECIMAL32_Bias-DECIMAL32_Pmax+1)
+
+  /* check enough digits, if pre-defined                              */
+  #if defined(DECNUMDIGITS)
+    #if (DECNUMDIGITS<DECIMAL32_Pmax)
+      #error decimal32.h needs pre-defined DECNUMDIGITS>=7 for safe use
+    #endif
+  #endif
+
+  #ifndef DECNUMDIGITS
+    #define DECNUMDIGITS DECIMAL32_Pmax /* size if not already defined*/
+  #endif
+  #ifndef DECNUMBER
+    #include "decNumber.h"              /* context and number library */
+  #endif
+
+  /* Decimal 32-bit type, accessible by bytes */
+  typedef struct {
+    uint8_t bytes[DECIMAL32_Bytes];     /* decimal32: 1, 5, 6, 20 bits*/
+    } decimal32;
+
+  /* special values [top byte excluding sign bit; last two bits are   */
+  /* don't-care for Infinity on input, last bit don't-care for NaN]   */
+  #if !defined(DECIMAL_NaN)
+    #define DECIMAL_NaN     0x7c        /* 0 11111 00 NaN             */
+    #define DECIMAL_sNaN    0x7e        /* 0 11111 10 sNaN            */
+    #define DECIMAL_Inf     0x78        /* 0 11110 00 Infinity        */
+  #endif
+
+  /* ---------------------------------------------------------------- */
+  /* Routines                                                         */
+  /* ---------------------------------------------------------------- */
+  /* String conversions                                               */
+  decimal32 * decimal32FromString(decimal32 *, const char *, decContext *);
+  char * decimal32ToString(const decimal32 *, char *);
+  char * decimal32ToEngString(const decimal32 *, char *);
+
+  /* decNumber conversions                                            */
+  decimal32 * decimal32FromNumber(decimal32 *, const decNumber *,
+                                  decContext *);
+  decNumber * decimal32ToNumber(const decimal32 *, decNumber *);
+
+  /* Format-dependent utilities                                       */
+  uint32_t    decimal32IsCanonical(const decimal32 *);
+  decimal32 * decimal32Canonical(decimal32 *, const decimal32 *);
+
+#endif
diff --git a/decNumber/decimal64.c b/decNumber/decimal64.c
index ac305c34..a21f42fb 100644
--- a/decNumber/decimal64.c
+++ b/decNumber/decimal64.c
@@ -1,839 +1,839 @@
-/* ------------------------------------------------------------------ */
-/* Decimal 64-bit format module                                       */
-/* ------------------------------------------------------------------ */
-/* Copyright (c) IBM Corporation, 2000, 2006.  All rights reserved.   */
-/*                                                                    */
-/* This software is made available under the terms of the             */
-/* ICU License -- ICU 1.8.1 and later.                                */
-/*                                                                    */
-/* The description and User's Guide ("The decNumber C Library") for   */
-/* this software is called decNumber.pdf.  This document is           */
-/* available, together with arithmetic and format specifications,     */
-/* testcases, and Web links, at: http://www2.hursley.ibm.com/decimal  */
-/*                                                                    */
-/* Please send comments, suggestions, and corrections to the author:  */
-/*   mfc@uk.ibm.com                                                   */
-/*   Mike Cowlishaw, IBM Fellow                                       */
-/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
-/* ------------------------------------------------------------------ */
-/* This module comprises the routines for decimal64 format numbers.   */
-/* Conversions are supplied to and from decNumber and String.         */
-/*                                                                    */
-/* No arithmetic routines are included; decNumber provides these.     */
-/*                                                                    */
-/* Error handling is the same as decNumber (qv.).                     */
-/* ------------------------------------------------------------------ */
-#include <string.h>           // [for memset/memcpy]
-#include <stdio.h>            // [for printf]
-#if defined(_MSVC_)
-#pragma warning(disable:4244) // (floating-point only?) "conversion from 'x' to 'y', possible loss of data"
-#endif /*defined(_MSVC_)*/
-
-#define  DECNUMDIGITS 16      // make decNumbers with space for 16
-#include "decNumber.h"        // base number library
-#include "decNumberLocal.h"   // decNumber local types, etc.
-#include "decimal64.h"        // our primary include
-
-/* Utility routines and tables [in decimal64.c] */
-extern const uInt COMBEXP[32], COMBMSD[32];
-extern void decDigitsFromDPD(decNumber *, const uInt *, Int);
-extern void decDigitsToDPD(const decNumber *, uInt *, Int);
-
-#if DECTRACE || DECCHECK
-void decimal64Show(const decimal64 *);            // for debug
-extern void decNumberShow(const decNumber *);     // ..
-#endif
-
-/* compile-time endian tester [assumes sizeof(Int)>1] */
-static  const  Int mfcone=1;                 // constant 1
-static  const  Flag *mfctop=(Flag *)&mfcone; // -> top byte
-#define LITEND *mfctop             // named flag; 1=little-endian
-
-/* Useful macro */
-// Clear a structure (e.g., a decNumber)
-#define DEC_clear(d) memset(d, 0, sizeof(*d))
-
-/* define and include the tables to use for conversions */
-#define DEC_BIN2CHAR 1
-#define DEC_DPD2BIN  1
-#define DEC_BIN2DPD  1             // used for all sizes
-#include "decDPD.h"                // lookup tables
-
-/* ------------------------------------------------------------------ */
-/* decimal64FromNumber -- convert decNumber to decimal64              */
-/*                                                                    */
-/*   ds is the target decimal64                                       */
-/*   dn is the source number (assumed valid)                          */
-/*   set is the context, used only for reporting errors               */
-/*                                                                    */
-/* The set argument is used only for status reporting and for the     */
-/* rounding mode (used if the coefficient is more than DECIMAL64_Pmax */
-/* digits or an overflow is detected).  If the exponent is out of the */
-/* valid range then Overflow or Underflow will be raised.             */
-/* After Underflow a subnormal result is possible.                    */
-/*                                                                    */
-/* DEC_Clamped is set if the number has to be 'folded down' to fit,   */
-/* by reducing its exponent and multiplying the coefficient by a      */
-/* power of ten, or if the exponent on a zero had to be clamped.      */
-/* ------------------------------------------------------------------ */
-decimal64 * decimal64FromNumber(decimal64 *d64, const decNumber *dn,
-                                decContext *set) {
-  uInt status=0;                   // status accumulator
-  Int ae;                          // adjusted exponent
-  decNumber  dw;                   // work
-  decContext dc;                   // ..
-  uInt *pu;                        // ..
-  uInt comb, exp;                  // ..
-  uInt targar[2]={0, 0};           // target 64-bit
-  #define targhi targar[1]         // name the word with the sign
-  #define targlo targar[0]         // and the other
-
-  // If the number has too many digits, or the exponent could be
-  // out of range then reduce the number under the appropriate
-  // constraints.  This could push the number to Infinity or zero,
-  // so this check and rounding must be done before generating the
-  // decimal64]
-  ae=dn->exponent+dn->digits-1;              // [0 if special]
-  if (dn->digits>DECIMAL64_Pmax              // too many digits
-   || ae>DECIMAL64_Emax                      // likely overflow
-   || ae<DECIMAL64_Emin) {                   // likely underflow
-    decContextDefault(&dc, DEC_INIT_DECIMAL64); // [no traps]
-    dc.round=set->round;                     // use supplied rounding
-    decNumberPlus(&dw, dn, &dc);             // (round and check)
-    // [this changes -0 to 0, so enforce the sign...]
-    dw.bits|=dn->bits&DECNEG;
-    status=dc.status;                        // save status
-    dn=&dw;                                  // use the work number
-    } // maybe out of range
-
-  if (dn->bits&DECSPECIAL) {                      // a special value
-    if (dn->bits&DECINF) targhi=DECIMAL_Inf<<24;
-     else {                                       // sNaN or qNaN
-      if ((*dn->lsu!=0 || dn->digits>1)           // non-zero coefficient
-       && (dn->digits<DECIMAL64_Pmax)) {          // coefficient fits
-        decDigitsToDPD(dn, targar, 0);
-        }
-      if (dn->bits&DECNAN) targhi|=DECIMAL_NaN<<24;
-       else targhi|=DECIMAL_sNaN<<24;
-      } // a NaN
-    } // special
-
-   else { // is finite
-    if (decNumberIsZero(dn)) {               // is a zero
-      // set and clamp exponent
-      if (dn->exponent<-DECIMAL64_Bias) {
-        exp=0;                               // low clamp
-        status|=DEC_Clamped;
-        }
-       else {
-        exp=dn->exponent+DECIMAL64_Bias;     // bias exponent
-        if (exp>DECIMAL64_Ehigh) {           // top clamp
-          exp=DECIMAL64_Ehigh;
-          status|=DEC_Clamped;
-          }
-        }
-      comb=(exp>>5) & 0x18;             // msd=0, exp top 2 bits ..
-      }
-     else {                             // non-zero finite number
-      uInt msd;                         // work
-      Int pad=0;                        // coefficient pad digits
-
-      // the dn is known to fit, but it may need to be padded
-      exp=(uInt)(dn->exponent+DECIMAL64_Bias);    // bias exponent
-      if (exp>DECIMAL64_Ehigh) {                  // fold-down case
-        pad=exp-DECIMAL64_Ehigh;
-        exp=DECIMAL64_Ehigh;                      // [to maximum]
-        status|=DEC_Clamped;
-        }
-
-      // fastpath common case
-      if (DECDPUN==3 && pad==0) {
-        uInt dpd[6]={0,0,0,0,0,0};
-        uInt i;
-        Int d=dn->digits;
-        for (i=0; d>0; i++, d-=3) dpd[i]=BIN2DPD[dn->lsu[i]];
-        targlo =dpd[0];
-        targlo|=dpd[1]<<10;
-        targlo|=dpd[2]<<20;
-        if (dn->digits>6) {
-          targlo|=dpd[3]<<30;
-          targhi =dpd[3]>>2;
-          targhi|=dpd[4]<<8;
-          }
-        msd=dpd[5];                // [did not really need conversion]
-        }
-       else { // general case
-        decDigitsToDPD(dn, targar, pad);
-        // save and clear the top digit
-        msd=targhi>>18;
-        targhi&=0x0003ffff;
-        }
-
-      // create the combination field
-      if (msd>=8) comb=0x18 | ((exp>>7) & 0x06) | (msd & 0x01);
-             else comb=((exp>>5) & 0x18) | msd;
-      }
-    targhi|=comb<<26;              // add combination field ..
-    targhi|=(exp&0xff)<<18;        // .. and exponent continuation
-    } // finite
-
-  if (dn->bits&DECNEG) targhi|=0x80000000; // add sign bit
-
-  // now write to storage; this may be endian, or not
-  #if DECENDIAN
-  // DECENDIAN -- direct store, in the right order
-  pu=(uInt *)d64->bytes;           // overlay
-  if (LITEND) {
-    pu[0]=targar[0];               // directly store the low int
-    pu[1]=targar[1];               // then the high int
-    }
-   else {
-    pu[0]=targar[1];               // directly store the high int
-    pu[1]=targar[0];               // then the low int
-    }
-  #else
-  // not DECENDIAN -- use network byte order
-  if (LITEND) {                    // little-endian needs reversal
-    uByte *pb;                     // work
-    Int off;                       // ..
-    for (pb=&d64->bytes[7]; pb>=d64->bytes; pb--) {
-      off=1-((pb-d64->bytes)>>2);  // 0 then 1
-      *pb=(uByte)(targar[off]&0xff);
-      targar[off]>>=8;
-      } // i
-    }
-   else { // big-endian; it's the right way round already
-    pu=(uInt *)d64->bytes;         // overlay
-    pu[0]=targar[1];               // directly store the high int
-    pu[1]=targar[0];               // then the low int
-    }
-  #endif
-
-  if (status!=0) decContextSetStatus(set, status); // pass on status
-  // decimal64Show(d64);
-  return d64;
-  } // decimal64FromNumber
-
-/* ------------------------------------------------------------------ */
-/* decimal64ToNumber -- convert decimal64 to decNumber                */
-/*   d64 is the source decimal64                                      */
-/*   dn is the target number, with appropriate space                  */
-/* No error is possible.                                              */
-/* ------------------------------------------------------------------ */
-decNumber * decimal64ToNumber(const decimal64 *d64, decNumber *dn) {
-  uInt msd;                        // coefficient MSD
-  uInt exp;                        // exponent top two bits
-  uInt comb;                       // combination field
-  uInt *pu;                        // work
-  Int  need;                       // ..
-  uInt sourar[2];                  // source 64-bit
-  #define sourhi sourar[1]         // name the word with the sign
-  #define sourlo sourar[0]         // and the lower word
-
-  // load source from storage; this may be endian, or not
-  #if DECENDIAN
-  // DECENDIAN -- direct load, in the right order
-  pu=(uInt *)d64->bytes;           // overlay
-  if (LITEND) {
-    sourlo=pu[0];                  // directly load the low int
-    sourhi=pu[1];                  // then the high int
-    }
-   else {
-    sourhi=pu[0];                  // directly load the high int
-    sourlo=pu[1];                  // then the low int
-    }
-  #else
-  // not DECENDIAN -- use network byte order
-  if (LITEND) {                    // little-endian needs reversal
-    const uByte *pb;               // work
-    Int off;                       // ..
-    for (pb=d64->bytes; pb<=&d64->bytes[7]; pb++) {
-      off=1-((pb-d64->bytes)>>2);  // 1 then 0
-      sourar[off]<<=8;
-      sourar[off]|=*pb;
-      } // i
-    }
-   else { // big-endian; it's the right way round already
-    pu=(uInt *)d64->bytes;         // overlay
-    sourhi=pu[0];                  // directly load the high int
-    sourlo=pu[1];                  // then the low int
-    }
-  #endif
-
-  comb=(sourhi>>26)&0x1f;          // combination field
-
-  decNumberZero(dn);               // clean number
-  if (sourhi&0x80000000) dn->bits=DECNEG; // set sign if negative
-
-  msd=COMBMSD[comb];               // decode the combination field
-  exp=COMBEXP[comb];               // ..
-
-  if (exp==3) {                    // is a special
-    if (msd==0) {
-      dn->bits|=DECINF;
-      return dn;                   // no coefficient needed
-      }
-    else if (sourhi&0x02000000) dn->bits|=DECSNAN;
-    else dn->bits|=DECNAN;
-    msd=0;                         // no top digit
-    }
-   else {                          // is a finite number
-    dn->exponent=(exp<<8)+((sourhi>>18)&0xff)-DECIMAL64_Bias; // unbiased
-    }
-
-  // get the coefficient
-  sourhi&=0x0003ffff;              // clean coefficient continuation
-  if (msd) {                       // non-zero msd
-    sourhi|=msd<<18;               // prefix to coefficient
-    need=6;                        // process 6 declets
-    }
-   else { // msd=0
-    if (!sourhi) {                 // top word 0
-      if (!sourlo) return dn;      // easy: coefficient is 0
-      need=3;                      // process at least 3 declets
-      if (sourlo&0xc0000000) need++; // process 4 declets
-      // [could reduce some more, here]
-      }
-     else {                        // some bits in top word, msd=0
-      need=4;                      // process at least 4 declets
-      if (sourhi&0x0003ff00) need++; // top declet!=0, process 5
-      }
-    } //msd=0
-
-  decDigitsFromDPD(dn, sourar, need);   // process declets
-  return dn;
-  } // decimal64ToNumber
-
-
-/* ------------------------------------------------------------------ */
-/* to-scientific-string -- conversion to numeric string               */
-/* to-engineering-string -- conversion to numeric string              */
-/*                                                                    */
-/*   decimal64ToString(d64, string);                                  */
-/*   decimal64ToEngString(d64, string);                               */
-/*                                                                    */
-/*  d64 is the decimal64 format number to convert                     */
-/*  string is the string where the result will be laid out            */
-/*                                                                    */
-/*  string must be at least 24 characters                             */
-/*                                                                    */
-/*  No error is possible, and no status can be set.                   */
-/* ------------------------------------------------------------------ */
-char * decimal64ToEngString(const decimal64 *d64, char *string){
-  decNumber dn;                         // work
-  decimal64ToNumber(d64, &dn);
-  decNumberToEngString(&dn, string);
-  return string;
-  } // decimal64ToEngString
-
-char * decimal64ToString(const decimal64 *d64, char *string){
-  uInt msd;                        // coefficient MSD
-  Int  exp;                        // exponent top two bits or full
-  uInt comb;                       // combination field
-  char *cstart;                    // coefficient start
-  char *c;                         // output pointer in string
-  uInt *pu;                        // work
-  char *s, *t;                     // .. (source, target)
-  Int  dpd;                        // ..
-  Int  pre, e;                     // ..
-  const uByte *u;                  // ..
-
-  uInt sourar[2];                  // source 64-bit
-  #define sourhi sourar[1]         // name the word with the sign
-  #define sourlo sourar[0]         // and the lower word
-
-  // load source from storage; this may be endian, or not
-  #if DECENDIAN
-  // DECENDIAN -- direct load, in the right order
-  pu=(uInt *)d64->bytes;           // overlay
-  if (LITEND) {
-    sourlo=pu[0];                  // directly load the low int
-    sourhi=pu[1];                  // then the high int
-    }
-   else {
-    sourhi=pu[0];                  // directly load the high int
-    sourlo=pu[1];                  // then the low int
-    }
-  #else
-  // not DECENDIAN -- use network byte order
-  if (LITEND) {                    // little-endian needs reversal
-    const uByte *pb;               // work
-    Int off;                       // ..
-    for (pb=d64->bytes; pb<=&d64->bytes[7]; pb++) {
-      off=1-((pb-d64->bytes)>>2);  // 1 then 0
-      sourar[off]<<=8;
-      sourar[off]|=*pb;
-      } // i
-    }
-   else { // big-endian; it's the right way round already
-    pu=(uInt *)d64->bytes;         // overlay
-    sourhi=pu[0];                  // directly load the high int
-    sourlo=pu[1];                  // then the low int
-    }
-  #endif
-
-  c=string;                        // where result will go
-  if (((Int)sourhi)<0) *c++='-';   // handle sign
-
-  comb=(sourhi>>26)&0x1f;          // combination field
-  msd=COMBMSD[comb];               // decode the combination field
-  exp=COMBEXP[comb];               // ..
-
-  if (exp==3) {
-    if (msd==0) {                  // infinity
-      strcpy(c, "Infinity");
-      return string;               // easy
-      }
-    if (sourhi&0x02000000) *c++='s'; // sNaN
-    strcpy(c, "NaN");              // complete word
-    c+=3;                          // step past
-    if (sourlo==0 && (sourhi&0x0003ffff)==0) return string; // zero payload
-    // otherwise drop through to add integer; set correct exp
-    exp=0; msd=0;                  // setup for following code
-    }
-   else exp=(exp<<8)+((sourhi>>18)&0xff)-DECIMAL64_Bias;
-
-  // convert 16 digits of significand to characters
-  cstart=c;                        // save start of coefficient
-  if (msd) *c++='0'+(char)msd;     // non-zero most significant digit
-
-  // Now decode the declets.  After extracting each one, it is
-  // decoded to binary and then to a 4-char sequence by table lookup;
-  // the 4-chars are a 1-char length (significant digits, except 000
-  // has length 0).  This allows us to left-align the first declet
-  // with non-zero content, then remaining ones are full 3-char
-  // length.  We use fixed-length memcpys because variable-length
-  // causes a subroutine call in GCC.  (These are length 4 for speed
-  // and are safe because the array has an extra terminator byte.)
-  #define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4];                   \
-                   if (c!=cstart) {memcpy(c, u+1, 4); c+=3;}      \
-                    else if (*u)  {memcpy(c, u+4-*u, 4); c+=*u;}
-
-  dpd=(sourhi>>8)&0x3ff;                     // declet 1
-  dpd2char;
-  dpd=((sourhi&0xff)<<2) | (sourlo>>30);     // declet 2
-  dpd2char;
-  dpd=(sourlo>>20)&0x3ff;                    // declet 3
-  dpd2char;
-  dpd=(sourlo>>10)&0x3ff;                    // declet 4
-  dpd2char;
-  dpd=(sourlo)&0x3ff;                        // declet 5
-  dpd2char;
-
-  if (c==cstart) *c++='0';         // all zeros -- make 0
-
-  if (exp==0) {                    // integer or NaN case -- easy
-    *c='\0';                       // terminate
-    return string;
-    }
-
-  /* non-0 exponent */
-  e=0;                             // assume no E
-  pre=c-cstart+exp;
-  // [here, pre-exp is the digits count (==1 for zero)]
-  if (exp>0 || pre<-5) {           // need exponential form
-    e=pre-1;                       // calculate E value
-    pre=1;                         // assume one digit before '.'
-    } // exponential form
-
-  /* modify the coefficient, adding 0s, '.', and E+nn as needed */
-  s=c-1;                           // source (LSD)
-  if (pre>0) {                     // ddd.ddd (plain), perhaps with E
-    char *dotat=cstart+pre;
-    if (dotat<c) {                 // if embedded dot needed...
-      t=c;                              // target
-      for (; s>=dotat; s--, t--) *t=*s; // open the gap; leave t at gap
-      *t='.';                           // insert the dot
-      c++;                              // length increased by one
-      }
-
-    // finally add the E-part, if needed; it will never be 0, and has
-    // a maximum length of 3 digits
-    if (e!=0) {
-      *c++='E';                    // starts with E
-      *c++='+';                    // assume positive
-      if (e<0) {
-        *(c-1)='-';                // oops, need '-'
-        e=-e;                      // uInt, please
-        }
-      u=&BIN2CHAR[e*4];            // -> length byte
-      memcpy(c, u+4-*u, 4);        // copy fixed 4 characters [is safe]
-      c+=*u;                       // bump pointer appropriately
-      }
-    *c='\0';                       // add terminator
-    //printf("res %s\n", string);
-    return string;
-    } // pre>0
-
-  /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
-  t=c+1-pre;
-  *(t+1)='\0';                          // can add terminator now
-  for (; s>=cstart; s--, t--) *t=*s;    // shift whole coefficient right
-  c=cstart;
-  *c++='0';                             // always starts with 0.
-  *c++='.';
-  for (; pre<0; pre++) *c++='0';        // add any 0's after '.'
-  //printf("res %s\n", string);
-  return string;
-  } // decimal64ToString
-
-/* ------------------------------------------------------------------ */
-/* to-number -- conversion from numeric string                        */
-/*                                                                    */
-/*   decimal64FromString(result, string, set);                        */
-/*                                                                    */
-/*  result  is the decimal64 format number which gets the result of   */
-/*          the conversion                                            */
-/*  *string is the character string which should contain a valid      */
-/*          number (which may be a special value)                     */
-/*  set     is the context                                            */
-/*                                                                    */
-/* The context is supplied to this routine is used for error handling */
-/* (setting of status and traps) and for the rounding mode, only.     */
-/* If an error occurs, the result will be a valid decimal64 NaN.      */
-/* ------------------------------------------------------------------ */
-decimal64 * decimal64FromString(decimal64 *result, const char *string,
-                                decContext *set) {
-  decContext dc;                             // work
-  decNumber dn;                              // ..
-
-  decContextDefault(&dc, DEC_INIT_DECIMAL64); // no traps, please
-  dc.round=set->round;                        // use supplied rounding
-
-  decNumberFromString(&dn, string, &dc);     // will round if needed
-
-  decimal64FromNumber(result, &dn, &dc);
-  if (dc.status!=0) {                        // something happened
-    decContextSetStatus(set, dc.status);     // .. pass it on
-    }
-  return result;
-  } // decimal64FromString
-
-#if DECTRACE || DECCHECK
-/* ------------------------------------------------------------------ */
-/* decimal64Show -- display a decimal64 in hexadecimal [debug aid]    */
-/*   d64 -- the number to show                                        */
-/* ------------------------------------------------------------------ */
-// Also shows sign/cob/expconfields extracted
-void decimal64Show(const decimal64 *d64) {
-  char buf[DECIMAL64_Bytes*2+1];
-  Int i, j=0;
-
-  #if DECENDIAN
-  if (LITEND) {
-    for (i=0; i<DECIMAL64_Bytes; i++, j+=2) {
-      sprintf(&buf[j], "%02x", d64->bytes[7-i]);
-      }
-    printf(" D64> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
-           d64->bytes[7]>>7, (d64->bytes[7]>>2)&0x1f,
-           ((d64->bytes[7]&0x3)<<6)| (d64->bytes[6]>>2));
-    }
-   else {
-  #endif
-    for (i=0; i<DECIMAL64_Bytes; i++, j+=2) {
-      sprintf(&buf[j], "%02x", d64->bytes[i]);
-      }
-    printf(" D64> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
-           decimal64Sign(d64), decimal64Comb(d64), decimal64ExpCon(d64));
-  #if DECENDIAN
-    }
-  #endif
-  } // decimal64Show
-#endif
-
-/* ================================================================== */
-/* Shared utility routines and tables                                 */
-/* ================================================================== */
-// define and include the conversion tables to use for shared code
-#if DECDPUN==3
-  #define DEC_DPD2BIN 1
-#else
-  #define DEC_DPD2BCD 1
-#endif
-#include "decDPD.h"           // lookup tables
-
-// The maximum number of decNumberUnits needed for a working copy of
-// the units array is the ceiling of digits/DECDPUN, where digits is
-// the maximum number of digits in any of the formats for which this
-// is used.  decimal128.h must not be included in this module, so, as
-// a very special case, that number is defined as a literal here.
-#define DECMAX754   34
-#define DECMAXUNITS ((DECMAX754+DECDPUN-1)/DECDPUN)
-
-/* ------------------------------------------------------------------ */
-/* Combination field lookup tables (uInts to save measurable work)    */
-/*                                                                    */
-/*      COMBEXP - 2-bit most-significant-bits of exponent             */
-/*                [11 if an Infinity or NaN]                          */
-/*      COMBMSD - 4-bit most-significant-digit                        */
-/*                [0=Infinity, 1=NaN if COMBEXP=11]                   */
-/*                                                                    */
-/* Both are indexed by the 5-bit combination field (0-31)             */
-/* ------------------------------------------------------------------ */
-const uInt COMBEXP[32]={0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
-                        2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 1, 1, 2, 2, 3, 3};
-const uInt COMBMSD[32]={0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
-                        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 9, 8, 9, 0, 1};
-
-/* ------------------------------------------------------------------ */
-/* decDigitsToDPD -- pack coefficient into DPD form                   */
-/*                                                                    */
-/*   dn   is the source number (assumed valid, max DECMAX754 digits)  */
-/*   targ is 1, 2, or 4-element uInt array, which the caller must     */
-/*        have cleared to zeros                                       */
-/*   shift is the number of 0 digits to add on the right (normally 0) */
-/*                                                                    */
-/* The coefficient must be known small enough to fit.  The full       */
-/* coefficient is copied, including the leading 'odd' digit.  This    */
-/* digit is retrieved and packed into the combination field by the    */
-/* caller.                                                            */
-/*                                                                    */
-/* The target uInts are altered only as necessary to receive the      */
-/* digits of the decNumber.  When more than one uInt is needed, they  */
-/* are filled from left to right (that is, the uInt at offset 0 will  */
-/* end up with the least-significant digits).                         */
-/*                                                                    */
-/* shift is used for 'fold-down' padding.                             */
-/*                                                                    */
-/* No error is possible.                                              */
-/* ------------------------------------------------------------------ */
-#if DECDPUN<=4
-// Constant multipliers for divide-by-power-of five using reciprocal
-// multiply, after removing powers of 2 by shifting, and final shift
-// of 17 [we only need up to **4]
-static const uInt multies[]={131073, 26215, 5243, 1049, 210};
-// QUOT10 -- macro to return the quotient of unit u divided by 10**n
-#define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17)
-#endif
-void decDigitsToDPD(const decNumber *dn, uInt *targ, Int shift) {
-  Int  cut;                   // work
-  Int  n;                     // output bunch counter
-  Int  digits=dn->digits;     // digit countdown
-  uInt dpd;                   // densely packed decimal value
-  uInt bin;                   // binary value 0-999
-  uInt *uout=targ;            // -> current output uInt
-  uInt  uoff=0;               // -> current output offset [from right]
-  const Unit *inu=dn->lsu;    // -> current input unit
-  Unit  uar[DECMAXUNITS];     // working copy of units, iff shifted
-  #if DECDPUN!=3              // not fast path
-    Unit in;                  // current unit
-  #endif
-
-  if (shift!=0) {             // shift towards most significant required
-    // shift the units array to the left by pad digits and copy
-    // [this code is a special case of decShiftToMost, which could
-    // be used instead if exposed and the array were copied first]
-    const Unit *source;                 // ..
-    Unit  *target, *first;              // ..
-    uInt  next=0;                       // work
-
-    source=dn->lsu+D2U(digits)-1;       // where msu comes from
-    target=uar+D2U(digits)-1+D2U(shift);// where upper part of first cut goes
-    cut=DECDPUN-MSUDIGITS(shift);       // where to slice
-    if (cut==0) {                       // unit-boundary case
-      for (; source>=dn->lsu; source--, target--) *target=*source;
-      }
-     else {
-      first=uar+D2U(digits+shift)-1;    // where msu will end up
-      for (; source>=dn->lsu; source--, target--) {
-        // split the source Unit and accumulate remainder for next
-        #if DECDPUN<=4
-          uInt quot=QUOT10(*source, cut);
-          uInt rem=*source-quot*powers[cut];
-          next+=quot;
-        #else
-          uInt rem=*source%powers[cut];
-          next+=*source/powers[cut];
-        #endif
-        if (target<=first) *target=(Unit)next; // write to target iff valid
-        next=rem*powers[DECDPUN-cut];   // save remainder for next Unit
-        }
-      } // shift-move
-    // propagate remainder to one below and clear the rest
-    for (; target>=uar; target--) {
-      *target=(Unit)next;
-      next=0;
-      }
-    digits+=shift;                 // add count (shift) of zeros added
-    inu=uar;                       // use units in working array
-    }
-
-  /* now densely pack the coefficient into DPD declets */
-
-  #if DECDPUN!=3                   // not fast path
-    in=*inu;                       // current unit
-    cut=0;                         // at lowest digit
-    bin=0;                         // [keep compiler quiet]
-  #endif
-
-  for(n=0; digits>0; n++) {        // each output bunch
-    #if DECDPUN==3                 // fast path, 3-at-a-time
-      bin=*inu;                    // 3 digits ready for convert
-      digits-=3;                   // [may go negative]
-      inu++;                       // may need another
-
-    #else                          // must collect digit-by-digit
-      Unit dig;                    // current digit
-      Int j;                       // digit-in-declet count
-      for (j=0; j<3; j++) {
-        #if DECDPUN<=4
-          Unit temp=(Unit)((uInt)(in*6554)>>16);
-          dig=(Unit)(in-X10(temp));
-          in=temp;
-        #else
-          dig=in%10;
-          in=in/10;
-        #endif
-        if (j==0) bin=dig;
-         else if (j==1)  bin+=X10(dig);
-         else /* j==2 */ bin+=X100(dig);
-        digits--;
-        if (digits==0) break;      // [also protects *inu below]
-        cut++;
-        if (cut==DECDPUN) {inu++; in=*inu; cut=0;}
-        }
-    #endif
-    // here there are 3 digits in bin, or have used all input digits
-
-    dpd=BIN2DPD[bin];
-
-    // write declet to uInt array
-    *uout|=dpd<<uoff;
-    uoff+=10;
-    if (uoff<32) continue;         // no uInt boundary cross
-    uout++;
-    uoff-=32;
-    *uout|=dpd>>(10-uoff);         // collect top bits
-    } // n declets
-  return;
-  } // decDigitsToDPD
-
-/* ------------------------------------------------------------------ */
-/* decDigitsFromDPD -- unpack a format's coefficient                  */
-/*                                                                    */
-/*   dn is the target number, with 7, 16, or 34-digit space.          */
-/*   sour is a 1, 2, or 4-element uInt array containing only declets  */
-/*   declets is the number of (right-aligned) declets in sour to      */
-/*     be processed.  This may be 1 more than the obvious number in   */
-/*     a format, as any top digit is prefixed to the coefficient      */
-/*     continuation field.  It also may be as small as 1, as the      */
-/*     caller may pre-process leading zero declets.                   */
-/*                                                                    */
-/* When doing the 'extra declet' case care is taken to avoid writing  */
-/* extra digits when there are leading zeros, as these could overflow */
-/* the units array when DECDPUN is not 3.                             */
-/*                                                                    */
-/* The target uInts are used only as necessary to process declets     */
-/* declets into the decNumber.  When more than one uInt is needed,    */
-/* they are used from left to right (that is, the uInt at offset 0    */
-/* provides the least-significant digits).                            */
-/*                                                                    */
-/* dn->digits is set, but not the sign or exponent.                   */
-/* No error is possible [the redundant 888 codes are allowed].        */
-/* ------------------------------------------------------------------ */
-void decDigitsFromDPD(decNumber *dn, const uInt *sour, Int declets) {
-
-  uInt  dpd;                       // collector for 10 bits
-  Int   n;                         // counter
-  Unit  *uout=dn->lsu;             // -> current output unit
-  Unit  *last=uout;                // will be unit containing msd
-  const uInt *uin=sour;            // -> current input uInt
-  uInt  uoff=0;                    // -> current input offset [from right]
-
-  #if DECDPUN!=3
-  uInt  bcd;                       // BCD result
-  uInt  nibble;                    // work
-  Unit  out=0;                     // accumulator
-  Int   cut=0;                     // power of ten in current unit
-  #endif
-  #if DECDPUN>4
-  uInt const *pow;                 // work
-  #endif
-
-  // Expand the densely-packed integer, right to left
-  for (n=declets-1; n>=0; n--) {   // count down declets of 10 bits
-    dpd=*uin>>uoff;
-    uoff+=10;
-    if (uoff>32) {                 // crossed uInt boundary
-      uin++;
-      uoff-=32;
-      dpd|=*uin<<(10-uoff);        // get waiting bits
-      }
-    dpd&=0x3ff;                    // clear uninteresting bits
-
-  #if DECDPUN==3
-    if (dpd==0) *uout=0;
-     else {
-      *uout=DPD2BIN[dpd];          // convert 10 bits to binary 0-999
-      last=uout;                   // record most significant unit
-      }
-    uout++;
-    } // n
-
-  #else // DECDPUN!=3
-    if (dpd==0) {                  // fastpath [e.g., leading zeros]
-      // write out three 0 digits (nibbles); out may have digit(s)
-      cut++;
-      if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
-      if (n==0) break;             // [as below, works even if MSD=0]
-      cut++;
-      if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
-      cut++;
-      if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
-      continue;
-      }
-
-    bcd=DPD2BCD[dpd];              // convert 10 bits to 12 bits BCD
-
-    // now accumulate the 3 BCD nibbles into units
-    nibble=bcd & 0x00f;
-    if (nibble) out=(Unit)(out+nibble*powers[cut]);
-    cut++;
-    if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
-    bcd>>=4;
-
-    // if this is the last declet and the remaining nibbles in bcd
-    // are 00 then process no more nibbles, because this could be
-    // the 'odd' MSD declet and writing any more Units would then
-    // overflow the unit array
-    if (n==0 && !bcd) break;
-
-    nibble=bcd & 0x00f;
-    if (nibble) out=(Unit)(out+nibble*powers[cut]);
-    cut++;
-    if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
-    bcd>>=4;
-
-    nibble=bcd & 0x00f;
-    if (nibble) out=(Unit)(out+nibble*powers[cut]);
-    cut++;
-    if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
-    } // n
-  if (cut!=0) {                         // some more left over
-    *uout=out;                          // write out final unit
-    if (out) last=uout;                 // and note if non-zero
-    }
-  #endif
-
-  // here, last points to the most significant unit with digits;
-  // inspect it to get the final digits count -- this is essentially
-  // the same code as decGetDigits in decNumber.c
-  dn->digits=(last-dn->lsu)*DECDPUN+1;  // floor of digits, plus
-                                        // must be at least 1 digit
-  #if DECDPUN>1
-  if (*last<10) return;                 // common odd digit or 0
-  dn->digits++;                         // must be 2 at least
-  #if DECDPUN>2
-  if (*last<100) return;                // 10-99
-  dn->digits++;                         // must be 3 at least
-  #if DECDPUN>3
-  if (*last<1000) return;               // 100-999
-  dn->digits++;                         // must be 4 at least
-  #if DECDPUN>4
-  for (pow=&powers[4]; *last>=*pow; pow++) dn->digits++;
-  #endif
-  #endif
-  #endif
-  #endif
-  return;
-  } //decDigitsFromDPD
+/* ------------------------------------------------------------------ */
+/* Decimal 64-bit format module                                       */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2009.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is called decNumber.pdf.  This document is           */
+/* available, together with arithmetic and format specifications,     */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+/* This module comprises the routines for decimal64 format numbers.   */
+/* Conversions are supplied to and from decNumber and String.         */
+/*                                                                    */
+/* This is used when decNumber provides operations, either for all    */
+/* operations or as a proxy between decNumber and decSingle.          */
+/*                                                                    */
+/* Error handling is the same as decNumber (qv.).                     */
+/* ------------------------------------------------------------------ */
+#include <string.h>           // [for memset/memcpy]
+#include <stdio.h>            // [for printf]
+
+#define  DECNUMDIGITS 16      // make decNumbers with space for 16
+#include "decNumber.h"        // base number library
+#include "decNumberLocal.h"   // decNumber local types, etc.
+#include "decimal64.h"        // our primary include
+
+/* Utility routines and tables [in decimal64.c]; externs for C++ */
+// DPD2BIN and the reverse are renamed to prevent link-time conflict
+// if decQuad is also built in the same executable
+#define DPD2BIN DPD2BINx
+#define BIN2DPD BIN2DPDx
+extern const uInt COMBEXP[32], COMBMSD[32];
+extern const uShort DPD2BIN[1024];
+extern const uShort BIN2DPD[1000];
+extern const uByte  BIN2CHAR[4001];
+
+extern void decDigitsFromDPD(decNumber *, const uInt *, Int);
+extern void decDigitsToDPD(const decNumber *, uInt *, Int);
+
+#if DECTRACE || DECCHECK
+void decimal64Show(const decimal64 *);            // for debug
+extern void decNumberShow(const decNumber *);     // ..
+#endif
+
+/* Useful macro */
+// Clear a structure (e.g., a decNumber)
+#define DEC_clear(d) memset(d, 0, sizeof(*d))
+
+/* define and include the tables to use for conversions */
+#define DEC_BIN2CHAR 1
+#define DEC_DPD2BIN  1
+#define DEC_BIN2DPD  1             // used for all sizes
+#include "decDPD.h"                // lookup tables
+
+/* ------------------------------------------------------------------ */
+/* decimal64FromNumber -- convert decNumber to decimal64              */
+/*                                                                    */
+/*   ds is the target decimal64                                       */
+/*   dn is the source number (assumed valid)                          */
+/*   set is the context, used only for reporting errors               */
+/*                                                                    */
+/* The set argument is used only for status reporting and for the     */
+/* rounding mode (used if the coefficient is more than DECIMAL64_Pmax */
+/* digits or an overflow is detected).  If the exponent is out of the */
+/* valid range then Overflow or Underflow will be raised.             */
+/* After Underflow a subnormal result is possible.                    */
+/*                                                                    */
+/* DEC_Clamped is set if the number has to be 'folded down' to fit,   */
+/* by reducing its exponent and multiplying the coefficient by a      */
+/* power of ten, or if the exponent on a zero had to be clamped.      */
+/* ------------------------------------------------------------------ */
+decimal64 * decimal64FromNumber(decimal64 *d64, const decNumber *dn,
+                                decContext *set) {
+  uInt status=0;                   // status accumulator
+  Int ae;                          // adjusted exponent
+  decNumber  dw;                   // work
+  decContext dc;                   // ..
+  uInt comb, exp;                  // ..
+  uInt uiwork;                     // for macros
+  uInt targar[2]={0, 0};           // target 64-bit
+  #define targhi targar[1]         // name the word with the sign
+  #define targlo targar[0]         // and the other
+
+  // If the number has too many digits, or the exponent could be
+  // out of range then reduce the number under the appropriate
+  // constraints.  This could push the number to Infinity or zero,
+  // so this check and rounding must be done before generating the
+  // decimal64]
+  ae=dn->exponent+dn->digits-1;              // [0 if special]
+  if (dn->digits>DECIMAL64_Pmax              // too many digits
+   || ae>DECIMAL64_Emax                      // likely overflow
+   || ae<DECIMAL64_Emin) {                   // likely underflow
+    decContextDefault(&dc, DEC_INIT_DECIMAL64); // [no traps]
+    dc.round=set->round;                     // use supplied rounding
+    decNumberPlus(&dw, dn, &dc);             // (round and check)
+    // [this changes -0 to 0, so enforce the sign...]
+    dw.bits|=dn->bits&DECNEG;
+    status=dc.status;                        // save status
+    dn=&dw;                                  // use the work number
+    } // maybe out of range
+
+  if (dn->bits&DECSPECIAL) {                      // a special value
+    if (dn->bits&DECINF) targhi=DECIMAL_Inf<<24;
+     else {                                       // sNaN or qNaN
+      if ((*dn->lsu!=0 || dn->digits>1)           // non-zero coefficient
+       && (dn->digits<DECIMAL64_Pmax)) {          // coefficient fits
+        decDigitsToDPD(dn, targar, 0);
+        }
+      if (dn->bits&DECNAN) targhi|=DECIMAL_NaN<<24;
+       else targhi|=DECIMAL_sNaN<<24;
+      } // a NaN
+    } // special
+
+   else { // is finite
+    if (decNumberIsZero(dn)) {               // is a zero
+      // set and clamp exponent
+      if (dn->exponent<-DECIMAL64_Bias) {
+        exp=0;                               // low clamp
+        status|=DEC_Clamped;
+        }
+       else {
+        exp=dn->exponent+DECIMAL64_Bias;     // bias exponent
+        if (exp>DECIMAL64_Ehigh) {           // top clamp
+          exp=DECIMAL64_Ehigh;
+          status|=DEC_Clamped;
+          }
+        }
+      comb=(exp>>5) & 0x18;             // msd=0, exp top 2 bits ..
+      }
+     else {                             // non-zero finite number
+      uInt msd;                         // work
+      Int pad=0;                        // coefficient pad digits
+
+      // the dn is known to fit, but it may need to be padded
+      exp=(uInt)(dn->exponent+DECIMAL64_Bias);    // bias exponent
+      if (exp>DECIMAL64_Ehigh) {                  // fold-down case
+        pad=exp-DECIMAL64_Ehigh;
+        exp=DECIMAL64_Ehigh;                      // [to maximum]
+        status|=DEC_Clamped;
+        }
+
+      // fastpath common case
+      if (DECDPUN==3 && pad==0) {
+        uInt dpd[6]={0,0,0,0,0,0};
+        uInt i;
+        Int d=dn->digits;
+        for (i=0; d>0; i++, d-=3) dpd[i]=BIN2DPD[dn->lsu[i]];
+        targlo =dpd[0];
+        targlo|=dpd[1]<<10;
+        targlo|=dpd[2]<<20;
+        if (dn->digits>6) {
+          targlo|=dpd[3]<<30;
+          targhi =dpd[3]>>2;
+          targhi|=dpd[4]<<8;
+          }
+        msd=dpd[5];                // [did not really need conversion]
+        }
+       else { // general case
+        decDigitsToDPD(dn, targar, pad);
+        // save and clear the top digit
+        msd=targhi>>18;
+        targhi&=0x0003ffff;
+        }
+
+      // create the combination field
+      if (msd>=8) comb=0x18 | ((exp>>7) & 0x06) | (msd & 0x01);
+             else comb=((exp>>5) & 0x18) | msd;
+      }
+    targhi|=comb<<26;              // add combination field ..
+    targhi|=(exp&0xff)<<18;        // .. and exponent continuation
+    } // finite
+
+  if (dn->bits&DECNEG) targhi|=0x80000000; // add sign bit
+
+  // now write to storage; this is now always endian
+  if (DECLITEND) {
+    // lo int then hi
+    UBFROMUI(d64->bytes,   targar[0]);
+    UBFROMUI(d64->bytes+4, targar[1]);
+    }
+   else {
+    // hi int then lo
+    UBFROMUI(d64->bytes,   targar[1]);
+    UBFROMUI(d64->bytes+4, targar[0]);
+    }
+
+  if (status!=0) decContextSetStatus(set, status); // pass on status
+  // decimal64Show(d64);
+  return d64;
+  } // decimal64FromNumber
+
+/* ------------------------------------------------------------------ */
+/* decimal64ToNumber -- convert decimal64 to decNumber                */
+/*   d64 is the source decimal64                                      */
+/*   dn is the target number, with appropriate space                  */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+decNumber * decimal64ToNumber(const decimal64 *d64, decNumber *dn) {
+  uInt msd;                        // coefficient MSD
+  uInt exp;                        // exponent top two bits
+  uInt comb;                       // combination field
+  Int  need;                       // work
+  uInt uiwork;                     // for macros
+  uInt sourar[2];                  // source 64-bit
+  #define sourhi sourar[1]         // name the word with the sign
+  #define sourlo sourar[0]         // and the lower word
+
+  // load source from storage; this is endian
+  if (DECLITEND) {
+    sourlo=UBTOUI(d64->bytes  );   // directly load the low int
+    sourhi=UBTOUI(d64->bytes+4);   // then the high int
+    }
+   else {
+    sourhi=UBTOUI(d64->bytes  );   // directly load the high int
+    sourlo=UBTOUI(d64->bytes+4);   // then the low int
+    }
+
+  comb=(sourhi>>26)&0x1f;          // combination field
+
+  decNumberZero(dn);               // clean number
+  if (sourhi&0x80000000) dn->bits=DECNEG; // set sign if negative
+
+  msd=COMBMSD[comb];               // decode the combination field
+  exp=COMBEXP[comb];               // ..
+
+  if (exp==3) {                    // is a special
+    if (msd==0) {
+      dn->bits|=DECINF;
+      return dn;                   // no coefficient needed
+      }
+    else if (sourhi&0x02000000) dn->bits|=DECSNAN;
+    else dn->bits|=DECNAN;
+    msd=0;                         // no top digit
+    }
+   else {                          // is a finite number
+    dn->exponent=(exp<<8)+((sourhi>>18)&0xff)-DECIMAL64_Bias; // unbiased
+    }
+
+  // get the coefficient
+  sourhi&=0x0003ffff;              // clean coefficient continuation
+  if (msd) {                       // non-zero msd
+    sourhi|=msd<<18;               // prefix to coefficient
+    need=6;                        // process 6 declets
+    }
+   else { // msd=0
+    if (!sourhi) {                 // top word 0
+      if (!sourlo) return dn;      // easy: coefficient is 0
+      need=3;                      // process at least 3 declets
+      if (sourlo&0xc0000000) need++; // process 4 declets
+      // [could reduce some more, here]
+      }
+     else {                        // some bits in top word, msd=0
+      need=4;                      // process at least 4 declets
+      if (sourhi&0x0003ff00) need++; // top declet!=0, process 5
+      }
+    } //msd=0
+
+  decDigitsFromDPD(dn, sourar, need);   // process declets
+  return dn;
+  } // decimal64ToNumber
+
+
+/* ------------------------------------------------------------------ */
+/* to-scientific-string -- conversion to numeric string               */
+/* to-engineering-string -- conversion to numeric string              */
+/*                                                                    */
+/*   decimal64ToString(d64, string);                                  */
+/*   decimal64ToEngString(d64, string);                               */
+/*                                                                    */
+/*  d64 is the decimal64 format number to convert                     */
+/*  string is the string where the result will be laid out            */
+/*                                                                    */
+/*  string must be at least 24 characters                             */
+/*                                                                    */
+/*  No error is possible, and no status can be set.                   */
+/* ------------------------------------------------------------------ */
+char * decimal64ToEngString(const decimal64 *d64, char *string){
+  decNumber dn;                         // work
+  decimal64ToNumber(d64, &dn);
+  decNumberToEngString(&dn, string);
+  return string;
+  } // decimal64ToEngString
+
+char * decimal64ToString(const decimal64 *d64, char *string){
+  uInt msd;                        // coefficient MSD
+  Int  exp;                        // exponent top two bits or full
+  uInt comb;                       // combination field
+  char *cstart;                    // coefficient start
+  char *c;                         // output pointer in string
+  const uByte *u;                  // work
+  char *s, *t;                     // .. (source, target)
+  Int  dpd;                        // ..
+  Int  pre, e;                     // ..
+  uInt uiwork;                     // for macros
+
+  uInt sourar[2];                  // source 64-bit
+  #define sourhi sourar[1]         // name the word with the sign
+  #define sourlo sourar[0]         // and the lower word
+
+  // load source from storage; this is endian
+  if (DECLITEND) {
+    sourlo=UBTOUI(d64->bytes  );   // directly load the low int
+    sourhi=UBTOUI(d64->bytes+4);   // then the high int
+    }
+   else {
+    sourhi=UBTOUI(d64->bytes  );   // directly load the high int
+    sourlo=UBTOUI(d64->bytes+4);   // then the low int
+    }
+
+  c=string;                        // where result will go
+  if (((Int)sourhi)<0) *c++='-';   // handle sign
+
+  comb=(sourhi>>26)&0x1f;          // combination field
+  msd=COMBMSD[comb];               // decode the combination field
+  exp=COMBEXP[comb];               // ..
+
+  if (exp==3) {
+    if (msd==0) {                  // infinity
+      strcpy(c,   "Inf");
+      strcpy(c+3, "inity");
+      return string;               // easy
+      }
+    if (sourhi&0x02000000) *c++='s'; // sNaN
+    strcpy(c, "NaN");              // complete word
+    c+=3;                          // step past
+    if (sourlo==0 && (sourhi&0x0003ffff)==0) return string; // zero payload
+    // otherwise drop through to add integer; set correct exp
+    exp=0; msd=0;                  // setup for following code
+    }
+   else exp=(exp<<8)+((sourhi>>18)&0xff)-DECIMAL64_Bias;
+
+  // convert 16 digits of significand to characters
+  cstart=c;                        // save start of coefficient
+  if (msd) *c++='0'+(char)msd;     // non-zero most significant digit
+
+  // Now decode the declets.  After extracting each one, it is
+  // decoded to binary and then to a 4-char sequence by table lookup;
+  // the 4-chars are a 1-char length (significant digits, except 000
+  // has length 0).  This allows us to left-align the first declet
+  // with non-zero content, then remaining ones are full 3-char
+  // length.  We use fixed-length memcpys because variable-length
+  // causes a subroutine call in GCC.  (These are length 4 for speed
+  // and are safe because the array has an extra terminator byte.)
+  #define dpd2char u=&BIN2CHAR[DPD2BIN[dpd]*4];                   \
+                   if (c!=cstart) {memcpy(c, u+1, 4); c+=3;}      \
+                    else if (*u)  {memcpy(c, u+4-*u, 4); c+=*u;}
+
+  dpd=(sourhi>>8)&0x3ff;                     // declet 1
+  dpd2char;
+  dpd=((sourhi&0xff)<<2) | (sourlo>>30);     // declet 2
+  dpd2char;
+  dpd=(sourlo>>20)&0x3ff;                    // declet 3
+  dpd2char;
+  dpd=(sourlo>>10)&0x3ff;                    // declet 4
+  dpd2char;
+  dpd=(sourlo)&0x3ff;                        // declet 5
+  dpd2char;
+
+  if (c==cstart) *c++='0';         // all zeros -- make 0
+
+  if (exp==0) {                    // integer or NaN case -- easy
+    *c='\0';                       // terminate
+    return string;
+    }
+
+  /* non-0 exponent */
+  e=0;                             // assume no E
+  pre=c-cstart+exp;
+  // [here, pre-exp is the digits count (==1 for zero)]
+  if (exp>0 || pre<-5) {           // need exponential form
+    e=pre-1;                       // calculate E value
+    pre=1;                         // assume one digit before '.'
+    } // exponential form
+
+  /* modify the coefficient, adding 0s, '.', and E+nn as needed */
+  s=c-1;                           // source (LSD)
+  if (pre>0) {                     // ddd.ddd (plain), perhaps with E
+    char *dotat=cstart+pre;
+    if (dotat<c) {                 // if embedded dot needed...
+      t=c;                              // target
+      for (; s>=dotat; s--, t--) *t=*s; // open the gap; leave t at gap
+      *t='.';                           // insert the dot
+      c++;                              // length increased by one
+      }
+
+    // finally add the E-part, if needed; it will never be 0, and has
+    // a maximum length of 3 digits
+    if (e!=0) {
+      *c++='E';                    // starts with E
+      *c++='+';                    // assume positive
+      if (e<0) {
+        *(c-1)='-';                // oops, need '-'
+        e=-e;                      // uInt, please
+        }
+      u=&BIN2CHAR[e*4];            // -> length byte
+      memcpy(c, u+4-*u, 4);        // copy fixed 4 characters [is safe]
+      c+=*u;                       // bump pointer appropriately
+      }
+    *c='\0';                       // add terminator
+    //printf("res %s\n", string);
+    return string;
+    } // pre>0
+
+  /* -5<=pre<=0: here for plain 0.ddd or 0.000ddd forms (can never have E) */
+  t=c+1-pre;
+  *(t+1)='\0';                          // can add terminator now
+  for (; s>=cstart; s--, t--) *t=*s;    // shift whole coefficient right
+  c=cstart;
+  *c++='0';                             // always starts with 0.
+  *c++='.';
+  for (; pre<0; pre++) *c++='0';        // add any 0's after '.'
+  //printf("res %s\n", string);
+  return string;
+  } // decimal64ToString
+
+/* ------------------------------------------------------------------ */
+/* to-number -- conversion from numeric string                        */
+/*                                                                    */
+/*   decimal64FromString(result, string, set);                        */
+/*                                                                    */
+/*  result  is the decimal64 format number which gets the result of   */
+/*          the conversion                                            */
+/*  *string is the character string which should contain a valid      */
+/*          number (which may be a special value)                     */
+/*  set     is the context                                            */
+/*                                                                    */
+/* The context is supplied to this routine is used for error handling */
+/* (setting of status and traps) and for the rounding mode, only.     */
+/* If an error occurs, the result will be a valid decimal64 NaN.      */
+/* ------------------------------------------------------------------ */
+decimal64 * decimal64FromString(decimal64 *result, const char *string,
+                                decContext *set) {
+  decContext dc;                             // work
+  decNumber dn;                              // ..
+
+  decContextDefault(&dc, DEC_INIT_DECIMAL64); // no traps, please
+  dc.round=set->round;                        // use supplied rounding
+
+  decNumberFromString(&dn, string, &dc);     // will round if needed
+
+  decimal64FromNumber(result, &dn, &dc);
+  if (dc.status!=0) {                        // something happened
+    decContextSetStatus(set, dc.status);     // .. pass it on
+    }
+  return result;
+  } // decimal64FromString
+
+/* ------------------------------------------------------------------ */
+/* decimal64IsCanonical -- test whether encoding is canonical         */
+/*   d64 is the source decimal64                                      */
+/*   returns 1 if the encoding of d64 is canonical, 0 otherwise       */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+uInt decimal64IsCanonical(const decimal64 *d64) {
+  decNumber dn;                         // work
+  decimal64 canon;                      // ..
+  decContext dc;                        // ..
+  decContextDefault(&dc, DEC_INIT_DECIMAL64);
+  decimal64ToNumber(d64, &dn);
+  decimal64FromNumber(&canon, &dn, &dc);// canon will now be canonical
+  return memcmp(d64, &canon, DECIMAL64_Bytes)==0;
+  } // decimal64IsCanonical
+
+/* ------------------------------------------------------------------ */
+/* decimal64Canonical -- copy an encoding, ensuring it is canonical   */
+/*   d64 is the source decimal64                                      */
+/*   result is the target (may be the same decimal64)                 */
+/*   returns result                                                   */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+decimal64 * decimal64Canonical(decimal64 *result, const decimal64 *d64) {
+  decNumber dn;                         // work
+  decContext dc;                        // ..
+  decContextDefault(&dc, DEC_INIT_DECIMAL64);
+  decimal64ToNumber(d64, &dn);
+  decimal64FromNumber(result, &dn, &dc);// result will now be canonical
+  return result;
+  } // decimal64Canonical
+
+#if DECTRACE || DECCHECK
+/* Macros for accessing decimal64 fields.  These assume the
+   argument is a reference (pointer) to the decimal64 structure,
+   and the decimal64 is in network byte order (big-endian) */
+// Get sign
+#define decimal64Sign(d)       ((unsigned)(d)->bytes[0]>>7)
+
+// Get combination field
+#define decimal64Comb(d)       (((d)->bytes[0] & 0x7c)>>2)
+
+// Get exponent continuation [does not remove bias]
+#define decimal64ExpCon(d)     ((((d)->bytes[0] & 0x03)<<6)           \
+                             | ((unsigned)(d)->bytes[1]>>2))
+
+// Set sign [this assumes sign previously 0]
+#define decimal64SetSign(d, b) {                                      \
+  (d)->bytes[0]|=((unsigned)(b)<<7);}
+
+// Set exponent continuation [does not apply bias]
+// This assumes range has been checked and exponent previously 0;
+// type of exponent must be unsigned
+#define decimal64SetExpCon(d, e) {                                    \
+  (d)->bytes[0]|=(uByte)((e)>>6);                                     \
+  (d)->bytes[1]|=(uByte)(((e)&0x3F)<<2);}
+
+/* ------------------------------------------------------------------ */
+/* decimal64Show -- display a decimal64 in hexadecimal [debug aid]    */
+/*   d64 -- the number to show                                        */
+/* ------------------------------------------------------------------ */
+// Also shows sign/cob/expconfields extracted
+void decimal64Show(const decimal64 *d64) {
+  char buf[DECIMAL64_Bytes*2+1];
+  Int i, j=0;
+
+  if (DECLITEND) {
+    for (i=0; i<DECIMAL64_Bytes; i++, j+=2) {
+      sprintf(&buf[j], "%02x", d64->bytes[7-i]);
+      }
+    printf(" D64> %s [S:%d Cb:%02x Ec:%02x] LittleEndian\n", buf,
+           d64->bytes[7]>>7, (d64->bytes[7]>>2)&0x1f,
+           ((d64->bytes[7]&0x3)<<6)| (d64->bytes[6]>>2));
+    }
+   else { // big-endian
+    for (i=0; i<DECIMAL64_Bytes; i++, j+=2) {
+      sprintf(&buf[j], "%02x", d64->bytes[i]);
+      }
+    printf(" D64> %s [S:%d Cb:%02x Ec:%02x] BigEndian\n", buf,
+           decimal64Sign(d64), decimal64Comb(d64), decimal64ExpCon(d64));
+    }
+  } // decimal64Show
+#endif
+
+/* ================================================================== */
+/* Shared utility routines and tables                                 */
+/* ================================================================== */
+// define and include the conversion tables to use for shared code
+#if DECDPUN==3
+  #define DEC_DPD2BIN 1
+#else
+  #define DEC_DPD2BCD 1
+#endif
+#include "decDPD.h"           // lookup tables
+
+// The maximum number of decNumberUnits needed for a working copy of
+// the units array is the ceiling of digits/DECDPUN, where digits is
+// the maximum number of digits in any of the formats for which this
+// is used.  decimal128.h must not be included in this module, so, as
+// a very special case, that number is defined as a literal here.
+#define DECMAX754   34
+#define DECMAXUNITS ((DECMAX754+DECDPUN-1)/DECDPUN)
+
+/* ------------------------------------------------------------------ */
+/* Combination field lookup tables (uInts to save measurable work)    */
+/*                                                                    */
+/*      COMBEXP - 2-bit most-significant-bits of exponent             */
+/*                [11 if an Infinity or NaN]                          */
+/*      COMBMSD - 4-bit most-significant-digit                        */
+/*                [0=Infinity, 1=NaN if COMBEXP=11]                   */
+/*                                                                    */
+/* Both are indexed by the 5-bit combination field (0-31)             */
+/* ------------------------------------------------------------------ */
+const uInt COMBEXP[32]={0, 0, 0, 0, 0, 0, 0, 0,
+                        1, 1, 1, 1, 1, 1, 1, 1,
+                        2, 2, 2, 2, 2, 2, 2, 2,
+                        0, 0, 1, 1, 2, 2, 3, 3};
+const uInt COMBMSD[32]={0, 1, 2, 3, 4, 5, 6, 7,
+                        0, 1, 2, 3, 4, 5, 6, 7,
+                        0, 1, 2, 3, 4, 5, 6, 7,
+                        8, 9, 8, 9, 8, 9, 0, 1};
+
+/* ------------------------------------------------------------------ */
+/* decDigitsToDPD -- pack coefficient into DPD form                   */
+/*                                                                    */
+/*   dn   is the source number (assumed valid, max DECMAX754 digits)  */
+/*   targ is 1, 2, or 4-element uInt array, which the caller must     */
+/*        have cleared to zeros                                       */
+/*   shift is the number of 0 digits to add on the right (normally 0) */
+/*                                                                    */
+/* The coefficient must be known small enough to fit.  The full       */
+/* coefficient is copied, including the leading 'odd' digit.  This    */
+/* digit is retrieved and packed into the combination field by the    */
+/* caller.                                                            */
+/*                                                                    */
+/* The target uInts are altered only as necessary to receive the      */
+/* digits of the decNumber.  When more than one uInt is needed, they  */
+/* are filled from left to right (that is, the uInt at offset 0 will  */
+/* end up with the least-significant digits).                         */
+/*                                                                    */
+/* shift is used for 'fold-down' padding.                             */
+/*                                                                    */
+/* No error is possible.                                              */
+/* ------------------------------------------------------------------ */
+#if DECDPUN<=4
+// Constant multipliers for divide-by-power-of five using reciprocal
+// multiply, after removing powers of 2 by shifting, and final shift
+// of 17 [we only need up to **4]
+static const uInt multies[]={131073, 26215, 5243, 1049, 210};
+// QUOT10 -- macro to return the quotient of unit u divided by 10**n
+#define QUOT10(u, n) ((((uInt)(u)>>(n))*multies[n])>>17)
+#endif
+void decDigitsToDPD(const decNumber *dn, uInt *targ, Int shift) {
+  Int  cut;                   // work
+  Int  n;                     // output bunch counter
+  Int  digits=dn->digits;     // digit countdown
+  uInt dpd;                   // densely packed decimal value
+  uInt bin;                   // binary value 0-999
+  uInt *uout=targ;            // -> current output uInt
+  uInt  uoff=0;               // -> current output offset [from right]
+  const Unit *inu=dn->lsu;    // -> current input unit
+  Unit  uar[DECMAXUNITS];     // working copy of units, iff shifted
+  #if DECDPUN!=3              // not fast path
+    Unit in;                  // current unit
+  #endif
+
+  if (shift!=0) {             // shift towards most significant required
+    // shift the units array to the left by pad digits and copy
+    // [this code is a special case of decShiftToMost, which could
+    // be used instead if exposed and the array were copied first]
+    const Unit *source;                 // ..
+    Unit  *target, *first;              // ..
+    uInt  next=0;                       // work
+
+    source=dn->lsu+D2U(digits)-1;       // where msu comes from
+    target=uar+D2U(digits)-1+D2U(shift);// where upper part of first cut goes
+    cut=DECDPUN-MSUDIGITS(shift);       // where to slice
+    if (cut==0) {                       // unit-boundary case
+      for (; source>=dn->lsu; source--, target--) *target=*source;
+      }
+     else {
+      first=uar+D2U(digits+shift)-1;    // where msu will end up
+      for (; source>=dn->lsu; source--, target--) {
+        // split the source Unit and accumulate remainder for next
+        #if DECDPUN<=4
+          uInt quot=QUOT10(*source, cut);
+          uInt rem=*source-quot*DECPOWERS[cut];
+          next+=quot;
+        #else
+          uInt rem=*source%DECPOWERS[cut];
+          next+=*source/DECPOWERS[cut];
+        #endif
+        if (target<=first) *target=(Unit)next; // write to target iff valid
+        next=rem*DECPOWERS[DECDPUN-cut];       // save remainder for next Unit
+        }
+      } // shift-move
+    // propagate remainder to one below and clear the rest
+    for (; target>=uar; target--) {
+      *target=(Unit)next;
+      next=0;
+      }
+    digits+=shift;                 // add count (shift) of zeros added
+    inu=uar;                       // use units in working array
+    }
+
+  /* now densely pack the coefficient into DPD declets */
+
+  #if DECDPUN!=3                   // not fast path
+    in=*inu;                       // current unit
+    cut=0;                         // at lowest digit
+    bin=0;                         // [keep compiler quiet]
+  #endif
+
+  for(n=0; digits>0; n++) {        // each output bunch
+    #if DECDPUN==3                 // fast path, 3-at-a-time
+      bin=*inu;                    // 3 digits ready for convert
+      digits-=3;                   // [may go negative]
+      inu++;                       // may need another
+
+    #else                          // must collect digit-by-digit
+      Unit dig;                    // current digit
+      Int j;                       // digit-in-declet count
+      for (j=0; j<3; j++) {
+        #if DECDPUN<=4
+          Unit temp=(Unit)((uInt)(in*6554)>>16);
+          dig=(Unit)(in-X10(temp));
+          in=temp;
+        #else
+          dig=in%10;
+          in=in/10;
+        #endif
+        if (j==0) bin=dig;
+         else if (j==1)  bin+=X10(dig);
+         else /* j==2 */ bin+=X100(dig);
+        digits--;
+        if (digits==0) break;      // [also protects *inu below]
+        cut++;
+        if (cut==DECDPUN) {inu++; in=*inu; cut=0;}
+        }
+    #endif
+    // here there are 3 digits in bin, or have used all input digits
+
+    dpd=BIN2DPD[bin];
+
+    // write declet to uInt array
+    *uout|=dpd<<uoff;
+    uoff+=10;
+    if (uoff<32) continue;         // no uInt boundary cross
+    uout++;
+    uoff-=32;
+    *uout|=dpd>>(10-uoff);         // collect top bits
+    } // n declets
+  return;
+  } // decDigitsToDPD
+
+/* ------------------------------------------------------------------ */
+/* decDigitsFromDPD -- unpack a format's coefficient                  */
+/*                                                                    */
+/*   dn is the target number, with 7, 16, or 34-digit space.          */
+/*   sour is a 1, 2, or 4-element uInt array containing only declets  */
+/*   declets is the number of (right-aligned) declets in sour to      */
+/*     be processed.  This may be 1 more than the obvious number in   */
+/*     a format, as any top digit is prefixed to the coefficient      */
+/*     continuation field.  It also may be as small as 1, as the      */
+/*     caller may pre-process leading zero declets.                   */
+/*                                                                    */
+/* When doing the 'extra declet' case care is taken to avoid writing  */
+/* extra digits when there are leading zeros, as these could overflow */
+/* the units array when DECDPUN is not 3.                             */
+/*                                                                    */
+/* The target uInts are used only as necessary to process declets     */
+/* declets into the decNumber.  When more than one uInt is needed,    */
+/* they are used from left to right (that is, the uInt at offset 0    */
+/* provides the least-significant digits).                            */
+/*                                                                    */
+/* dn->digits is set, but not the sign or exponent.                   */
+/* No error is possible [the redundant 888 codes are allowed].        */
+/* ------------------------------------------------------------------ */
+void decDigitsFromDPD(decNumber *dn, const uInt *sour, Int declets) {
+
+  uInt  dpd;                       // collector for 10 bits
+  Int   n;                         // counter
+  Unit  *uout=dn->lsu;             // -> current output unit
+  Unit  *last=uout;                // will be unit containing msd
+  const uInt *uin=sour;            // -> current input uInt
+  uInt  uoff=0;                    // -> current input offset [from right]
+
+  #if DECDPUN!=3
+  uInt  bcd;                       // BCD result
+  uInt  nibble;                    // work
+  Unit  out=0;                     // accumulator
+  Int   cut=0;                     // power of ten in current unit
+  #endif
+  #if DECDPUN>4
+  uInt const *pow;                 // work
+  #endif
+
+  // Expand the densely-packed integer, right to left
+  for (n=declets-1; n>=0; n--) {   // count down declets of 10 bits
+    dpd=*uin>>uoff;
+    uoff+=10;
+    if (uoff>32) {                 // crossed uInt boundary
+      uin++;
+      uoff-=32;                    // [if using this code for wider, check this]
+      dpd|=*uin<<(10-uoff);        // get waiting bits
+      }
+    dpd&=0x3ff;                    // clear uninteresting bits
+
+  #if DECDPUN==3
+    if (dpd==0) *uout=0;
+     else {
+      *uout=DPD2BIN[dpd];          // convert 10 bits to binary 0-999
+      last=uout;                   // record most significant unit
+      }
+    uout++;
+    } // n
+
+  #else // DECDPUN!=3
+    if (dpd==0) {                  // fastpath [e.g., leading zeros]
+      // write out three 0 digits (nibbles); out may have digit(s)
+      cut++;
+      if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
+      if (n==0) break;             // [as below, works even if MSD=0]
+      cut++;
+      if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
+      cut++;
+      if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
+      continue;
+      }
+
+    bcd=DPD2BCD[dpd];              // convert 10 bits to 12 bits BCD
+
+    // now accumulate the 3 BCD nibbles into units
+    nibble=bcd & 0x00f;
+    if (nibble) out=(Unit)(out+nibble*DECPOWERS[cut]);
+    cut++;
+    if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
+    bcd>>=4;
+
+    // if this is the last declet and the remaining nibbles in bcd
+    // are 00 then process no more nibbles, because this could be
+    // the 'odd' MSD declet and writing any more Units would then
+    // overflow the unit array
+    if (n==0 && !bcd) break;
+
+    nibble=bcd & 0x00f;
+    if (nibble) out=(Unit)(out+nibble*DECPOWERS[cut]);
+    cut++;
+    if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
+    bcd>>=4;
+
+    nibble=bcd & 0x00f;
+    if (nibble) out=(Unit)(out+nibble*DECPOWERS[cut]);
+    cut++;
+    if (cut==DECDPUN) {*uout=out; if (out) {last=uout; out=0;} uout++; cut=0;}
+    } // n
+  if (cut!=0) {                         // some more left over
+    *uout=out;                          // write out final unit
+    if (out) last=uout;                 // and note if non-zero
+    }
+  #endif
+
+  // here, last points to the most significant unit with digits;
+  // inspect it to get the final digits count -- this is essentially
+  // the same code as decGetDigits in decNumber.c
+  dn->digits=(last-dn->lsu)*DECDPUN+1;  // floor of digits, plus
+                                        // must be at least 1 digit
+  #if DECDPUN>1
+  if (*last<10) return;                 // common odd digit or 0
+  dn->digits++;                         // must be 2 at least
+  #if DECDPUN>2
+  if (*last<100) return;                // 10-99
+  dn->digits++;                         // must be 3 at least
+  #if DECDPUN>3
+  if (*last<1000) return;               // 100-999
+  dn->digits++;                         // must be 4 at least
+  #if DECDPUN>4
+  for (pow=&DECPOWERS[4]; *last>=*pow; pow++) dn->digits++;
+  #endif
+  #endif
+  #endif
+  #endif
+  return;
+  } //decDigitsFromDPD
diff --git a/decNumber/decimal64.h b/decNumber/decimal64.h
index 01284ca5..19a1b5ed 100644
--- a/decNumber/decimal64.h
+++ b/decNumber/decimal64.h
@@ -1,103 +1,83 @@
-/* ------------------------------------------------------------------ */
-/* Decimal 64-bit format module header                                */
-/* ------------------------------------------------------------------ */
-/* Copyright (c) IBM Corporation, 2000, 2005.  All rights reserved.   */
-/*                                                                    */
-/* This software is made available under the terms of the             */
-/* ICU License -- ICU 1.8.1 and later.                                */
-/*                                                                    */
-/* The description and User's Guide ("The decNumber C Library") for   */
-/* this software is called decNumber.pdf.  This document is           */
-/* available, together with arithmetic and format specifications,     */
-/* testcases, and Web links, at: http://www2.hursley.ibm.com/decimal  */
-/*                                                                    */
-/* Please send comments, suggestions, and corrections to the author:  */
-/*   mfc@uk.ibm.com                                                   */
-/*   Mike Cowlishaw, IBM Fellow                                       */
-/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
-/* ------------------------------------------------------------------ */
-
-#if !defined(DECIMAL64)
-  #define DECIMAL64
-  #define DEC64NAME     "decimal64"                   /* Short name */
-  #define DEC64FULLNAME "Decimal 64-bit Number"       /* Verbose name */
-  #define DEC64AUTHOR   "Mike Cowlishaw"              /* Who to blame */
-
-
-  /* parameters for decimal64s */
-  #define DECIMAL64_Bytes  8            // length
-  #define DECIMAL64_Pmax   16           // maximum precision (digits)
-  #define DECIMAL64_Emax   384          // maximum adjusted exponent
-  #define DECIMAL64_Emin  -383          // minimum adjusted exponent
-  #define DECIMAL64_Bias   398          // bias for the exponent
-  #define DECIMAL64_String 24           // maximum string length, +1
-  #define DECIMAL64_EconL  8            // exponent continuation length
-  // highest biased exponent (Elimit-1)
-  #define DECIMAL64_Ehigh  (DECIMAL64_Emax+DECIMAL64_Bias-DECIMAL64_Pmax+1)
-
-  // check enough digits, if pre-defined
-  #if defined(DECNUMDIGITS)
-    #if (DECNUMDIGITS<DECIMAL64_Pmax)
-      #error decimal64.h needs pre-defined DECNUMDIGITS>=16 for safe use
-    #endif
-  #endif
-
-
-  #ifndef DECNUMDIGITS
-    #define DECNUMDIGITS DECIMAL64_Pmax // size if not already defined
-  #endif
-  #ifndef DECNUMBER
-    #include "decNumber.h"              // context and number library
-  #endif
-
-  /* Decimal 64-bit type, accessible by bytes */
-  typedef struct {
-    uint8_t bytes[DECIMAL64_Bytes];     // decimal64: 1, 5, 8, 50 bits
-    } decimal64;
-
-  /* special values [top byte excluding sign bit; last two bits are
-     don't-care for Infinity on input, last bit don't-care for NaN] */
-  #if !defined(DECIMAL_NaN)
-    #define DECIMAL_NaN     0x7c        // 0 11111 00 NaN
-    #define DECIMAL_sNaN    0x7e        // 0 11111 10 sNaN
-    #define DECIMAL_Inf     0x78        // 0 11110 00 Infinity
-  #endif
-
-  /* Macros for accessing decimal64 fields.  These assume the argument
-     is a reference (pointer) to the decimal64 structure, and the
-     decimal64 is in network byte order (big-endian) */
-  // Get sign
-  #define decimal64Sign(d)       ((unsigned)(d)->bytes[0]>>7)
-
-  // Get combination field
-  #define decimal64Comb(d)       (((d)->bytes[0] & 0x7c)>>2)
-
-  // Get exponent continuation [does not remove bias]
-  #define decimal64ExpCon(d)     ((((d)->bytes[0] & 0x03)<<6)         \
-                               | ((unsigned)(d)->bytes[1]>>2))
-
-  // Set sign [this assumes sign previously 0]
-  #define decimal64SetSign(d, b) {                                    \
-    (d)->bytes[0]|=((unsigned)(b)<<7);}
-
-  // Set exponent continuation [does not apply bias]
-  // This assumes range has been checked and exponent previously 0; type
-  // of exponent must be unsigned
-  #define decimal64SetExpCon(d, e) {                                  \
-    (d)->bytes[0]|=(uint8_t)((e)>>6);                                 \
-    (d)->bytes[1]|=(uint8_t)(((e)&0x3F)<<2);}
-
-  /* ------------------------------------------------------------------ */
-  /* Routines                                                           */
-  /* ------------------------------------------------------------------ */
-  // String conversions
-  decimal64 * decimal64FromString(decimal64 *, const char *, decContext *);
-  char * decimal64ToString(const decimal64 *, char *);
-  char * decimal64ToEngString(const decimal64 *, char *);
-
-  // decNumber conversions
-  decimal64 * decimal64FromNumber(decimal64 *, const decNumber *,
-                                  decContext *);
-  decNumber * decimal64ToNumber(const decimal64 *, decNumber *);
-
-#endif
+/* ------------------------------------------------------------------ */
+/* Decimal 64-bit format module header                                */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2000, 2005.  All rights reserved.   */
+/*                                                                    */
+/* This software is made available under the terms of the             */
+/* ICU License -- ICU 1.8.1 and later.                                */
+/*                                                                    */
+/* The description and User's Guide ("The decNumber C Library") for   */
+/* this software is called decNumber.pdf.  This document is           */
+/* available, together with arithmetic and format specifications,     */
+/* testcases, and Web links, on the General Decimal Arithmetic page.  */
+/*                                                                    */
+/* Please send comments, suggestions, and corrections to the author:  */
+/*   mfc@uk.ibm.com                                                   */
+/*   Mike Cowlishaw, IBM Fellow                                       */
+/*   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         */
+/* ------------------------------------------------------------------ */
+
+#if !defined(DECIMAL64)
+  #define DECIMAL64
+  #define DEC64NAME     "decimal64"                   /* Short name   */
+  #define DEC64FULLNAME "Decimal 64-bit Number"       /* Verbose name */
+  #define DEC64AUTHOR   "Mike Cowlishaw"              /* Who to blame */
+
+
+  /* parameters for decimal64s                                        */
+  #define DECIMAL64_Bytes  8            /* length                     */
+  #define DECIMAL64_Pmax   16           /* maximum precision (digits) */
+  #define DECIMAL64_Emax   384          /* maximum adjusted exponent  */
+  #define DECIMAL64_Emin  -383          /* minimum adjusted exponent  */
+  #define DECIMAL64_Bias   398          /* bias for the exponent      */
+  #define DECIMAL64_String 24           /* maximum string length, +1  */
+  #define DECIMAL64_EconL  8            /* exp. continuation length   */
+  /* highest biased exponent (Elimit-1)                               */
+  #define DECIMAL64_Ehigh  (DECIMAL64_Emax+DECIMAL64_Bias-DECIMAL64_Pmax+1)
+
+  /* check enough digits, if pre-defined                              */
+  #if defined(DECNUMDIGITS)
+    #if (DECNUMDIGITS<DECIMAL64_Pmax)
+      #error decimal64.h needs pre-defined DECNUMDIGITS>=16 for safe use
+    #endif
+  #endif
+
+
+  #ifndef DECNUMDIGITS
+    #define DECNUMDIGITS DECIMAL64_Pmax /* size if not already defined*/
+  #endif
+  #ifndef DECNUMBER
+    #include "decNumber.h"              /* context and number library */
+  #endif
+
+  /* Decimal 64-bit type, accessible by bytes                         */
+  typedef struct {
+    uint8_t bytes[DECIMAL64_Bytes];     /* decimal64: 1, 5, 8, 50 bits*/
+    } decimal64;
+
+  /* special values [top byte excluding sign bit; last two bits are   */
+  /* don't-care for Infinity on input, last bit don't-care for NaN]   */
+  #if !defined(DECIMAL_NaN)
+    #define DECIMAL_NaN     0x7c        /* 0 11111 00 NaN             */
+    #define DECIMAL_sNaN    0x7e        /* 0 11111 10 sNaN            */
+    #define DECIMAL_Inf     0x78        /* 0 11110 00 Infinity        */
+  #endif
+
+  /* ---------------------------------------------------------------- */
+  /* Routines                                                         */
+  /* ---------------------------------------------------------------- */
+  /* String conversions                                               */
+  decimal64 * decimal64FromString(decimal64 *, const char *, decContext *);
+  char * decimal64ToString(const decimal64 *, char *);
+  char * decimal64ToEngString(const decimal64 *, char *);
+
+  /* decNumber conversions                                            */
+  decimal64 * decimal64FromNumber(decimal64 *, const decNumber *,
+                                  decContext *);
+  decNumber * decimal64ToNumber(const decimal64 *, decNumber *);
+
+  /* Format-dependent utilities                                       */
+  uint32_t    decimal64IsCanonical(const decimal64 *);
+  decimal64 * decimal64Canonical(decimal64 *, const decimal64 *);
+
+#endif
diff --git a/decNumber/decnumber.pdf b/decNumber/decnumber.pdf
index 8e9f40bc4cf893e0a97cd929203bf869e553f1a7..f601105beb3031ec5681b5224775e18c371b43f3 100644
GIT binary patch
literal 1416382
zcma&NbBt))()Qc7ZQHhO+qP}nwrzK>wr$(J+Qw?*?!E8(-g9!llYHmDnK6?&k{VBD
zJ-@0^qzWQpw2X8tP^3d8L)}AdL-|ll1PlcBMpjTfJoGZAcIGY?1k8V}DA9{q+PIiH
z(Tmv_x|oWX8rz$g^6^1AyEvH|+Cq8c*ec0dZ!;kDe5jx4G`O2RnFb=%@S`bZ30D+`
zFAgp4uw;jXaL9eUa3`(WHL-@7Z(v#OdOsEj-IuT1jGeo5{cuK}bkgd9KvYOrlv7jI
zB&*Vn7Qa4A@}TnG+HaojjX842#*5#wuU)H>6NHp;=l?eURAmts{QcTp<yt!8fRK#~
z#bng}b<+w(>ZMG+9LOU`QOZs={%LDMF;UHjrja|@*)K2!DSZ!;FI;c(nVnV^yPu|1
zcSstx_`B5gVC=5rEd1~!H^q*hR?0y(a<QpNNXy_?5)x8`BqRaCI6*2nD3=91851}(
zE5~RFa2w<jn-DN9i#1D|{nE}O2Xdh*k=TR5I3=DW5z!AK<SKCV2_DjNhhZj!DPJIG
zCqxH@vk}v|Zaoqg&gjwQ<+MZ{Q<bi%N1aMXD58lNt~~O)0nsm{#J7IBl!eOngTv2R
zi@le=c74uODJ)K@pPl$h!EUFUfPO2)Vv|@N$2-M>KNJH_kRCEK+F;8a?%&CWDVetP
z-LFnwUKzX!_&gOX1<cYCDB&RxC+*eKDaF<?iBL6cuzyA|nQ;3`HykU%Kcv_C<UY=A
z8FlNk>}a#&T!%U1TQZPDUvQo=_|lrAJ)T3AD+3c0nl9j}?1%NUQ!c5YOzlkm=g9wh
z`dcMXe~aVq2Nn*Fzu*3|#`wRB|I!d6%YPvv*#v3n5e9_Nmp9aAw9Q!(S$qZ<7F#GN
zcSpi~A)ScbwUesSf^Y97Hgyt&*_`AzGRPAU{i?IFHzyy@+<|MaKada^)(y2Yu*<a*
z*cotl9^mT7#(Gb;`20)9E_p)--ez=eUta(ehhfV&Yc5K36iu+}lP73{*eJzdL=a=-
zWYk%a6@zk2GZrOgLK8H~vaqeuLez~{NjgO2sLJ%iED~mRH(^l`5JeYd4QXlY3P8wg
z)JTxH&u0?kEo?G=g>jc1_x2t}MJYe^taYy`*+~oaqh=qk3AM7uOldtaLwQ5N4}#Zg
z{M$qHKNTu-{~?_J#Od!KGO;lIE1vBC6Xbu3C&zyg&mL{v_@g#d-+X;T0(;P_<KuD&
z2q2sIST>0u5R3wNQM|SZlSWD|(O=q6w=a50NR*dRPGQZ_pxwsWi==Z0UmWQz9Q`-`
z@V9aKeEy%;U-bFz<+pS2Kf95+9OJq7Ck1Y^)xy6%p1MCS^WEs-(LcX;-t_77^Y!_D
zPO&M!KR>_M;_30<zjt0v`*?1K8FKKJkni@&;o-~6!)N!0XgpZ{JYC-Gpt>pD<oSJQ
z+dmbk+8ZWx{&E61yY^)0VGX`6#kjk6T|WXv`+>P_#d>-@Fiq%La!D*qhxWzT<!1f-
ze7YVwK0heu*uLfK{WQiQm<ID;0P3a<x2%Z{X5kKCkN_OoeG-CVy)vbD@kkB64TaRN
z82B@|n?ZvRw9xXq0gx1qOItO0<<)^XBb)!!&CloO0MqvKZqNVw>ut$GqA{#R?2}yB
z?Q}t|e){g|14_jUn#$I}a68~QfnWhNhDmQ8nxBHz&#@#kXRu^e#4Br`*ooY(<0ydT
z^OFWJbL@#sL2ESy6~vT{HRyb8z~$1w%bS6_7)6K+pJTogJe=TK@Od5<NuO6p(s}-1
zhyj&j)N_Dx_9`Ro4A145&Wpy+IgD8^3SG>?#KZNjeKr{9blGuVqH=wL;q~^`bf7sb
zMf4L|nHajjAQv1#TSVgXu2n?GOr)O`;UKK1JX>Hv77qP^IOn`MLRbLj{+Sq*a4?|E
zBdur#Q5a^MXoL}{Aq<7T5p4~CEl(1eNxUspGZ9s78I5`n_mf&Pk->aqEH!^Sq#+hZ
zB6A<l(jhW*I8^!vJVI{5H$rNUyf{)y6VfP?YG#NWJ}%c5S=DAZg-vAIhFZClN@WAK
zs)fBi&O~XBSaX=89dTBWJ~FFoN&@9=aeU=lcHD_3z{|Fmb^z|RA&OHxwT(%$Qz&hZ
zs5%+^L#t`ptfec`=#4eWEpD!HqlYXwvN2-o9xjSR+e=FJJTTidnqQJ{8Y?<aWqlH5
z!!@d8yJ-A<Eu4?NSi()k2vv@BIR{dnuPpkuoCxS##&C(eq39(-gdJ8Ov_!3}zAM6b
zO4Sm#*4^xewwLs+U<+{7IkZ+rN1bri2GQICs-DD7Z_#k2D7uqwwAMv5BD$Q(b%a8F
zo<iOu7R7iZy)LRm%%At@*Ac-@K@4ql=~BygrY5`MX!vg35Rc~iWQuB(!-lP57}5F4
z!JQAgDfZ{@&4z3zyqHWHo)4a`55{fXVO>_v16-Ylk=7RtYzGGxNM$xLV)NgA8>{1_
zhpn@vn@SH_RgGXX4^K$1?P9f_WJaP$_sI;hOewqI9Z{^V(;9Xz^pY=?MZN7ne{k;}
zY_F?c=>*6Xrcj9ekk=G_i2IS}Lu+B&McFH**a<q}B0?YFE|+6FhT)hfrZT4;6HZqV
z5>fV$`*mtI5?O1FdMN`a1T3kCv=I5K7SRI~GO71yC#Q(y%MU4|$2Hr>t#;Lu8?#1-
z(DDNu)tZSd2NPp?+KCXx2GvFzmCi1rYUDYL6f`*2SXs~<C3mG@2CwM)S+t>o0A*xq
zCcyex@VRR!X-(U$YI|sVYIAhZa!c9eCBZxYJkWEtl5q&DLG#t#I$O@HTFq0&=xyI+
zB^(chmp>FWuo_icMM|oJIB7+x`G}^k+5o2NWMN7o$N9WQ(B;~i;!qbVs<&7VDt4KA
zF5WDL)hZ=PJCk7pF#Eg`q|c_^1Wl>9m;_0mmoCLfdR|q^4BA#{1KVkqliTbV@$QDx
z(m#ig*mT^prtpWMdkc7WHl!}py7b71UXi+#>YU+u7LIn(ZF8#LYqF3pL(?d?syy}K
ziBF&fmk)KecR$FaS{6<wl5brAb@wv|8PPK@kfHB`=B>1lG}X!|m%=ch2Bupe`BmPD
zbo>;a!U}zA99E4rEdH@S1@k#yQjCwsHjKvB;LGvcgrl*EeZ9znYCv5;y#PD6XJ<Oa
zGN{cb0i=^MAx!|StKR-yLTA_cCoOb3&o(j@K8RSyByFdfi^OX9dU2#F6f2MxGej$A
ztm!^wd(>Pyb5n|YN)1HM1$X1zG~~m`H2PS&NukYw*itA_-KEfm(q<?8sH`aYb$bNM
zf?oS7%B8p|lyw6L1HZ4qhLYy5gZens{%BlOag_j|<E+SLgDsoY?pgAz=jZN~a$XMB
ziK{2o;MP0z)Ffie-Kkg!t|Pi%<bok5>rLb5)|(aeHxpZI;=#q|F5)-W#vGG6K4m-3
zQMr(QZPs3}9mwZQrVY4n4F2TQ?u4(a#TBPC<N<G6)U2>mLcP&xLAkL-cJrbA&0{zT
zQ!|pv&1d0Z<%ZrSrc&#4S>cv_C>M1@&E-7io>t7vOl+x{jf>Aw#B8qpa?nnB)Xxk)
zzM0!`L>;p~T{D5!|JolotE2JPE>Ss9-ZcAVve}mLq=SzfS6waXLbsXMNDY>^q*t9f
z*>0+xscKA>V@5Id&KR-rgt)D!P}-RLQh$zqJ)x|NddG3GVLZi&?)9U7g*4Eimdy6c
z+8bUR$AlLk7;T-_$|^jD4dd@jy?kae6l5i2N<l;W5KCquwIl+oU#`8^=F-ml6|yxv
zDA5gvY@FP{toK})XOG&B*QK!Fj?kC|$gbDfI4mr*462F!T4cP_2G<wd5T!(x3TS6R
z?i`^z5IV`GoQee}b$%hc?eLzo)epn^?nm<oiq6!Pwt1lzH$*KP7*s1Ob30Q~X;Fu{
zH9*ro1GIx##n=@dkJCP8R4I3mci@J)Jdmh<W*in4XQXCe%zX<Z-a!QXb^fE=NyE>B
z7Je!)&WhX7uLTNooRA<zfXlHri$b6_Yd2%|!3O>Yf)7hedN8O#R_%7BWOKpU^6M-g
zoz!3wV-4rIINF0v5F%Y_6k&OEi2QBc^qqn$WwM-#U9@$QS?hcb`vKdG&Q|A6+@Q1^
zfdq})2bwO8KOqwjNoOSU{ueFZcMIrJOHqE=el;||t)O7s<*Ju=D|(3F1oSGHs3Ws~
z1!Sl7_wu)y0{`_leA8M_-+yvXf4ic8+!GV~zu70Y|C4DL+5Q`<sa2JYU;2w`PSrL3
z@{G&O-%+Gfi)@ml2+<mpNa3jApqnc}6h$caFPLMJkAcF}jp$>MypKG$yz(A!SMF`S
zoOyZA@cD8!&e~@D80I|UWi^wa%xb?uxo_4#(ytO$T6+B+U0yG?-`jjt8E?MIE{rIo
z92>H5@tb9nF|(=70Gy|?=4^UUVFFk`yunG+cRAMIQMp?5xa<;w_gCvvido;MRWpKP
zxzCdwDu%{oJ%C*lJW6~`eJYLGoEb*iFbBD4q3w4_zG8poyJs)Rx}sTA_u$KS4xS!C
zofg)>k~cf65I|5<sH#O{PxIu;C2sNX+(RCo*M7x!8N-K4Qm}Mj3R{XL_aKW&?D=3G
z<4_aPQ4R*T|0tOVM-kj+6fd}iY>wmJ*CQJRoK56eH(HG(nA3Vtzy0AFC*jmNX3~_A
z3bJ-pu$-XPO-5WU2-aH_)SnkbCtGVSHeS&So9z@#s)k^yR0c*2kxcm^tdI~A6hy-n
zgayeo4Z30ylv18s&`KV(<#T1Tx<f1o=WtlSOe#~wDB6H&M9XWn$3-gx<yB?yXmEpA
zvqce-8HhH`I@pHyX!4+)z%3r)lNJszc?2{DS^!=ZXwfCZx<guGa(Sm*ieR=PUOB<a
z6S=qwEihvf^1{nX>KVv#=mV?BD>bqk>-+IO#i3;sdx;C98=3bg-ztTgoPOEkF6~K>
zqmCcMY@*??!cwz$m3>h+pl!*}yp8(;^g8Nv`A?GkM`(X*l9lb>B+0@0A1poFf8*(O
zq@zj35PRq9E$(C)np1D7D6l%KyAoqv5n#>;d>U$XiLqNeG#kEdaTDhvd|dums0&%R
zb#_uQGaW{|FU!y$-sP9Om&@n-f8VY3`Sa!UZRLIYX22~)^JI*4R|IP>Px-t)ecuhS
zhwJCn-F<c0k978a*nJ!wGvLObO8WqPe>}yPKVB}`>>E<2q5FD#o!{M%!6|jO4_$`i
ztNU{EMXziWYt?e{ZLLfkH4j41IkiqL9Gbpf#rb=FEiL`|bN<nAboue)_Z^(`{d`~k
zQ(8OXV0{FmaP><KobYp03U7ofmpm3*wxLyX1T24>%FaVlFU~6!S%JOYh)=2m%GF12
z^)6suf|SQ>)pEd`{9IjOjMVp6>BqjJC-)%Jfm^$xg^p5%D$TuRyX<(o{JR5UUe!4Y
zWytYRsF2GEB!5fG;mEvlw#&u&mAXPA8=`+~c$36e3L9&+N`J6NGr%lCcEa<NA^;<r
zeQ3Nxy=DSikJ(_$Y1#u!&OKoEs^Y7)!LK{^@Z1D6LS{iv?i4AL);Rh8Q7SzlDSHRF
zxLE$5&#68n3KMvgO^*J?Ow!MoiiU_8_-YPZ{U1+!v#PG5T#hm3*{1me67<i8num+{
z7yxCccpplGCh-ocYk0Fm`AQ}Y)07#38?iTMR+W9Ka}C}<4N!h+Cf>_{e85b06mWfA
zEqNM|hj&p(fj1-gXU^XRqJ<B{f#6(`yhU6z38A^FG&OlEqGh!TrU-7wngRi`m*S{`
zs<2#W>dcDL%o_)TF(%@pqx7?aYY#(053Dz5#gdb^^c28%`bdUv(cmb)PKoAz69Q?`
z;)|a;ej9_-${8SMSx^ZEg4!ks>u!WjxIAF#xV!DKjOF@ia3RkO<_d;X)42;eCLN+!
zs{0|)Few|;CcUBZ*r3CQwAMnuc?-PC%wwm<#G*-MI<gYekAG9hv=K-S8K?mB8ar!Z
z{}N86=>l(~Mif67rrU<*ZN<GPWY-|N0}lF(c;%ENZta`GrZt4JLckx{t0akzFhut`
zgy0_}^26e|Islj1Q93#eTL!c1=%<_vi&nX(VBS5AveJtx>2X~R9jTQ}Y??C;r@-PS
z+HuBq%Id$xs8u#m!C7!!L(Ke+x)^b57vA91nvVmfh}gOE0}xe}11;W;4NBq+I{F|N
zFxmfowl;mWL?H=97rf~P=6Rmga5lp=8>&5OLc!rOuh3tdsw>m~66HMmv@Ioo+WX)=
zHL*o<+OfEZlah(aB2W!CS%+e`!~C0Wqt}4M5jgH*G()+l*v|{GeUz)Hx4#Lv6}BP6
zrZ_}GSZlu>1^Zo07`#hf^nk07ov~VbAMd_f5aNIVQz!avdb|*r@IkE&T+nvfpn<zu
zAuPin1@-Y4#%`$dK>b8K#c8q8Pp<Wsv}cl+P~q9c3d}<v_(%vlD2P|RCQuxiUs6&N
zUkLTEZL8nCS4!x^BL~HuT1DVkoZ?zE9ik`G#d3W`kR5Vx)#|7OLI`ZRo)p(=1#iy$
zf<QnxcUPwvo_djzXPc?4u!tR_ey0do>xdy)Q2Y023+ZFh%V8lRRz1n&4$mg+PJmlH
zN1zZnz%L64ep<CQi0Y&i>L4m1XG)JqLB}Ra5k*ZL*lMz5wHjICR+3w(RG@=?ZTjfD
zT%ukJQ$x5)$QYq#2STHn%e<+owUFomwS;ai(dtAs^((}Q+#qRXO=%aU<IL^K?lR`B
zt2f;E{F|&%#cUDK`um3R-2{^53)oXWRVN8eOz2($;w-QG_7e&6=YqvDIgzZlz)fLc
zBk_bBk3>)G<35*1T{^&>$EVo!G=V=uU{ORWv<r{!ruiMHt8RP%9V85>AU>9GDJ*M}
znlMjkfV{&AS3ySbq6t*(SfXqw*+ybp<KIsaO+kI>l)tGE#q1NW5+q>-m8<n?v4;?e
z%z`%d=8YSu2G?MFJsOe+*Qnx%8Y$*_*n(VDgB~0c1vw<(wI^-`MOjxk@cRJNx2bx-
zyo-!f$`)idM;#Z&%a`SK=&SFKyAD&7a(YmZ^-x=>p3RAMDZTisBh#5waOkONI%w3c
zSBQNQUX#0j*20BVPOCIp%<=cYHn}4*u>r0QM6;42n3s~Oph)2=sGvc)jy}aZ5L*Yw
z(FK34fin{JsA(Ig>RydNby0%etL6JaHnyGN5tPOi>jfg5O}PJR+s6mf)*e!~Xsi2L
zjY#nn%)CwlI)J8-%Eu_JW`$zZ`?Ze}FFNqZ0hNc-;MJF{Vri~U-ks{Hk=g{ct4>N-
zb;u!$sc|K;{aRcp;u6qHFGf55b=36g{^**22oPyZ8oH^2W#kQCP)r_)L6hVdUP>UY
z-L;X8D#y**AG;bv-;d2PAZ#M8qrI7NTHVIDwhV|KMV;uDZ{Ba+^+7cQ94fG2+j(Jn
zUYE%lNMT+N%`|&0o4@+erb^qXD7ntWAjft$eQyV&8%;@DsbD85Nfmns3fuhd=w2gm
za#pj3zF+5VY)#fys-VQmDUduDr9x_YJZl1@gdl76Mm)Et5qP+jt)_%4o^XbA_=ig4
zXD|=zk}&p;*)rl#>#v`WIhw6KtCy+dg%GY#UY8t&^SO=^xi-@cmEDLGkSyHIQ&JgB
zLW*3O5}kGXJYtYs@79D&lgf<=8EGIZVN?%(JzJoZs@JSod`=be;N#U-)IlqJ=y5|X
zhGP!YT1^A{G<sv@!l3~?hnuCXS1MRbM}0)xy~=Mki9PVmw+vHE_Hkrp%dwlr=k4+9
z^1A+5lw7H@#ZX(xnO&$ICE_v#FJkY8Gi6oEh@MVh<gLVaJee3<ti>L<^T_?((zl38
z+s$(EUswVliZ5B^8pYO99EspHcnTOP@2_#BkHhK>%SnU|^z^crIrNM!o37H8k^vJT
zuXS({)4Ti1_f+VDGNRfC7${ABE1Wo3@IjQ8O8CxU9}Xsf=JRX?yL23tCJUJd5Lh}0
z2E>E)cK2yUK(@gENPezZ=8Ggblb%4egWg}FKO6q0_~T3>?tGN<P?$Tw!q)a@9bhx=
zE+w?8Hx>uoaFgezdW1)z#o)!C2@qRF!dzhdX*-x!sj~EO+#E{wQ0?|l!Fk0Qi-(a-
z?k||1ks=u*9K1Y%Ow)2TK?dchXK|8A2*j+;n)Z13SCxuqgcn96LF5}zq#R?HibWhD
zziLuNjE}slN3t(YidppM_Qxg;l<L@o>&O_4orkExn?DuvN)t;u30YQO-(dq%OiMWP
z+^z~l7=x85gW<vxMx)W+FJgK$BEyr_xvBIG4uo9b&qUqGb&dZp@m;N)>DRL!;O|!0
zcOL0`uWtiC(rgCSE3Y;Zz&dzJUgsHeXTdI~VwB2RyD^Z%kky8SMR1m1%>+u+G!b8n
z(7YAL8^?)&d`U3=uF^gR7DXB_eT&kVH$<H2rI4y45v(7=)Fv4j=p!bOcOt0El`6`@
zA#wXX(1pc7HB3?dN@c$kP|u}jD-q#d-ionFC+x~-(UkRgRT-VT_13m%fulm=L?U@8
zjn&3iXGuc{6qYtV<oIJ10U<HdV5x8Fzw31mw<WEYMOhB$%xj!Fsv)ru)N<)c4pPbe
zrSc{<huM1#cl<qj4{S8<LeLmaC}C;EF0|RinVoc@XRs5k)x~^gI5(?fR?nda9Huz}
z?sUZ-(i3>lcSs9W_!{UTo0-w9*aActc<E$9-tGk74U|yGA3Lb4C;sJI=G3c}{5IRr
zaO2=2k62;}Cf_SJmYbWER)Si6^t5z`QWd!iV>KpqM?xnLPS>HpK$e)EXtXwFFJ+E#
z^Cw!Of;DRfm-K<VxkI00F|QIEJ;!{!OAF>IP;A`n#ItWdr-uv{Cn(JIROuB*)F3|D
zr?;e=q2DP@!;>24D3L+E(JaQr#7c6aW4A3!9Lrl7eq3jnI4x`4xX7GjUBR47qUaLW
zNTb`E%IrS5QQnj>kLgZ%JCp2;&<I{=iN&FBg*z;FD5UTfXI)n*nN3xG0>@K3^_mUN
zO>{jbJ;{m%Rf4Liy>Tv9po}a!jiVa8TdMWQ_XutI3>OBf?2Dr8Ln;hCCqtCkSWF9u
z=giONHAeG5ZvBIUE2{Sf)k1?x0qR|*x>FE15r~UoWOt?t7g=#$(aoX}R~7@is1je9
z12nR|hby)yGy%#DQ9}V2bs6Ltp-ZVM`if-7k#mcXSh<Fqm9FM<6LG9m_&9C_q0O_r
z2so8VM*=JaHx`8paV%Jl(iVw40Ut-9^n{Ah`XR0Z7x;JTAvm=S(v1BHT&;Bo2HYHt
zP^@uFNLCk2FSEP&2c?Y`8JLkIq|=MvfxG(<o^q1=c7%t-qC?tHy1j$WFw59_aBAZ<
zfLIVL<1HaZouHz7D#SP2W*2VjL$B6EpDO4(ma-N1&csu4i_>Vk3=8CK+`BsSKuN^p
zXj6xY>(xo){3g=}wn|HP<LmTh;XQ24>29>{kcN98#V^!9cx)|JwCDEomiv5f&-X{C
z`h0$V`M6Fmv7-V71Y$0gyUV99^m)L4z6y?Zy`x;WInjh3#FYV&b?~zXiXL@>`dHtL
z$QswX_qX-uXXS?cles3cyE%`^?gFtt{e!EK{Iska#Gv@@iR^to5sS#gWQIm=KDZrT
zcbZk@BP!=4rZq&f_#Pg?**5R))EqG25CH`aY?&2sh68*7fR8$)86$%(O1&i8!UNy^
z2)?44V}-og>4vc)cP9mx!}zF)MhGSjtLQF>*t_v{Q)1VSn&Ilfe^GS@PRT@AkEsr_
zqPLf>gJtwrkC*p1D>FFUJ7#CJvsPc;wfa-77j>_2-WvLr<mTO1dt6#ib0tW9tm(H?
z<VgCDlisap&?su^S2*Q0%i)541ER-V{4Po9rh;zUm%9`=RkhVo^{&bd$NqN2_#_zO
zU!}XJx;hM-LGXcJP+hL8@<PtSW#i{HCYF;}2C&&Zygbj}#pm-m%76R5^H)IEH2Y8V
z%kekU{!PEk>@1A`Uqg$D;eVI^)zM;N_`A#Xf9o?}>uCOszkd1p3;XPXFKWA~3M@~N
zwl&}b0eEQq600?dre@cF0<QgU$GIP>YV<&&r<>+w)YZ*Q#eD8ZQd^e-ufD&YZl2Ds
zPvQALk8Rz*pC6v)c3QIGT*zBE8gdt}7;gD`u6lpWUfx}T_x5=EK2NXRUEc4H<bQP2
z-1qdp9d=~Lj@~Z92m9pxeYyDgAt8xT3&DH5zb#*GX5B)r^7y;;F?f?qx#U0F%cn@<
zj0n+RLbqqgd+^?b%8&HuP56-75KjEV<juscLf^FMzMG!;+acwjm%f~M2XUUi&yDCI
zGQ5hOgNW4GQGHGgGkOFlVIG0Er%_}FrsFsD8sH5VcZ+67zAIDS!t<`5Kl`a|mTp$<
zCUr;*ryPoXL1-XnFh`1Jh&^*iK9BPZ%S<M><#(h~Hdv5S`}9M}XT_~frk@$!DuX!Y
zxBWsV`4T>6hL7{&{QbU<magB<yM(@U<iYq;zh_G3{H<dh0y1G<o%-8RL%%jbm4P8q
z+ag`qXUt;F*-6G%3CW^zlR|f6C3alH634e^D;Ap8Y>;@u239K7L?xpGqDc738?dMy
z#hN2*l-Pi4Fkc4ai$=m;rlzL&gANkw4kj{H!q{~UA0oV7hM~1UAm8Or5b3EtLAU7I
zkj=4K>~^Neb^+Ug2b4{Z1$Y`7?}J8FH2NtIXlTo1QB2?}#AF0NfuO4$&;&G$Ks*G7
z{Wpn-GTOI#a%ID4seT%w)h{XO@)B)yn21EIHtF~C(h_UgY0=oi(6a}=l4=6nWfiR$
zMz9cpl~dd_;0S9NMJv%o<|j)x0jN1aMnPaFw8qMj)Z&<nRY~C>y5iXUAeXKEO}ZKK
z_`g2ir5ms|o3JJ;5tEP_ocqi@_r;`AL@57UCA6BOfG?yF*+kwA!fW0A7Qh~Ciw~g~
zh4U13ljbXPW0>&tDk?!9q@<Y6mU@u8xp#JIDj$Sns^0{^qKT!WnurB}&Tj&tLEGGE
z6mn^EJlGBRI&RzpJ>J>G`5KD%_Xl*);p^?~>F)ia1_*hH%n}bTciXg4a$1K-*3u(Q
zL?6Ximq8BX070$=M;L?w+R!1s3rY|hr#%Qf{`SvLtUF@wr$eiDcZk4ib;m?Y8n487
ze2QN{+fY2D*zUh6c!KwI2tQ0LyOe6|*V{J`C`mwc)L3>!gUZA5BcC8(YTjVdfnqPm
zAbPBc*hP`3l3sIGw)TDU=2do7K-K3z)H7B|mst_+hnwzJ7pB$VY^An%Wg>61MI-q@
zV>x$)PKvQ_AZRrbOlGPpuosMas7G6FBXBCZfL>2HgsqLGk+Asow-Iz+3kr$SS!yG2
z__EnG5bm@W7Mf7SCL(t#POn#6z84O8pf?oltn4Vnl}sx-+Y7;s6kLoIlzTs>GZg;z
zIeKzKaR!qHb!?H=Qv!&kW-y)JtcDNGu^<g`Z=|Zb*^Ub#xkszy%;cr`y-;S&*vS0g
z<|N`;M~mQ+O6ftxntYR*9WcYlx-H^BWGH&zGp60H{Oe&+TV64?20wa7vTu^8VzlLL
z_pxjvC?lqTlvAm#ANBEN!w<@`D3Nh8OS9@1eN`2arlu-vwpyVEQ}!NX83t2A$c$f8
zW+fpS+eK7Dz8*QPVev4@8AU@^ML4B@4uiN?T*64`JPR3pqnQ)YG+ItWs}Az0<TeIy
zDgD*WhIXTMyy=JuRcWhSIE}Q2D4Xhri1FI+Babif2FFMtlIEScM_toz1(^)*;>lKZ
zQV;NL>l$obCtL%KLaQ=j6g;Ac#q$H8`eQy-MSaC)10WgH6@Z&_a(8Dr`xb*=8fhIx
zq3)N*?*!OfxJ3q4&^-uyFq`DGfw#)CULYPhA1ImfbapmRDX6o!>3O$!EQ|`wA|w({
zQv$`ZQPNX80?vpxbOG)2km{$+gRi_y=2uLqg~%M~`~1SP98VEK+!gtG0!50|b|p4^
zmz~^2jo&sE=#m{x+x=NQpktL<=GEn;^ahUgh$5mj1q-8Zi6IWi)|3YeXy>*pfsC0Z
z7u=f2^G*xC5oY)TnBL@EjJgY(!VpuMW00e4+71pW>=#V<$wo1#jECLoAW2tfoa79z
zTE)UJ6`hmkcsRiQC_2h06ky2Fy#-gnRQ~Q}hq)`rviDL#pT!s^u?dWw66Nd|pM)Ut
zwXp#m_ArClr0&=$j*4sC*u1BNh$&(S+e*iqZD8`XHghu(j>*5IqVUXBG6!7a+6>51
zV{+Aoij(yz9JOc*WxTj!w$27s!M-)1Rt-K^U|LsS3zYi_<*T_sIkav@v&uB$x<a#o
zRFv^+G&n#(Qzf`LRcVq!Ol(kxOzkTMjBy3f0zV<5T-oLW3>y;ZV3hIc`N(hM+k(`y
z;otSVod#E--GXg}xmv%)0}M%vV`#nuy@dKWhb46raB%a_gUEw#gd3*rv_B?n#r7LM
z1nSuA?A*SZzl?$)l=qs)EzF!KzG0lJK{)WW0ALF(%3;EggUzP4&dlG-&CS4K)T;eK
zmMWv*K3c_b;B|zZLcaD=a%A#+NvowL?no(zS*XYoC>x>^DWjgILP{JlhyhZ6XJ*~L
zhp#Wgc8m%k47yjdxXqDIAC5LP$3juH9%=KIpRC+USx9_MmPaO%Uy0vp2=H6hxbOu)
z1P3%LhR@AhE<kBEe_Y{}9|AViv=YcTACRSXOEeZX3S?dLqa!ej!kN@I&npWav|1_D
zr6FO9HUQDZ9S4M6NkYj`_b}8s2i2n%+s3K2jp*TUg9UN`pLW5gSrN;ZAE9Bw>Px=t
z&quwSz=p;<k%0jkfxaUvK_s;or^G-`5y|=DExcu{YL>7>s=FU3VJ(>xY8Cf#P3yEB
zuI8N{P{y8k_QZ^4RMWMRp8j|wWaJYwh3u@cgR^T`+gI4rRe`CfR!6F33n}JpSWIW~
zk7cnlnLjQE8p~BZmf4)qIndog>455zwC2YNjX9b%173lOsg|dGrV6Lp_xNeT&B)<y
zg#o{cAn|uPmVmuzTf18bAb6gDwag=<sv+e%#t79!jf&1INv7OC8$2szT}wH`#nVJ(
zErC`^Kbw%f#k_u+$cofL=}vMJo4AtXVQiu$TIhmZCWDodT9z<$O<eB?Cwo*DE-9p)
zGeDbze*QMrg*yr0HvM)bCS;9w&=4x(T6DmhL?k6i)SlH?FuU9qjI(-64Faotv`-0X
z0oY%D$4x{CCDHH)gDiCHLxNnP_RI&Nb+Q@{E;<A)S@+SoF8I*D|KRH7jYYbPaX*yI
zn=4Fe%FN2gZZIt5Y#MB0*HnXFXP1|8Fp}d^<}Ed#%V{_@KC!?H-w#0E9fTB;a3A#p
z51j1e>Gsp|S0-ImaB?N`3w}2?$x4+{%~ha;8Q_5HGev{p&|=E~pc{Ipl2yfgIt{E_
zIl|hxfs%?>l~HRhbew_O66@Q5Q=`SQ!dsRL@V?ONa(EtK^5!{G8P|RARm-#6_>IE$
zOFhCDz%8C9Sk}*q7^QPjTkfPLSR0=T1eMYr#>fLQd2*&w4zaQCvJ=SXS+sAITj97e
z@SS9y7>;`j4-R;cxa+M_Pysd?G455RPm>kO{sFzJn@BBGhqe1Lq0Lon^x&Wn{W(Yd
z$aNHdoXSmRNRoanl72VMg%$By&Sw~6c*bxjy7fh!H(8a?n>5BDq#Tu?oS;+NGjoxT
z`0B02!6`)<j6$w<g)PhKdstzTceSdk1TYn`jbN=>E1OHD)xo0cu&+4|<$h_-jP%bF
z^pdgu77fB&QS)x=F9ZL%qmnOmp@=j>%MkkEoQ42PP~O=Sl|en)laN7^Z#KdL7;;v0
zPvBNThIaNs<N!Iwc8ERAPs}tD&TWuA+b55wJydLT1B<?OVU^S)J>@kk-Xr1Kh3=v#
z54PO*@pq3)@VD-j&b56PqWNiP_4=Xm29Em%Zdp|ahPXgQVlGA{&$D`hbNvb1v{U)1
zcl)$iQ&ABAvvMaa>T*;W5S<GzgL#ptO-&U$?2m_CMzyQEX|wHKubw<GzidzuQMZuj
zeE`>W<nt@Yn7l(kj)bb$HXEAY<ch8(4x8U+ytClcte1uJ5@n|E$J6NKW8QnFF_bh=
zCB`{Oo2eWL^;1~5sXP3BKHgui&q#k(>W>kGl*~2J?K#)pX>Y-z+Q5X=`uUuB;Cf}A
z8ATHzx^UCf!{Lm8@LrnFD_OI1P{aL^xfi&5sLRMGWjJ+q52!-rDM5QA$!;H{Zr`M3
z@3~X4Zp<9;r@{JkA5hbjOlN+l-Fr6d9QqAt8<j4Gc!J?97U#Do#YlteMvnIw0Immr
zl*n=opekODd`hq%Ua6YgI3Z(0$oo<GFGXs)vx6X8lkLOFAWKsA&>_8J$sF(8*195C
zgOlO*c<W@cTJ=eF(e{a|w>^9`^(h}sT*=>v{ajy_9Fy}D3*JOsYi@Aw40&YG$mN*1
zXfav`@S}_~)=g56RvE$3uOVbDk7ZZat1c*teDyv4UX(AVh(zWazOX$|E`<l#q3?Np
z+X)pUV`&nE{jA)9lv}Z#aV!iNoC+6CAdQd79*1hz(mdbn+|u1W8}1*^2syJe4Zp{1
z;A|yceg#+l4amjt1HTY%f0c3T_5*A+FvIpA$nXEfxqrxyg@fT=<j3~EE&6{WKQ_+)
zg8Wi7Wvxlr|Gr_&^1E%nu~*AVaEW1w7Z!43C@By}2rjz@mkp4cF^uGgPgO~h>d#nA
zGqkaLyb6_SPt^-abg<2LuQx|;udna>=cTsuJIC(VN`x4W%F_FD0ru&iLTf$zY<zx}
zId}8d?}LZexh;07&xeQOy<Y!U4nJ;IBMdoY+0dW*zMWh;cclyAEsjdK-VPs2JhL5%
z4V^r{i(|*T9=4&m^xK=+^e*|S$VuGo=V7;Ydv8Z1vv&0!3viE&Fz+2{Zi#2YK@Ll>
zts{j>uMJqG7bBQQl~=bU;}+nfevy`wl6t+kVCiZuHo2|_D<+1c@+`0=YQ}AEEm<qO
z$umJv`;_6^)Xoc82C*%i^VVxual8V4C~+K01fQ-bz2H5vYhpU4^qt{Wv8*WK&?9(q
zkC;(eO(9ANoQ~@u=mGQ?!mC3UypbK1UtZJ;7H1D1s1^_)XSNm!CIhEdOPGjKrXDel
z40G&T?h&jd5x#{iVMU|zP>iNFMe12^DZoL%JYJ)EcLDV~c+~nAI*j^|F+^K+X(nn%
zXQl9tT%t!2*@_|GlF(V|&mzTR-M_JzyXcB0ASj$<%f1%8aI8OG2gq6nhiE}IW^u28
z1lt=}D&2fR+Sh@kA5sEIxn*rdG{YdH1fncQ$?e(L3e9$Gj6^vrTKARcHiP<Aa_@c%
zu?=Xl!Z%63{+Z|j(6)u9O9{9RQBZEBkX=25(-|1E<H~&D$VG>ft2bgihJ)lAM7u#(
zb=j6}W$0JC9Nv*>Wv0f9lnki#9uI*2wok=!@x&Ihb&)g%gE&x>AKB}V<Nthn<6J1(
zE)pf>z3T7mhTq~4p>HoO#VQ;J2+^_#>?<#S<>pz5wpD1{)L9}*w-*J%7$HI(8|<~z
zy+!W%>keMY?>AhLK2FD-8R%eXRo^}X_lZuDOF0!F3(7-A0RP=81GPdG<b^=k{5DX4
zW!*t{QBEIxI+cNpsLrZ##sC_cE1)x{Q{Cqu72C$3^g+_B6I*W9T@e`Qfq)SPT~yEy
znK~_ms7sw)8u{WiCi@xjxGb@YxlHEKP7`UnM*A650*qRQ4VB~9s4Nxn6{;burlNKc
zg)4#(HLNw7K`fHn`b=kL)Wp*~igL7?{g-j+0Mn(E?lq2Q8O4WvhT{f}nF^>NX}I;^
zkd$>-sUY1WVLx0K)|IV|4#COYHo5CZ@8}sPOQ76tD5_ZMwSrF7KZJ7RR%kf*goJUb
zt@|r7gNQZM$r*KNz1mIGE83M>bX`){bt0yv_4CbDtT7!FX}M(i5R?0;to50=y={~x
z=K_rj6t|x4VMnkM@cC*7R*5lULNmvQNf=ogJNrc)gLN%9eTkRZwBl~o_iL%mNz_CZ
zlx@PE^d{&glPVjDHm7{*Nz$BV%EA2wboi16i3&WSu5Tn7AbG2*+Va7f1Yi82Rjr~x
z^oE60&YO~JT98&~R?D*rjb`Lcn{S&UkyqXnzgQ?od%J8#79b8(JCV95qYYadRn{})
z=h#i-Hj+4Z@nx0<$#GeIgtE7VwdX}`z|z^XOVeE5FH8a>NLFry4^Fg!!&)6Tq=-UO
zvcd56MhwuQDk5tloSWK+B1n{+Oe!Nu;wXJ|kl|gjnW0K33G|5@<ub=$#6%`4M2<1X
zSLglWH?8Zpi7fa0eZPrKt9K^T03QO6f-DO6DPPeZ!nYMWhxER$+eCq5&8Ty)q$2h>
zr$6&Z5JCT-xnUYcn@m;URX;jkaDi?Z9JTDB;a>S%pQg591a8_wdhni8?yiMiFzSHG
zDE2I`k*;ki+7(m}Ic)d9<1#nP_;$3Ql-`z?XQz`HU)6MR`MJvZ=BLPeF}qXJ3m?sz
zwilB~voMi+s@337eMIT(BRc1<WOF!RNAc{f)7Y1u1w7m!muykh){Q`)w&@<oyRMUY
zXdusZa?LUl7<bDbu5SjEY6id|q-?lVj!ucnC8`5rWI9HHkv!+0!<Fegn(DHpf3%=B
zA)~;E4?@*W$*M*XPxbjYi!F1CRkr7ryd583za3vQnpSMhB!uK;byey=Euv~#@#!T#
zrJG0KL1o@4TTl)*!^ju7_H#$OS05-68UAsMNVzK&#u)|1jA6R}V3>(;NJGFXO=Msx
zD$V4|NF`rLRo@@-3gno9!v(qHkr2$AkaKCs<cv!`FyrYuD4NsVMySINv*?HWj2<=Y
zEIz>d3MJ>U=7thxK(MJ&e#O~14Ou!&xD%qN9Hg$CwOSR5(Xyi0>EScTsdg@;M4yic
zIzVgl9MvN`TmVx*UKW;LfUBOg{K+ss_}w=;YL^|kj(~KY@li~sRTaBMf-tXr;9SvC
zM)(_ZpZnVk;hb@{fR@CMJZ@X(lNYVKWXFhK4iN4F)Y}Vvei^RnGB$KPqCl9iCrLJ7
zjz<2jr|`wqxAvz~O+D4x7=t9VFtoTNOqtPdZ~_B{8+UdJ59L)8vUWvNyWohI72bEx
zq&lr8i&LZNei$}8#e(OvVRcDcW2ED&xqY;+M`gF@qH<WJb%O`{nG(AaAr#98xu2;%
zer740;Z*q%fB2Dl`#&Z8f3o=B37?UZne|@@pW{Cye2)Jn;WN)Ot5BQ*0f0~d{!=;r
z{|%ln{qvE3_G9_iZk&w&Q*Zt^d%^kl^}qjHVYyXXJDR%V@4~X-xVC|hi#jw`@R)5g
z<VJXCAP>$%f{FVOSp#7>u;jO|)C-kvC+}1k;E|)dbZMuL>L1CO+0Uojbon)UegF6S
zIsY#&uaD>Fhk9i0#%2!7^0^0-Tps#zdj6d6*R7>FdiVD4bL`%_{NA1~JMPA*V_RwY
z{=M|Rp6;GL8Z11v?c9~~uaBj2aDGU?w(=Kz{(3Eay%DQp(K<3eRP+foayp%l{0<G!
zt_anQDQf-N=NHb`Jqmwjo`>?6y}s=|{od%H?w`B-`aZ-f`k&A5K20LNR0(ZZXh@_9
z<WoUBN;<V#7&B+;C3M*4=IZ>YP{<*99FP@i?;-x3L;lYL{t-7ty({(J8lMh`SKYG9
zyNM;{=}<$E?Wxi}0(G~pbq9DJB0O}DoRJQcPr8^jNS}A?A!S3RSFGE+A$#=nk>G{U
zlH!o?!!-f{p9d}V#FCJFo1S~tnssW@Z(yX1C!3_sE?y|JH!=_im2|rMCt_ARJ?mNO
zSm`1b&EqGcVO3D-5%R+zyK^_?nd5SepeIX=Op(2i82Hd?B3fn%mE0(=STwAnVs~u*
zxsN?@c@chQB)-agQD(A48(rt5b}N>;vZ$CAfVmDHkx#-p|7i3GuPNJct_^eh`%@3`
z&j~|PqQ53o=9p2F#p!{JiOUD$GPcc-h>(qm<(nxjj7UmZ!!DCr>9W+jP{mtTsFMaA
zZ9MNmhU73)k?{f%CI!JL_D?SB5P$#VddJ`GE^!VezF4@e#=aPAq0M;MI*1Y(Lbur(
zxj{!uTv{pwjoLLvU={#o>7c&0t3oqNegbk1(FK96k)H+SvQ%+FB-F7D*fjo#JSvOh
zcc7*(*Q#h;8rmT~ZWD>3KThj#&8Qhr-~2{I7Udk!Gg9{rAR-}gLQvz$E2|19r?o2S
zW`-Uez1M<>qv})TfNY|~>O=Hi+RiDf%fTSUWg|7$2&fk1e!3*_clfeybseu6Hc!C8
zl&gkteTqR(8WeZE!h~V~JlO6ULxd9eW1{6x6$iX2Kk6*WCaMz4+)NrZd3Tb2nGk-S
zgaSGEcGl2bdM_FjBcYU-1}3`VVd<mU&D7cY=4Ag6qO8E_X90Iwp(5&Ub<axLm&PL0
z!^7zp1#*e1jFW$%N%wsNguU-U0Bi4T|C&c$k;xsWAWA`j`#X`eP?bh(L-IyMK{>`%
zRSSV=!daya*FdF$W&-{$*EtA@)Ws}tU}YU04k$RY*?P%X3!;h+rw+)1ivS>-@llM3
zJO#3>wt!ECBw#dej@l_p9YsXua%^}5OPQ#<egocnp8+`O^N0{wK(0{5dD-SnLom#f
zU?Y<4PmE~ddbSkg8hK;E151SnBBNCfnCFqghgFI1X_vaGPMB?aPx72Yxb&U*6UgW_
zd6jp+W`fqXZ;G`2z5=g}A*HsfD5es7jplmRBGfan&H%b4QoSjmTyzC9g|kSH9FT@a
zWO}t+jwdK&wf(&F41g{Nw+fO(T_d98hx#I)+@!6o`t}4hozN5W>YDQ<bvkyRd98ka
ze`}Y!#bHV-3?D_ag+-hIWw4%v(gAngnU?gGpyZWO<Zc?kE~_aGt8T<<Sp|N2S_uOo
zCjnWwd5q!7XadcW<Q!HppW@cth&bB0mRAatgL8L-4iLYzk;$RpN)@9fD$Hpo$YO_A
z2x3;0ljw&}RpX<|kZ<2+ii{w7BCd9nmJmO(gPN4mBu#K0jv!OI#ak#Ku>{@B1#f(G
zmSPhr4QT@ftm2bVwvc;${9kofY#m`#zPe2pnjG^TtB||i;(k$$+8l&K!A@6<7Usv%
z(8(F64CQgI9=qRV`*(!Lu3Q48vvPps*Zt;jlkAWKJf`e+wj-NqnH6(SZ4tX7R|*dL
z%Dl1ZnmwG{HM1*;*9}kT%+0`3t>l@(jLYL$!9^BEh?N)`z?JKHIqZ>&V%U{29hu<=
zYMPvki7jz(3f38NtiO=7IaYovjUr$nKJryE&E?94Yx=*QpZc3LXfbHqlaSDWaRum&
zt6KQcLuVi4V;|%<nQ{C+MSVk-T0#DzHV?btj*1*{Q3XCxrBK(E#1HKU^*o5+ph|dN
zMI_+++Q&cj5s+j$0AAGJifAdJ_kO*sW62-tJn{Tx<@ps90}H`(0rf7MsPM)Dqb2v-
zIjxDnq6S#%14T5pRmpIgyVrLY2)aVS>k<DgT2=Rr$0{&9)gV$#h>}k`fKAU;`qk2T
zihboMEYN_#wM)Hm1<P1K+~9P8=P?0nuTVPtbK=Kvj|f~Y2D9$~qh3m7a3HG;8`8$&
z4>3Dqw|uL(3}oq=c$!N@=0$Ef5;P~A!^0Iu1)?$T^)4`k7?}<-$x{FWbXTzO(|oaQ
zAD|Jhshv*nX^|iis%fo&sya`j6He9$8UEoC>UjG~=WLp{+e@m~C0<9c7S|ySS`8>F
z4QxofiPfxFWfnAhjwh=60K76QzTL6&h*|YS%awC3LjLWEgavNC;f@pM=BuA&x_#_p
zi>jB~Fk)^NjZ)J_i>sun7ag_jmVT^9k>e{Y)RKAe^V$)9@i4ZjwLfmeIxPbgGQa#9
z8j|ZRws;_T{0xS5?}W7#z%K>k7+Bt+IzXP&K+DrbRWna(rVA>)#&&(nnLB6$C$Q<1
zZR-uO*h%d;1Gmv&-bVeUlzJ4*UPVxZ6P9ibn;U2JhC=z_Jlu{CSkgxTQw@ym*GI_%
z2jz7`Z{0&uXZcC3Pebx+c-ByS!3>89j=TM*zS>_@{!bIwyZOlvG2MO8QV_kHBlr=A
z-^Pzepg^PBhkqD;7@uc2?G4kKOTK673%Yo#YW+`~Wt<>#$_{d1Gq6E=jfdith=6Gu
zkp*aziPpp8B1_Jy$5)pb+Tn<Hyyf-?L5LLl3eBh-<{}WM5<{&Br=PEH1QYL0Oq{z;
z;g?$%Lo@fw0c?SRMty$<&B{c{&D3Y&g&3XNi1#v#^dDeqyJV!`X<$EQq=;EitBcMQ
zC@ez`J&<u6<5PA=aZQCMX4|-9`l~6oaN!%KOsa>f4&Dpp7{_)fx;`4<;ZQZKDb!1H
zpA5gt+PiT1!!v&k9U}>J%i?Jhwk&U=gK(1xqFMer!+?gs(R@V0=YdPTOygYfz&n4K
z|4@mRV!V$PA|jHbtE4hhz~lc&H@EpZ8GmX}Il-dk{DZ_2McpsNW<1}{nmpj}B{DIG
zj|x@n?0)97T-y+bN)RA^_Yi!_eV@3-h{KDy+%c6ulxz>K<&576p5jy+yx(l5X#OkB
znY^6nPEMxId~zcz<|8R&ZK*mBzXx$rI_|f)gA1z6_7HyXt+IntRGh#;q?0e6Oq)dS
zfm)D859w_@)JwU1Q7U5+XD2oSB7fzTxsSJhj9^>ZR&a@FL7#AbuwDO6GZV5v=~v+h
zxUDTPnN5rH3Sub<3V1mRt<#@Vc8oV4;au*utMR%|KLxGlIUhOGblb{18SNAgQe649
zYgq1k&7r4l#2=xu;|6&UDPhLh3-uQH{104}>|tDig|XeI7}}k9(ly4@P5z9GYN@9c
z2}Cqi#bXk`$`xv;n9GYSQ1{na1QlR&P6*oG48E3&I7_}I27;Ze<oq2#QWpToKPVO-
zJ(wABP{jvW1}-L~SK7r-jEEdmaS+nuDdH|8?8|@}PG$&Q>vAV~*YtF~kD^wyn&OnD
zsVeNpEkADR%^7M+ONe)1#%lF1y=f6;G^}=iCak!Sj9O4RUAZ|^uII07E@ov_ZcxI%
z;e4&ao+?{{7t|e7w-`OSc+Lh^m{QPNNkCM7iwF2)&SJQhgxBk}c7@N(VrJ*k;Mftj
z+REws<Md4|H|VW9I-GZ<Ml65=GXSH$sGf8kHNP%GSyPFpFSs#o+oWY?FC;~GW!mmj
z*M)WBwZt~_+C<Eomo#`QwVTB(xOovy;D@#c^w-;m$`rd`zAqW3P;GefTD5dO3cpVK
z$3_I|Un^FlCQ%(EvH>J&ll1PslJ!aBwWmba(^a~{-9lUOC3DzUpjfcONC9eM`=(4_
zFIHMq%Y^8+Y|b+d2-PRpxt};p;%5n*yg4W>#4I3c{ld4YFQ94vc+ls+C@h}%{;FLD
zRCdC{HN(QwbihF*8$09XSx1_(+wJiodR5%m;bjK860{bBPbV18o&SMNMJ+Z!mpbZq
zTV0R6Fpz>Qx`6j)*r^;@h;H)uxIoY#&mD1V^&H7P{fw>E<Ow*zUG<Lxr><q1<Z%84
z)$g7eSa10Bb^@~&D<Ch9FPWr0F-0lS%uSkt^M)Ojx!?bFdE(MHa`Ac69$g=c{gW08
zdAq5B$R;@0byyG^-T_Tk+Aa;eVVb6yX;1l3K^BkoOSxpv@LoTJf9_)PF2GMlv)T~J
z)U90-5|kL#BQ>t(rEBR2Ko_C$Kh2*r{R2z?lx>+A|25Ii%=CZGt1vVDH}fjF8q(26
zVhFt->JU!Q>r1*T@T?Glwi^ivyfhe27*6XZ=0hiql3{^1-@aA(RFbq?7{O!2u4`Sr
z^_?SfY(I8+&-M2C{JyWpwVd7DcHfpF#BTEz<?ibm;azQ>zLtKUZEsDS3m@fEQ)|EM
z1wKF5#(p|)&Ufy+3K4z%F&5R{yT3a*b=YdjDAfjMS=0ZbSWIln?5XloIJqx1cZR1b
z;VV<}Fu&;B`JS7Q^Frb9y1mXPlRf+Yhp}%A60J$LZQFLAwr%sYZQHhO+qP}@Y1_7K
z<1}7>b0hA&h&K^${_d(Bm6^38Yv;<$Rr!hQwumFQo^d1FN4`lrRI!BA{2Q6Xv|_`7
zEB0`n1B&KdytTyEc6Ko5TA_WE?JwW+r6l4%>;c(5jR^EZI_xhES3yt50k^|q<T+N>
z9~3j&^KD`+-NZ~;e!mujZI?C<#TI{Gt9hKVf!-7*38;-pLE4Iy66q6z(PJ0>&86M3
zl}VlYt1gIgp1qGLAB~a}KV6_Kf@vzF(l^%hdDMFTg;x4kQbZo5Ga($j!FLFT<`4Q0
z3bCWBibEy-T9Ku!Fd0+~P=+H#rSUBrR*M6m_&z_-FiArw-p_9wZ|^CUB`aG6hqo~c
zU0RF(_3<}0bram786IY6TBZ=rbTu$-B<B+2RA^>u4MwCCbw0~1xk(QttZm)QFuH}G
zD#=-8*0#tsWO-Hw0m_>ov5UtXX+_ZTvcHXb-i;+h$xI=<Xf=U=6T`pc2`nDyn>8({
zns?!4FND)kaqE6y=?G%8T!wEq`{{fdt;%3qoY|E^3I25i747?4IV|>&E+s4N5FYVb
z0V38Yj)EF*yHbvKe=i<uPx$kX52`F|MJGz6D0ek^Pk~FcvOcP`lO=>;sajdsI!GV(
z8Ra47+AtFdlq`IWT)4#OF~#Gk|Axajr_nG8hB6UyGy*=wxXV$s@1A^%osr2A%u?`)
zlZtIOQh_uh+9{WUFR6$IzfzW~(bRT)m3^?W92Ay~TAstZ0ilXR%&d%S@-5nDyjh<I
z(ur3t#L2Ll-3YZ@Nk-dVjJn@)9cocQ6!IK-m&kC({xvKmX~9~$yH|`Ms9zEppL}pq
zqKhuV(B>5el|~{S_=8Y9=t47&X)WqNaf^}DQo>u@@Od*x$jXKN8+!=5yP<%ws@LA{
zgEeB8p-hHU!+V3Gu+gq<@oU3IP?9Q)V_+$JGL2U9X2#z#k~EJh&5I~ez?&)$A;&DN
z*6&XQijqK5DXE*T5){(NWy?W+cwj3bQYYtsYY&=O9aO;P^q|J*Nvop*Q6N*E0{D<h
zV`ehr<E$o&Gxl`i#*lh3(0pG%j$Wd!M(ednWy45L>sVZi19{-s#srr}fr_djylVI@
zDx4qt6sj;zoA=dYmkJ#^|0?Wd)2LUkQ|(GMa>uwVr8~nGpx$;HZrq&EMEA!=vT=G}
z8}i?V9lBhaX=`{5XPw<3RWIKcS-Lk2avY{)<J%^Q&M9BU1naJ$$8^UZ9)UO^3ABX;
zov24DwqaPVFygnYiT4gJnD$ZT1lg?{w2AVND;sZgy?~813_%34+lujf!IVf%TL?}6
zj#9tc#nZ09NNp|#KjUY2a6;4utBeX6F$SJ2M6;zLBuk58)A2DYf~3P6_Kf!Ta>}9x
zT;b4~ZTC`#XjQ`*>I$~XW^n{tvyO(kBf38Gt1FU5r;6eWSn^9sK~Nj%$_nKjo=m}-
zxUN+r(6-Q*+)wVk-FtGgwDD7M^HG22jS@PCHNb`Da5%>e#=(}Z7d&oc3~`S+K*D}f
zGv<f7QEQ5n`}>2k+~UFDW0NI)S-1zMyP?%<4*i}iJSH$fXF7msWZi-6T+o_yQ#Wqv
zr6gzo5YjV31V;gJceX5YR^;$1z;CB?GVJoGgk5DfKlQi&9tET>3>K!0pP{G}+%sBN
z%Zascv!o)yA2oHa<SJR5!CXE>lw_S2MH`z+CZC6yT+XcfYG2?a2KK^dKP@gge6=Oi
z#)exTJh*Ty*lG`kC0=+e<6IX#q0Tf)Am;oX$RC6p9dorf_cHa(+IeyRA7H@$ITii|
z%dyZi{Vy=b#PkmV%s-F+4a_ky{d1`N|A4t}EzMYJHbkEtT?QmuvBnWsSINS7lMYjm
zFm7Q^BzP)3B!>W?Lx9j<{k^5*D-Iji6C#3@S(7fE6<0S@D?^Iim&v(b5BGb|N2T~Z
z-^a3i+1I+#bl=?d$eyTVJm;$J4TWB~GP=CkU$++vC#m3@-?!NI?Ov}I?^j+1D;M5y
zNVgA1GjuPpbb(;{6U<@WAJ>n299isM?_XC1O}H>@jm9R78uVkerrwBF%mM1=!(Jn|
zmF*bLOSiF@G#{op$M&BGBRk#Pyggo5rFTEMd%jPJI@|BBE#Ct#H&<S;uO%Pe`@#0i
zSQJ$seOFRDtV<W3Na%%IsghfwR;!L24lj%vEuGg<5jL4%`&V@>Wdini&(_KzK+_r(
zX1i#t575$3PyNMVQ8>24V0D7p1Coz~<D!11t<pM(FQ<%afj8vR-Q&R%da7jFVE0av
zKV3mxVJFG(_6Cg7Ou+rlIefWqAdOJHQcfJKAB=m_eCmK1mrvaL!uy=4>IxceK4suE
zVsHK^?7a%UD`&E|3dALkRqS(C!o|sE<yayCvVUJwm)&fYRfMTzRfec12l=RJXNH&D
zB^wbz;A>zHHVZ!4HT!d((&vkiQ0FYB=YGX4+dav&w<{t90|p29e=r>=&D`P8XhIly
zLAeB`iYDFunlRdWCR9$7Z8yZ{^L;qr`+BChR+(F`K7f!JF$4bQ)Z*Y$7X^_Omebw^
z;QjtPV$0|Krn*R}slk!>$Ex}n79FTE{(?zaI$O)?N3HEHyd;E6WqC+vAj~)f*;oCN
z+tP%{(D;CGOrNy)Q-*4PhJMQ1+HsiaMy%V?ehJ?xjX;k!)L{*46Su{IE&mHUY4tN=
z`=|g<1)fcEe~lqxHPh`Jq2LK`{7{eJ0f{T@^-b2$l8L=@;Y=L7_*)#4aL`a38xo(%
z%R5#y1Q%8AY5H^jLM`T`7+af>$%@}1#CA*so|RQ%zy#mkRja5fl+CtnpRMYc9aU8_
zO=IJTkTVh~VpUazWRqO=*s67!<e-O>aEES8Zw|B7lMRrYUw3#d?7aS@*`5F^KqgSf
z<Y@{LRCeeZm6*J-;}!B$u-C#8<#xgcBi3QN9@p2%B|gAj^C`bY50C7LFkJDq7b%Uk
zdSh;gquCzD{%91V3w`5lXXww|wQw$xI*Jl=yQ&A&g?5SC;bFOhkO~iM@%cf{>C@JO
z8*&ugW0;jub5f7q(`=)jwy9uF6c5-BFBkY0zrZFI<3>FVe4i_2M&ZWaMj40m8anjH
zUAqh+rzgasmPic4T(hleV+f1Dd=FPW1Ulz?)A3QocQ5}9fjoxu>B#r?uAuRO6KD4c
z8|?X2kniMXi?K(=(DpO_dmHYfL%_|uLi!^{%<ZE=cyMNeVD%U#9Nr5}sAFG2S<I0v
zbsz4POYNSfs7_?(iJG3F!`4nuvDh^$Fj-CK0u=6=iydLhtcQ1r6#Pd)aCO2BJEk*m
zFq~(>ZCAIn-%_qR6DjriVLKOpB2Czzy|7>>%#>Xg@NPQ^+Lt>azYrneeNxQ)ZZ6n^
zn{z5BiB-UQAwGhKyLZ`$D#3LxWYoJ$ThO*nH7>S5zQcmR`6N+x$#w$lmqbMjpSm+w
zwn<VYW`Z#AwaqbUKN(1`@gmn6?zk-I0H<cpAmuu0!f~HHp$zBXbCb8Ffqqm3Y7i#!
zvf-bP3c*7vzX(_qXegyb{R~q(+X^}i3koHcL}BGHFd+@W06ro%j&kPm?ULsGL!d{!
zbe#yME#!XKi2h~r>+v>{5{mQo1*N3{A8M$Nzs<J`T!%T}*B8ndLz2LHcH58wxU7yI
zh}MHC<DQZ=;$c5W2H%bQDI|_RLSffUh-OU?U(LC}B4AG`Ve;p#>d)dIKf3WqD%BCW
zLH$8JW$7Eh1F$5~Vo+Z3hpXZl%DW7$l(->P`!TSZdI6B-HoOd962DkwBt7_aj)atp
zka)E#be0ej91dZ9vKWQ0&d@;o835c8iAvhWJ4S78-t}I=Uq#3vmLS(&?LhRQs6W0e
zV|Pvi+q0;bBzgF4i+Sgi(};DYNr_v3lrOf3cf*3neo4v!0X4y=irL>LDNH9^P3oij
zPrR+<fsQ$l?YeQsfQJx;G=3644xkq~J7b=Rttw8G+W=HP*(BHr_b0}YXb{gPDssHs
zuaR=}WZimri3NEF>xvC_xscsf;E(=dU3Sh|*BmLg`StS(kgsq*a4rd)X+s5mjbC0z
zhk|D%)e@{~^R~3u&!&kr48FGq1dO9tnJpKs3)bSuV9%e$9C{2>jp^cx=PgRCDpovH
z@8>{CJPqg+yCNSFA>kcT-^s)c0U6y%^6NlaD=e|3uWKfj`<PWe+5~tB_XlQ?u<}1c
z`ZQ?Y`^pD)U|qLm2|U|8=OUIR$C0l4ILrPn`3oqG^H}kB#B=rcw^5W|O@50-C!B|u
z<7mv2MBIKuP0Ql8h2%@1($9j^KMT%M%Nv150;!r&tAlEk{RM&C81RJ)wp^fEp*{S(
ztpyP#y?B?ts@`$p`=#Q+w#P@fw>N_X`eB?u5d*LUZ{d*SOjG*2?9hR|Xwj|7kDFk}
zj~EVA#^FBlx-|<_CZbwq6GFW5hs^qX;_bUBxaN_j!Wg^As2zQ=8KOg_o8x&ypKiO&
zDubA(a3VzB4ej~pZk7E!mswZ(8jj@3t6iJ9nJh;WLy3xf9V~Rwy}YiNEed;~1FCP<
zPz+m^hML255NrvNTc;&xpH_oaVcR>>qVxpW0(UjK8P>|lTY{)k$G{m{I*!$Ok+ccN
z$7|Ay22tgOWUD@Qh3d9<Y<7*a(`A>rqmh*tYL(xpf{>+*H%^HSxi8yiPLXic&!?zf
z$E{1Iy1x#51o}!Ky1Qfvt-nP<VvVM1ffE%kXHn{MJ=Nce*GLF?(65Ye#fXbce!ZJo
z%}vU6M;J8tECFtPb9PFct;%z=dgp5WUU&*;8C&@akJx`Qn+&Ro&IMhoqyETh^GMX9
zw?!<H3D3{9-gLZVPsEWPpQpOdqp$9>FcKFWc)sMKe60IIQ^p*-*Tm=I4w;mcwepoC
zQZD$dT#8zNja60^_e}q~<#bTQuRFUUn9OB8x5$*U2Lqu+Xuwt4X(tj>N#U!&9{h9A
zWa8N~ef>eGm8}p)#4_Gy`}f6nr<f6O!=tV^xlmyy%CrMVts_r;K)eooFG3opQcB&?
zj5}xXsP;z$*jw0ZQW<2U6utD`RY1Mnd(l)5>m;3HFyj~NrSjju^96(*TZt!F;cpu6
zH6v;m@9M-Zqg0^XZ?nHToQ^cphy7BYJw+CLlf|M;ZhBgV2m{XE#6}36qj`E($$Lm^
zFyis5DCVIni#CQErF4(On1p2|8q?-=PjJYh6ggVRToKV(sV7VCB4pdAIxjA*2sl<@
z+$OusombbyBu2sHb5Ii<R!k3+F(!?bbZ!zh7%3ym)#MljNQtRy|60U)vn*Y*W(8mv
z9ihBlQA)>jDhv8O*P|(WmS-^Uwu}NR;%k-Jdn7057jNosmS@v6gb{+x_2+q^R$`J9
zgwFT{kuB3fIzt5?X-X+i$zi!Q;9Bro(O4pN-P;u725+$GuO!?VT<zi3<^Vd}jbjU2
zr{@{hgVF9MY+MX!eLgHD19Li1tvt+vi5@AeCgtp4v#5<1E8jD|qQKkXVA7)3);2Si
zF`9wcj>nP(lzf+z&Jy~-Hgd(IvH6^^ailQBDFG1XOX)Hubsd<U6*~~M&l(^T<Y(z5
z$qqIa_4C>4zmk}yI6-r{BHw_CXc>$>1sA0f-;1(FAn~1)^3Q7(qZdh4D<G0d%rJ1~
zp^%C}Zy29n`ZpTC3pk!wIeOp3irO?QTUqmRsAS&Yvh<}%0HN<Hq9zNF@-n>1%BD=^
zl&7X4^ZX#E8U4wD9Becf5n4KuS+<RBX6~nl)M#hO^=_IuZgMJQSTC(Fo)5E|$Rw|G
zpI@gb)8%f@rto?R0XC_OEv*is2^VA#){=H%#aIHRPCJ4{lt!c*<tIJj+nR2B?v*Y|
zRjtYoF0=!a_u5t#spTp5hLr&nNo9g)Hv2mG%<sjIR6LQ0%>_P|ijDa`x}L-{R4Gpg
zUh%|33z|)lzsptGAJsI$O|U6|jeCwB6A|4@+o~o#k_ji(tJ%$NK*H#xMO%5{gm{Rg
z8#>Nb1E2h_Ha}cO<UyD!;IOkR4Tf^@$!TKo%4jd!jO!+VJ)}y-rf?v%hkuGU(teR>
zJ;fGOP9?E=-w#9<Rd4Se?eE<2fU?AUnaob>l6%-t^HgYekT{GYB0oFY<7{w+<G)^r
zwa1dgd0^CdfW~2sC`6#~o4V=*j3u__7{@f<r~ay|s%W-(MYFL!(quKPf&?cC(!pwq
zd~oQd7fE*+^j6g)mw`G#`{mB(WDs)Pw7nmvPRlyMXb6dI67QjescSv3=aXT$9-TN5
z?8w82dN9`2(p%~ntk;C(fToq>6+$gqgUdCpy0Dvz74;C*`@Q#|n+Q$a6M7s>l76HL
zSYxsEk+aa$3&kp(Z2J~gv)6dR2cd-38O;-3I(IfNw=xPX1@P4z=XDpEtO~&A0wzI$
zH~$COb3`U;ZwCuXLwd2In{?K57=EAf$XM!}K!+jNx7A=UCXSa2nE3uEh(JAsBu6**
z3!JBfBKbc>i2n-v{sl3zF#fwTl!@&>K#Xkv4a8WjB_2!EirVv1ix8*jw`^yMhyWs{
zOhOFkML)|A7mai2hBJ7ZG6rJ*<-L6{O{gBpZKGCA8(*uo^P+NYKboHN_4g+{JbU2l
z{XV|Qm3^rlPW8<m4bNH=$8tX=vwn4F_kMSKzrdH}>z%xP3+4N%*cebf$Sp-~*SSf|
z1?0>9x^wXLjE5pMBiwts>RbpNu`9T}{u>$RA*UprQ6?`g!frT7E`p*8@A;HpoRRED
zB{HQ!UXJ-O)7;kcdCS<_?R91I{e0It<EwYLq1*FUR}K8CMhNzvdW-WlTtRK*Z*U`3
zcN~|#sy#vL1yv`4yLU1=;VsXSQCE+G8<Q4h7nVVP=weI~`gusKsyD&r)cDb#kzcPe
zd%)Mh@2XsDd0q(AHRlO7zX#+pYKOwxhQ_oupxYcc`)b|Tj#Yzzw><3KD0G+v$;fgN
znTN&GYf79g{b$@JmXC7itFqrVHYnQVUe<&~`ScBL^C8n5ymU85WPo};@#%wkYNSM0
zM@VqI#DpR{`=;>Fz$9ab`nB~2i30HtW1)b)pP$i7^`TJ-p_)pU3A$`&$5Q6a(USNm
zvsEL?AYOx@<R5QMCus1_{Ue_)ULb%{*BYsnO{mpCv7u*9@iHP5HUb302D1~N`HAMr
zPzi-RCWQUc)+8g+G%B-w{~nj>`hH+gr!-TmEF=N}v<J#$kqcCD91(x`+2&z!gQ!{^
zC-|ewLw$e=*#_iV00WhoWDF#S&)kl;2hFgnYVG340FKc3_W%6~f;U~bBO4n&z#p4;
ze5kKG?%0-tvp{;xu>Yp*r*$}JKD-{#ezY^aq~3G{JYPR&r?J0J0I10QepqP5=lkRu
zO_EMW5)`9(!cB#l8C^*&*B}J<QNf1RmYN-1^@l7`bCBZ)&4*|*4Y_5efDzBLL1-|6
zFd*v6Y?{^Jx%}G~Ob??aamz*2>4SHB(7zkC2Nysb#HX}3%@|KN9*~W5Ecx<QQPfkY
zZ2Q3S_@<$47Fi37ELDHV(t}g8ive;E@*yWhfBE;6G3Ks#4wXU5Y!{AIeN8Wlp8u6&
zSSq((;+*T<&wAL5$<;Bbx~A#(+CMTqP#Obqb72j%Wv0=LYw=Png)tP#CNsm_@1K+v
zOld7TC`W?UEaKH<%*{JA_bh^`ijt-oOhMOVbqWsQBS=rp!Snzq`cp;QYj4$~`FT;c
zjkxuqK8Ki2MX?_A9N3gqN!{qzVA|q3QcYOhwRpCTsbF&)Sn#_Z;SlUv$S1oJ1fl4;
zDnvkTW9J9Q10j`g8EFg3$Oh9NWf5!we+5*+P{VyUs&w~fmJl>^PHXXjmk$B`^pjt|
zi;uo5XkOx`=|!-BgQ><VGB09}#9x>KH?O)@$+`Smkp*8)T^GFm1EN^vKBWuURq}^W
ziy9-%;R_lW$Q1b=aG74y(hY*N48&2d#2jAcWv&2blntYPcMJA~U4=dIu`2hdDi?my
zV5gpY^*HM3!T+hag`JDO55*EL%bnHaqB3tY=+G+Q{YFwaHLFowzbO1g?MPD2Z=a)Q
zRYFEC9JJ@!^HpOEQYCeL|KeX#jHL>Gu9$(RFn~Qhr|wObZno3~j3yL7ZyT!5y@dZ%
zhwG&-)D1O~D~<4IRSCaI+@hg_lm0?CcjHS%i{szJtDH38d+$;jMB|H69KKxIMV0J5
zX|v0%O0CAWY6@hn>oYUm(3{x?)C}K9-lbuMlj3Kcza?88Wko_lhp8$X8rF&0*u$kS
zX`+3i>GC}HZb90k>eIx)PxHel-ILYRvYJ&>O5f1^;K67eV9=8?)6UY2dQm#{A|X@_
zXr<?+2V{^Lz<xX7#OlJmJQc^#NbN<7=3$|~8R^ux1;Y|01;ARnJ-|}6;a;O5qIZCN
zO3q^SwrU<ix!5Q2NqH&wX-)FFEVpv!JEj@3sjv5BcVOV25pFqCrSH>_x*Tdj9|$6K
zUNfKDQuMs{fvE(w-SgA~BFqZm^S6KhDqeK?@}$2WqR$u8&eQl2tGo+;z~X<UANjPT
zTZa%opPwnHFa1LPG*g7$7CiU^B1{CUJI7u|-2@~p1g)d-uwN^Zr0cO(hi_$iM=|aD
zYNbbqU4VTBQVz{EF`RQQQzhK_V|MHxvtygTLSduSgiGToc+bT+7&ld}wXN(dKc}CH
zaLAmm%Uo7p4N7EHg4i<H>j5#whrFc6t+Ewb+tl@moMoy$#AJkHcOLCj-y9WT<6@Rm
zao4x@BU8=QBXtdp`9qG1WAzx|CT^&L#QxrGt)CpUZOqt2QQr^19ua?Mr8XqVY|Tux
zVJ<FuIJ(J+kgF12_>qe2M=CP&*NE)Zn=h2s&c=qZ(fykOJlhfY7mhL4ZmVTp4aq%=
z@9Csd5of`3EQQNzf+Go~S`gcM2R)#Mgb@5`dn39E2ciENGUlsT4q%&QX9S!b4XHgP
zH`7a&N7qRA^>if<P3b-z1)m>ul!Yb#TW?R{0zI`gfH*<Ve$9&<3b|VZz%)#}o_~ST
zcoQkZ@M6A25wdbrX3~n>gubE^bTGd7l)I|=J?0bivxWLUTUd}8Le@Fud(IQpky1m|
zd&1I+Ufag({6zMw;@f~<`?HA<Kc65(>7IPx+*j~$jOm9=;NmND2Z}M1$tvq_T7yXG
zQfWj@um>L@0O=x=#fDP#f_bP7{!46&kuLbvr=W}iqNjR<opU=U>y8c^o*aWlqd62D
z?ApXMnH}216jAvXOzB;50dTHE`sxXH#I7pC6&HCvg_}mpzMzp?elVD;093u4)(M3k
zv(zWG&HHB?@I5h608-ZbdzN3$U5D~V?veG=8C6UWT)XX8(^x^#C8pC-W!Q=f4|grL
z8!sA7o+s7AnKbvc*4n|kU9&D5z`O>`x3Ep+nyCjs_aVoC^iiL4#fs)?#pn1DyJwY=
z5Qv$nr3hY*y+VfNeBH>9tyOP54M?-VDfpbDaL@qMq^!3qp%_iyfhP@N_^OYYCsD?R
z%AB<bVe?1w0SxEXm%g<|$!zIpJl8T_CSLAz-Q9o8okaVb{maV@qMkfD26t6<F+1xa
zF%Gs4WK2u(iFpzf|5(Yt^psQ3H)znXN=2vVvo^2Oxe47)9MhN@IKW?Xi=LC~dazc4
zb|57LCrsM@ZC(FlU|PG60mO5pxTJruFf2)RdoT;VPQI)7`?Z8$KbQQi#$}KQ%Haz7
zc-ZoYE_o$`NR87ts`&}+{Gfs>cSadB$fU~Bs|m%RbWX3)_AwR@X%mx^2IsAs1^PFu
za9+5k<cQKnYL=^Ozdi&wroq<&+F_)QsLNrT@Q^~u)Z>H)F2`A7vLlk$?qXi`G%spG
zQRwTbrHBis0V(q&q63f%GaK3VH;602=)FGF%NlbdP)gqOlEvZt<UZ3@prvuwZJP~X
z-(B&8=o@0OT?Gx3pC}rB!1P8vH9T>bEf^G!K?x}Ju|5-T%7O@NuP4y2ctdLz!n-iV
zlG-?WxKANHwT_jB7ApnX8C*1i=4frF-vsl;AQD#f*a29FK+ox~gUpGqVb5h+?){Mw
zUksy1!GeK?^gmw?bn$p|X%rx=G|TN8!a}T%%qo5UZ<BQ5prkT#oYe!Uo?6c|`hrkZ
zFjpot*v(;&u2Mb^Q*Be@u!)a`N@*NrO*~GyQDN?+Bub=SneH-DD66{7U5*arhJFPd
zgoZtz`uK8PYTx_PWmdTJ{ZYM0Zc~UihV{$cLY7c+BK9+eSQ_Qq+Q!gh$R!~t9h{~~
zp%CdmhI^_(?opL_W;$D(7P;UH*NEFSrp$Se&Ae6=2q>nKvZsm(mqBGKX0F1Es+vyn
zvFNPPrnKG1MwIig;uO8pdZ?lbA;(}fo`Moo$o1~BM54DL+pBkWV--_pot|(FQXroX
zg9Qvbon-~q9P)IE5em8cO4(=Dv_4`MhPfnsJeNcseNj`+dI%UY)%ij?H^tfDlJ;F!
zj3m!*0uaI*DY>P^Zh=lX?(QyIVBj+{Q(G9)%A_ID-u$*hHj3s)dTh3*lOdS$Vw0)h
zof89H*?-FcC+RYAT~$hTM%u~Aiiizl5W9W1dpw)G`o1n25YV2kcPguQ=m&DOhm&%<
zbSsR=dN&mbX%>iZuj5-_?$dS)m71vldK-SXT@^J|^H2Dy`o-X$D1Jv`6qA~vdQ!?9
zAIg+BUe^##3{!D^eG(RbO2p?EvLFnf{&w^NO>0W2nJd;MJ#Q>u24GxDj*M)`m-kGs
zm(OWTujHN@0{?t}^qt&A&ihZ%&%Z*Ne?>oxjQ=jMVE$j?|9|Jlm>K@N{Fr(q&KRQ4
z$`2vvMu14ND=IVW0(#3GFEzxo{_Q}GDx;+*iDt^(`wkZ&QS4}Cg$Im@UP&n@5fx((
zdn2Kx2U4hSulvi#(ZvkD@9V<Kz}v<|rY}y(z#}od34`qUF4_|_evcQs*Z0)kLMFD?
z_jT*No7c<Lk?YEU6K8g<Kafw)$J^A~XXY9}eI`s?_xBGWC@(&U*ZZr(;_#HpYGvl-
z5Eci8vxjAjgGN=>Zid}BMJKywgQ(>xm1Pz;q<zqi-JK8PEo99;Gh3y82IyDE0{+hT
z*VNT#=1o}d3%<|iJ2uDX>s#r!u*guHJajKCLj|0mo5;~qQEVb_ck+lhAyI!LQ}$j4
z7u2gDE?LK+%!K^97odm*R@k7Exj%#dsBQ?V7-7o7BMw-`ZL!_L(WA<r&^KZdq+acq
zh5eC*qI5xOeGLStO`=<m@?nA_(6^rct_S&T*;}p#G%|iP>7MX5B0z13t_Z43Ny<aU
z@DnID$pfO~kc&Dctkyg=LSLtw$}Br;{p|7DL>n3IdgltDD5}lu6ns)&xL)n7-Go24
zRSTzndt*DK=2GQIBI2_lDr9l7FTQ8;aY!7P%{&x{z@mL*o{y6ebvpa%(ozPr6e;=j
z#Kt4RQIU}ftYJvBo3VFTg6RB}DN!EK1r&#qEO{v03VCuzC^k+eSaMN<g_9+Sm->+X
zxw6x^$tF}!)LLt^0c4qK7ASzUTY(<$&iw#WMXPK|KfGKeO?wKt)Z3H@Aag&i__vI(
zmB&6J3g<ed5F`kKGoKut;Zviw^|}II<d;X058*0h8iqZY@)?Md#<L$ye(62!`!7->
z$(^d%RzS=CN#O0Y8|o}`G#4uG>rf_%ad*@n;@V*Hyce0C-(^kwK6EAEh+H>?Q1~g?
z8giH6Z@+83ivVg4tlAyuD+xevu>`IG;^Kti^<zXlO4El;O4B!iL`M5HS7M0XEWmja
z()&r+5vFi}*nmMJ8NCgmysA88<^((?otrHOY7bk${up&Z%6(`^7bEHF(?mHBNppy(
zA48^<S6~jNe=L|#5{#4wX<;d=n&N}sEeksM#?8)1-nO;f%09N?@w|(IKGii3#8m83
zrpic6D=+M<4*?)HML=2(4x4j0AV*d$u1)i^C8hmJG}^Zh1yu${;)ONObr~-AParRr
zRJaySOO<)U(#5E9B4X)Wgl;4|t1h6Yt5K(bu)Ic5(0cY@q4zNeSvA8+2%QO?y9FhN
z%)=$J1olshQERD^UM156j~K}|WhS^ue><;aE*z8XiaaX!(-B)cCPpR&(k2meUPlD%
zrUz?DB78d`j2)dYZdY_jw&v^}Sd`=3TxjUp%V9FW1xW(ULRL!|Z@g>|3N&^zFXryb
z#9?Qdne<<XH-UUA;)-Y}R!{WMuz+^19uED3^3gUC8MDnGHuAPkFfV2jwW3vVyH0xa
zp>G0jZW)?!DTfhJAi(*er44hf;4uUpJXl2$5ZRR|&FHGbIafpunO>}+k)U7hW-dG)
ztsbRFDk5!C5R4OmWTe?Y2v!Uh8J0{|%enUX5-Pz0lMLpw5+f#197~u$@G`D!qj@|Q
zM|Nfa8Yri%5<T^?39)vGt4PSzO&sffb_PbSsyS#XPs-Cv!a-_UCWA=QYbxhffF!7B
z61viK3bbHa4jn87dIr+K4$eAQUADTSeW4dypp8f6p|Hm@iDO?`wiE^%3(O%@%^#yK
zu?(!DBN~`0PT^+9NFiKod$F0549nX%y`6aiP4G8td0Ha68K{p7sAP~JF?H@hmt4Nv
zx%%e$0>1a-(-yzr=q%@m2D(ULcs0#V2==5a>vsZEE_Bq}La)!;-9W1Eu)4IZ3SiET
zQ;D|#MZssaqeZ79RC}Kp58lObDET3XevJHJ!m@>B)jXT&<&wmv@1k7nMrSwHsLEdA
zj(t*N6M<*4%tYkim1Nst6$h1mjT@*aKzB+c=Ya3s2^?S37KJ?%is-KPZbqYPTM4d`
zK5z}BfVKbA3c;xgg4NHWPn#lkc!X`^X6SvQ<Pd#QcTgZCD)`H8P3!>;p}Ul%<Gkgn
z1`Snu^HLWVIo49buBO|84ddqMNk6lberC&|VT79$Q#LBV2NGIS$KrwgcFM&7QOa=F
z72InJmT<lKQ`j(Wfu8&`Jy|MVPQ3~=d|IG@O($*wRBJvZ$RG7i1Jbo|;MbmsP8I31
zSR3|hSCFdumBcF|RDxYe7?Q}yKIyz|Ts0_cs>Uj|8LLh@&Nz<+$9hPgJqO0CERawD
zzAb^#t`J?D%`}o6qpG9-8nMPOr9z@Njf|yyZ^jeoLk})_bl?|MrgqeGEZI**bByd8
zGIui2j?+WFyURL#r(c+(ts>yP*aojS9qIB|EKxmD_lCPJee#z75WQDz<GRoR0aPq_
zAvrY|5r~9lK{0tf#S#aPwU1T>)m>}$3+RNub@{mdhqh@m)siT=SVek4+_|$*#58xi
zs)T&a;DpOII<>uvm^}vF%8zDuKbjeosErvgyHMwehA=nCP*i?j!Z@)-<_xH9(IA$w
zLnxhRoZjdGw<R)M1s7s#K^kX5T~#P_Uiuqh=xw;O5x55h{2D`{ii2n?Ve12U$>}*;
zGB@sC76fwM_F?Z}NZO@0kz>Cp&pDz`XnC;dzk>kni>Da2;~(ud1cE2I1|v2;?$zLJ
zwd0;J73sxJvk@cFYcjvk7w2-~^1}>WGTD~a!^{7r$2b&`t+n?sln<P_d$Ygie+Z_C
z>v;yGbm^u9fJh&nBQ$X80=y7C4id#^Er031rifW-Z)9`41#*lC1w^V?r3Uk*qVlG-
z<D_5y)v7w0l4qb6PVvZN(i-Uu(7t0*Aj4fnSBGy)#$17Y4vA&HKE5i{Sjw$(V7D{b
z2{}cC0wP_qs*D$ycU06j53tY)wra;Uz?Iu!w~cTjQHEAR6WGoEve<8dQ<3S;HuMGo
z8qTDM!g0!<biR&m!bTkH(^ay;WY%P_Hl`mYI&!=rhRogRuMWAc$Y*pz;j_eUBnuCA
z`FQ}DFy;hM&Pq1=CT9fDCx981Yd-)O<o>ck%o(|x^C5QsfSrki-H!)u(0tm`^t8XN
zxKpA3%jRSY=~W0t=P+vjyWyaY;Lu)9xzUD7o9>Y3s0I&g$z@xbfKO0Ba2lnP4RIN?
zc!U7X&MZ=$u8aq@8ZV^nXIOwoP~a!gJK*g<*XYILlU5rQS;NZ{xg@!Dr1Y{`Vp_G8
z5-v|xp^*n*#CDkPu^LJ#k<kI4{8Xc=%~!6;^{4>TA*2W#OY@#5I01MQCLw!esHo@h
zS}7|zcctW7Y0YB&aE!hUd7G6hzmRzN7^G98TvU^?iJFjehOS+)C(vZOG~*~oHbn&M
zuOW*Q_j%<fw;CJwv6BH9x+MpvB`LZy`VH4s6cYlsWcM9?DRxnU{+xUjBJBy^GGdS#
zcF*XC!t0z!uUwJwSS-QAVVoOHmAR*GsmW`{fKaB?Ml`CTku1;|xLc;X*zWMPzUrPT
zxpfhb6=FySfALK2(Nn%xa`{I4w+_R=`Fl<(V}xsFxSIip$E7nXdK;ry*b}dq9bGv3
zGK){SEqe22uuFRmN~Ma$xfz5ZIn>n+8{uNz^rT>wAh_j50zMO!1VZF?sU#4xNOYO(
z3yS$Th68{dW85h?Q}n&in!_;0%oP6*o+aAK7FHBJQpM67mHCQAsOtHZ1(8VYUHO^*
z(JM>09SS*Vxr3w?>QB~Ec?pLi(pqv+Lwl$%TSt`^`F(~uZ~h`>=>S4ZaY}wD;tn%V
z=3-rfIP><8TIiAv0~d_N5>9(zwHYEx#*^522T?kw@dHQEx!ZhQ{HD`T(~(|Dx%rE9
zzk&1^#osf09tobxV!8@Ak>ixzxB}*>V=HRM&HSaAQXb<Cs~hq^F^l3Ui1!h1I!p9x
z%(dGO#8%C}b-6SZR>%p^9i<<rI3yg6BDg^GTvb>L@l4FHwTDL~L*16x-w->pikZ2O
z@k2iIDk}A{DJf3cIdafmS?6yIHoamP_OT~|3{of^cQr=gi_UTgd!}rJUFVDT|48#S
zDMUR!a@!i8bV_l%Vp_%?Zx&C3so}Y*jWZIKJVA%FdQoXexqGCz4%)OfDb$QUHQ}Yg
z8DEY~{5nksH?Vd6j&T~IjdnSo5U*UmVQV%Qsl4Qx`Rq_;V&&6I&5BZcV3g*sA;z|7
z4wB!Z;jQ^eeDWM(B-LpdQ5g3I5CNppOBI*Y<f&JqY2>WPQs`dz{GBIHuwY=z;HsT)
zjMracSm{E+Ml>Lp!1y~d#B(;C(1L@!=<i(V!MzYSV_ahMe%=MDD{@b{w<)E?&nc&t
z!+&qw{=f*A09<PDCVzT<$zpjilBhcb7<b&%^oxd8m+X(MJU6&f#D3_2+;Y()ub<OL
zks4=h@_j@i3RLY9hjJC0?ws68)1+d{NnZsz;ozS?vc9o_nNGODtMk9e9Wx9)2Y_p%
zNS=Lyzsz&2K*wQUHmg+sP6kS)cs(E^aOzw;u#Z*gO?3x5p-PTF?@p;~^RlCNYM>1<
zcF~ubrT3f0UXq~p**ALs5#ZR_2ri!{FU@l|4xAvY6w?wPNv_%7#`pPpTtT_*kWKjo
z3DiE*p7R9zfFC<=ee>pmKW=u_!8w+^I^*{J@pe%<qx*2|`XV2-Vn-mnnXb}=NiNF8
z?StNf8B11O3<_5TE)aLHu+TU%NtM1+Sk%A|QokU{0pjh?0v-((4!k}t0nPNfx5vpj
zPtwlAS$lJWfZSu(w~-d+`iu4BBg~=;Z)OwRg}?E%pu}@F3FRJXFF2mgt?~9Mn2xZ`
zojXLrG!Y3tL9Hdncp67Olm!@k^tT@67D&+jr7ggo#v5k;(d%%4)3*WW-g>}I{+|^D
zH}U-<tzSXW)2j$)uyhNR5c{~(@e})aj{Bl4Sun1P$7FMJt@+@j-kHKyW#R8BzX;Xe
zE_2yKHrUGkrrv}V!Uy8U9~eygFkp@s3q=dH-Gjs;f%Yr6$+^(l;<x=)3WZh-1+W4t
za$>oXEReu<xifb{h^uc4wEE<AaEnB~rHi#^lc8`|MEh7LzsS0+2DDefHf3Q(?jeZK
zfhk_J7hfpcHoGi(!A(CP=LY^D84x8&qQq6J-xuaHGz^S84Z1CR1X;RHg%6G0am%=Y
z`v#r$3Cj2n@%sM+;s1))IsUJP2xjL0x2>I-`M+svuhvqpJRC;-hru+i^-p)<y7DaZ
zriyDK$cG-r?Ene93pbqlB|CB``!{c?O15HV5h=zxPe;Xkc_Uq}hlg?Lx7X|I^HFN=
z$L&?F4~O>8ufWFxb9RZUkAg~fL}LBEGq3lX*ZXm6X)f>P-VMI*$jnKsE=_N5cFDw%
zM<ms5FP-m~-RGl#xtbm+Xl`x~pSRZ}8Q6}G8=s`H$<*VNl*e3ztl<5a1#cgVeo>1^
zXQc+FkNzc0?t2w}$N)*}Weo{+<GYW%sWq+d$73k`i!6Q*9PvM_I&{5z3$EX<U%lb1
z%f-?&=gOe#gW(LanSQ1@r5D6>bRXOlZo@`&bhquV(6;D~CgZvgx%1le*R@f(YhL>M
zlU7;@&vrYt`oJ!R6GJ(7uvUGVeI$r{WWcV&wYC>3b)P`4!;*W6oqPa+n`kz+w9_B<
z^_SG7zobF}=>d04U%+3ZJj)}coC*rxu2!QX>u9s}jvzf>Yr$d)XT`bu!nxGxlO6;k
zRHM~xWzg7tS!Et4#R{X^yxuJx%UPYwQ!>aREN3Wt@Wve19#+2TaH!}PnKp6>k*s(M
z30Drso5`~>QzxS72O;Ng!iO5G5q~AZ*)A4gjW}YrVj?xI-Wutr;|tWN7Wls>^m59J
zW+U2_kXT4_TK(c2f83j?Keyeb!@-b3wvo~*@bZf;eT6SL@TX-W05fSMk0PzdJS<+&
zPNDaJGlfxrg>r`-4C?$890Y7aCU7mb+fo`Hc&2Wompr27LF#4C;!Uf8>JYxlKPhwD
zk*82E?|M|Aq5zE?teFtbJWaoAfWi#x>05g{%mxul8E{7YrVT`@QW+*gSS!56_&N(C
z3GaTRrRI_KiHp4D{JmMxYd0Vvl(fe8&hbJ-9K<|0yX&(Z|K0vaz7PC~RgP(JJViLG
zR@qy}RYqLP)2T8QJ(E~(>!oUzuAsPv+kt|+!OiCc!(n;K(24_lOvn1n3TY_?OB{--
z&p{f>o4w8LtQK9_M6aWAYHB(?Eu|JIG0m7th!XHV`#r(9F^Id=xu2iHtVbq;wsFEp
zvc(RC`jJBuZ+;haD6^YWUNin1#e~F!h2xp@IHpfjN90>n5Xj53t%{6YFL5kMOpP$@
z^YWVMjIo8yRbW6@-6`m<+@;&}32~I`kUYr{Fm7&1eFJ4SW!eFnR2B{3WgYqv<k=5x
z6ghJfh@>ca_tzq^=S)Ket@dX>WrBuYpHd1=oVip*plE)B0xSHh&+&_3eFvu*_PuaT
z6uDF~`yn;erYFfB_mTcxTqWYrsX#Neg~+_MNj>(SmvoENG>t<EHq!bftAbi5>bNLP
zTWTsyLMbu5ub(idQ3Si;_`b;U=G04?V}G-c4LS2d9Js2?YF0Qu!Z)_ZqNJcO8>GAo
z*u_Rw3RGiF!i2zb>XQ-IgjzNYC;Qk+L|I#jT`;BTSuio~#eyX5mlSod!+xlhY6(E=
zFrSfjv~XVha!C?7L-9qA{S(rqdBhBiFZcrF7syT0JW;}>wDf``WUy9qS!pNrBbY?-
z>Z~^Ck+hJjA&dGd6-W-`g-S&q1(pBrT_k=%<?F_&`@=fI30r;;3Bic0ZCn0E`pb=Q
z8?AaNdxcF2E016!2@AFj=*tK;(Q|b6PCZzO)Je*HO0i!#fdm->APET394QtNX&!U%
z-YX)#?IN<GB!|@NmF~8`<p>oy3wZQN?uS5x+@Y5hi`Sz$oz+p#(({7QFtK)osP~AA
zZHEt(w(=cntQVuLplPpMzZ-78@|EaGR%~;m+aL-_+mfyrPt<P-<QxEz;w$;P3Pk-c
z&FI>MWW-`EV-qM{vudiA6vI+hk!%tv7B-smXCJ$Tdqt!hK{r%OBL#@CNo(WVX4l;W
zrm9t>Z`wWRcU`7-IIGK?4XL0;8FjBpN)JHVPg=qzQ?<hNa3ROtC$3iNYRf-OmPGH@
z)0t;^%&+Pa{&Fh|_ymaDDJv>;Byf_6m%6AcK3+6cOC|(4Ra8}!v0nTpvCw3%7DHK{
zV(n5bt`DhG%<pQdRjC=KYBrKA{}r23tWh1#A^Cl4k3|j0J{&E(f_Wyf1mu?2q_H37
zQ6EeS<Vd{_)b@4w5&fMq5u1QcZY70m!Eftfwe+$&sf@1NZzEUyKpv|Z|NFA?v7ZAB
zHgjt&iRf>4sIJ3rwBPZ`t$XZ3y82wu9v6Stx~!KRFOu!qv%=;FXR8QW1Eje$j1tJ$
z`p03DSz6X`Fy$YX@k3u=g(s)^DIsms!h)Q%@yvtsKq*+51gVJLwpf+~g`_tJiEFa0
z({`P53+R9<az4{L{2+@m8f3yQ)`>;$i=Zj=N{T9Q@j0cAyh@5{J_p#t9(jcM-Z5B^
z+MT$XVzka>3}u#V&P-tCgCR*t;H#tUo+)g?DAOCl)m&cWdP{TT1`(86?<DOn&G@KJ
zcCpXf@_QX~NXeX&6euYcg(wFE2=H&$GVvKzE(MMRJL{W3Eyeaj*OD(Bku>66qpTZd
zPh?uY6sA-=9czB63uT}aIF}E%U%AH$Jf@y8*o>jGB$5%R!j00O4N|<*Xe^&H$}-4b
zIF`#f8B!~V4hrG{E06L4K__+`aA>K{EE@e0S|;3?XCkVYZC?oIH;+&`v3M;>AE9>g
z7%6!h<w@sollMk@G4Xf(e%iqI{rY>7M0u)Gq36d#`GV}Paj-VPSnNhN%H#9?61(I5
zbzj?5YJOdwS5fQg?P}C%<R*2zx$fXn=FgBn1axrdrsq#Wd?FHLXRsjnbLIBg9A%{a
z3XGPq$DS)sB-h~6oiF@PkIn@YeI)BvN@!x-qPdK#nqUiEzQu~Gsl*17fpnKF!d%>Z
zN*Ek<UC=QsqCf(Yhb;K-rW(&#yk$9l!BR07HU6q_IVhxxmM0ng(4Y*xfM59p<us7E
zYI=}UnOoc=95ssIZ|o--3lV?XEjC`*ht~GB8bQ(6*@&Bm+JT{|^EpOfYu(TDIZj)^
zKAi}3+-Z*BNXcq4J))g92yp($)acCI5V(W0J^DHM5EF=HzBVFRq?8H>F16g$ux}FN
zo8UkrVI{05%=&|-%yvn(l4Tpb+fTz1S~g#GN^ZE?*&t|y7PYXu{+NRKL{K5nwOM2S
z5BW+R1n0Er$%b@KsOGB+?w!`EsUqfbY|>H54XxqUG26|^7-BlC%}wtXp@k|gO+qZ@
z0p=@XlHU|BsT<-g-$zMuZz?#z4L??#`v%!j-(UOs?dL6Jb1vff*hoVKO-7EoKS&w%
zS`j#gv^*b_xWwTht}8X~#=P(u`oW8_oEmPLnO#d;BfPq4S`4_UntYTi8$F#rFkSmo
z;eFa-%H}`zHZhQ88|<YmYTU_oX76{1prD$JqDmT@Eg(-aXCr0hAA8-=?nxx|O`}>{
zt<e!P)T5xfbVlMhMRLMM4RmL;_JU%p82fZzx7h;a%#Pf4ZnZp(y_pWyKu1l2zc*uD
z%7$!JN%+#tK@@X>m`iKQ3nvq$As84$`;eBd(NwvZ5}^|s1=|;VEd<t7zZOkF?t>v2
z<A3vTY1;4e`(X9ql3o<fL4MK4%9qAl|1cwd3PAk>Ys_HN`v)YNp1BS6otj@<(MuIS
zFlT**^g;vJMn>HTI-5b5ysUWZSO*jb<8e?}h^FOHEa`e&c9dZnRUZjv7<0*i5FEcb
zE1V-%^x05sB!<-J0XKWfRbPZ(#U12phuRY8LOr@$uLnDFlj(_>uHIdOU&I_GeNG|9
z(nx15o9Bk>rUWtlz8d1v40{9;+`Z7y`lQSmF4i(I+bs`^MCH;0VKU+ry?@APev4Gz
zO#ltYJ6X6-Ne=xNLK+T?!8C|4c$V9I^YIvoKyrwc`op4-9yh}wuB_SydYtKuBmCtG
zFcM&zFA-o%1n*Q-K1oVF6$O|Y&<=ScmQ^oC>d2>76>>HV&uER^@9g7vrUQ4%n0P!;
zPX1G8n}{9xz*>9W1u*0o|Izt22Jv!aY|6nCu<iX6`?@SqI<33}$uJt$7b6T1MR`ew
zTgKuOcaA*jO$`|*hD;TF!kM85M~8S6g1|@&+b&b};vEKgTmBRzIN(a`pPyHgWhX~-
zv#8xGh{B*_!?#Zwl{&kKRb?n1IjTB+(8+?TlA9<ji~3?wk(IgXiJWaNFmU?ot~Cwl
zrZNvRJ{W2L@89Q$I7Xn1>N|91Lxm6oGs;-Q39Bq_hTv@`^dQ0!NQ&V>T~{?a4$smb
zr~xfiVQo<12>G&fhg(H+TwV}7#-rv36W&FPxHIVk2ud}cQcr`NP*H_JeEAc9Z4V_Z
zb(DpuT9h<Ycmih!&YZP~wS#sjCPmMeu?mT$@uY2**Kzx_?JuKmGT0QSv9yg>9&e+~
zY#Jdf%p?kFu_}G?d9PX@prqW0%&sN894t#BV_b`u<*nm1=9Gsb!`h6p6$ku(b07Q~
z-N0lV^4Or!MuXK8j0QP(YcA=2!W>TPgXg||$5kv4r)<bueJTSu!<-24`@*PHGlh?S
zaT0GAyQ?v78rE@jzEqz;N^7%RdXt%!H{;WpZ`z)TTux*#Dic#T=G;3T6g;#Q5xYwX
zYH5m<eX8YoeCSQ8|GDoN&2*DiZzm$h5^CEdOaJ5Q;Uw2FWDch(7+AW?N2tjonpTzP
z(3|*>3)nB|6kr?^B_se=$fA<=La$w{A2TkbJbQk=2(KivyPc4<xq>2{WENc$ZCZav
zt{~o__Pte|m5aBUjfZF>(ob%eL_Xh^oEs+@`^a(;LK&U1O*@ZfJ4d1cIa6686F$~V
z*pdEBl=-QJOJB2qqvnAqgP}YcaVq}DL1y_Qn_E?Fi7k|E$%P{^>*EwH3X$rOy_&p4
z@ubVk5}gY>3S$~6T6ZGXkz^3H|H}OF<!d<q_;Sx*$WoQ1@iqk<#4uTvEnAR9NK=qH
zyPI)~Xea;jRvD~c_#v-=1ALgq5@rCyBpt~_>J(4Rr_xP*WjZQLEnNAU1?nr{>agP0
zW9NT>B+W!_Qx4s2KvdLXUqb^w&#x&)N8sO*ft}lTB!F#8o1FpNUNe6<h`>LjDoXWT
z3(~hh)|5A{L7c-)(x4l#e_a07KQ2G2AoN&9;fLwd&57FM7PANtX^)M;z1^ISNvDtZ
zQcgvX2lh{5pqTEDN+P7-@jpcbk}BY6YJ!e{Hc&Uj`S|gH7aE(diyi_+b*%t-?Ey<}
zzNaLO7}!36^wpRWVU?x+J`M;smDa96Gl##n;l-`RPyZ2~6e+{&8bk+@+VWT{J}q&F
zBojzXT$@8oZtGQ>MvrInHyilXvLF;0uI=x}c&IT=@lU&NxS2VyoPt7~)m?q?d&8My
z9EUi^I?97pVEM$rC_{b|Nrz6`)-VmiA7W)3R}L|KB(K28L@%sMGVnM4<|~=mG@L_V
zAqCAY?tc!Kk-YkMbkzsey%)t5bhZ8)BPcL)o4@V56|<k5JzZr6*Sits*go>gZL+sf
zV1${@E=#`BGk+K)u=HfT5$~(K6M4QQDjQEiSCIN{1chSwjUJxPe6#vbBK{L>@h>dm
zAJ~GKf&JeXuQ0R!zx;U2?Ee)%o`z&3ktobR_l}Oz=*f0hLPzyoKl1~5s$q=kj}nYs
zhaASm854~4#-3Muv~NJ`_g&bxRw&Ptoh4R`#mo5e@#ymUzFjTI_Ijn)+@zHDk}}2<
zWfsMY@|q9CK0Ll1JPx!j;LEbLeSN&&<<jlY-#_HyfAM7J?9l8~BXi`|S|SAd=K6Yf
z^zcq0smvwePCdTsd-&`j7cX3twkFb>+7s@3>5)O@a(kT|dc~0u&fM0o;(x5HZC4FM
z<M;$-VgzzIC7H-fhs*h}k{N8m6ISW>GIfrUeDkBX!9aJl<w~jXqrd;*QBSMcgD>s$
zB>W&w$aqAm@nlgUgW>y&Uwb;87or(p-=PtVUKG-K60scKDZcKGO#U|;vDI$}Jo<cH
z_KI1?SBIb5N;^w=mEhpiBF<(L$)(@9g+;q+p3p2U`p_B5(qPXnmiPPh{d3{}F!s*D
zm3H6OXwtFOQOE4qM#r{oc5K^r(y?vZ-r2Ej+ewEv?|W|DbH6&js_*=_tM=Y&&F7hG
zt(tSqF~_)gIPr!+2Mj8>)EcVzym$TF=@X%mm$G}HL9{s8CP%3XdH5Dg+3NO-8KaKF
zOzNj?M-zMqcmP&`J{nyBoB`+LWaB(Z?!+z)O(HKo?Y!7Tua$J&EUaPvV7iQ>Ns=nN
z$O01sA@f~t0F2%kHkE-?()3u$N+_fbr2euYDgrfEX7RH5w*nS4df^(%gos*7LLP=f
zhI%tmKro6Xg~T9qXu@0!3ayXmQ)I!Z#JX5}I%}AUPk-5PhO++jxzp}4m9l*)((w$h
zTR8SFTgg%pi3w4Cv_@@8Yhs8Wg6|0p@t>Iut90+_UK2mP8V?lW3<#egYET-4?yU0|
zO{Tu@{IaE!pwWgyYQYZ3^-gXgE@Lh=Hn|7a5rauiptES!FBVa%8fg-r&Ad*)CyC$>
z{VpJ}&>K*dMr<AnA&vBCVyv*z@pz5=2uXo73)`nF$ktk_l87=LPGe%PIwXRlU(OEe
zqQu7YEF65iAJ8h}6YWK&A*p&lau94cA@ry?lsQ)e(&_CmmEP38Q-KDN-OPORD#K(5
zh?*<SC5+kAzkpBj0|_`qje|FOVjsVME9FL9g@q@w@P)Js`HX)tDk;8wR!=LD)Q}fJ
zN5u^{1rdjnEKdG$GF93;>zwABB+=1fKS9}*R{z^H?E@dA>#2gI6B^lTXb|Abv^iZO
z?4A`EIbW^dpG&<r(CC*_Zf%luKZc<k(7%Xs&lMA~ZcoO>ydlxsS@(i5#sQHxVyD_n
zwGmN|S-^$$Oav<#y<w)xldn|O3m4UnfDKB2&>i3tGFWPl7)D5#3{;W}zqQDXg;o{e
zZtrNUv;SQ%ajB{Xstmztd^bpR-i$DOJ9{<Tc@>a#%Cc(s>l_14EVY-J63!br*eoAB
zSL!g}xhqPxtn5vPBTu~`MaO^anqxhn$T-|(`thdX35O13G}lry<#yk;=MMjdroUr>
zBOMWQNA^;pX@<HV4K;M4hFSt$xmgjy3E5c`su3#*LL1^qzWXAW=}KS)%PlDrTmD&4
z$ipA&<V>70G^9J(eNCo66|^810{<9LnowjV(SHgGe~AuB;W%UkW0-IFP=>-e{dZ7z
z@|sgH4u|`Ip^4NrYT9LcP{G%rN3gQ+$huuMN~hvHs>bQU8rT#)UQj&&=jE*>;nX(!
zIn~^fsq<67nU4QExg4cPApq^cBosqwN_>+ysyUHdM8nbCr_cK1IMr9o7)C~FMYjIO
zj$F*mPg25i_1GEOH&!OvkH^_CX_dBqnGsczZp+TddMV~@{BavYh#!PE4t$*)8U9K{
zucV^QrI^r^-YxzI=}EIlZtBsz<4(L+-@di(?1&y(uRHGg^KaO)41+tkNi@~*sRBT8
zTNP~Vz73or2`k`q?RUV`g#HPg+?P~0V4rRo1QK|19MkP;lE^-x({b-5!Q2i;5^Z{k
zsG+hKvs5Rx*3zA2<>WRv<Swp$UOGkG;gg0${R9b!Am2Cg9f?SyT0=|DYIsrr1az9!
zenW~5a-w|Y7d|l%hABu7OTa-{7~@fInE8f;)jL<WIpC^x@=It6#9Ht}k)0;cgNtJA
zqZa7=Y{Rvqyia|Ky}nK=K+}{#1a4oU;W%`P3?|gVYjbW~xM^&|mk``+bIjqO<{all
zS47Zz%QIZR_|Qi1MJsD#-2Slj8HCC^8U9*4>JY`>L)uICxLH;z?An22xA9~?eZc$$
z{?Xu3+v`kTyEYV7kz=>I=<Q^&g=u*&8$l9u9%LQCopH#IvoraQp!8C3_+wJ0bpzC5
z$CMX4$BuAAp0;t`D@gG;`W3p*ng=*)r&T4n((1BeZvj=0vjFGj%zSz(=E^)r6(e8~
zTZndnd7fsG5}dfb;7RJ}=Tw9rH?#z%Sf_VJdMBO;7Y3h5Hh(be^OK??<HVS`!#Xt6
zwcr?4MKCEoef;=Ba~=|YF6<MxzmfKtw8>0G@yRNoWJxU~t`1KP&QE4kd=Wni#fd@#
zDU&Po&+kGt_S9GsbH{%DVQl<>;#KaoANWm7wnJ?Tn(>^&I-4Ye2U@GNB?T?6%K;Ae
zmox14X@nJRuJ;HCtLqz^AK6XV3Pourii!xE--EKEV&P`jGPoV;0e=vlMw;3iI+{f!
z$<kepdXR7#WA%j48r^TUHKS{d4y{9v7(3DUQ#d}0%hGd~8pckXZ}P`j@ggC8U5@T2
zGR)f=23A53=;}F(1ApeXJvX7j>fN=2d7$NbP?=M!zdHolxS~taTF|~nNWm%jcBX88
zQ@@m!Tc6!TDKk#71zPto^l|L3{vgK@auaZ44m$c1$2Vs@nNt|XO;22iy4S!;TnsfI
zZaK`Xt*DDB;tO|7yDW_{{Gv{xpnz|YdzYK^<H-2NPFmZUdjbbyh$?GE9akEQolj!N
z0JTiTddQFr;RnhVULwmy0BY7^+_!hoS|PvXy`aTC9ORu4{yVLi?&!b~`1|)zXAUeV
z>;`XOi?T}SUvOvP*9+2Q-cYqm7TpGB1`_@CYjFzeX-cMk&JKGB-kZ_@WNyi*it^U-
zduqy)Q4E^#zktF6|40<VB~<)xLBG$Vuq!pGympiR=p4VE@QpY$%>Spz>fdnbpU8@d
ziSu9OgMU85vNAIK4}ud`#($!%{~N){S3xM2RP0|#yDx$hW-WI$iK>+1j&=xWK6TCT
zP!uFKT@o-|ea8MbPvYD1FrHJahJvh<>M`csNNVc*5KQ}*skzW4dcODTcXr>G6Q}pn
z$NQ-{yC1sy0O>=Kto1_O;kiF@C46r$_kT|ipZMNHv!@8U+uvP&A^ZV4$M9|+0dsPy
z338%>5p5W*U-w)~kYaC0x96U0&8*kWgR?gDZ5Kxc`aS_;eN?Z#6|$OpNlJ_A2x=E1
zVGZ8e<JdOisvH;d2eAacPfnlD_s;5o5jnokdumRv*QcwGj1<y#srmwUMgxgc(jdKr
z1WbGU>cDOu;GMoc9V5(h{^U+V(w`HaQD6h-z-`D5YxBTWx4+%;wu?K)wR<Nt1Q`6B
zL(W61&N}BNe2;xUj|J8hhN^v}9)S<~orn;3s_~!%skYip_apP`F9R%tT<hfkTtU|z
zv(S&Zv`bq03Av*u=$4DL$#b!RAxW%D`?Nug9VVyqVtv>|S5!XT_g{Bk4gN10I@<i?
z=(95QDYftu=H!Rd(T)C6KYqH=C`a=4+wyrXmq<4v0;jfjj;BfbyF#EQpKj=@@ImEd
z$-~TehD6$ccS#(qJ4dZ^Vgjjd?lIc2XJlRgW7KdGe%-V(kgepBs#YR+u)X4E*Ga;3
zUYuldv<$eopn{xShRVa{ZGf<oaX#@GW_OZXgbw90&pet13Dki17DlSDKO}$bv;r7K
zh<Hv=!7^i*B?dU~@(*DKr7rSdarn;USc7;6ge4wJnt=amW#89@aU|isIjoYqpjf%m
zJVmFpicA8lRvbk**@~<px^4}vM;}sVt8kL4FvW}qOw^yKi?-v?0nrfQIuV4FAwl=L
z>7dmb28H3{;_N@(yfs6>#;T*V5RuyeRX9svn6Lw^{gip14zj@7@kwDZFPz5DJ8q^h
zc`M`_s>|EvJQ4pieM(L*S}+kdix{lN&H$VpCxac_Nh;KG!IsX8s1Q!eZ^Y_N45r^i
zw&TmvMQfMsz9m3O_S4Ntfb><z<Y=S)&{Cu<k)(13;RL1uQT;r@O-%B!0_z>^&uVJ<
zAnVjl3~k%3DGPu3;liq6vzBR-myoCA9wciZ?|us+GPYv-D`6Q*m_gp7Co^M5qW3&}
z>l2@p`)r_o@*{=pECc~Kl&p{Gkv#hS$7fT@<+*H}t`7C~bV=!ULomC6o>h2@ABH4f
zxnzCJA-6cb9+?^dc&k0;*2=UIjXIpU>i?X!PMMZS(l6|!KsG<m29FXJYV?wgCX$W<
zXq6Yq8T2!5#4rqlf`q_x7^^#OQ(w@;b2U{P0PoUjuza-}mW(pux}&ys+cNY?{nH9y
zCypV9!IbQqPx6yFD{Wt#ktS*V=_Rttt=FCeMoZ^n-s<eg43a?X+1aEf2p?y7DJrVI
zlO>2rzbml+opoJ5PJgi}mAX7xu|_oakF3jubICDGUDu)I0)~>QS=(a+Mz6bEXa^)E
z!#LBo8FKS;YL$u))uE(uMzQ=@WD3)vqQpwm#H}SQjBSNLV<FqL8K?WjCg|Jowr>8+
zGaN>t=+XKJ*~TZ??@gmX8vsZ=Q+C<H0kz|?GK**vrkB?763Wo))YjW`Y>&63VX2nk
z@gQLNL<HQyU(i0gn|SU|47kJl-z`3$*ArmRY-%xQaUWQQ#XNfuqRnsbv}V@*Qon*T
zI9jgUQ0Kyd!IVs=3a{QN{S}RPrdu0-fI~<QXk$&?n5-LxvF#WY-c;P>q#)nPHNKCK
zdSi(we(FgUuAMjHccX41td<kL$CIA=QH%#y_MA~e=7V?}elt(7wc?u~*)hnfE0?5g
z7#H7fpPD?V4DGT{_jsmhwAp|A%zF<2f}`LVI_+g87LaS|4?kiTo^N&O<h<$B3OowB
zC(LGe=n<lHb$&-KKygW1O?bOhWGKlFm?0AwH?-H(rZubu2nFS02^^FACczmEsJkTd
zI!K3-hOUsLLv{J{E!5f`n_q6r-N_SOn>m-!e&8N6)UjTDYsS)B_oQ5MLIgV~H`toa
zS{7(4E`m$a(y@qi_;;Qa-lt_S<@{U!DTi@2{w{T>;{8LJ;jk^xrkb7hhC>TePC%cI
zS{YvyV2xAu9sN}Y0dAh)N#1wJuZFHk<Q)u;y!jBKh4-PRn)@DRj=C3hn)>mSHTf(G
z2rrRi`6E;FPPh8O+K2ZX$D@(Eb&>t`Ov>8sLOe9Qs_jtIAobzX-_ny4oUy})KJ?|W
z9e<Ia%GOc*@#5jD=@OS~+Q87##*Tuc<42b9yv6hA{KbJ%hR{$LHID-)3(q*oO3TVa
zt?jdu0aWY@o2PdfEk52qkIjs4(h;z!d>vHDtX9=DBPr*xDCoIif*;bH$_y1KCsJgp
z>dN(FJ=qTP(>`rgpMUKhOzk2Skt%Zfra2VK`%Dk1b0`oDFAhrTjtyy>J|tn7(osbb
zTkwF_$J*M~56xiw={ENQ1O#b(8D{Hg@VfpAY#z+^W}6>szi&44hVZZU91)!29sl2f
z#oR2!={D<n|H*b(L>~Vq;Zuhp(=(x)zK=t3gN;}Ow$f>~NPdWeQ^LhL13A(PRT?AK
zYYZ|(Cw@(ui58lIVM~mAKYuJWAd0q^E#=HB(&{n~Kf%_6F+b+giw5LA<oEo|EZpJY
zZ%EYZ)S~0uZMmx<NUelAc;y~+=izD#5f>F-7s&noh@-(pe+{I|tI<)b5&3vo9|v<S
zhG12|Y!&wSp$dm*y?9|~_1hU&qF22Ki_m`&Pbie4B8T=TN2$jScHLiSruHp>7MEOQ
zQz%ubr&?^&zThAG-Rq<)y@&!jK{p6Z#i)0>45A;~Favk<7_@UL8#d>nKm50=48HSJ
zXI?Y7^KE!yh{;qVqVR4!4ThK7I-dHoANv%7O=q!~wN93J>#v!y60+^g$wcoYcJ|A;
zN7M^+WM?VXUQ)T;HLjucopfiFLv7}7_#=vU6mbrmZ|{Bc5RAB$>r~F&s!&w;C}QE)
z3*RL7dgKz^?7PbBjJ~V789eoKnda3h%&ZV%kUQbEPrY2r_t>VDBslg<(oI)O%6^(F
zGD}W!cD5>f8WwH0O+NK+Id;een>G2}ZIc|;jO22fNQ?T$YwGDV^+>UIdMtVsZR51{
z_~mMao3FRFJL~mc316nZ;(TRUKl+Z$+JPaW=993AGjNRVnUCZy@tQ$`=R6=pbx&x{
z-Poe9bPYiB(*2c|(e)ES-9sYs@y%rZa+T2JOkLtCI(a+-p&W8E|M}|)?}|7JxOP<n
zTS)zjg=)7v8<5%;g;u!|W;{u-8w`2N{aehPzRWcLJ!#Hj_Q}L6LS;TL-of<VNj*-s
zmgstr&M8HSUX<9xEYoYsBy@#h8wxAPz1cIK?8sQeY<fC)FOY8Kj3n_zlSdZLyIeDR
zqIauiWML(ZJ@I>ihP7!@h9|}E!qHI)Qb8ROP;QiD3W1=~C99rf^f%G|gJFdqqqz+t
zp=zQ0!T@_{Bj~UW&=4(5%gKt0+L3lLCE=wbo1vNTfmK!wJhWw8NHPmf58iswRu*rg
zdbQ;OzRuF2=9u=5kxjJZ@KBKn9~h5F(CkV~ZD8>Z97%Bdek=4SD@;7xlfPjwgMLk^
zw9OeDMkT1ohpmS8{Tw*zF@5Os5{YM)fB-jmxHqGm@2pBlM@(a?=R91)&Yu{pP3mY-
zh!ttT#H3Bpk5g=S6p@pylq%v6maUb-a35=`PznQERi(1id|O40u7h4$ZIk20qawo#
z6e@)BPB5>=2}U8kQ(|`B9g_qt&SpcUH=9f_8VZRh@J}Yb9(>Le&5T$Z))tG4?2-<L
z*<vV9Z8xoEBXia@r-PoMa9pCoX0POjQDuq~bGVlR=~?Yf=dVP!+7e7hYbx3>os?{X
zT5YF@jvr4iLTz}F(7QrWG*H?&I-je5I{K4g%7ejXHdbYgq36yazaBU4mWCH6Nd=oz
zcqIzbRkQn$Pa_Twc&%zmrZi@bk4qVyuGE)1Qy$Mx8KbHUrnXELm$7LF*E63H%`(q{
zV+)(?QVnTR7hP|tgfrl7J8u=8$eOe!i$r?2Ftr8ML!vJVFy53OSu-!1zp8SuSwjCw
zkOD24A8!<wpB|8WV$(iYqbUEm{Z*N1dtJHH^U`6;(_oUmN$cGhY0IV1nQ~N+yhD*3
z=_ZX71cjyR1vQ!GDT0QFs-Tbzp%2DW)<v6vms*BWNGR-Ysm8TRrWbkgvQT@xq{7l?
zN*;{E-qLQEo1W1xTD=i3bl?}RDg*ilZf&zZ6cnMt6#cluxYpbjj6^dKnMa3n)*Uat
zMr9u<Z{L0F_|a$hUBl5!>L)*RLpd57390rrSY&`<xWX4l3_4|}bfvE96vVJhDw$YK
z6HKYD#WaZSd>bXPRVr*Nhsa171rs1!ifO!Qn5e0ccEpTQYAAw2B{f`db@sTDj=`{(
zR#I|anNXIyHRt{MyR+=X8UjNYCBZN<gVj=Py`a`DEYb)t8ErH08F$)lf@H4NkX_Xl
z{lvUgt@x-@E}z^&SP&i0{v-8l@$g0ADNf7@`!u;nng`@G`fApR^j_w^TB;xoh3p}A
z-NcYdYWLF{R1S)U@m5%lC@oFvq%9b)K0u6KiTdFnA2fuvQ>!85Njp|&TWH0q(IeTM
z_B;Dj%K%rSCsM?f1?2awy%W7o2vD(U7tRktz1ZCc@jCC<4XA?(2=mND|66FS1*`du
zgs0A@?+N93K}@HIq@KXeEiJrU#ElmjYj~`k^ein7aIrcsvtdS(N|Vp+bO}zFX~*37
z2@Gz?yqb({kxb42KuRR`>^_P~O+2K)cs1mEInZLA?Ag$ay$rYYsXkrLYcYeQy`0p2
z0q;;$oA%0B16Gszij_+K5aMZ)W6-a?Dqs|&xEIZ;b0%b|(~}8JyHW2Q1-6To+qUR2
zP_#1BNjq`LHUgTw9IxW80VM*NzW3Y!#2KDDC6FS9?7ZB$!zr?S*Td+QD5`a7M@zSH
z$^L$bf4;Fr@+6Yj`HFa%30FP5(}Qa4x4bMXSM&D1-mpAgdK*`v*8S-CdRpDz6fim1
z4ezYPxM!<q>FfZz1LYc7mFK1LMvTfD9Hi&$JD}7tQ5i{S$-doh>S8xGv8?cY8TL1(
zyf7U6O|FzOY4V-c65DNyp6>I_d)-q^R0oDuuV#AL#G?>DGH3iP4vAH*t&a<<C_a(+
z(iigZnjcQEzJVUjh<9K&_P>`#4GXoZL5CYLi>4NP@`i^Pg(%x`lM-A_1lU$Ydw#tm
z5z{{WCuY<C%I5z`_L(_3|GT8Z`X7*>tp6({Xww%p_P!|m7jF&2KE^S=)PsXR<MJiG
z_$WTck4NPHgBn{|uEI*~2^ku!xJ0{Xc5m({-~uMS2MKBK4p<U<<?HdgnEh_2rr3HF
zjcu$v(L4&hq}tubV$*xW>zDTN`@jM4b?fu(qU?%bb9^f^!v(9@kw?^bijSc9tWVPw
zV;{h>gfuZwV3liKP2gz|G^Cn26r4>Fmo4aYU)X~q=QH++U)_UCw=}SpJM(Y?1gb56
zJdcF>CaBhysFaM-StIavspf+cR(1bu3Mn`qVj0DstojjCZhN#7#`|8Jvq+!odA2p9
zRIGB+40AC#XDf7MP+X-E@JCFn9W+Sqo2KV|eMxPs%cz@L3hx1#CW=$(*^NCv8oHe=
z(Qh#umzKGv59w$6&eKeqK<nvbmmumv{nuSt&f`{olpRIU9?HsbCrR-ZJ*S%pg6geJ
zM6ksH{q{tiP*AAtW~i(#wZM^4J;F44Mo~~uI!-G_NZ?JuQ)?MPC<+~xT&_#^^)Kgm
zSkDoWJUjoWn@QmQ-i!{44*C-@l(L&i0En#|Jo$-V|InX&Tw?r1PUw7C$645T|Ls)4
z3#)JRW!9cE9**p$;k)9Rx2a)n!hNnZtv{pl>-5|5hd%?2cucUsHx?nt$q<tm!2M~F
z*8xdeo})AAqea59Wzf0OJ5#FhGOhcVNTmW<3lJGXK!Kxo+gZ6p!LeI%ancsj*5K<g
zCr@c=Ov?xuk<kFTVq`*C-*E2~S9Ep5Wr(=()NlDHO8`8*niSh_l4NUHWh8+Xg)9jW
z+7V*rUQj&o6mLh-%ot@fMbG_b^%w|aT#fe<7la4+jY%9Q8>?}O{+x~C3r(&Ft-BZ#
zMII(nU{ep$h@x_UtRO8&7(-n=iD%Y(>eGAbdA4vK@W4r8Eu|ZVMm$y|X=$n(O^c%7
z=9fx=DM7e!%ng-JM9~yQjFy&}Q5~*z!XPG!mwHtU3_FaG$ohINg42GxMwA_iK+c3t
zZAnlm#i&9$I17p~4dYDbzgvt=yWTJ%Jk5LFltl@Gx=9IUFV;ozsuE;WAAhoF4~##}
z7({=JLT?%cXkr+OA#AI@bkPV)d+%|<q0y%&>{{)2<ITU!KVQxr=_$#IXQRd0g}FQ#
z2E=h}S+gzZru$o2HakgmX`HH>ql`xwGu3?Oz=@o+Rk`=-Gi9wp#<J(Z?7b&s@e-5#
zrqRrW@?1uM@IF>vkkoe8745nx*BvtElr^U5o?v;O?JYG<W2lmejt7iL1?V#wY_%r&
zBJ<>F6l4>tJu0@Wl{iP{;3R+cN+e+>?+aDvxHfS>H8|46v=9ruP}h+QgS2zC?-}TY
zGhJ|2MDGRUTW4eIMOhj#y2xYeWCPi0Z`$KG?5P&iFiwK&muU*-Y&LhQUzRo?$*IgU
z2LR<39iScjokC7y{UNwEnA~CxW`8!VmBZHI4MT}^QBd2eYB}jdJVPpCIKzlb_(GaZ
z3_o_qQSG{CXoc+zg;BKnm&OGk5>v^3A94hgWF~j{b?`bN6kx+0q>flP|G0BW9j7cV
zi@#0WoZUmI+DC#c0}R*ca{AxeM8<mhF{P}QeO5T6dmOCmN(+;nZ;Y)hP#;y(N*zQ&
zDm+5*9B7EwiTnZ?TB+5UP<>jJI?4o?Y1_Q2qavsCV3x?yXcZQJmp+cYZ&c246T^Xp
z4>iJ1QJoXI(a2-+3t~b^__l1-b8S3ZgG;&cp1j)muC8u4U5d<NUKyJ<Yty;lGs?<h
zz;8Rqk2(8=-rs=Y^~X#{EnlZvUG$cUQgluz4<JoA+m#InKDNd{+L!+wl`mzE+qRLD
z0*huVKWw+&ZT$h!3P{2H4|lr%bzc8-v@^0W{Qr)2*8d6eXJ!50fc%TJrM@W1P`;|=
z|4@=;kww;!6GF$e|I10nz>gUC#Ytw(5te1#Adu;svzuY{t6eLy&w>@TqP@M_BTi*O
zNcZHVhn}D&r|0c$&(-(cq1~Ig=j}{bb{}0<FjCD$F}+K+WGYA2_v8I!=?}Nh=M9qG
zFW)!Qk39$CKS1l7@6UICOa82_MaGHehV?GB5Xce`%!TiE5Nu6pmr5wMQ4pI^`Z2%=
z@9_!HDQA&2)tnPg-J0qK?PJ<Q_H%ZdC;}nEkAP5jX`Op&lG|`Tu!`CgndpSchJSiG
z-%k!c9&fAA9xvu>^?acAUwz-Mdk9%CBx!%%P-V`a3zsFQ_XTGIqI-jL01vmIlfqa;
z(Ck-b#1yEyS+bbDYBEmG39HGw(l@+!K!9;8#V1O~aR6DeTUjQF3B*Y6^<>!l=-cjb
z8QSk|3SZ7oQ1xawh8CA*OH8f~J@+@~rb)?@UyfcjkB+HPRJe(u=%McT4IQA<A#tw|
zW4F2MTj3=4t|V^|H=<6{c+6M4O-j?~?hM(`qkDqC<7jB@1rH@>{%+`fThd<YP0UM5
z>1EA*SSr?s-uhU~w`(pSRQGDkO70hUUX!Ol6{q&adCsQP+3+Z)sR}+ZwVB!|8`yV=
zJKCsmB`niN(ET+UHB}xfqkCyChx<;KULr*9g-p-!GlPO=*iW{EnXoqT&rfx2rf0;=
z^Gi^A-j9zp*Pge#tDJxqA>bN1uYr8uwdqa%ej!aS%ePF&{_C4FU!T7pb4R{V*_8k#
ztcJ4IZk)d8im0J|+7vX;WSoF%=%l(qFz|Ndw46AQKY=hUuJG**{S;P)tbUCK>d5f@
z(wovwAsv|@)4^~>tlz4Sp|sglWYNA=$I9{+TtEKS2CRj8s<_`fpiFdT6s)+h!?<7*
z7qcs%gwLR-5O14VGOsxqGyib<y_^z1<|{GlN{plrjnXFj4WI3Sh!_u90GL1rk^7}!
ziWQ2_s9Ef}ek59dBnl$e5r5jDFyvf<Bje5f19sJ+;2#?~dqXAzb15guZ{%^q3?rn<
z`Rxxj#McM=F`SKrWuh2hnQbE1J!gHU(lnP5@Mhn5u0xkC#VKi?An@k2?G5Iq+j7Q5
zEZ<52E>k-tug@ylThVh?dtw<{l2F_7vlxC*&`v~-_uNnfM)IJe$iFNe>q;#QL9k0x
zL2Mdwlo+jTRI_5Jn-{lSk6Y7FvtmN?o1MJ;_%WGWv%uvCQZ2dYhzqF0`q5wb7A3x^
z2}|{7!61_i2Kg+KnfqGSnnsudc+DSNAxRi<)Gzd^nSXb5BioJf`p57JNZ+gQRjeG+
z_5W@*e6?YN<aSycw~%cSQqWrE<<Esn>&VV!OwBMK;OYj+YGil}8b!Yeuy;U?2%#Oa
z?|fP5GJUl{Wahp;EqSUdrR_vSJ{CNz79;IMG=?H|SD89(&GENvzA~Nas4_Y>+y43q
z9s%KW@Oa=kp@VO47|BpJO>HtByqf<Jo{g8}K}jZxOF+J6_5k8b+P@=jao3)ieZ33X
z^M6Mc7)B1Z<%!h{!CSvE3qmQ$i*v*+5MZlW?#|F0M~s5}>qTJ!_m98gI1LB)jSW?&
zDL+ih8^h3EFw9;myr}UM3cXS-zxxD3$+<Q;L*yZedBXW&F~5vuj10LW5eMq<54pj`
zgMmZFH+J5q7Yda1tjcMIF$fRhqoerqvf`Q-J8BK0Bt=JZxOWXF%^01qsZ`$)Pl^07
zN$G4XmBAiCPas<OarfgTb1CO;*Qmq+tzxI!aG!MClGJh6m`|T2g>mg5>t5mR*SPg}
zrmy&r-h0z<)M6)Z@SO<##9g-_*0rNRw})=YGb`rwp-vrG*hO^^jDPzfR9-gI*`ATK
zNgV)V7@^-JW1X}Gk+*Z7{bx&s0r9DP)*I5^QD(|rYN!fclH!Vm`qv9Lf|YXFwU(8h
z@H$4Ly4GUj<2gJB34kgtTWo2z+Ool+l@r<C(ifN&=`4Al=Z9@89ipY!%`UXk##XgI
zq2f#R*it`cNl{JiYMi~s%B56B)fsGqtiXScmy}}LC7FDYx4+_+XEQLu!et4zTFdcE
zMx_B++=Wkrav8li(k7Q`$C(#%bf(gB6T1$Kpr)ii=X(~DJ*X<>v<l!ar;;~IJn8Xw
zswEMYXq(yy?e}!|bET6?!k*K?ogY~^YVafX5n?5x6~EC3fIj6d2BT6BackNZ81o1M
z3GH>A4lth4+3%$=EwD|TRx3!CBoAXgnGN8cI_%S>NL@tIC6}TkpeFd)(qyEO=2RII
z4(9l68wk+o&2IqElqAKZhA|$q6(@AVtxHIgiUwdJEoYMO$yqYcm~s)adE3%ya;4@G
ze9ha~17dTfOFxN8V7aCv@P~%OhyU6^QuN#`&7C&<n2Vqc-KIrwGZ5l_@J9dIDmb0>
z4B|0LxnW~v$Y7$OZX-Tc#QJ<R_Mbh`N>am>699zj+51>Q%-Q~MFW2I3j_EB_RV#G+
zl3g#Dpo**N?tj7Qb>yedL|#eobfP-EX4$+5X&=I&YJ9r)Qos8Ww!#lv>GybY$dd4c
zK2mY*&u<+5T8DX7)0Gy7XSV#Y6~UPaCDg~28t!(ZDpszK3F>#^m$f(%tAbY`{&dE_
zg7j5XY~3un$lWXohC4n?fl8KbVqtq9$0t8{EL|@Uc3Ic5-YFJoz|{vw^4XC21i$vb
z>u(!kIkiO%$F)5cwYrTJYr~2AGZyymO+{`0?6bD}<aKrqF@iY7weTFuNC`)jymMOz
zrUep!jEvfCTtysQsC<p)gAU32Kr}ggywd(jJJ;2fm_;-9t88Zv0e0jUx#2&y;S-A8
zFn5QqfT5ttRIc*IvpTSghL%d)Iu&I-xuSpBl|{3;r4}V(o#*n;vG=4fV0<k<W>UoH
zpkZ@Tuq1Q=yA<UUltUP}`T+R_Kogm8F=LN>dcrVL(0a!E=fnZ4(b674E+FswY!X3v
z!Z978J0g$y&91k1d>whu8GyY3%_p0UKeQK^B{<|_RuYNi0{e9a{=fhI3^e??DQNr9
zp?w`xyl)hDwf+QNQ(Pnn+#Wt!M?(rDOf+<DiEL>h3}YsFu-mw_!6Y~rq#D*L#U*4Y
zEj);RUsK1)&stQ#;pY+w;Z25Q96d+hqqY9}c2yksdW301JSs%DK&cErMSt+bHB3Ci
z(L#ztKb4K+c7J%9)|L$U!;=csFs@F`s-<?hYn>1UgP>*1Wwqevbo(!PE#7lZl}Mk%
z3T#{RU1-o#VlDip9j;;KVR{79DdKY$DE5t49-|%Cc~Neo$V7m)DHiACcX<t-(Ss7u
zdkeMtysJ$tF6s7PlbYUFoO2OA#pT$xC$Av>Gp?HW1%5dxeiEk)d?8n+%xC+X0|-%S
zXwJQQo-5!<)v*n#j-Hc^`8hHc!&>Rw{Q4|^QhxR{F|V3pT9r^p)3BH=u*?OtcQBD-
z;JktarRB4rQRtgdF3p)J?u~sRC?4y-!zzDqg{M4a@|o~SEkw06dinL5bJEf`cAhUu
z&@1^(KlDwW8c&_bK01m_xJmtlf{v1%z2zuTU(MXoYQF>R$R7?0cPNI6BNqbg8B*%N
zU>23I^aUtZdCNX`aW+tY#z9qAIk*jQ;pp(Je6>$ULS?F2i)SN*6s9=N0JI*Q7Ro7A
z8wbmMQaQjLs4r4u@};as4q|JnUo1p=uKuoIj1F^ot(~vLXD)|6rc-FWi`=cdi0<80
z9|Ck$8PK}zu{CcmjR;qmwOme#nh+{Vj4nj1fjvuBBYtK-DN-+Ex57dstQzY<oj7cY
zR3Awu`=7BPN+9bmtxY|uJZr0DT{6cN9?m5!&HIgZ)AxU8moOZ;7nOp@@*eMrsvx#R
zb?GewD6jC4_!5%Vd@_Fny2>suJJN#u9E!tPz)BWf#7aH_7j<y(TQz)f1G;X%CR;&H
zeqa&Ub9c~BM*2fRP9eIeIAwA$l|uh_{ZBJy@Q8>KoEJ29l}3;QlOOTN<j(b<GY^oT
zI8hC-E!FW;dzE5_hYn1IPNeNO$PZLbN!99d7OiH$3MgQK$!1h%wi}(c>Cs(bmxk_s
z`!9@|#4<|)uLJ60BXX>Ee4|4o1%}D-oWkDd9NNS0;Xl+)cqN+MIqHUGenNXLER;r-
z@9GWORF5>2Q|2t_$&1U%M2;&X4PsTukOWMMS4gPoYd}*&nQ-|M6URV@7^h%CgwJhJ
zGeqZZCzP`%Dt}rhC^k`rAb89UYsQ_;d&+AHH0!QDT$vGBks(FFvZhkxrn(Q6R-WJe
zbhEjD<j!MIsW#!yzU_b3Sf%7Sa3?Ma<wPnt*_dfBz7_4^eJ7xju*d&TIn=+2(ZAPY
zOq~BsY{tg$KXEZ^4F4-!jMi5UHG=SO4wd1bR%O`L4l3X`PfG-|9q140h4s8W!WCw~
z4KNM-YL%`u<n1VbVSI#5wQfqcS`@?Js~4%m^m)0O3;k-Y_x-$CyW-2S(UX<?<oXi+
z@lX7*5Xq6I&<S56M<A!?Yya|a5|iWm%$)g!jLH09%2_^e$mjy^{`G!w^7z6+@tsXN
zZ}|-A3mCIAcym0`(x7ZQtvwZTB0;U+ubsVsy<F-~X%dA0@SZ=p3c{?2^oUB^G%ILd
zATPiBs=?Pd=vumcJ8`C$b6F#&7q3!7;QRXaQ-AAyFZ2`Q&TWY&+7~_Tr)(zo9k}*$
z+6I<-#qz@~yjk%yKKTU^yHz`nBM%mxcIMwvQP-^dr5(mUn0T`AnC_;KQ#_H(XlZQK
zH*|&YttybysxDnoW_|0wxrqGi54N<H<;yq|o4g=*YVxUVD74Kp-l*^&>DQ;Zlo{HT
z&{hsohNj6#vip&!Bl*`3f>~$0$t}O>aEi_yle-<j`@xQ{L?T0j)BB_fNvDiYVrT|8
zR>uKGiqH<A>FakyDlQ*NQo!3b_`}AIU3_hixG4x5#gVCk@Uoy-qE#sh^&GInp0>K*
z4|4c?;RT?p2yw;MHL+Homox@e033JjEPPAB_V52>JC}PUzED;9Maj(mZu1sfl?%{K
z>MhD_&JN2APVQYkoD`trFH91nXk)qHJl8``@vK4q9m825%-yM9qMOB0Cgr`~4U2A4
zH?j9Nw{Gq<z$_q0j;XA#v!pm6!J3W8+@)8Cx~7aQhK!O|*>N1#@aJ@5tA4EBFQdTR
zswafuYl+F37iK)=nW;`!%y+NIv_)@Di`XtqlY5AfLU)m(%oM0&c=Tf>r+k25D0nY{
z=|@#}n=jFXI|^>-^E*bp+7HO(Zk-g_4@tol9g}noh;?cha{R1PUvZlGI0FdmymWgG
z8iSJ~h940uvhH^8r0?Tb5wNXbh0qC9m5SJM1XujI$+Fp*5FC9inte5`@Wadgjhb;c
zUS1}%g&R+JMH-$3_=#RPa-(ImCV7=n_2II;RI;X`l<|xgPxzJ~+#9<)y|BEFKY%=?
zKg*x+-Orh5_)~w&h*a-{r~XK0!cSsoebHN=8}?3@pz_+R>S<!JfZJ=DY}#2#>lX*<
zj#r#SA(l;{&7~cb{aU<EJ+2WP{{2*y4&lnK*@BunL(d<`XIQNzk1Z>++5t74c3t+S
zlL`{l{R&crS4mhJVr#?^#f3{u8p*oc^^=<B8jK%mye5X2PU}k4Q95Vd4LUQ;CAq+r
zvtl-0XW;;zWKvkUp-vOd40Sae=R`%S@D4#rK+(B5B#kq7x+f~^Dk@datM(wY3ZzEh
zw}#fE#Z?-=oK;_wiuy}q^I5*37*%uA3bo8fj&`kY^B(MY-ogR6S)@NMm;DL>$Kc_L
zS&!~=NC-NrH4ip|4#EM15~w2QvCZv4MAxmULC{{_K?)3z1l9QRm*RQVM2FQ03T)f9
z37mcODjRUz`%ho3??3Oq6l~tUeE&fjKVYjTk{8RH=^)2EP1MhZ+6q9|^*^$*ZGNmI
z{x#ED0izYe?GjkfdI8l97zgi^cgDH!+nSRS%E_Yc%IGDCC)`dHhUg5IBkuImXY7mh
zTObwt21jM;B!BVyw@42D4k71dPquylBqLYc;YMy4I@3<Q4H+Jd=ZnP5&%`e?7{1I%
zC#_T2lJJzZ{934~2vE{x)te0}Tq<Z?>H0}s+|H!nXUpVb?tcnS7pT7>Zb{r<D$k20
zS@Ga3ryH|8o<Oz4{uy5=uJ1Bv6zr8=#A|{p;I(c#Mzbq&WsZswm&YOtA7BkXP9$#c
zu(87<^=#LkAsf=X!XOPL#U)J>?g1vNukYe#+?_68(rmpBAHfGytYn9KUPAv3|MeFj
zu&7f8<|b!J)xNLxC4BT81`e7@x(Uia0}`?YW|zZI6z|M@0<t-$Fh*yx=)n&9i&y~U
zXE?fF8BHW(#yb*gu87LSP}I`q{YQ-KqXbrTDK}SJOF^OzYW0`a&X;HXWKq3y(N+5{
zSQHw^#CBC50noN;u7M7=>=Yfw%4ZuvcVXatX{3mW@!CWrl-ygYmnYN4IZ;$y8F61*
zM?66o-vD?CpLEgEYoqK+YWlQ*h+hGC(3VjwZ#aG>aR@FCs(fW>YmrOzE-$~g>Gu^5
z*p~Z8>n3(M2Bb-lb9yq+(}QK<CoV@S#FL&JvH%I#>c@DZ$g_hfsJzjO#KTAq>74J|
zb7DqRS%}9Qe=GsaEi>!Fcw$bK{fPas#NR$5eXqlYoH-Pi`m#=TUG^6g60m*(5leqa
z=hl1Gc-~fZ4AXdFM#|*FhI}s@YNVD<Q<vdBBKJwCRA|54kMxb86e%IYzu-xocFvHm
zgtXrdK+~(FwS|A_4*z6_2|08MDf;dbFEnt3GoaWn^N}o2k97eXsN}<Y0Q(O9Cv-;Z
zvWCSZhz4q&Cc9M?2}Fmr_#lwn%rT7<K$4ngd;}Lvu$(T{kRott%WV>qfVYM*;OO4i
zY<A@r_&uG+gwNp#QotqHzx$|>s*{{HD$>fJwGeb>vgBJJHXU?+ADmEsW*&MJQBv%>
z3bSXjk!KzmJo!DBVzZ#-wtt9{xqE@*_HSylH7It`<&PB_QcNFKq@JCZc+m>Rk2$YX
z`WSh-H)K;h=A(F8Mr!$TzY&vtjq;UDS(ORRjO!WX>;Y0QZJ)<xQ$o<GS^Aed6qm>>
z6okAERNRiA!UdN70AzA-1@Ork{?R|=G7__T$lk>;ky56+uoNQ`L+Iv(D-FZ&<nR|x
zvq{-mC-Wq0PfO=l`!!HUUm4vH&2^aHZWHR*$_8amAT>X{$^Bpr9c%dIU<K+U^(YrZ
zvrD?+f-Kzg(Pr%0mgxIzHHRboLamj)iBpL5&AbK}JJ_O0nnd1k-eRj7W^{X!WI+cd
zInz-G;P@C2w-sR(=bK#=Zv)9x4K4vgn9=fRH21u7*UCzl6>kXHsZp$xp3GLIaFWZu
zd;koJo2&5=VbYG%(u&ofm!Tm%9wr)quI#Eq4;BC3&g;&LPTIa*)LB2qKkDEn8$0s=
zbRtz!r1?$&n~@pA@HZoq$Wh6((2uAH)_D>}rFd3kzoo<wLdSX*alGY_c8ZXgnW^aG
z0o6<lPi{dZtp+7^1wDhVo1KXg;``uw4$&q9b3xw2ZGJ>nl|GopoY}aYiHBCM4jUs~
zVP&w0vD4v)*7q&1T46Rr&hB;O)KnSJhkR?|P=QCs$f&IpzP#EQ(>YacDrpT7#oZRk
z_#DRs%fiZafW{(Hs<SqXMcpZf%W~?~mAAxD$7o%oW*aA)GJUc8-QwF~1Sm<82NhU0
zX7=&BPq1Z%h$p1U-6pS6p+QkdCVGxaxu&qj;Y8Ub9Ou59Iy-@7du@mT^c3!^fll!%
z-IH!#P&XxuOt^o;TVoAQ)Pjj9o(ZoMV4~s-E1BJ~XMjQ_CA1p4HMkeFPDLDMz_D<x
zZw?NZE?rmiR)^l9uXz7*qR1&wVB05mi4i1&Z<E>J=tBWsR~Z-)E$|DXJxOalV>U};
zuON@8yH8BNTtJWV0E`xb6Oc^-r8`DvZ&By-!9&NmK30RUR~;Km6m}Vjr)U*Id6DzJ
zF!BPHGW^T(KH*I3+qs_&*vSUAN^0Hwbbp6hkZFi1Ur^>+8XJaJ9U>fd9mU&Vy@)NZ
za8)^|^!^8t0(%$)lUUbe72zU~c0dR_{V&@aP1C1wUow1ip5}d2p6QK2nLOHa;-EpX
zS8wZMXa9#&^MvUGeHKt9{d(d0x09vv>aV)#%eLUY?lhws4}q4IoVQkbYVh@7(LqlG
zK<Yb6(^7e$sz`d{!A~1>ID7m8j~J<VNHCYizO@Gu_~X9W?S^ebnr`gp(|g}P_087*
zA=Lk``2C+ypNW(8zcoJD{)5IR+y6@AGwZ8dvfunqxx}2X1%w&ME|NRb>r{aw0YU%|
zA2&b<#jT5jX!vu*3i)WOB%*NeNvI((>m+3q^+Bbsn<|3rR#5KK`{n-Si^G`D=V_^?
z<cz(g<R1-}&e}wl+u)qW9eUsi@Mtc_*Y_*ZM?B(t_s^Qj>27<s=Zyy*w7=kgNqm-+
zoUJ7)PYa;I^lbTXcze)%^%DAc@xhg0iY%0ew^IV3^{^NtP$*f|L^qO6g<;6h|0qkD
zQ)10%V$;&yR;B<OxQxKwi0P-UGa|Vgwa}Fm8-RM7ANNkao-d0Cw-<M|dcGs0PoK{_
zzH8>c9UCp;>1U%;awwV#4$cLq_9d4^G681?X<6Z2R4C7B77iUeO3$_0SZ{2DRzJ(E
zDO+UK@&O6JWu(;_<=v5rM61`?jGl2Y-v;za=5P6bE<DzAVryI*#8i*9Q0$wCy)rU-
zE*<jTq*;OsAg9vp0$=Tl{?vxMhCcsVCJbGfTGe|T4o^O`!BS}SE?8^2z*)KpB@xcV
zz3A?>kD-0wj7Lo$kg2+MZV8t@F?L5muQJ+d=~3}iXP&WQKHZQ$j)-9F(7kq?MyNsX
zVfH^h9RFgDm0LUcR<1DPFN5SpoDA{)ozoG;?&u|d(s*bSYG%oYrURn_3@Sq+z9yQ3
z-Im9x<D6mPd@kR-=0s**&<iL%AMUZO{@`NK@G;1rr9ON<-I--GXOscAw2%MfV&^ME
zLadU3g&i+=l>S3u$N0G-Z~*_-hzjB4aAV?E>{6=`i$v+TLL{#|@gsI}gsa|hQ?cmM
z)Yy!XcNa!OT3))-NYvlm3yO!!udL+tAjkK!)7?e&?mRs^X`6o4Kn5V8bug{NSx1^1
zq4#+QeEO=qc_soXn8=Q+lPp-FTZUf;zO%-|eTne-o8qx(&iEseW7l&CK$%bCUkfSs
z1A0eYhp-K(-;jCtO(5W7dg3Q^B2(jcmdo)adr^Q-(K~tB90AviynyCx*s?40a3kKb
z=InN`s*@9bs6=@8B_$;GVRlIFs0^DuRdMeTY>r{;-+POA<_Ildc+yP!c<g2!+8eze
z;Hv~iY3N&hK7EoMd^Rb@i%5^~{uQPX7R54ZLP<h}H;f2r%^|R5xkRjaM4HjdSrP3d
zRb|Itb40mU5_5Ean`f8hY>+K0p(r7a1Fwc&k5QaXEMR&5DCI7W>4y%jJTihUSb!h+
zU5We}L&KR@N7cd^?HsB(xBSloJ8Bud6?1OWY(IlN3|<AoptBUugE{9B!C$W`@lJ@3
z3a^N<&Y9jRo^y+`pr!wwbN4MppTIrQPhgyy4hj;Oi6ve-TvDVVG&7B}M6>cOW!*<~
zVgRJF?`K}D=m+nbHJ^+1c2OgMqJY=y-@*Anoq0QtG$p9DG1+~-tcvLQF6T6Ia$&y2
z%shbKT1Q+WG=#i5Iif|gsapmsQ})O{$Mnbg5%<QHT2d=tn2Xk7-YIM}uC#rBjln)p
z=dPTXe9v3Fcgzix7}h?efIHn_w=fIlo14)V6RXpnAdz{<GjmRd@E+sEoI-6_gMYCu
zriF-|=9>ncL7JdGb`;Oowra>#3n-MfVB}OgJvKu%v#&{{*rrn_A<70sXoQNv^^vS2
zIq|Ox-GM)CEE!qt<)alHs6Z1zxM5I2pyv~%%oNeJEM$jkdSdIj%QRl(m$=DRzv0Jz
zpJd{Q{G2s+&E4W!2=w8kM*Cf{nr4;myxfh<GkfKaSh_XcnI8)J!}%711&eylC~{aj
zW}FLN8yY{)J{K$>CH?234a21=5aZ$+=SWN0F(|a}7N5-`;V}_h19<5<i1MjhqRO9L
z&vel=I<?>3IZz$EjdBacMR=R%9>w!Px`JffHcL0?Pp1tDYzo4#ga3oAA7Yt2;XTM|
ztaz=q#@S;RVqbn>4!PP1#1U@34%aJr=*{4fQcoM#<Q+F|>>Owa-j2urf=KfQ9R}kg
z%jDU=gD|Pf#%|B=iWsP;X=-Mg-b!sA4k=!Pl#t+ol$5&r&vC^{Mam8Kj}6Z3G9~if
zvgITNh_&J#`?Urg7I4UHGZrzxwfU=Q_cpDzBA69Ml4#!eDL$MvuAZH?2BEkb7&A*U
zj#T$cyi-XC?{`Y6$2P=5!&mS1l`QR}^!7SvuEP<1(F~b7=xv&AYM+l<6lWAn96w4<
zfCOV8!HNLE=XMzqO(NKkQUb)pzh+erI=n~*0R^QQFJz7Jv;S~oTU*lQNT$YLF-rkB
z5SxXrW(WGrwMJrG!AJn#6vq$$<WG1OZKGU%y~WEscPQ8A8e#tSx3%6jd<0k=Fs7&D
zE9e&)HuT1ErXi~oN-itSFK79FIg22@W#*5cTKy#InSqu)HW9(JtG4kSUxz7!4=U5N
zWFnB$n#VW`fFKeI{8~>{U#4loOuSO-%J}ZD8S92Gbk5R@$!r=mj&lxKO;U1=t9^~@
z^))VT`jbM6!X>JPm&NA|yXuX^%^38-+2$3xLtfQVBVGEr)bF(5h!q-Tm*tkPRW<ar
zsv@Vo#=C{|SPa2S;7oId`ZcaaAT>Zf)fNw-JbBWiq|MX9BUYr9U9j5zzdv+N!8}k<
zXk6el1S~*w3{0`?(qbHjq;OWHPW(2>2$t#t8;o@V87w#qC9z*I<m;YhN<?o+tF&s+
zqjU=z_D2j8HOK#wIQx-YL%~>fF(?1J#L%zy+DXv;_o2ulNVneTcTYpQIV0(k^Vhlx
zsh@~#TaL&0avh?R4A=?Rcg_Hr$huZylWq#rJCOy`O2upF956iOylI|3^NqhIo~Ahl
z$}8_Rt81Ta%k1svS`Pjn4HwI;3ap!RzgC-KUqj2TaR%PIEm}nWCU369(@qXOZX1SP
zHb<^lhx<;r{#rYOZed@3UYk)~3;6cf%HWN$Brjfzi7DLSDdJSs)E3>P+ob<SJ1heC
z*X9wB57A~#v!pD1fY}`kueG`-bB#rE*OgtM^j)8jhsxTZHYdZe-o!PJV*9X})y#$8
zeF%|w$Q>)&%x>A$11|O_Ni`z^Mm>&A=U<N=b+1`T>8GKZyiUKr-jCJ4_+NKM&>_3Y
zhg(oKr~A8|>HD=Ne^{6uvjuq<v?%3mx_;5*2roDF3~Q~}7q~eX*+^QT+RFA^CPT(w
zyM=Z_$X>Oo2mmAXHQ7ipEQNw4qO8IWO~??xsWs>3gM!}b0~yQ=4iAG7lYhkMKuozD
zmdc#1PD#cq16l0HpWfvbviIjEA8bHIT45;8xf|N4Nvo1AOfB3n&=sTo?Ih#_-}B}Z
z3Wx22jO#j`_+^{)9W9Lmx-SP+92?KaDWJC;%1Ee59Dtww3{=&GHB0p&dv%f8($cy<
zzxarsstW*n9Q)}U36|R3XbWD+3v}2+R^7Vb4tF+&cPM=vcY>9fHi~Gv8LTpYam}%j
zM!a!RCd>X7cBKEj(11=Di;^+ViIh<ldR0ok1k>{0{-xJYxiR1$&hJeAw5&`4OrjYQ
zWT*P-tw)Ee!isO;M+T}J64&JABFkP*!h6Ia`@54E@zj@2K!Tl!?j$=dOmV`gQcd)~
zX|dfE*EJwHTYZU(CtB^1`>qt9^(KcZB9R2DkESpb8^jd7$WOF{fDi}q>1x2J{7lwc
zz;dKRj4*R*s;^b#$@u<zxRJGzNOggXBs6Z7p#B_sB{Gn<@WC}+VUsDLI{pF!mJ|gI
z0g-W%^BlEsvcE8_DmIkg4F&r43+_a`r?u4?tc7jG>z%@NfnHvXxu34Os8q;9L;%ff
z%UnY$`nQ%<MApPy0tX21rNQkctVpkbJt1u{mWEwd4!1agXu7{>Y5<^MyyZMj2d1*P
zwngI<M~bR_AFh!bUPWw}LcA*P8c8U`bCk`5zQ-CVaY&9d;)H9GVwj-)p;)Zb0POIi
zy!9k^S+o~ng(3+rJsnW_jQ4n|^>$v`B$tXOml3`%6X<}U3{cSce;9kG7}273!M1GM
zwr$(CZQHhO?y_xbmu=g&t9t*ZlkS`JN$z=D4=Y)(Ykc#YV^nZ4Q8<~o+Zb=vMX6t+
z9IYbYX7Z_zcw>L;wIT0OT(tNfNMe)rya1Gi;tQ!K%=^|DaAl^mCb*0mNxIEinyhU4
zFKsP1u_zoJFiA!%gM-R(yHHYXKe{l0h{9ndb9}IT4Yka7WAQjs*vW-oz8I-jt69rB
z3@US$_^-nfWxC8qBOfeN+=>v2b0*0$*uEEZW4B#OZIz%<`>+We%F(Yosq4^G<gh%%
zodTxYStf?A5i~sH;D5*54}`1dkx$FLP>~#w90!Os<&K3NkIqtUYL&#4C_!1<*J>RV
z_Ah1Wy*^VpkC`(%?}2aQ0WHdiSUcYbou`4?+n08Psy08FVrU1sM3Y;wy1RjM!u5D8
z2g9But@ekEFX-fN29*)aH!EW*E1vd8m9JCh4)WCZW?VCKK&Az+N=DZInnjb$$E@_n
z_Q}{m*KoAnx2DlH%0C3X(Tb#+gMa0jb7uA-zR8den&+FQri-v(k|sA$hPJt<QAHe6
zsoO5`yVmwZs3>LZ9xZe^_GT<GTvYkxN<$A+l`i+%?wxWe0AK1#<Zd$IuVIxx1}3KL
z3s4H1>vr6f<_D=}8#Xn?9&Fq?O7Ng|GQ&P?g&5%@6f9uJ?N_7--YNHz(5l9&eZDZK
zO9J5Z$Zi()G+yt{zKB}12Z1&80)qWXh}p9j3jw>v>h5{r$_JC482y*P35E7C#H!DF
zVQNs@<<mX6f+L_kkM;BZ;Ma|k{Q2()^8eESWo7!$3;&@>C^q*0sA&H4_<t)nZ0yYc
zgG<yc+PYQ59f-bteS`n3y3c3Yv<zTfw#gtbhWmqjG@cTTU4)<YghTyyKfX^jRH;k0
z^vGaSxb9WjRJmNPl~QKnes9m$i^q@Y{@+h+{yv;KeVV&J&IaIaDB#ymig?w@qsMpe
zqeJfgJYNrPudDpuk@<4@y_&y1-1U#|UX#RMeY3wlU4GrP8}MvfxXb&8;X`HM{1AT4
z;qm_zyA_-7x%pFvH1cA(yCdTlca|$noSAQB2B)tciYN5dF#Z#7WgMU0y6po@zcs4n
zdB6F1p0mI|ANT2PpQD>?mYw+gKQG7dLEqoI{9kQT+483~H7}E~k7?jDht(x_w}$Fy
z=2KtQPm#JaFDboy@oyEg7sDdmX79AysdS;g`MT}IIy#5y_hSB=r2LI~5dIIW{2ej%
z$K!N<rP0)#?7ZWBb9wDhXybJbLy?S^<RmiP@~7q-JfS@2mq#-^6;;1jSRwT0bVJx*
z%wGUtWl-vxXn3c2_^SEJ>J(o&9aGSfO%MLg@bRPT_sKB7ik>1~J&@W<v%l`y<lTKU
zopNU@0ilUSCA?XHE`w+B`QpS#D=|;`7}g_Xercr{@LB7k9L216V4|M!{ujPy(TGpF
z4r(<^^ZW0Q(d^G2pgEI8croukBscRKp!`B24keVIzYqX1$JKJqITbVKY>X>D5xb4{
zD(POc0`;)qm`bn^)53%p2S5|mR6efY@bE?Lx<rFa@=b$kB5MyN(<F9;#lde^(vR;p
zG-zbc7W&X&28cO(9kl6>wCI0<(e2-T?I*`G+K)SH>J))nTLbml%q^kU3b|;vCVZU9
zQtoCNInU<zfnH3c1aQ+;mr7`DE(4nq-2Q?oo%MrF%Y5}~GAc*7O}Z4TAOla9XqDD#
z7kVh{6PUni5Iq8iX+Sj46{HBYtSLJQ@YsF@)N4mb>lHSFU+`qxuIAlS#y?36a2_wh
z$o{T3DS|1iPudZeotTWk%VKhc8tciP;2nT8QRD?um~3Qu(C<y;u~z01?+U*Ftki}G
z5!KqsNC#<S8hHnR*qAgR_6}eGkfe=6M*T4%V2CXl(FEr^Y_aKX_xcmQaA2#^g?|7G
zG#$hNY%}jxK*q2Rigu_6<u7U=dinm0#;S2EDWB{b;v0CnoN~GxWbTjT6Mp=O_zNG0
zKPTCFakxcm+46%)PciONHO<KU3BMKu3uHcXO1%uk>pOYQ(F=2RQn87G&bZ811pBf<
z$m||#CKBQnXYD9+<pd+j99DtiMaeOAmvQ{Ebes|P*Joir#dLW8&odK?8K!z2K;4wr
z38hG~x*774Mr+9hBPt$^rg3W^$}}Y4YJWGuxb%>TGm^v$i5b8PnThZCcucGjgRS}Y
zm^Mt!TP_3Ju0a?S8?Qecs+D;OA^UBI_LwYQuC2IB`}hJ1P*=e`+Y%;&^yxbIVc^oH
zyr5zuu2VF)x)x%|8!yi{U66O^{d03%p-D}j%`#)2>}K-0&L$5^y1l2f?aacXGT;(z
zP}B5>5Q+6Y6E<NWHKDb5X|TN=q!RnFx|1O@d`1xIVFwUzFKmy~@7x+rC%V!m0QE8S
zW~7A*=sD+KaK>Q6uwB-t9qhF@IVm=|X}Fx1k`DMOq^RFHSq!oxSUc;?GU4N97S+Y8
zJ^YI%Op;*2KErtGlz10GAN_@<Om1vnY2YY|^1UF^Z7%qK?aAjZnh~1ir1Mz1G(rWx
zI}0S|w6)T$da&x5i{uXHGBRh(k&%8G7v=)>sH46)=T*z{7(csD5<`SudeoG1jmI-3
zcpk*i<N_?O@2Na<HSQ9yj<qCS9!WR@5V|BqA>5U)`ZBZ&U^NOs^sqOxj5w<uYgEKY
zKpI5SnPvoDRrqTQnndJ?Pk<x_fs{Q;KyzZ)LxX_?5wt{{6!9DuQ{^_cHDD3<?Yp}y
zQf@NsB%`Kf9pq6ZIudx7$yW<OEm<8z2c!Z~8)uSch{q&~!vy<)5Z_Qdj<Ke8>0^n1
zKPwp48%-j3_4fiY1m7^}EoMRT-9_LBsT9s~9g$O&y;v5Bu?meZx51d`5$GLOKxr!T
z8c5uz;(A>rGeFT03+Y5g=)z(N6NFH-?;~tz)m1p*`=p&nW4>-lbnWQV1Z(M0abU1?
z_4JhFcnOf>1P*#kep<8!uJ?EyAn=J+3P)0;Q>VtmO!0`7Zf<$8h*2*=N35($onz6t
z+~f2LA7QMMS(}j9$8rR+0l*o!QBrZibfuzs$zlTc+tK1du_h-pNZo5$Aol6t{EaY8
z5rhH7lX&_I>FuesiKZ~k5JQ)m48`8Ogo4kG*eAE_MBC_hhp)k>Xliyqf>j%4OJ)XL
z^P(t!g#&;LS1(D6zJWHa^cXC9qN!p@X-jK!>p=VL&#acA*FtC-Fu0IRpTDEFhbacN
z+67Xr9LbAf*p#+w*w~3<T7_y(42$>8P~DqkV9084vaD6|sHb75>KqNQYs)}aE`&kn
z*TOR{F+El~9t6i%zGCHJOG)vKjL=1MqEyywpBO3a2_Ssvxg0o~?uwzA_Xghq+1^tp
z7-3uS4^9XJGlO+w^r+*m1eUJEAqWjZ3Le5sX;Ky1hZzEVf|_1RZ5WX%DUrYBRLi*N
zf_b;LUBy&SnF;aTu$QweOW%Ya<7<`KHeLnmtd-9E;0y^Tfj>x1^E*F{UhYabh-U?v
zx5nND9$5VZs1OHqh|cXI4`nuHYyNT2Z&wnJ#CXIW&<Ag~JC>se0yPM*cR6C*g$x0=
z!WwpQF{SzyvJ8=)4tNVu$tP2(9aXWJo9q-3z~H0CwkI@?=azElDc4uCjx$7#TVPCx
z$_uoe^pLvVLK<rv<n?siL!VVgHE(R&1scKZVEVHQ0NREIUYOD>9;GEFoRC8O)u8ox
zbVW^19#?#Q6(|T;JG6}wGF_cvJc-aa7o1?_aETJZu`6?UIJ28G6#Fz~NCn~dcn(lZ
z#tXoooB|{`Pa3OlSuVgPKB3dE;=O9EZ!LBxuwvisBPpfn^ElP=$*+{SJ4ECR2<gep
z02P?{$}rVcIEKhLt#j{g0E_QRX00W`6@0P56fcj9bcBZj5B+SGggXoF{Y>4ByGO(g
zw{IQA@s5VyV({pf9R&OQTVDO8`N7rn9(5^8)=lpL5WMB<??t|u@X^xb<meIX6H;<}
z;;f*@9gi%*KbL}bBsUE`AYSqsz2<9!MJZ^1Ao9VpQql7-!vEbe1>w<wLQ=~Rt3I-^
zaP8^EeMx~n*`RMee5OX&m?7jK?4c>z?7CFdSrmz*OJw)@g(9~{R`|fFwql4Dl0nDT
zyk*bb!~|Y#Rs`Jp=~}NKqf9R}b#kkV=)9Vhdm)?3s<(`e2myi<C8km;P!*j!C~1p}
z?G>BR-RNCl5QT$R5mM`l#$n@#*CX4)#e~J`#Dly-5vl8BqaEtv6PDC6K^iN_N~69M
z2?r#F1I9YRRWR!aUE)Iqyb>(j>jA)DliBhr>=UoGL`*}F+g7_Z*=x3Et`OJO=Zbys
zE6TC})9wTZg6GfLd`2}$__1TlOzoG?;jU}XrhR?>r{L6f-2N`-{+gGM>D+oipL{kL
zPHSEvB}QgzVO2EA)Rc91u2geAu`3&8s~IWkJUDR<2STf}6Ss#OS?+3B+(z`k@qMj_
zm7T3~{UaDyY5h5_vWluvSQJh@pxii4EWRHjwz`GB<bA2g>0@D7%R9X;PDj4Il`$c1
z$IVolx&q8=dm>h&r5QXbTy(*f@1_BY&Mg)$%gzn|q}ruZSn-l`<$8e@8;4ckCPPWs
z%7*8=bSEI`Z(!4g-0P0iu@a?19UI_>Nqb$6q=QvlM}GwJxNGWo9{0uSW<`v}EjcUq
zL?Iio5bW&73KADxSdJ3}-E_yUJ0STnq0J>7HhCV*EZg))|F;TQVFr{oD;C)inT4n4
zuC`f1MSfK_{CH1ss0NR`Jyj2ZQ{Pk6nJ&DxtMj!KLkBEk?b&t~Qulz+{A;!Y_G?}Y
zr4m`KE-CVyW8}U)l4f*A*uPo_A0xh3OLykF>y5@%D1C5PFZ7w=V4r-D=PQW=gtacA
zxLumKtZxD-x?+~)J@W!B&lnF8UCa}=35!-^j&+59GRkE@(@fPXKKI8)U{oN`{Q90Q
zJ3idh-}?=p1V+~FzeAJ%;*I~>V`F6E{6A>I{@?hW*#Ad<r)wSUD&kQ@KmI<U1ookM
zxo20b5CL<N#E`dv`h@U*!H;e@xj{NdIFk3*ieB|yGZyQnhG0!KoN1Ze%HG<K%1*IG
zM7UosFX#9D=g-^TpU2Dn<H_T5{P1%I+;u@L&m(Z#H%Gp&yPvyJdN}+%JCEOK`}Omu
zlga-obn^A-2t$9p4(aFV?eIy4!akAQKVG+mv%kIrysf(5%1PxMOO8J>`#B9P>uxu5
z0IykJ6r0no71w%bT2!EQzm>K1`FHmCeoVlBzI^xT`wx}c^Z9+|bMV28syFdS@$>Nm
zwBK`b4_SI;4!>vSl0_y5j`#<5brsLN74AdX#qFo@Wh=Mu@fq>~x5d+*nmZdUnmi1N
zmdWf_lAUbm41G&`Oz0(>&rg{-3V+O}xeT#8!vf%+a#ZFw_$SG_Mcs&9OzZx2<DxT$
zL{IgWIYskhBGaFX3Du-`e2Mvl{D|z?YjP<d;6>3vQ%%rC(!t||rM^Z-&O=dCb9uHq
znj=Tm_BgvhQ+djoQyMU2f;dEjZ|!UIzixE^SfByo0Hi4Ao9eIJ{f#}K1Wir5B|YrR
zq{(gOu!+ZF0@0OBi=ao|KP*VX=5%yG)MDHr@Fsxz`=mIR8VM|;h9X4~sr?Z4c~hB@
zlm#m?WJcjF(RdF4={*z$mS$$ZR8aktMPi6#fe=GAKss1wk<%vck))~lUPV^$ro^v2
zw5#v-S)K_rFR>GlTuaW0(7|v~&IPn7l;4Qfo>ZTjfRER%U5YM|F^}{z&nzskGpm!!
zQ42+LS8m&Xd=^1UpB_WqmO*+u3c=TRUL$wPEbT$2@WO<ojHXpl$w*X&$%~*_!-oMR
z5o)(rD*!z$9)Qw$6#(Qksb#L?a6N2A+Xh!<NKavCvv=I^FNirH#Zjj=xFBNJD$h;_
zyo!nKM)a=eu0CX5mC&usb&}VPjT_7N>d{A%>s;<8yPK!Bz1Mrkt4M5Dczlm={W5`f
zR%2xiUtnd8t~cvuRUH7#1chBgbOV&}x{ui2Wbb(tAilNl&JxF7%<zpFjAA+j6+SX7
z9&D{i#|<~r;*c!>*9M5eoTLE@2Y$c6LZ;p*+5RuP$ha8vLQbdy*R!<5`BH@ZUePMl
zx;9|6|07S9u)#|no|N#s2J46!YCpG_)9vK+Wz8p%|5ihPTG#jf>5cOAa6feU319ac
zGk9WbDEvUaZh%#i+E9x0tsycl5&vhE6+rxrA|uXBIB{ruh<14b*M+RD(ci=U3bvz@
zSAKb8BXrD{H+BI;HI)2v1F~b$Hw>=%cToBwxx!|89F_F%_+R}Y^nZwSel9JS(OUlr
zFu&>TlHYELFeq#yz@eTuzSinIX^+(tYuhEB$-;cmwZH-k{w3r(nX!%XxH5Deoh10^
zHjPy?%(|XeQdCjy9?l>oEgO`xeRSRd!!4yy7wSq3_Satx1-A6u#1ho1D#3MFbO}$d
z!+fUOtV*cB!bhCs4Wg#jPfig=n_`Oaf}u4l;i<WEYl%<HxDu`wFU0&@Xl=QH#puEl
zuu%SyAXX3(z*tT*@L9o4X9F`Xewz0qk%$YbA<^D%i+ZwwHC;-4`-<VOPKvBG)8ZA<
zC2qxXJ+zo)Aw<S$FGv~jDWf*F5SZ*hMS~~N3}>=C?}2_yL!;}9?xN<&x9EBicnr9_
zRD;RJe)I96x0+33PR0PX^otl?-IFAGv95X>&9sjOnxMU|)t!lRn0)VBS$o4Tjd1>h
z`bS$2YrsN)M>*krLgW24n<;>oUx3RQYDN^kD5uh+m6C8Hp=D7%{IbM5X}u(=2wVfB
zMQIw*45qnQ#0XRa(U|g}TI7==NhQf&n^c|MT$F<M_B8>KO^9tWn?&1s<S4AYV)E?8
zkxRBZZXy^A^6bQ`MXrcbdYYMXWmb2T&hyar!Hk**p^(5Mfb{Z0mNyrB-uOnx^@sLT
zdcEvWJPJn1apA)^xdH%J1(j?AdBg}-sGr26=Ct_$=~P%rtFf@s_|?nO(_Cg>s~j6G
z^G?<K5+i9)<4!?QtW>+8fb|sV&=F`u#~1{GF=k36Qg@;xO0u5tD^`+hpbo95YYCbd
zzLFeeR2+28<7X7^zK5LDP3rspM$r}D81dQ`^sY{V;n-Qi?5+$N*x_kpv#f5C9NpDN
zbXtN@GgCLR9>tT=4?qOAR9K2+6wq^N?5SioY`lX9AtZup#q=8QoW5z}Q3@IIWk1r2
z_Qdz!3fLI}XSp$j;ED`eS|jP8=^V{?kjdmiwpuxZrHa{-xO#ORJX~gPjJAmeaFi)7
zDx%-f_D~0yimFzs(x^jZqs}n9?Q<9CZKFIam#)Vin(Km9qB7A4OT@Si0}P4ccaGs{
zsA1GAWJU)~wojgYNR6HoLH987Zkum^guFYV!)MGPWQ=rN2*RRY`IP0L@ph(QY%APq
zoK|S)&Qwsqx*+>Bv}!Tx;@}$+@mNx4Y8&xi{ZZOh@*FN+JbI<$byAy9+$k07uX7;y
z+9eH->_G7y1Wwe;L*PAE9|EevI4io^bEO+fDEl)A8Fb+6xPZ3EXVn+ItXD@RPTY9C
z#>n+iX0Ii7MW|T>CrbestMaN{7>kHiS{Y^Cz(*Ysma!KbqS+iQxCZ9(d*%6jq$LPr
zc@XVm+e++{7oM-xf|GR2rRIq(mER@FI{%vjuuk(4zaXER;xzwQs}IF#;F%V8izeJX
z2Wy=Os+WX+mV$C!-qud)S+P|Bdk&$VYggzy2`IjIo(kSeNO)j(FaefSy54B2Tk=tW
z8>I_F16Bw_3D2CqYVr#~qK)8<$8)rn6ig($%V8{GqvbD66*w^Db8mr+nRfmZ7}o^d
zLO|?i7iaO^YzV~`{;hFi(FU)H@S2+9o4=c~d5^W!Uw<Unl=;18FIJXf6N{$cjOCYg
z$4M-jH%RRx%TC^#m^g`lXr>g+ITsXgiT48UIvQ04D->fg*Il2w)1KZ(<7qe#f?S(v
z9Nx?4q0v)EKZaiMf6{bR+ZM$7LkJG7W^^`5(;Yw3r<>@`)Yc&CN1mQ(M%Pdawou&0
zbsStn;wZq<NIMn!3aNjU)aDZhE8svzGd+8Z#|^unl<|S#8G#KZ(BRDyK~koz1X=I3
z+Pjf<sC(RRvfRlHr~Au8X+5_4w2UXrvXzY`hzhCk+ckcUuO{HQ+Lem?Ij;aY9P+Y#
z(zf#1+V2+=xS9P0Hh&f#{fJK)n4#0Ogp9fQXP@3_Qfq7s1*@}silAZL$&g1!;Bb&8
zBbGFn#iMWI$lrqY!WSZ`OW<)doB=whb0xSmGEX?F$|v~vjMWk!h=nvq*D=8-G^W&h
zoP-f)EADT4MgY3S^P}3Uno`;gW|Iz6Bmxcnj7R08F^Ub3h2R0RZyc>=U9%2`sBTrz
z@&7I~lP>o?gGgB`RB04uLsKb-&C*dRf$HkD*qI(>4+i6)xmY1HCmW&$3!);;$f2x(
z6<2*uohWmldNtd>w*Xv1FO8W)kAGfE&a22z+pNe2O2wpG+_WxCIBVl}*WKZ$!4+r9
zjgPfM5r&}X?2sb6Q;xv)?SPJ2i_yIOl05;B7|!t$nhZ|FP%ifCI=tQpthuAfh$_}W
zyQa~g^|3?J_xBqdO$r=9jb~Wqs*O%qZiEq;VLaY7`m$XfbPGdQdrzS@6KJ}~R%s!;
zwV}0vAI)}>>k0liS<TS;SATgXv&ofotfsu&5_r-=av~i`ktI1QG9T0upbEXm?XDC5
zxe7}bOvzy-SKyaQAx4mA(;_djRc1=~M&mZ9>$=>8{7iLM#^3?^&;+oOz7F<h=YixB
z##=i=U2zrL1uL*uNuwl5)X$8ODfD<A1l!R0gFabj9KB%qw-a&E?6XoG-{frY5b|Zg
zWTj+WkJ`ZHh#vkzR4Vipe?dB()4L}iak}t?UYS0x?0nc}g2Vp%u7{(kYlSnX;6+5{
zk#m_r+gSOo#$q&uh2oz<m#9Rt1{$labNyyyABq*Q<l-R56-SD)Oq`)zNLJvw`Gj8?
z<X|^nA#zBa0xF{8o&?vHryRIfNM4|v%;Vac&?fdskx*QSu{wGX@=B{1`7}34a~}ue
z2xq<3<Zbx4XhG8ur~ia3;tY2}$LO0QVfE{<LPS-Ov3h5I#q9{N4W-Y^YA%;!Jd0O>
zn}OzX9cJ^|Z%oi)A_P8`%!OPgwsdj(`*3s>9$$Z#e8hD;Zjx^Rq=Q`<mpf(F+9F>}
zvqJ+*?(lF$bIvWdpqZ0$pH!CXU@#V{C$nNTJ1dbHiuWG6tEub6OX+6Rm%#yz&PPqE
zF}tx3%*E9Gw+nuZwGL`2sTY_pa!YyojpQZVJsq~g?Hnpy8@kq!;~8W!g%_=rL$R<L
z$VY9xuk$dP+J`rEn+ag1y7FIpn!ig$NT3SiC{P?g+>7^Na3QIFODJ?4>LFOlrtx8E
zY{}PX4$5_b&E3#HDl&fdgEcA8i|JNQDYv7Ze<#Fy$Q+0D)wdzi*=@-2qy@E%vAAV-
zuhHONnE{&SGg*1pcVElb^^IOCS=RHvp|}5yWdB8PEKCglm)<!3Uy}nn$N$9Su&kpQ
zP4bW4{^c6?*oUT0a#QD6o*>!I1R3_iN8poMnApSyAA+v^Z@Za^n2RdCR+%)S&D=Yw
z>)H>a$BgX1?q<{BPxbkJk4JBRp57haPd*-Afw}A19p~iw#)DlSY&pLk&hNr^@%+3x
zK5zNE{XbSucOhQBXZgQAJ-+UypWWMlxpV2-c$R+Ok7w!AU(pTI*j?*&x;utG;lttK
zJ@@{R-{B~6)0bnT`0t@A4(Q><6IJ{bj-T;IalA~9-m_xHo8w!+<sD!bgKGZ%>Q@R+
z2M+;1DA?LlboJq&@`cG4yWe_tKC$2aZ=C-7EY2FhT4HwtPmw<DEj#SIWk2hTGd1)3
zt}UOyP81ZlS{Z-u@6Yki&x5Tv^>hgNqeNBx#HYSFF_WvN0cvS&cg~Vxgio`>hKyvo
zW#ii|Gp)<psVRy4$6n6cA$X<O)~W>FayfJUsJ|_-X8Z22(*cv*1ax?vZQz^W&YzlQ
zQizh`7ZRXRHSigr!W5+q|Mxi|-exuT-^(HYmpQd<NF=M9JDu1ND*V<PBFP{3-QVkE
z^zVOrpT0j&|Fj7x_ovMFr%~Q%S)#q`y4=eX6gU2TR-_u+j3tgiD;!OCf``Q%j@A5`
zFTBB2pA5keb`piVFggy;G0_JXl`+5RD}Vjv??olU&A*j;$1oGouGej2{1z>pyd4Zj
z)wE38Rn@dRf`6<+kHtQ&>lX71$l14~p)(8`IfE>=@+ak1XTl~xdeD~9NUasFRGCJ0
zI(s?^U<RW@qJQNsAf9vyJ0ieBcY`3q*hKy!&Y2V+XM0^T5n#?Vf06ncRvnYeNH>?T
z!AqIVl$?sJE2inM@(A%6HqRTl+YV!XpgBw(RY4KzW%EZ4Q!C$T-&Rm4)31lfHW$tc
zm3YpsG;^w3=F3xX*`3A*3u|#UHt+k4K)K7&&EoULxg4vCF$EsJCaD@ht7q=xCR+Ry
z(B}RtEao3m;F13_Uk3x1meQ_uNYj~|uA%|(1W1T_3f%bW*rKVAF=mV%07QBX5h+xY
z9=D`fkaOeNJ?PN!0cCHfmc%su{iTm(hId|tC$3(E_h#Funhl1*>h#PG)cRVl^jxNl
zxErqF`rELppqc})$&3lrVD6}CR6(UDj^d`;_;Jojo>r--#lRtv0nY25`l*R?F_>!E
z!!Z>b`w9xT&c~k&G^i)Kc|w^)-Qp^^0Aqpg6JNcC0#zt2pqQ!Nnj1W4mR_g>{JH83
zW@TC?%FYxN#zvmcHl1TB^L{a(eu1h#Q5|oQ=Nh`xQB*jGIztnAtprOLtO9`zql4-j
z6hAn6g+!;OvTRkC<z7|%q_{9dr9_H}xBG5upCOC#-o2mm^aMsxCBGPL(qNLRiLA1P
zk95Y-l@EdzGT*6W#-uF6!fJglq6k#SRVV7M@R2|arcSZ_Bp*bYu)vB8gu7MH%p)Ui
znS-F*u(t3|lwIIBo(q(n)V6?9fMjt%%VwdyxKONflJbn^!4iGuX?efOS_h14F<W=g
zWQ!bj_lTy-aXmrqJN+i4&7S2-z#Lqn%Y69R%}5m59y*nFOt37Ck-jaMOs~MIFsYAX
z=jq-=hQGyqp17I)&=Aqa$5ExXhsB1id{&u~U<7@~zU+XG7T%5=(l(})u5cwStdllm
z9xy<GGU%8ODp-^K*ebymfL%#QJG-HmjGD&n`=C}JpFkGFVt^c(xNJ9-<1)=W!`W6J
z3Y$k+tbDSA5f8JC0(c1an7ao4?srYeVsT62O%zJHq1KOe`g;_>Ne0Sb95~OfLHVAB
z=V^(wHW!$MAan>QOaOIjW#ws!v0gEgOk4P>90CY10g%+g_azOPZ#!{U`3lPO6Mcn-
zX^XZL(wB`?82h^}84}|ZCBu#|BbAy}r*dp%h+2Hsu^tZi-d%vfeTJ?68Hg+lM6T6<
zR9_l!bvQq2r04lQFK$X>M4k<pUjoc`4Q%wyx(AtI&@1TlhBW<a^3D72n~^~9P)cwR
z(zo&kk4T!o`^msY5By3*tdCUL4_{*m^=IY4HW1T#)2wOne|P$~1`m?ay`-s|OziCj
zj|vDuBxp#}Dto{L&ISNb1bf{I5fJb)WM5SgQj)$W!Ws+-vFCobplZU~QL=1Q4CIKn
zoS|sYMdy5V0}bbb-LxoR6=MlLSj%Hbz_-d3=U|imL^o$ylkF2t+a`4ElVmfE9xF^_
zgk|u~6n={I(gVF4r`02IULn$a63sx92iaS0?&e=f+uhC8F>i`ACaJKczDnFflY-VK
z0)b$dHYZAf<;>uVZ;nvWe((OAp4_K6d#C|T5?n?VrZB<nrjYyvV~3b>XCt=@&_Isa
z;z<pPgAxm*6Qm|GM2i4kEhR5G(L(OMz|y{3+q>?h2BEg#vDg;fk&245Ldg6C*1;gM
z#W(}%+XmdG?(Le571IhhT|nOBSx$7jDEDeNXQt3TE0CczLg~w1r8bbaB4Zvp_r1zQ
zc2i(HyNFx1n4v;tPUxV4Ru&eoXpwMuaYew&K&?T6!io!kYtQXVIaL9=c9@Y%g>HWo
zWGnDuB-NrS3xYL_TF@_H#p51A78C^zPyy%`RVj*%&ZKEJ)k<+Jc~LD~P#CE{v1{*$
z>e3uTDjPcNx&S>MMJC20e4(O6=qUw5n~;EM2syoiC?^|d_}PTD0DJsqEo?!kQ<S$T
z(Vmx@4rhvM2aoG0H;a;?DlOz@s7Dlaof{HaZz29-R_u3%hZQg>q$R@CFp&T^^Q0Li
z-B+^5j7CIepb|!|cqXS}&tVvWSgou;XsPHlFswlBk0Sny=BTP<E_Cc}vR%6J22z~<
zF=n%t1N@S9=-1vQfd>6mbeO0Ji4nlDAmgD{HQJPv7`(7RbchEq5T{)?jw&z)_Ni0p
z$2t{kuo;$GT3v5o4~6v8;UXehZ1T5l`+RIpHSNj~c078?y`L)xbzFp_f9vpu?O1_l
zHxp^n(Ukzsfc-*ZM4z38lUx~;@J5Jt>(xEfP*pX~Ojf}WECJ(WtHw`lemSW}bu}q?
zgXn0)07UUt&@D%YSDEy9k!*4b)l7OmNI+Cb(HHeQY7aBxRJ|s%aReOJpuya_bYt({
zI5^{{ufk5QfS~d>^6<)7DR@af%xzW!rk0#!w-J2-*76ATjFHBU4SuCEJAl5XF%lYj
zE>4ard(*3Bp@*^tQ-lVMFf$bUuhCMG_h*(3wpNtMxc`>vAApR;WpDs_&R8))=#@RU
z^dzN+>VX<?@UnuP-WCKlX*F8arA8YH)bVnxOl74c*OA6#Elwql{-AaCA*9AO4k@Xo
zOb2)6tXM4R9&Z9C5Wl?`-N3J3u@Bm_X9H0{I`ArZAcr;aRRNh(M2?%gbFc7~OK1{2
zGsclh^Q1ITk*VyDgj+`Iq<E&)vxeq*YeCfvyT4!&{G_O|eD7-6+oP?2O@PIvA#=r8
z$UvnEr9&2VZKIOqfj=4<>D*Wyd}HevSnLS4QLbw6gOD5<h$A(UD0q)4Cmw^|$>|d+
zG1$RVO)UPXDV0)LN;A`%%5kg67LC{Kqd4j1UP~PPb2%gcB!dZg?Zn`0996(qj1JmI
z-5KHqJz`rFuoDSizzsf$2~@935jsr2oTc7gpx&6R$EmsV*%r-~p%Tk|sdS*pFkIQT
zEc&)Scp0gZ5@lafskF@g%jp?9ven*dc(AwyDU|T-T#-|O4(u$|#&;Gf_^OWp7{>uP
zj;(j$8j&;FG6Qi~N!Rt~=HEDEr-HE^Pn7mDaIahfs41*1>n;o3Un<{JMgp7>3mb@%
z-D&iO*D&e+GRZI+ApMco!BssvT<ajF)bU=MqT$;jbTHmf6D1LR5PI6F%|&CUp5s;4
zky~#c@z{R?P%I*nA2#rXN^QkFm;~9Z2%I#@8t)MXyF`I5nx1x$9+(o6;Hj1lHCO+}
z2vLxBdQaU<Z*XI``8D3?ixynW?ae%1fxF-BxoKE&5{fFt<-&G?7|lke3G<9sN;v3{
z3AI(`L1+9($H^^+G>YUt61>IlHdGHTJcvQi3Ec~%6k^=!0`c6fVevk!!Z|NX7f!X<
z8Vx+117d%}p_0a}3zB=^3hquHNS00dr$23m(g98?uyagJtx`j^zLETUx?ejoHZP0G
zVAmeRVSRwz?If9S3FnTz&M130g7W8(&l)Oy?iFOFX%<C_?5-YY>Ag7$t6>kZWndx+
z7AKH4xu!w`#YJtt2Vd!+aC0*mF5be2w@q*EqEENBp<h~38XO9Un4$EQ8>klzHl@nG
z6|=XOJch2h@1ihBTx(dNF}L1A8oL=6_r*(k7v@6>QxlZ({i@LjSdTLQzPsd)t*xa0
zyK4kf)j%Ct#*<=sTi#hyrS`O_YQECzfY#89k{dTrUi%m2KnOugHFO<|&;+D3d#FG~
zLtdzlz~qqqm_%H$2wiPI@N_CK=t1q)DB2*5>%$UkebK2e);&sgpQWp3y9B_>E@psK
zXt?c?QA(TE7e#J81*Oil8uGo^g^4wHH662uMY?}{&75yc13V%=E5{77Y0xfcd=JLZ
zdQnDT6<$pF+<t*_qAVSiTWVYg6)&~QCId9;PohL1+!6$<x1Th==Wi_lG8SwL<ZlN=
z<As7EaYG6KY@j4o)R3H)XtSq?d-$@j6H<_Dmj)VFgYc~J4ghHc5k|^7+!AhoM0RDV
zQSm})1+6kV{;&>cGM_^-)6b-2$v8kDHP5WfD;qOA;?zY7>*btU05)igSE}8adlm;V
zLt$SJ>wJ{@(+y4mW(v_++@Uj+blOh@HR<W#^eH0AUOGvx<5%}7G4cCYOR#ZoNc5K2
zrEcjOtUMQRIPZX<pWonqjZPMv6t4>HEv>a|>H5MPfgF^i3#kQ;MwJ#oCKYGLW&f6u
zW_WiJqD@}*jVHQMOOo;h@zW0DikmJ$xB`R@TV>^ugCj~Cg5D_X8tTxVP%ZPEP5i2=
z&Ou>zhuj&_vhv^qGeF?qjeCv1ftKP`w264h{^x{4*7YaaaRp#1g<+*hh_x9PgK6T=
zgan%Vy!&DCB7}7p@wJtz-qQv#jCE2;JvM%vPe}A@idxX0Ep?3h9yRj4;ctSU9=j;&
z!Iiph=3cA}%5sl&&7c*kFjJ40eI0-_Y%YYfRlE{V@p;dhhe9@f(ZMz6_+In?NuZVp
z8qGVC@~R+Zt2D-<3DVoU2TzXL?VN2QV4>L5uO9ZI*B!It>Nju>l<Zbp*r-Ab11oyt
zkvbmq8#d$ukz;msE4zV}p*4G8cX^Nqa5@NQ{WYFP#Y1J@n<@=GEj^`f;Vj;dXDGbg
z;|!&TB_ca?7b=uqK*(@H&>ynYBEj~|!wikyj01B;3X6+5cZmttNXO0Q>!r_VHZ*-*
z5VIO4LLDHh=?0i|;^O^jKqy!&<@??N2wR;5LgO=}{q^z}DntFUwXnE(+tc!O=Mk?6
z7x78v(6lPI!Va<GE~b;~*m+@Q4Mez>5jIKsB33Jn-7A3fWIh{5G}?bl^NFtRy@dFT
zE^l#%lP#332WGsaKW7@R!jyNMEnz@X&j;bEix67CGk&hu&fkn6xq;d(d#ZTMb@`Cl
zOIHX4l!k00p22E`I3wW9eYk1e%-GOfJzn58Ko-*+Bi4Se4yOY|huKTsc~qmiSdyyI
zB1e`uW%HCr`bT(_P>Os)99Z?-gEt%e=%^RaXPBxMxLn}18EjiOpBam1&enGEet=hQ
z@5=tW8OnbRM*cHHVPR(azstECOf3J;axMoG>;GUmcUfmMig+B+_qGn<ZF(+i!W$I@
zs6uLxZ6`c5%-7<}z}tMv%g`1cxb=4@@in5mTnbBnh32VpIaM_i^Pd+bVk~Qa49?&G
z-Qnl!I9$H(_b`3vIQ#h6K75}6=Uq_tf&$JAY4rZ?{cyia|37n-!Cn4t->=bh{kwg5
z|M#E#$FKeD<JC(;j$Arx45(k<pT)`J>rh5V74V@qN3L#P|2GF@@V{{O`8%h9`FhJd
zIr4QrcuSCcbT`BwMo#J(hCGs=)7Gxjw>y51PQKpntv=-|;=%Y<aCiHQ)v0>V#dT$E
z{OsYeSZOg~<G|Qg9KA1MGC6S&RoS8EaSHXRu@#aT8S}}BVlH7$rRQ_g=Z-Vy5zX&c
zK3Qgrd3vHd8qCb+y$Ocy`_^m&FZuiOhLgF|836xEX1RTl2{&XH!y`1;HDS@e%-ZsG
z$?RnsBM7xY-fv}k3qwmZs9Pz_{?u;A|CV#Nu0Y-Z;-8c6*wxPUSd+HIF&Nk1hbmpV
zx8QY;6kx(E-ReoiMH^6LVT!oPUJ~%De^I*lJiiVw-$!@9LIx-RpYFLJxpBxhML!M9
zGxFPDwQuobF{4}~7Lz>1x4~e+%+lR_@!96su-kRQL^TuML2GR)F#50I01NRA`wJX;
zwu=nJe13iS`Tqt%4p3w7a>!J_vr+$xc;TQ!<e^R&ROH2O1sy)xL;R6;iZ<!Q^K9hv
zyhvO=>e%pf!o_J1hoOtZihnhEgcI>F@?krSY*?2l7^!OIKjw{yd=c4N;Rt&9JY+MT
zpl}>U>cuz|YslP{+ad-pMUV+|&(7^K8CYQpb~%}umN>=R7M7|gR`{nDNlm!xi|c|I
z_^gW8XxfX>0cv+-p1Q#k0L`BHi%ib}(-ry&_9r}#aeY4)l3jGIc<<vHp8p#|afGo_
z!-S=Tl8UJ4zG*CG9=Os1P}OR&`?w1hp34roUzXrge(eVLutG4H%W}#!*taFG-z2nQ
zW1iTDg;0#}$64UgGo%q-AU?9(DUPIgj@`GV)>Mr6T{XT3ffl1jeuvXjitp&4a*y2X
zUQd+!!1tZ}fH|_z+(zUC$JnZj8dCA<y2*zq29{Trc>Ntj?~pR#4VBX_-al4wfR2oy
zO8SdUf)PckU)}zk`i;~sX&mtqH9V!3Edz(E%GBo1qNhQ_9VtBv#ww425Ka`rXPASD
z!6nv--U3;%05-8bL*P^;LNs98C|Fn2X-!W8=!27f38{)^fPWlmv1J;&`5kmu)Uv-A
z75zjMhLdu&8Pgt+iUA4&k3BK6>zBXl-a^x2j4p3E_RD5-drAqKjLlfLl$kNnNU08!
z2%{F{p+k?p(HJ*Uuy*37E0Q2*`V2c2iO`4^Sp|B$L_jn;sNeCGT@bq_U^E`u`YJ{C
zE+(azD|3&>%!q_I`u$e;E~zD~Jd$4*upQ`E7T{@+Msq>IxL6{-t(Ig<b+OG!8Mrfz
z;;{Iofu>{f7e<4yxb%`FM%o_FTW1&8JxyG}%)5Pvb&+z`8+aZrv?;f(1iBms;6cMd
zxmLOpgFdQe9N}@~A(5EAj~XUDiWcc1CYZ)X$9PZ`83=#t9Zt%E3#lylwef=qV7%s4
z7fto7oLM7cg^*N!K2GxziM2k&c~S{U-MY_RAgLV0j=Qo~R!8c?+HF((-Xxs;duoK-
zpDwvSEYXs*+zjVxM5G*$cbR!Do5HY<;q<lpO@MyF`dt9P{wYm}n>SV;%!x35Xjyc_
zL$JA~G+l-F@>bGh;$Hbdr&}U2A#X|@$Z3XSM+5dwM0vH3u0Wa6K)j-9CgWMwP>kHO
z6FKlAjr4?<aU#(Cl17F>&{XK3l(y9pcZmQ}O`m#Jk>w-mR%+?@rgAYI)H4SZy@rey
z@W*qr9%5szRz<d+3~h1xsv4v-E*DT>VSsc$qO}!LjD)W^jqCLQ`Vs~OGWp8L_-8%O
z4}ZCV-=q8Wpc~(<ZJ+ci>1|rDY(@7u)QzG0ad5(S9kCf1ywG!!N_t#CGXm1j1mg}&
z$jcGux1RAnT@kIcewy|eisX0FJL5po#TVOwWY}{R39K(e?FHj46B1Nwd+3j;zNz2t
zXn~p1P$PR^ClM7F7L|x+yVOz(9L!wNy?&$|x2rb)su3_;5s)LdIY(`db8T``Md(@x
zu-ln1*F}apsY0$YSW~bSzpjeePQ5h0+>As$qbT{`GI<7grP9p#&@od|mNTYIxel9Z
z%a~5k>C~K3BwSk9lxMJD+AWe&6WXjCIhFP*AwS{8rwHVL-hv=3w>$1e^InN*nxbbr
z)(i7ea<yOV{%o0FyeFu^dnVAGTa?`x1y2N1&$n2ZiL`N#rdaT-X;--{=ZGk(r>f2o
zR9HlX3G$kr4%%QnA|Pjznw|)iYpPR<UqJnxI0zknfUf*7=zE>6QmRvRq*tbuR8_Qs
z?FaW4gBq~M`9gbur)pt%4iU15>QC>D$AHi&>1gE<xgX^<k*4GVx4IUmO0|_(o3i|k
z3j@T~!UeA7Btd%qFsEDhY%=c8>Y;`ETJ1dL1}x|poyl{YqCttc)Q}fx=%u;k&4*V=
z*2|GBI@`3G-EfN@hCYtOsohcCp32OHzZH*0`(ZHX>YDW~rWzJ5rm6%JRZrnC8;qT+
zAYs?Ja^ucH8te^|6GZHQMvrt&0J0&8t592}{Cr}Ha^(0^0~O9n03!hbwoq=z0bo7^
z932n<*|SQtKN04r=%N+l0;*ZZoUw`tOs9h4o;VRy#~a)Gmmt&>L9e7Dk<z3QBo?f_
zSM*Sgu6pP8TQgMU&@Q_8UEw(eYCLODMuzUCa)I`_zy=vbHh?XwM5!oAX;PGFof~gh
z(=q-xTa6jHW{j}-dTZr!ebw4*It_Hr_c8A_enNJox<%UxCv44rM>5V+fK6lRZwE~(
zFaN5%L!pge3-c`v3;2#EPJ#sU0x=DkdNtvlj0l&PW0-Rtkv)xzMNGg8#X6^_Z&G85
zkFn|?<RV5^G_vS@fjUp?v%^k%#h@0|!_0hegW)<X5YnLrvci*`d;n0#GBGUA3XM0g
zUML>^5H(f;8KthrRK@Som1x1lUM`eSBO4;%`i2HXMx&u^Bb-EO4e5sURkclJpvsA+
zLtEukheD7Gp|~7lD~9Oy4-bre%K3`!ip&<LXt#206I3VLF`7VXEj*dsM4j`oW_z6~
zi*V!uRH_mz6w&XU2AA^)Y3ow1Pm?bns%frbVi_|+`%Fx=C{{=LWuf(7rls0a2~ORo
zD@b~GCX8!W$BQen)O~?b_P6!L1hu=i>to<;wSz)T3x1Zbj^QB|vwG@#i`Kt1+K{;3
z*xc(>@ME#Jmy&WM?(GH<1f8ZOtkN7LAkRY0P#ENuREc6-yD{8%5Z$V4HAbr0wD^*l
zjSLiDY^x>-8__-z7h^{Twg;<fi7xF4S<XBIL<bEtvhGALcnbr2bh(%iIW0A9XEBo#
zyb1E?wb39+GG98mf5EEws7Sq!{j<UOz+QOvsEbXQe=pXV^(CRmO+!gYu_K?VBm)0*
zd<xZX>D##x%?xW!1o>SIUbP9=g-nT~Mw5SD1%R0>jDy>H>2`hotX_4K^hGyr^;|HR
znmS3#2wteG^gUgwb3fgy;rh4l&g~#I@cVtet-6qOyk{j?lQ?ak`9M~oeWf|e9FXGL
zv9|O|C9y@e)~>LFP@>7b=^#p8DMaVxSPnyKw(QUtKogZQZ|)8pO>@;e<60h^7v%OP
zgYzr~2@X*&A8jyru?BNTuUU@Fak5A26+0~7Sj-`7aZ2JQ(u*EXddB5(Q>~c(i^&E!
z%D@f%8N&j-4T1M)UQu|`R<cV(Sg~42fWqaHBS-`w*My3G8fKK~VM`~(zBF53RAjAg
zL459@;I>s6PhK3M_%RhkK#A!N7p(}0Unshh4w-U+*X2a2Iz<Ntfa~o!je~J3^0@K#
z@SaEYtK0T^?$7F4tlkX)<F({0lu{-RwL(`q^y7Cm6KBw-uRzDf*_Hxa6pc@)8M#S^
z?q0>&ml;9c;ijaA_lSCUxQluq^KB9THeeTdm0&J%{=rwugU_F3R;$JZ*|0Qm>NvF2
zmvX_HJjE+ubGCrD!yA#~Xw`*kd7#DOL9=eed5bie#x&<^2-`@PBiW{8s0^EKjj%6|
ziY~59xpaS?$HmezLgUz9^x4<D$6%H#y|2nbO>QyX_66YCE1gcC0eG-MiSMAqx{JyF
zv!9wx_hI%KbkTaKYR6V_qVmIh6V;K=ktxku|8&+{w8_UOrDv!aF>&tUc;Bly6TswP
z*n$p|4>kFEQD|(e&CUa5rry_b2Cw2WkvJ_^n(XX4hT}xf(|Z&vby|$BS@93(EmPDb
zHO*!1ANluGrcbh5sYc@9bK8V~^PDPqx?QMDp^M*_i~O#vW%p0<KV?8e!Qb17KO%P#
z&fb6w<jN5Js43V0YO)wx@%OF-FE&`T;V3Uomi)Pc_?12nd)Sza7lY$c{)H7JJUxyj
zfVLuniMIuS1wQ_y-}D6%Wi7tFb1Sokk`fc=NutRyCNUXHX)JORZ<DmfMttl}7pl@G
z@1UCU1)}J<?8>OH!Osx8jD;Ol3aSM_qSw3`tj|Hvex2jPNf|S!Ij^+^eas`;@v0_!
z=BM&OTJFXH@xP8n?XBGC5wL>x4LXZ;9@xYG0wwvEZ~ZsO_`f;uzmDBmnc4r(u{#Gl
z`~QoK?Eg86|No2P9_vV3lZ+$wUaGUawK8N)xTCVb*4VMO-s8al;e+A3^<XvWF&oE&
zw*K}IKVZH`RN7g(YcK$3skxb&n3(YNM#L<*(7XNidi#GpJRJTzdw*#3etU6wo!xHE
zzB!(uInle``g3!-oqoEV-@ESH=^b*r%g_6Jdd%+h@$(4(yM4R+&)c)@$&L#Lf69US
z<NJQOJ+!!O6A*>`;J42EUGMF$$W7=bkI#QK;xgy$n3p!h-IQPaTS4aQLH?S|nbE`G
zcNPdE8wb<b6JU?x7c4A}1A#BkLFkjVXgF{S1d3A+-W6~Caa#PKynGZ66o|<Y%*rEw
za6rxv0ya3OnUg^C%~u17?5Y`CkD2M3dCs#;$V*U){40pYu;qMm-cc`-L0499m1zQ@
zeaGz}bsp7}!-GkMnsJPYEa1vF)|^j4{zkd1rw3<bM}qRkf&cUM^w~99*2T|eZXeRg
z9y}yYCGU?t4Y9#gc*44&WDN{eipVk{WES^O8n5C_m%23}Iea+e4DrBV;_oO?bWps^
z3%C?W%BL3x0iRUs^~Weo@-~gaxbV*TsQvB_jvvU&9E(c}2`^K@<;!{VZl!t1e5k}U
z>~UBl?C`g;71#iUED1nzT8~eR69SO~pcVS@i6%U>=`o!-0P~5~x{gMoG81VyS5u*h
zo7-!vVj~Su?vVlpz-VHwtkT~hB}&3n=X>~ASG=lI-5ocaKX?q3&ORcDz7kPb9ZttG
zQ9pkJ89dKbn5?|-p<6B{|9X|@UryN@(ATerdRZP2V5_TY!z2<jrjq7`)79oe{28Mi
z57xT8NPG@Dc%FhyF_WImxdFzHRN^~e?e!S<BW*+(4xBY*p5$?A(5P=%!`h_m<vB#;
zpj!Jdkd%n!BitO~P$Ext9VaJOcd{EAH{f#yQo6|U??Fb+3tZW-Fs1Wqh+k=6hpNgk
zn-Qf$CI-bLL}4y8bBQ@siU!;EIvmh?G<Yei22K&>aP9(aGiQyVw7nkJt9IC+G_&?<
zWDPX4Hjo+A9)*;J#$jZv3}CflhZ`+E5_Cz^{c|Y{r$3eVbO6BrLSwrgyK)VO<W<3|
zCqN^lS|0C_fn>FEr(e`s^N3Mp%jd5S81V8H{sL$hZN$OS2Lo%sJf5q{m&?twLi?pg
zYER&4Pe2x6p|@m2-i+SzLgZH7{DR1@1q$SthYnp8)zkAfi*X=`$^K7Vm(Ct-G1H;S
zAyzkRGI4YS{-=<FAz8d^9+`s{pVpjiumceI$wpTwl28RX6~c=InU74bX%KMdF1Soy
zF)d^%P>-hG2<C~Uhr*hOA;!Z7R5PbrPefaidNDvU=w~gkOkd7XDcfNgNTR)X$l3Si
zn4;H-Fd0IiaUkLI{7Q7T41L1wv~6Eqfb@oYmPyRFWs$6xuRt?fp;JBfdWzP>s7NPj
zQm3MnB5E^If>3iWs6_4A&vfV37=)`ms(*x3dUy&!K}-mEX*cv&`4DnQU=H*9k&+yn
z7gd0E@G?w2ql2JQMz##{Ps5u4Owr8lL$Avv=7J$GX!@7?42P;fX?3MMf`E5v>(X|X
z_o`7(1rS|E1;zH;9sk$cdD&6-^O$F}WiNVvJdI?!=nCJ>F(vbGC@^y|1qeWBo?+(@
z!m`UB<M;YMOjmh<Fieo#ZCJ!u5u1i0$=)?aG|-MS1`)tKfbwHK+4tdm<xfkHgGxEn
zchr#Lwkhx_ZzwQ>>OV#BIS6R`?wt548qmb0k%&$DqH+}Mfrhwgj#M$dO^!7ZsGP%f
zNB{1z;?iRq-gXph3T@HSvsZgGLy2uy6lK!4#3>`|^*3mu8H&eaO^^oh6fv_+{ZKY&
zkrEcOF@;Z&ds8YFdL#AQJ5CzD@j#JO|1KaCF*<P}esfEh@?5a<+=LI0!N9jZN_3)l
zCN=#p#@;bT)VNt59NV^S+qP}nwr$(CZF|nl8QZpvJ@4Jk-emtb+55Hg`|{*TI#u0W
zRjw^9hyc#_i=@9T;8B)C?0<fn@=|}EzP{p1Qkkn$GstJK6%s;F0K1h?7|XRL_h>dK
zO7O<7{9eCz^8<GmPvz<7^7VdFJ@h>C%w05(Y6eC}D4Y>?v>{j=BiI&EAwL_u=vn|8
zE!s&E@_LBYz=5q=1I;I6mKiuEiPOoT)fX{Ce<Ci;c*xU>+$P~R=QS{IAY9P0p_>OD
zbt<k?nb4ObHDcUwC8nR6uv*x79P~pZk<y_faz}vD1RLaBoO4hatVrLWV%wsg0SJO?
z@2JAo^_EDeH<-@T$Wk#SlXDuOFA|ibvY@ps5TmP3;aMnFBBhtzBf}kzh6Czyyg3R~
ztZ3Jqj{>`)<fLA$-HA-2K-Tl$%1@K*T_=Sok5~5NYvaQ(>!>!;l?pVRI{8$1RUkQB
z%4=mSQ6V^E;ex>v6b+xYI0F=)>ZZvk&)UoH>{_jMxZuP?{Y5#<4!2-UmHSi*RsE?;
z5#tnnk}g3>aZjNzlvYGmg(0NJWCC2odj`wISqo$GMiJINYpYBpJ;yfpn_uMj3tB-J
zJ`Rv@j&Sl00-7F(5G3datUEnQctA^R@Eyj2@*RSnPkmr{(1vkHZ2a=N9?n<C#wYE%
zrn!{<JOQJ8FH}i`IIJ&u!L(bNv5V|sZKkUh3zD^Wq-=v&A?1^-#{HOORf?WECFooG
zIEqM9{^6eesS9M--C{mRlOp@_*6R1VLNz0%9_QkBrd&c->{x59^(srUjnLyDP{3PI
zO>aKhVf0j8rM7@%0l9o$%_+%aQ(CBQilH_h)R2@UDFU4=NbVF5pg`=Mi86KbXP3Vx
z?);p$?MwM2Sx~C$q_ZpLug$xV0W@(mafNl_VO7Yb)nz6-rjQ+MW;{epvY1k{#mkE~
zJBMBwadu_H;KI2e+P%1Tn%X(F`JjF{MCRx6p<3a6=r5;9^-*8i^HsV__M|XgW&?rY
zg6M*NJm`r~>ju*Z`NWI&ub1xz)u&Xhs)hgIYO)(dZwLqmk@OF1@zzL!SW}Peq!qIx
zkv192Ubyi)*4N+A1^=$HH$}j4>L??G1h4woo|R<L&k2;N6k7p6W3+Akh(gh-Lor@r
zX%&5=t)*aYQqxHln5)a%z65d>&R-aD)<5*#zQ5b%?!kKd$v;AuG=}SJwwLD>MSD*0
z7S7&mT5<Gx<qk{8j8_&bZWF;h>8sQVvbAnO2m$wMNR*c5m|Lk@oV{p$`)adZPb#c;
zVNc+r&HUt#G=kZvH3GqRyUJ{3)AiS=<E`%NS{SHoFPyy$qUGvD6RiU%iJXH1X`_4&
z@2$l9<MR9|rRR7{9+mM{Cf5T(h(0eAN~^@6Es_Tx69%DGu}>Fq4O1q-f!}JvX&uTN
zIK6mcL~j>FK+%{7NsNGknOPyanj#L1WnH>$*jjVB-U%k9nrNue77K1+;~ripzdzJ|
zgrh?^F3TDjV~f`?uuqMXQK#95!eU&#906%0qHRif{%HZ3_#^OKtOtWrnx=(O%2}Fb
zS4Ww8rs~v`x>C{QG5@0FuG()1O+(5Ps?>bjssv?x(#cbMZ%G-17a{JM(&e0)TIhn2
zv1Ch^nty)<JzApRN;P)k_b=X8wDVlC<)*g$nD~-!5J|V&d?B~1@^~s+_PqWDlDV|r
zvGETbHEwKz-I8+nY*sK&0xiPw3I70tl_l?K>UOr$9^rF0%L~j-oHcvkQbC^E;`Vhb
zZzYRUW$9<TQNosOYjbN*X*U%l-VVXc$xT&y=;92voJ%PIJ5iq{g_KJ>4smd;OQ`cO
znzk{-=#gOT61wq#chPN5>pZyxxZ#LQ&V#kKauME>8unA~XvoU*HmH-K=o1ud>`o&~
z{mXI%;KUXER+n{ulZaRVrgs;{iGJa!R*`3$(`N&Cq9lGAp~E8HnpszB0trLY=E_TW
zS>!^)!P<=G0Mk}LqU<yRb2JFRn5T1k&xH(Ztd{HBPiEtFtt&T_NHk9~*(d4Uc#geN
za&_fXLa6hP&^~89#ATK`a*DPU)oMNe<@5I?@)f=s7)T$kYwM!6)5QGojDGw;9;1i5
z37e~3lkK!1pBQL3g<wj7D~8&2WNk4mYbh8^y!74$&W_n;LL19Z3$&wBI1gw!Lc_=U
zuC5#n?x_`5b%ZZ$U&5ImUf$oR3kw~;mP`$aXK#UK$+6)Jg1*zq8#488S6xW`jSHes
zhSDlc)+bo{A2x-#_b?Ls(qORWnwN*0F_QQM57Q)eqk|KYcmz$!hcAdPKe2%zQ0W!-
zKdiHDwp~*58Zflh?>3BPDfo^7r5yP|y@-d##S~Q+lK46rul0;e_3+Jf3c;bT(e|AJ
z`!d?SFRu`LUA?Q?oDhuDSpvw;bK3M+rJMR2ULiyftG8%OBM-y`1H~+S`gPTovzw;6
zs7-FYzNTi(^tHT#v61z(2Ir8@p@kjn#U(7yOZq&{$>WScrqGE8J8&3VDtrL7v)B=r
zoHPbmUK{EYhJY?RaVPh_Xw%pBhSrH1Q%GAset}dV*p=m3u}8SanY45oVU7p|o~F6O
zv&6XX4e{^uqv8!3zy`H)|IV=YotYU?{*-y1g+j|8qUd7_$TCb>rZciGx0k%b)x$v6
zUM~8uMtWWRs%F{WwRI$KE?f2`S4bJJ_jXpWW)j}Z@~YNZe|Pq|vg1Ji7-A4j+~Itp
zlXhj~0o<R#Yp|HN*3FwzPZ|rCfeM^mbsT7_oCd<^Wee~9#K+FX_=lRZ_B-L(v~%CR
zqY7Z}Ze4DwwLMVtcBX!Z$a!M6(zg52$Xcbgd)O^hWiQBXOB{X7Sgq;fKCAYy)+5=^
zRB?gX%~g)nVy3G4uv(R&>?X+T&ZfNVOWT<%<0|XZrz7>CKWVwYf4v_so~EDHIQisv
z1K=lWbEKVIFMqt73W8eZ{|0CxTA<yqwk&M)j<spodsJ``y_7@rdm`%5tY3ovV&cQ6
zFTGp;?nIAPdnV$63BC10&4C*&3i)+4aO64(k(&;~Sbpz92&<JzSmUch!gJ?HtPi)N
z1F2WejenpO4LEq*6%wIfKw>L4NUSx!#2A`OY}p(shT#>6P%P9#LgT7+ldug<Gi3f9
z(xYv9Gh>}9$dQzAMn-08Cy@OS#V&A==^4*`EB{-&zEk_`PhP)5mHwM2rhsVtcTU{?
zb`S&r(noQqoqqyS>0R6bnE6uEEZcHJLOCCDr48Vc01J!L5WrDjdh%`*sDQLh^KNfc
z!iKG;Gb~1%)lJowdoG`s4KboHv_8<-{^TFM9k>6g;lKF-SCqHK{hyfof6?*(V(y$w
z{~g=G$@G85c5pKNZ(=*HwYQ^5I${0u`-=$e18-WtG(lwtUH)a8@8Q9LJv1Ec)3Kx9
z1oxUSCmi+1o22WuO<!DOWp2-s8XC5Dcacap@%bh79sqRvZ}oQnzI_e9?tZ;{x_?;p
zd~V8JjR@Yz*uz<!dbyst;pe;ge_h`UZ-e^#zrH=qo$gB9U(@e?UwZhwF28*~%E1hu
z^CTYR$NP73^X>pv1g~=@g!{d|ZQpDMZ|;ZR#;a)?r(R#L2jQlwdU<@^-#mD{y3P)q
zB?WE(5`@2s8;13A4rxXi?&23>m+%A?%?ZJKf5rGydrjk%BD_9HOhk&jj~~d`2jCKX
zQa7Z&E=XMOLir?!%JUQ0yXSPgvyVo=m$kaQyyfjc2W1H2D++p9fep+ht#A^WzOjB8
zklpi?BAuT<4N*G&E*|1*r78W{qhpob);9Mp&ozpv@zPFG6H9YzP~@ubX9tZ*u0ndI
zmO<iM%$Dr#g>*x(`*5P)o}cq7+m)0T6W(@}WsJ<b&)fT_LhEdZBpi3f6)%&Kd^x`+
z6pT}9M(gZ)L>hIKrriZ+{RG^zpr>hMlo&g^P$ivvp#o(z(`Al_eK4&`%j5NRQSU*=
zG0oD1=>-<lCY{S!lu}h98SJGcgf669_~RIE)$O%D|6*Ek3>nfYRQADvxXy*x!nRu;
zyCqph+Jm7^Jiz9n7Y(q<SwekP)yk%o3BG+9eG@w-{{!jAZ#`eElu@?9QyP+F-sCgo
zB<WYD1)xt`bM0s>J+^_(em#@vPBPzgged$IVtHru&b7#nZWqeZ-UKWokC~h;3wt)L
zLzk3G*_n1vspF(f*EFv^gVqRx5p3j`R%G;dr=-Us*07wc{-rxSv@1T)xT;6d%YU9+
z1QH!mjm1PG7TCCWt}Sq)HCF(gQu7Nx%7Jbb@?kx#akU@<O(DrIZDAT+@6R_6iC$Fa
zMSzw)I8o#o^V$$0!y-Kx5mp0(D%TE#aE$=W;?fgy5CWy8dNBgKKmwh=KN!Ja)Nd|A
z$?e}$>s<A3y}^^J4k!V$JbD0vCQt#GXF)WyGhx_L{&yubHt@y?C_0ErAQe=UDZaJn
zMHT9rL70I3eT`~huQJ<zf8~=KcUh$-t1KB&)NLY;FIfW%cLr-|HEE&Z9dGz0P;GE;
znWU&_S8~H{t@}=Zn}#?Ks{iKt??hpC1r8@y5)$xSH$H)%`<t%Yhyo%tNklynb^`J^
zUBl?mYQ25+$#d(40=N~8ziSmtA^~WQWj=nB2$ECmBSZ^DGIAkB(wqi49`mYsx(_Ai
zLK+sesC$4;Wn~eEC4Nq4kPB%TEK4n-iUQo?I7ulnase8thF}0NpFF}^W&mDMS;&Uk
zMN;;|Oim-z1jY<4O(@QWXOsAw<)4IA;P3MC@_w;+h8}T?;4};G5Ir(gfms!}`!muz
z$zIqTI$Om4_m@-h6vwaQ;m5`B(|+-PnO5ajQUs%>@F;ey0yw)Kn3C0~mbkfr(wA{P
z7G)8ZyZ~0blj2Q@IuCh=i_fI_p5$B)Me9u&6ahgN52Huub!Qk;gv!MeJLLn>7Ff7-
zaicz;-2=nNfwW9uj1m={lZPh!;7~sqUV&&F)Jh<KD+}w@n^Xa#B#C<=53fh-4}D=5
zqdYa=yK%{Zx}@3^oN#5dGrAgLvywCHH#EtwHh@mWtV<h=tjoSy)g-)EOg2gdCpOWQ
zLb*cX(Ts3i^nk@}jGt33YwRoY=5Y?dX=U4C{_1<b&!j{hD;q8V*(ktn78xN@NVd0{
z=68MxIxnELsYHvO`E-7O^AL@Pv7lY7q6=6E9Vh^{raYUtmI9ff)K>*er~1R9G90GH
zCn#aC2lvF7r`EdAc9h2m1V?U$&-kzxglgfq`6h9t)1u&lP;1NA3F6jyI($iV(Vj$|
zLn5Sfa!iY@Zw0g;={yC1&rMZgB-ht@t<l{WuPax+yt~cs%X<|K7)5X+Y6uX$z?MD2
zlBmN9Q%iz0&W@2g;S`X23u>v95=Bpo_bDCKZ#1Wa7gfB7sJ^8wOdWcgJ~<`agGy8P
zrh2Apn}MJMH}M5eB&rq#8PTB|g-@epz#rilzCR_={2R|JPf&(WUdhZE6lZ6?y$IF2
z=qK4_N&Ru<o86ds;#NL$t$NfHgw-*sW<=GWcvDlJb66r$?lYM&0<mmeip4(yRbOtv
znep$ESsG%V1!IFal@Hm4o72Ipu^VOc87>W>rMKyU+GOcY39xOrUk|Za_^cmdeXjZq
zt^h;7WjuQ%ZgXWA=14liW?5HNE+QHwG~6O{Bl0_z(Q|v*W9yU`Yeaq3P+p+d88?vZ
zgDIni<ES2a6{DEEC8)xZYpi};Av!b*&R`i`7j{p92X<M7LP;osb#6VFrPxxij@7K!
zlhAmm1vK$p>%(9Q1<zE3x;%l>qhxA2=B6$eT`2Xt&0=gB_J4*gOIS$NagG=IW`t-T
zA=s^uIz&s}Xy$(t>5<aZSzn~})X_UvJRe$VqqG&fZ&J{y(Fi9ZY+hKO^u2l9tDGZP
z3=|A}pJEhZU6e##St$)~$`YP=UUx9UPwo@9*@qI%SIgO3b5Sm(f{N`_DsteHp}Lcy
ze#Kj1JsqMd(7Zv}Nr%7rTK=0G9EMyonxY1M+Yfo4&UqKc4RWF54tfMVZA}8$Rdpq$
z9_CgH-hC#`xlw!R*9ab2*9iU$xS|?ve7m~PscAL_8!KWjwLtZ|gruXMnhm+5a=#WG
z%4>QN8d9xSnno<rM!&(*o%nSnHsqxC0w(^1xw(q7&|b1xz{c+w=*J12WRCCADV}m}
zRYUKql0NvbKbTYS;HEkYNpqM?TtU@wut1NiYtYff6EQs8JkfoSYLmNhfFY?&g;id{
zK+Yn61@*RzMR(`>iQ^}FTZiJxs@Yk5+Yb1bmH6Hw8fj@kT20IA%wWI1&oxRtttpG8
zon<v#5|Sq_Irz-DcovJ=eO5vt`syYnhtR7L)$sCY>*+XFRm81!Ae%fV34b~e@jhzg
zl03&HE}S4CPs@Mxn3gQ-@i@arqVpEQC5xq`WZ5oPNy@Ja$cpph9Y}d<CBvFC#pZ?m
zGI%nCoE?U&S6}Usb2dQCP3)Y(j2YNI01ZrP;WuY^;`o<>8h5I6x*1_fRY|ihczA5e
z6vd5d{v!qy>)Ke{x}<;%QJV(Ui`LSc9A}%L0IN>p%y{ChmEksi430{qt4KLwzSmPv
z$zauG(6vkHu-^R_i~|oT;D5k-|2K&H58h*9VPX4!H#MAW|EEBblkI;aki6E>{LiMw
zZ?)dyF1wI5)twXt^n!}D%@7|A<kR4*;c^)Ze`dot@Sj9-g8QMWDvigO76!N|ev0}a
zI)a|4$-INS+<)8G<L&9;G{5inaQggV*6B5V(E;n`T++gEPVV0w%l*^&`_p#4JpL`-
z{wKWr+^^p|D(=t6*Vn7%$KCA1<}=I8qv^Bo{%$${wr<{y7+^Dn(Czd2`S@ZuH8-M@
z*T?xQaxrse*z~|Db1oQT{wNDga~4E?WClg?u+IuIruh)rD}rXE_f;XD6C8Y__-A9r
z@7+`PfA%Hz-){ZC`}T7UyT_;T^mF+7KbS8vUEXP0JI?Lqt_yC{Nt4w+Dh+~6l8ne)
zm5PpQ7L94hv+(@CZ}|-{wzR?=fR$3Sx29y-k(KY~^mao|Asy%*ApD7gF$p?QlO4PH
zD0cc!h0O4zRQcqVrY%J%&38a$#fr&T6`sN?m?{S#w<<%2hd;)lyCm0OwS(we@kPL$
zAMrC>!I@Z;3zzO8r-pdPsXH0;MFVrmgTYz*@Qw%@C7f`<tj)_?$<go9mS0IUF}opD
zE8?kGgBu7{WSvq)89f02K}}v12iO!!NLNo}D5Z#iqEY~7fc!CxRCNK5e?0EMiW-T;
z;`7dm|2}c$PjdXNPApX&2u^0Pk(1LXN5gRRQHcxAy<33CBCYlp<8Yaup@pa)oJv+`
z#}KR=;j?8tIhj8xm74|>Q3V)LFhH;c@HY{s06&JXK)tKluTG^I%%gBNG8~nZ_BH~Q
zIV`gXun01%qaC!s#%EB6$4664Qr!uZn$O}-eh@lVo;%3(+<eqx?2M(Nc_(JGL4Uqz
z3~ISJ-!!phFS3u*Q6V_75i4lfyr0ssmUkM&D=7vX64L;ob*=7=Wx~gAkJ`J89hm-F
zaPo)ki2`sF&1|l*ehByrm&6J@^Jgc?FoGu6U;UHPpaMk@DNR2zKmrhlQ)5H>+#=K&
z^i52O_RCQmQ^(3-kJi-X?hPByfZ~&Z1c#?8*DmCI4_TU>V*<xxOcU@CKn93mPJpNG
zM0wf?2D$JAQdndLpRZYxp&0d*@Jd21=ua`GDOd!@ifkQW$LA~5j&Osy9qnrmi&lK~
z0N)UkOU4-!vh5ICCW->*4I7%;o*5u>uzp}RXbjbJUuRWa4h*&`E}rHXK)77P_Oh1=
z63kE$FGxZX{t+J^!Hj0?&>!^9@H#*be#>?RPM>k>Tx4Az6(_f2{2s`e7z+Sqq<C=V
zwKLS7nc}N=v@uIQgwHhJ#bLeyZrJYYQRs<x08V?ZAY1V`=9tEKm{K5Ze{;;Rn_Epd
zLTWGXFu|<#bm(KDGXXC6Bw>~VSxT|q2YSj;k7Q78e#9^F<f%w7;6B>F1m9n(8q;>%
zz{1=mTnUZ|u_LN?fImASRV+kBP%psVTIUKkb>Y-g51CdviYrXtI+>L14j(+^p<Z#y
zjb9loZ4z;D$aW!dZf$#-N|2u;$=)Df7Np}z92bwBB<};ke7_v~WZxhf3Ro3?WMjI=
zYYn?>7Hs7=a>X#zw>GeGypop^&6Moor&uA;-Y_+Afk`{llS0Z<QuCM=Un+8PK}>*@
zvH8GN<jASq@wN?Kb(}YVzha*rY3nR(+i!yg)+rrT6eu-JZU#R-xgu~Rj4z_Vsx*3{
zo*5zkqE51S0Du8zQPhE))eL_Icqf!`{lNFop9E3UV3~_m>QWF5?izQN%bNwKbeAG3
zAJm4<)5mfkNGoH`m7*03$srM8sOCNCJzUJ%!ObdfkNRe#CTk7SBoCn7=mYa`Ww`)P
z5_;$k;I!hUR{%Dw4qq1x&b5tnAP0oCT!XHw68YdUaGe^0<}<%!`li1_X=jc!fhCrq
z0OT!L>cdN-Pgt8k;3-asAE<WPTOtI{Xu1H-zyweW-T-D)Q~hzZs%Rs~BDB9h9$O%B
zCi^7wKs4PDwMZZT#`?>I?}eh3#-oN8sjJh9nFpkn=}CY>H#FJCfZ+^iJf+uW3j-#P
zDcwz-1^L-K8-PO4Izs8QMWcmBE3T*ttC(MMxcl;u&XrF7?SxU@^#F5AoJsz@fkG~d
z;it^DTjSEv6P;XWQFe2zYcZ1D^zL=6uf+C?i5*7Sx0}`fS}iQ|2>a?z;9ic6N?3Lt
zD{Ibjpn5&zHClf?#Bu=L0_~mHIY%2IY6zM_*M2vT6`q9MUw4)02~c0OU}P*%(m04g
z#3kd?V<7nH%0ecoitX<_2qgQF79?tIe;p)xIWxPF$IWc6%9>lp7EZQ9q*E~JJ2a9Q
zX2_(Hdp8k<drhIC!a@)(5_Z<<33(EZKRfLl0GO+=NDE-nNSb;!wNpgTB+@WSBrFFp
zy0@JI)-A#<&bw&jGgg!|0paGTPBJXe`1nLXPj`fPXAu|}pkFOBJu*o!InSpXz5znK
z#ExXSATTS3H?*cOh>jc>!i)kEl-*GjYl#jg<YggOym*aEJ}G^4ESB}AnT}k+MF_n%
z6)isoEqs*N-jVLdn*wNim5KEbO{)~&k|M>RXGo`MP%uks#_4%YhysUjhrqenrD6a}
z$-2Gi7EvwKdt||n-=6V@X*QOjPoH5#Yy!+A1W>iZ=NQ7Q6qv?Zdk-pZhW=2P#ruv7
zs}tm|;0y&6$zZoaM!I=yJWf%u_A*P4LZD{N<^gFjYMO#-`}-`i#sMWGQXPaBp<(j|
z{`w3V{LKQQT32p{@ri&R{cm1+C_UyI?CV305bAnpxFYW8Maw{=+{E7Uz{7)*9)cEe
znTqPk757h}G&G3mYYku^?@UaU)uP#|)t^F#z*!y572<LjWsa7jH<k3YEp)>2=s%{C
zuB=aie{5(HuVT39FzU9#)|<o*I6zg|TnRF(t5R@*ndKeVrA%In;ICgpDk5I*`h4Ug
zq={ig_Z{qRQ1v=Bw~7t4zoiAuoL3#X$z75xZlx4#h>w$ZoZur~J|$9?LHpbn#Dzl7
z4|{5LgQ*`^wySz1TM{koEWlx@@U!$8ugElo|HejwQGdPWx+%C}vzXhdJy6lJxG9+n
z+wn-sbb3i}MhSh{MfNHf^jnIwIyR<Oyy(yzt7?c5mP--CI}!NgjLx<!dq0X&fu$|T
zRu9Id2zq)@ef$U!x0}eBE3&`BS)0_it6}VsS~bW3*x%N)UeL9>EVp&!+87wYi-fG?
zjz2i`MhzO+`4(W>U9KZa!CYZu4@fSp=IIU>_Ea{vK{v7ub-Rbni2hsLhzo(BbK!q<
z{n@b7|M!JLWl3Lr{$gUEzJy73Wk2wK;%$G?iKMnP7R8Bome8xze>Tt`qI;U?MgH@m
zZb=OO56n4xdRN8y#9I1`*C}1znpk`UgzKUF)O<t)IhnWvjSH}_3Ca7Koxg-TfC5sm
z-}TgcV1ZU~mO?zG7MYs!RJX~9Jr=3WDSe3X^C-MIR8GssZEjNDtH#m|0-W1mN%0W2
z)E{`JNxgu1oE}x-XI-O%!J*6DBtK4}sL8Tg09$?dO;82QMo)HZgBcft`E%gA_u`&~
zeTfU!D4(z;(=L?I3$SAjr`v|Uxkk9-xrU(3f(1HSYV}W4X(>RqXGOQcf9m~ivmboj
ztVW(j&x-44R?}97X)!)_sWS^YtTAJ;m>Q`GP=umo0(8o_eNj_q!xju}K^N`90<Fi3
z*oWG=SeZ`(BrP#1%a?%lYOS2+7Y~|qTOC{CWk&Zz5tnb`NhC^5ThRLtg$y<cEHA|F
zAAO{UyBZ(WfVVZ8l6T&qmVPM*Pc(~_rH7V64HttLJ|@V-I`~|U@+aqqWv20J=%=lK
ziGXnjc2MWcsO)zj1=9x8N*(rkWEYUv<XbErx~Qj<wcWfQXkT+H{Qn8R{}(9#FZ|BQ
z_}>O6j10{G=fL(~@qaV1J=T`~kHyJ<(%0^0=bKY+r6{n>s>&K;T@hf;2z(N15))0;
z+IkE=ce#o36YHyPwp(2of|gxeP0dV9M$i%UP2}URp6bKh<@x>J_CM`^zV@HKMnCT2
z7hSUO-X%4kDdfhY#^0YFH_xkg^LF@q23~LVc7MM2*?m4<%5Q&~X>R*8{QGmurjI?L
zh4=gOe;@9?J_=Z3SYr4$7BAh)-PIk9uAV-=SEEtT`(z%RPN0?3o3-9t8li*1jSM%R
zLiA-W9?Dnwd3t*Id^BY*L5LQ!l3kmv3hO^cC!kNG)y(=B+6Kx8X<{D5w^Qw)h#Fx-
zvS|G7n!pB&Jg6Y}dBf|&k(h@+h_C^H@)YIjYW*Djt(bGb-0Z}Of^oJalSd!n1qyG1
z)!Tc{3eF}6eo6I5j>6t+@1mc8?}lOU4V?Ybs<U6#Z#Vrlg1Kg#N&px!8CZxqc^V-}
z^pB#IoKi23pX;|BgHjLS+;H5;1WPP5Cab=F)H#$1hvSl4h?~uXn^)9=-cy+FVNt`Z
zc$qb<#Drm_9@Id7of_{hN14jq$cFh~Cer&%oIR|D6AL~>oe=nme_$6ESHB-)Yk%GZ
z0GY7uR3zTua)vblVj2rd;!+P&?m~YFw3Ef9CF_gISfS8+#;_rjJ%Kw!tGs^egGTk|
zk7$}LyPF#5`(s(ab(yY!^o`}J@83~nlk6-<zrC+34VWYesY3~^q=%-9ps=0I_xG(V
zuATA**tDPr?|r#n$yl3LX7YnJG26>_Rk-$Tne-BB7O!GQJ*jV}CYgfwA(6j8ciGSP
zhJY`_6nz4elQdK31l?C^rFI|3_DYGZ=w+LDblMyV%>>Ffdz0gPm7@#Ysf^G=Me9?O
zJHS<H<>crDu9qrvZ+Ve#qr=oQw-98{_xwgGM;)!G=Lf>*5q5%IMg)PML?1zkGbo)z
zVD}Ds+T1v#uD7_}UH0R;<1k>SsfT03GcSN49zMoDkn%S=z|eoV??I%4u>p+UK?(8X
zMjb^-;l7k)+l(>A^(r;4lL>c_OQgFe%`flcMvWtH5@O8Y`?dOCz_m?eC>uCS+~Cqz
zB&n>ne%p*?`7%<v4R;D2l!K%}Qle5OjvQjZ>y;M@p?#l&@eAl16Cx0Nn34%ja<-}R
zCf3vbHncs5aQ`h%;*1;Esu}}}lM$Oq;7}J6E_P0=08!0yDOxHLYvhnYzWb!~Pz$88
zW)%dY&GfB~Y$jFmKu-F@r#zK_1P_<N-yI+X5QX>7fhB&6Y4Ck(65_!a<{?3us{Q~Y
z73MX%43MxO^Z-v#)Hs$9;Tqj{K!t@2E71<>7f;DPVfO`0s$jt$<MVRM^m|u>9*o6g
zrxok(s6ZtHdue-zj(ON0h&$(}IB|AdgyHArJfKcf3x@oNi9Qr5Es43pC^w-oJ%HS&
zhf!w35SmO{=Mnc9hWdB>+7TvI7_{2ck0liq8jjjW=Ruw9in76L&drg&!vRa<B#>ky
zj6LSJAuRAm7oA@wE7XLIFAQP}U{LY3ATapIM*XWzP?c$7SaZr?s^e6apImtvY$GLD
z?BF{gDNUgjT=i}gHtpe^M){m_(4t{0<PIi`1&glH;W85ll6YUm^x+YL;IEw9!_m$W
z_+6Du?nbApj*%I~k4XX!BP15m4GV7kB4fHL!_&d}sO(5MDQ7mog?1zXqasOGvNAcP
z*31T$JJn)GPC_D*+n6ohP&t-&y9z{RKa`Ij3yPD@a_>|*6htx2HmE(I5U(2QYW%}5
zE(Bz#NfuG#80!`YW%Z{dMQCea0(VH#ATuF(vf;lw<^Z<2+Uvb+00@L_WHQTEe$&iU
zeCIj7{j>lH_4g%=2!Lor$Yu<bXp)1ub;HE<Kq5}+3Y)Gmu4Ck(1tSeSRiQ12aT%7u
zLj8g`$ZpouRnmoPL?F!LnR(aaoQ&bQ5GT+Hh!G47&==AZQO}e2C`_Q98h7PpY)84R
z5Zy-&KrOzN=gV@VRlLcK6l}Wy&<H3>BwA(&ZYDQaGe%&-&xoZ)G_SBDP%EJymIiq`
z5l*&C12}7R0<9*RMQ0*xpv35{buy#M+G#H{*k5$fTH!>_rMy)gGSAXA7!TDH2Ec$W
zpC#TeQ_Xqi%$NX_^~}V7hK)6D<!oRRme1Y+7)p&`#q(lFzbc?1t$gJgFW$DA5BAcy
z2u_s}#neOu_nf6&U3IUAo144Em+Os}oQId)dbIcyIfi=_Fmws6*pLk*wg~jT|Je)J
z+Y=mqEPle<-|~MkyE2X8a!tDE;yh_v5^Ot;muxZ_A`qj{kQjCjDGc0xh7DynfASD@
z_AW_5V}gk6D>M*-G_0pRDnQJaAO|MQqybeJDK09lnN3t9&OHs|&?*y?vIYnkWL7OZ
z6{oXDnq(p?sdp4|t{BIKO)M6G>^nn+V4h%OByfu{io_d;C6wP`@rli52@023xU7tG
zTpbt*hu8db1Y~t2M35{dfX9HaJ9RqawJft<9TBEyx(G1GWF|<-vE|EX0!%nx84y+;
zd&cpK+2@evJwXt=_#U!~Q}L3^afnJYg;Ssk6q)DFYCZHz$PnGs5|+vyTh*z6kF6Yb
zP@}YtU1l_&qFQTbRE6*k51sAlpVrL^Qvnk#zyUb~gMwUm%B;ria2P&Hz(InkMr<ne
zF%{5%cL|mXSviJz|Cw}-&UY^`DUXj`2{EWwmWlM?bd;Dn1O0`F98a+WyecxCOMrKx
zHPis7u@=8oZ!XnM&o$VHB{}z<m7mhf+I9@zetH~G0>GM%C6iu{S)g8vWKGs<?V7ae
z$OW^KRzn`FE4_*W!|h!_xm@2IwAp$`sOp7tc6aUup3keTThFMy5J}29D(>~0Gm6@z
zHY>Ou`XJ(;o91S^FA{bb$tf#A+pi#j#nw??%({VPQtLhBQKVVb(xo(8xU;>xkd0t9
z4R7MeBGfh^$hMf>gMd0h*-Y}DY(cv7e`EKKT5>p1@7-tiSCoxkaO2o>D%C4O-uN>~
z;JnGHeyrNx5^9;HytQQRR)WLHm`(f<mYS}g7#^c(LM$&EdY~m_VlusBMgVT)W=xse
zUDl72f!C;Ivz3LM91HqXzMvJ?W|Y{AUO4Bm60K6eKc~Sd$r~IxlJ1sTZrlJf?5X;r
zw=JyQ=;#fk*l}LzLuHS;d6+_m9tm{@dXl!mC$ncpQx^F~i6L28l2F|O_3M@BbR@LL
zQ&tT?M0nE%y3A^<Ats=AT*iANn;r@jiQncDJ*M~jHvEad=!wRQlD5FGygoaWKa$46
z(2_vcN*!~94N-ZP9fA0&9y*BdNYcrdOivxkUfW%XS!X-tVf&bXWn`?ChP?xDR6hY5
zD@jwQq8rU1QAHC5fpB*A<&p0CV9KNZKu1T>i_beX31|o%=gT1HHjdbNc_8hwis?zE
zoYu#0lBQ&f5FD`v7Me~T9D)6*)!U^faC4mEzF@6>O;+_!6ivU~Bl|iZA_tbntqy0z
ztf7=BhMHrh!dofKZYT}1>Ab>v{#ENf!S>`(lo{CW@|-ioG?!=~P86L^m<8O2nU&aa
zf-5+dA>2`J$W+eljOS>e(}v<TWll_+aslr}9(1Ie36w<!WFy>cDz8d@pUytcO$Q!-
zd*i&r^vM200_tl>O)Iz9;UgS002}s7GqkNXF@P)Mj+~zc-eT^If>S-cFVCy4(y5Uo
zEPlUacriBu`Yhzkigj7F%jF?oZC{*6T&|f`w#`#e@SLBpf38Q1mrt!C_3eDT2_YMH
zdd7nJtkePkOwV}~fnp@gd?;u*vAzVHT+F<{+Tb&TiOL%V#{79oY}ds#HSWT|%tjXf
z+x#I3DYN+{3)mBVNbV*yJ`H%Mc1i{aUz#d`p6Nxe>Hcf^@S48`s?u|9^u_S)b685w
zXO@|fw~@Af+V{NFyR>Bt^(cCt6#ek7xV}S>b4UlS-L}fbo`>Z3<V|!uce%0==KFN0
znryPPP(3xD)WCllH@`o(Y5_Vljsld-qnH0fgDT;BA6)R7y9|Nf3>0%|sDG4ZRpLE9
zN3Iex9d*ZBB|Z^RMuZqtec53*Uxl-)0%tX}J6idU&QKBg6=yKZFJ4fNh4x2hWiMT1
zSPo8!2-g*MP28+S?INQxJn*>3m2c<ktLEfv^7vW+?*S=t0W2I49sPFgkKo52g0l)^
zQvq8A#YW;k5!p^FRboIBXC4Nh)wc`V1x%1XV?F(ld^N3|LoICa^MxD9*ftVI_+X#(
z9g@T?68)ZGMhZc5dwJvSF$Pwf5RcDAPoi%Dv_qlt85^^s<PHPq8s>EFU&rVDTQ>Ct
z{{ut%e^}3dowP8q{kMMsBLn+?*wBCK|D7)OulS$HvHw3g%C)9uG%-7Z-)p_ag!TYl
zYMqtfqCvN9(f}U~#sk7bL-unR&J0<0AjvOZX|?u6nvaZ`B!OYUc(EF;lCM54UR&VF
z>+<l+;UfI)uFvbzmEN^_KU<9<_6|icTah3!o9*NMme056V+Ys#XZT`vJAXd^q0R69
z{rT71llCfa&xSuIOU<pja6);0{BFHlxoWipYS5N}v)3vQP9x*&xo<f*EX7k?^Uu@a
zg@aZvT-TgGPvS*8{?0e%vXCUL1VKB(+n7gh5nw|UXdKijl2x%1<T^kzQbo&O@Dw44
zx;P5!2N%RDgZpf`mTxT=ndd2&ulZ@XFh5w^@%UcHX<VE0RV~d^m+`jmEO(g=a*7SU
zsYN&hwXp7ZyFvQJC{^qi4Z^m^?jSbn(Cb{O_27$+f^6MvxQ#q-V}bfGMRH!P>d{Mv
zm*UKs!N&1|xaOtZtw5JaNrjwi#jj*NV+VMcUMvHAI5vm<deIrVs)N7RlKs5Cs!_o#
zPQ{BHAR>hVk{L-A3MxVs1+${#2xX^3S*D|~kZ26z3#>DoDNNGkTLieea)Hp{FX?9o
z1DM-s;S+v-jG+)Q?q}$2CFArEn00PE%CTlWQ+nG&2SX)i$S~gFzE|NOiG!87qb@G3
zPMri=Q*4oy-skHVI()IVBHnv2+s)6W=?>N|T^^l**b|}TMd|Ke7?#Y5_%CUmdI+6x
zM|C;c0L4ogZ@%0)p$VO5Fn<W~Vc-N=AElHbHL~L0JI$~XGgO##0k_bZ4rG=b%L05H
zFSL}*IfbEGOQe@w2(DT{aS82VbNM!wgIh%t3bw?!J;G~!C-So8B(vYXs_v?bl!G4V
zeYGy-gmpyRHSLh?&+W}apB9VS09~^s5CfLw?L2^ec7ci4UXNx33durWa*=m5bx*iX
zO}^<s$T{Zf(voY1c3u&Pfj&Th5SQVa7>$o8)SG*52$)O<p5ikU#mc}9k`F=%2p_=*
z+rSxX-wzI7ZO5z7=P{GSvsi#8RorGg5n-;Jf%4+crnH|h?$SWs7T>?5VZy4wflWwJ
zBtc2S9W;FeMf}5t0)r;F?2y8nnp4B1)p^yxDm5h`WO<N2EFLRH8%3K<p{1OjsH7Tq
z0@m>mZ><K9A~W_||AW!K7N<T(+fjLO7*>@nMutF<^9P4Gm*l8~Ei-WlxzVU*s??%x
zA=~w$*4$+7tyRebVeVl?!Odw?rruldCA04e1lC6;8<lljOr^WPf);PE(5ddMF7Jep
zxwAe$J)HsNRMd`q9kNLBmgnece|G2mi~N3+it609G=@e}{j|^DTRerCLA8#HJby7Z
zIQSH2bnPwv)H5)PaO3=1`RmUJ5N9$Pzg~ayE{!{rJ_mv1R}9L_@Kz7fcYe@Y-c1`y
z6Y`rH=SV5`vaV{H++;v&>GqdT3-tLq6gVh0_dVTC?GdEr?nv+G;^Gv%i6($EP%L~P
zB?HewXs^D1`sHtq?LhUc9TC`J!4&YtN*7Zqeh()PK8cC~C@xH@Q5)AlYBrM+tRJFk
zIF+z2QNpjx=twt8cQ2{ZQadR*(v$6D$^RANf}F;cVYQ{>%HE^&;~JBWOGgk+I?i*!
zi%K2+=ZB#$BhU^np@6?l+UB_95s7ITH_d%YR57=#^q7tnUBJQcfhKbCuI{&rwJvgC
zKPxId{rlW$F~eZ|4@_^|oaJ3Kx24Q|dbO;OJLXaM#w=A~jY<ekvU9oY&rJIR9+!^@
z*hB14NKw~y{7s%Jp>-TmRW|NDiplB>o)77X^3TaisZa*bb#gE#23Xfm;ds`g{zC&_
zQHo$P*2^#v0rv-Py(SKh*7f0^g>+KL<jLadtUmnHEx`ZS-~Zo~NJbV0=Ks9-Pfv$p
zWMue{8O{HvzcVth{V)1^ug-Qn2|J>Hf4>pQPJ-Fu&rO;b@%5i8NCeLaj>vFic*xEI
zfGz<J$hX`3_UfxDx7(dik&Vq<%l7Lkec$w6o`}W%U7zQ-$8voCx0ktmIeGovov+81
zoHTGxrfg3I^7hK`=cmW;MSOqXkGGR`|KDZ%qvMC=)%M*T`RV5mmpS6EU;f|Y*~M=5
zu@68y#-G#fTY3FnUHPHkm*LOoWp(Gq6R#KkR6n<|o!XW$$<DXkow54waQ5Gc{GIQc
z*~f17-4e)M-?zDP{mJ9*e~WbcOw9)7&1IepmS!$UMDu@>Yr5&hqIz>r&6s@gtp)r8
z+c(Nvb>GD4=N{b=FVqVnm7k4Y6~hpH=MOW-`^s#cG+H029_0-Vi7~;~OSL@D8TqjI
z*n9*U3Lh6}`JIEB``{;UA7?Bq@KV%CQd%C~^WOz^??C&<Y3apM+pPoZhoPK&2-_N1
zH0>XtIu2iCwj}g4cQVzD7vFFvgE_wp{U6_R_SIUci90e__8WHO@t{P%th}#d-XBs_
zK3u-E=RrgO$iv<5R2)RaW0OHAQ57P8uwk#%K$m^@xu_<o@QLG9REmnUH}I`VUgz?K
z9cYmNp`r&{xV$D;{@30ip<vHT1Cf%E-?x!4j}`h}C$2td+CjkxlcUL~!x5sn-X>6Y
zMXp<as{N#Nhhl$B$arcLQL?BEP6|_5HX=b2JT?Bi7Ml`eE@NWeauM=Gb2XB0VLBi3
z1LQUaqCh#eJ>g23%bksE9X~uEiYo+1Rw0slqNLiZzosv$sVWG^%dK=<sd-}d^+ur!
zSO$oyP+IEBNP=oAZ@DTcc`|f931l<bBPeFa+Vz*gWP6Os_Oy6yaPrg2DP`KlW`@{H
z7J;^@ZmQwrRFyI(9q}9zwfmB~ECR^&G(VXO0WJZTc|O=D5D5kh%8PvO`%jCs*1F)<
zK?^v+BJi6b2`(6O00zKY@N126TM4%cnrzlO6cog0oR-3$f3mpGtl@PacDX>I8)QAw
zEk>qc44fW+RLljM*!P!BQA34pD&lpO$8*H$r&xaO{)Nv4O)$lvK_X!UGV+E$oyUC^
z1C-@Mtt8QtRHs;f>9k$x>Dz_$Nr+J(2?$6Eu|V3VB?PbeMskZ$bzNiMX|pq&>avTb
z>a$1~Yn803u-O4hr5yIcA1g8#8G_*%;@j9?x83=>k}u@nxeoyu1*=>)&oAqk^)CCw
zll`5r)kH>d6^^u2K%jeQ?(D_$1ZyA&Y9iMpJ6)*-kyB!+@C}46)IcAysYXA_g#N23
zw}T$`!Io_ZvFG<Yv8N{Au>n72dk<kQOFqQprU1ri)<D_%$cC&in%f2-TkWG`X7gtM
z*l+*yYF>`nF_lV4lkmZciAx~`%I9QM(10SH%0L!~uDWvpW*w-TLv*5X+vEtNqGO?3
zgN;-(A`ux`fQ_H7A@Ti6sPUpUTWi<((J;|`z{wntxjue@)>q!iEUFKRMS{n|h`){i
z3EmGvC}^KSsoY429e}erXe#8V_aOnBmKiP^j}*qVvpibj2|JM51|L*R@8TcrN|Tr?
z#1Z{g6)&*a#EK8k_1<3c>Tq^e!0ZwO;iU?gLHs9Y_gyt2`WXQ7m*){~J}gnI;2M2g
zz&nwI%zS9ii+0E`AYy2Qcz}uU4WY_=5?YLYyV<(<BSaQ1zDh4JYHrZI%KN=RUG%-O
z)zf?QMxpVsz#o_gd<wCVaf3ChGyTJAnPc$bZ<=+on#g(tIpXumEar6ofM(QYaPF7T
zOmLDC3f!G%RlnCRG9Yt}2bg&`j9FtP=W*y~XNQrbJaaNPI!H&aO#TRx*{dHAuXmD%
z)yw!EUtKQpbGX0HXQPLF)<Yf}CY!zKBEd=FS;D1fuLmztFxI_ypjOD^JPd1iL>yD=
z*@P?dRw1qkRN;5hz};$vm*Gq>Uqcu`rMT-ZVKHg@Sy6?O%TrQONc;QhGtx|7`QfIF
zZ2Uz6ulm0GFQf}F#|M{{Q|J7W>W9}%y`E>k)~n+U&Hc+7_E?3YC_;4XgjvZruA$nZ
zG7nWv$fb4K94#IMAl%SLMcb<Oy}sUIRDu;2yDtI5TxCM7*Js@*602)g5h<sMGOk=r
zyMplrm?UP4t32p;jyrBmzgcbn0yIvnC=q9R;`Vag^ZhIcOmX(`##b0>t4a-l#MPSs
zFesgz2l6p1P&K^L-41+m%_?%}VE9LuxR?ZHi;TbI$Gb+lYh$n=10^eX?vTYq7m5wD
zLu*RIn>s(Ly)pk>KC%!UIh8eA)tWM!TTE4xZQDExMCv19G&;@iW^+4~&Q=FVsH_5X
ziKf8;xYjf9a^f*w@f|lp$$@U`8^ilf29L;2Z3%+zSF@Ppk}_xyv;WYhi}aP>i6X?M
z<5nWH3As}mv)PY<7ueE=UF6)n^e8IjELfJ%<-lWG7*=B$#{uUkBHM%Sqmt>>sBMqk
z&crtkn*_FX!c$uuQ$&iRjK=Vt4Zo}Ksisv`HA%Yk#kCtnyH=Gz>j(&63M*e7BWbc^
z5zmo+1H?(uq7>uV=IzhVp!3<w;<!9MpWlai?fT<2kk@F`@<jzVk5dkiRN6Hd!6smc
z!VZ^pz3vDJ(Sbu{&?}6dKuz2;J}X{SEa}|lL~BqHQ5U;HYxa^ulGC(93RH=OxyAm{
zXBj0@4~2aZ%Q!?G#tW$OYWU)45Dlj}il(9$fF3|l%Pm_AvyHHel<D{oTW?@GojZn%
zAa*TfM$1TqAUbz#O412!{_r#0ff(I-Gn7ewK_&%cZAX{VzBS*LvTX9w)crirLT87r
z8JcUH!}_MhnjPrtS@k&IHMfVjIdgqwNIeFPBUC)SfJLoTqF370^HGLyI?M{Q%ce@b
zO2GK)RNn;XdbwKD6RPRFmqKr|g7Qp$3lwWLAh~NrFAvMj#Kxs&gS4=)s^RNO=bZ;c
zmIg3J!q>Hzcmlk7Q=f1i&Y8=f&6X$=kXu_bgi6!1!~i{nD1{C5%1ml>B~T+E4O$2h
z4ZW**hcT%?4eJq;ZH-WN`>vnG%yOL9hS#8Xr4FxBE8e*%vu;mcev(o2->%D`po^rU
zios$92T5+IOlymc$UMs3Sw`YD!k@qs4#U0d_yE`uNYb5km$wwL4X2N#InhmBI_ift
zOY<aZ<}h?`D{UzyrKU%PpR3>(1I}CtPY7sEhFPpDN=Z7!u|!|V@J^BFa)He;sck|U
zM1zH^2`RaCi0p_Z`FdU6$!jCzYdFst$@aCumDWB&YT@U9xRnmccAZ76$uKdk;u%zC
zdD&a1AQoLp6YL~YN6>_Yp3RRIW16j!i#apZox`%2MA_G%dE4x^0{8?kz>ky!31GZP
zBi-!9m<0+!VB0%{vz6avIXP=6yGHIfm)8SVVhlDc8SpMkWS$XeaoUcqk5otp7b&4u
z8X*)v$g~ORl94~Ta`G*O^q_iPm*FnShSI`7!AOT~ES;B@#1BL$)p%U03QDhDATPY=
zAw13>v=3shQ~Udlzqk*k2Wf&B3ZMJ>P#Q*?hieHfF>-6ov32S4XbD$&>R`!Kjetr_
zmgC3cSx*;S+!QH$(?n{)1`wn}mB!mkEWsOVb4L}<l1^-AyN+`^YnozmH*0FyQA&H6
zt!tj1e6f|AcksK)acUcUx~nxUwep=OZpP4ln{AGP1?bzznN$QmIm^6+?Tt0t3Yu`?
zEy=J}5C7DXFjNT6>@r)C2iIbl@N1-p7<(5;egDgf-0?yfXTjLId8gno;yEi;8RpJ$
zu;fAWes-^AIhx;EUxJ?eyULxN?fDmosX|3R0HSF;)`8Cjgji~ldIYmE3nyBCXR6`c
zFjSvGzhwO`qA<Cb`ncc%`6aC*zynh8()>!Q3bwz%`gH#*URVw_B0mcUs$${Zu=HO_
z>a|m8pqc|G5Yc&FXlWEUM~5Iy&jcZYkh>1pdjhwGgk+#|8L_GU%YoF11$`;&kLAQ#
znOOQk$xWU!=S{%;ETbiGG-g!vytW1$ha*{zF(`f3o?}IP$%dCq@9CS*`0zSV^neNd
zbaypsJf62C+)2)4T7HIe+U3e;*@H)9tj&jHO;U9>iY7Ux*<FyGDb85y@UWh;9`K-<
z<-`DO`s~T+Pb7B=7^}v$X0(+Z#(ZsmQ}d#CBc{A?>8QjYI?FTFAqLrk(%<SU%dI^5
zCtjk}GX4;qZmVz?brqqtQzaYjP)#%^W@cZ?T)b)*IGgr14aD9~bIun!$-f3g-o$Qv
zU}=5g{%43rxbs`OE4bu_a@7ufJ)6^H60k_)rL+Ol6e(Vy_KTiY^SJ1Q5f|{Ck8p+1
z7xsI1D9CDY$Dcnq2MM-T3YDBOn<az}XM%)!8$_a!I8bN?&pCpy;8t?lfI>yaSzS{n
z&@mkAzR8po%M_}wIJbU!=I+$g?!5_XvOcomq{{>H@2;I`!81cL+BcBy&0xW9TlIVn
zQNGY{ynBL<k}WG^;g;EcD`~WVHXc`N&4c6q@SA^X=Cmy6g68c8jVI+2w~6<{Lbg?w
zQqQW1Ej!Kp2MgtKV(p;8G!YD#_6n~A(GnZj`-xW512)|Dp7>mGl4(7u{L20E#hQ7u
zHpOm`3^oq+E;MCvOB#nD`4aMnC0kMcAX#E>n(ZmvZtHY6&-yN5^SEs^E~>bjVr0uk
zFRbnO@(9-CjtO_0!dB(6hEPYYRJugCT5KVx#LMntik$H;lwU~CuUX%E^S${M_hHrD
z%%`X__+mn{7!)qYDPj9S72fKqo}5LF(&Dgzr1;yS)Tna23p6@py4(M)3$o4|`XdXu
zRH9r$Yj%}+rb}1EOX6y>I)&<NFLfCcqKJJ)M?{x1;7XqJMPUk7KY>#NbC?YzU=`JM
zQIYl%rsq@eIq5~}T|~Fgr})rO1j*WyY6etOa#tSQ4ITWkG!KNdmx){}?%IPld7T0m
zq--Bq`UioGjnzVtXd6xm;@m5-2|l9hy_D^k0hG<utaIYDnlj?S>6i=t3wq$=m@?cu
zH$Bv2{A@1tEgA?`@+IE9j%&NvH%TxF4*s+M>4fXJ95@+ml_ZZ3N^{7SUYr63PZoE8
z%BmV{^1BpL_fBIedn7Xyv9)NQykE)HEpz%xAvbkjw1Sgi?Do_x##(}kxm-nyW=XY5
zL|4tfTCwy0V(cB51Pj}2%d~CVwr$(CZQHhOXI9#_ZM)JoroO%tGaWM>aqpiv=Uva<
zu{JV!%fOXOD@D+{^0U#2Msht8ffQNUBxh4cq4sg>G4;SEq3!hK24?byIGxH>r+(>L
zsC~Zq;#^W+hT=J$pr!pnsN(D}$VnofdB;+b{@!mV&eQILo19?naCZ+Nq0_v`HDC$i
zIEp~8KP2ngO^DZ|P*#dkp5)n|H?<Uuxg>3?Q~$LnVcjRrXOvQ**p|8yHDw`xh)&++
zV_wHU$!l3bKw}jOQN0qnM=`s{+Bm`<Yje!1=u$DYFq%nSVkjF%2-3^m-sG9*<{d4#
z1GIx!7wd7Y>VK&fd}sa?v3g_~eAaVmkQ5&yvEV3y4}$4BOjY)$>BW&DnaF>9T{;j~
zUFO!(6AVR!jhi&8!o^m)qu3eYeuBrPY`e!od)F|td<9YJyH=`nH>GO50txJR;pBJb
zFi1e=JK{a-$=bR{Z-22YN<<%(C!*j<JTc1Cr6e3z644U-oAQ>W-z2vOn8B`AB!!1J
zH)q^Eis6xBs+FRl9vbk+c#>I6ez=Mt=S%C|2V{o(OI%dI%9Yw-cCMdol->*vPKluC
zb~XfLFOK3F5(RR$Zrxx&91<PRM#8|=*^(D49APU2?tj>9xdE#%%fvKv=wo{5o$r|X
zwP?m1Si}D*cRN-^+j4*eynq4d7<7vs0yv~_>HEDu+N)|VEYnsTpbAP~l=VxD*K;X*
zkak-*S4Fb-(Z5yL?htktp%L-W8TBycaeLA2X;va(RE_E(lEFFyt%_|pQA_fm^yx&@
zqZ_z)o~&Bz?d%x&yBv4gqsex5(~Wh7{`g~brTTXfg)TWif0q=!^tdU%ybJ4Z_R=o^
z18*+>|8xiXU#Fe_+<RD98Cn0^9f;-sFDhnaWcfca71#b-d-`W8_Pf<5yxS6bJyy+3
zB><sK1^JJv7>u9BPh;*W<M}Z2dHz3TsE4@mVyTrpTm^UONn)bjx5M!oQ~9sE+i>`~
zy<NZWuc@)Nq4%+=p+2~){=8ws#-(H)4C?&Tp|-UleLoH#&-TGHd_BG2#~1K{pO@z)
z|M)R@e!ZV|ob|shdWQ;cuh+NmXX)T|95AdpJR3t(<wN1wJPv*y?_ZCKQONv_%*y5B
zjwVZ%T#e?x)f~KX;uG?x8T`TQ8HgWG6i4jzo(Tp%kis5sdB59zfRC9RTz+nRnp~7M
z<L`-c<b;bQtNsXjL+anHcUK<NUz&|ykbOn`83$DUvK8%!kkqr{j@**hXU9=A$giyV
zDNC^d_+O`c{73R4+r?7Yu+Doq-C^{O_2{qW3NwvWU<vtC6#VRV5ebTvLGRy#|IS?R
zOGD2m2j!Ff$Y=7M#s=)qQ~X}UL?jtQ=%FD9hI4vk0}-Y3dEaASK{T<)$|%Ypco!6^
zD(Y!wA!dAHO?mIQ7ID<oB`zkr7D~=u&5ASIVl@y?I}}+7fZB@io{@oq!zKNu3wSdF
zT;3Ly_FjuO{Lp>cZ{JqS{bGYvfdw0m(~LvY17f)@_lO`Ws%*QgieOG2M@YH@^AmZ@
zDWNi8pybPvl5I>G^Z_V5?Q9|bsiUy1qFVqi-YHGYLST?GHMyEY-NW!ZC2)z5TEe#s
z0S{{N+Pi>kK*VZU>I3|_9)|P>u+bHjfRb)@@U2mkomr}5<94r>Xw-z)Kq;T&qFS6)
z?B{7*0D1R8jQ))yhG12x$lh5EMazNA<yxi7B_!PqmP%`ZS*55hEMV>C=@rRZeC72p
z33pH?nqB^cD<E{`-`|bo8RBjdF^odl4Z4MF3v8DA4pm@3G61P;1Q_!Ro;Ij_*b?OP
zAzd{@0sy-^a?3lU*}$!e7QE-sW4jO<_@s@D1SKZm4vuTk?E#btz>+q?9Vk@tn1Pb3
z8-wME8cD;0P#J3$)+vd?7FCH*WLN}3KY<XmUUYIiTrvAYHgF|*ZxQo6NzoGxz<Voj
z&&1n|w=y$%?2hFsv0S&}6etAIV-ga{L(Re^h$%=lh(;3MjpjuHr(`1f`h)ldtR+bd
zw)gAjD~iPcT@77ik{$eU(zW?AiVJXG0nk}-c9h>DH*j48dC0{uu#BwtpYzrYbX<<Q
z5a!%KtR-tO%qF7fLASH>!%|^nWC{anVPFA9i3)%S6OWOBj%9sm^PZrD$0PvzIHrUd
z?PIFq<NI=4B*ufIBNEIH9F#s}i;6I8l@uiEjaLCKqNKeb_8C&S$0U%7`VnHMSEi)^
zL2G|vq^1*?3a`~1kD(Mz0{3c}CgrTKIEO$?!>*44b1mw;$S~(TCES!czdAD=ldn8-
zEk$s}NOXjX_LC3b2D`m8-^QHfnoQ>I5gK%D340zW+aX)QD{+dJTdI`p4prZxLS7%6
zy=f_HN1JL)z=)&-CExV+D>p_O2h7%%&`mM%wt}<jlYu_dzGDl?bhw7y&71+=vpx-Z
zqd7<C*`OW(g|+Z;ccnY}b7^SDXn1Gjx+k;P#}-3Sot=X|kw~x-!E7%vIqY)L=rT)y
zd<bvhIC+E-M(LJG0NjJ}T}m^mOJnf=w%T|Xy@^4W6jHLw#-?Rt6oo9A@-;`*0pE!+
z4AqwAV8ZkEO9?ny=g@A;D!5ntPK|)3yW~|-5Vu&6>%x!JR9Wjx<}R$JcUFcQ+&<|t
z<vA;>!z9bD(E@boDZE4brJLa`9PtS6ZcFj5wl(8aG?bGgVIH!nu1JRBhH5Mk+TD)$
z|2$9GPxzv`>F04Oxw&7hzWUCb+3IC@bpu#9%AU;*cQ7X#zZ?edAsJ&%=E4Z_-pnS+
z9X5oW27L0aMx2LVnAa(4V`-;C8`CAg+-p|N<UrJYXBDN!uNA=_!Ujhp!Ty=?UGFH#
zMJOLAeQ+68bq&W+E>=AStuiA^ugHf5RTF=Ni0r5(kOs=_5l?*IE}z6h<+l`5CZ@->
zTiF_aD6Lf5<QO31oIzat>k$!(nbf`7n605u1!)r!(#Rxz`3H)dT4sf!DOTfKimeuG
zK$u0BPdVuqAiU9FMcBSr@?wh|6kTNkDRqI*X?qCml*nagIZ-0VD$$@~A11!khw5=F
zW1WB=qjgr%>3o42ZSCc1Y>tpkhig;I3mH2}*hSQIYfhmpw_nlcn(d-Ww(e9w*wSFS
zY}(c(Thm~>x+J$GCJ0II^If(so<>lHtlY0PHqmwJ#Pnv%N8J11CT23oqh#KbF}AF=
zAnF$A*d8?GPJM>)mJ+AKQL%~fkj&_9TMRAfg=|DmX^*s|=S^gyWcN(1QFz!{YO4xq
zO4C@Qp`m^MKBr0KaM`uAhuEl6j~6?h0jl_3C3{?^l;Z9vc$>>{T2fI=4ZQLMh3Nq0
z6YTG|=r|F`iEkQ>^*A9?W6WxAc7#DECpT_xTOk5)+HnX?ksidYdTuX{Vo#vGh<h$q
ziG82znRmD~e75S2kohnrHEa*qyLT5&Lh-gf@ug#IjhXPA<1IY8#rY^E(8(97zE}rE
zCt%_dg&~eoqjwx!#fgl2dX;GHQ%Ru~OR`?`d@^E!m#%KTw+gr;Z`vax?gP?6_e?eO
z98wz;`oU;ff@_tktBjSDX0iHmZB&n|$R0@Gezfqe!x?Suwsv>n^zxlpoBdv2nBWy(
zP~M82wP~U6nZHw6vEz671mlRzqQ|g1x{rInrjbh*LCy%$C{<08ld?{fh(|#*PzS}z
z7%ghx5zr;^KWR3s6<4!Wf(VVd2s(OvHWdC`DGe=4w_CR$Ria~#SX`>SyISXYEAa$b
zNQ(u$7`Mp|HTzmbEMrRkeo<pa9?qirfj@0ZfliDFJPs-``vKT0s3QiXUP`2-b7MCW
zM?y^jWFN=KT)Iw`njln>H0q_aRt}(8=<{E`Ad+4a=DHd#vt5v|Mq3n%tO?FsNlfuN
zt;-xoABo*<R)zyNfI5ZGcd*HBh48A{=D(_?8Cyyk2-OoOKRQECPO%#ug-PA6wWN5A
zriPc<sqfwEU|YqFkwWBukCgu0_CDFWkclSdN8!FnD!)&Pl^}}Iof<6t`?%vjz7AVg
zM=;^{a0O85HDXBFR$ua!T3onrUb;zehS9onAyOLdi{Tb#+bTyU3LmP)wPV-Bd@~0`
zv(IX-ZAU02rp`1dQP`GTJk&7=rE249m-_B_Us_Y<W%!oQicAR1=gI6UZFN{Px%pfr
zxJhs~REmslSl&dj$>uU7Qvv3b^)p)0jpr^mEEJl7?N`wDf+Cb<S9_2oEUVL0=n!IC
zUOb)~K;gbDm<5kW4yZUyYL~<>Pe1J?CT(L?L}uwFRm6WLB_~EBE`HjEDXh#4G#+?t
z<Sb6}Dy47pVKM|$?0}~829cJ`q+x_YZsjVrYwy;UHdx+=^!4=q<lQQ}<HO&Tr8{r$
zr^Hv6C&yE63U89G{1{=to24*DKC6?9xkAjRP%_)wr09Iz?0&&vueA2?9uXg_&EDb{
z3k<odit1o-b@s;W96wT=DGUKO%y`+W^f{}$yM-V|A1nQ9^|nt!uHvG2dKDd2--M)(
zlI&fQ@u=EaUVOUQI-WnwUTVcX-Cy$i|DGIaiwVBEWxBFkpA6@_=}#U7EflI)oY=|K
zr>-dN4@e#f;1iEe=Z=Wo)tlb#Za_2&2hvr!rSPjTG#Qc?aQZH-y_pOspnMPCi=bw)
zs}{l_U}44YlZ#zs(BL*H6I#_EFe*|+xMDa&f?tCG!b}M>gJfi$@VKzm*)(lqK@Z03
z_xX5zE1BHlErV}x$`_i7+b1!bM=`n7!|7Z?!^(Rxn2Ynoxebdlh>MtE{xzvPT}K}6
z?D_Y53+ZEDa#_owayWT;R<IarxA-yoD*Tn^I`oTU<&JFBR`BwPcx`S6QjAiJzQij+
zv3*s1KrOOC?@CAS^i)sK^+(T|Uh0k}c|5o6mO=9OFURVfFj5H4q7>a0Pq0|`ixLTj
zlx$Q@vPs_-O)kpb1;ZVW<O6Zymn|y1EtF)zSs=kiE;e#mhBHDrYTh7?nW@$F;bKP$
z@>ED$AYF_HF-VIWzm)w-sk(h|!RjoJiyM=Um8ct^55D!;Kk3ZuSjJnhI(^e!rW)m>
zXnXM;&H}$FU*UP8Q>sPpOqL$zcs&Lv<J$2+uPln(6|J`T${pUU^Qh+<%_L_p@@u`q
zvl1P8QKrU<sZ^a%wX#j$7Oy>mSw4Bb@Li4y>kZdhxWirEq}#MOe0jdyO0T!C*ZgoC
zoWP{IvsqdHYgzr%>rZjP$cuUs3I{JbW}cVY*N2R?@T1B3yI=B(`il?@2dooJ?Y2Bv
z3xk)XmJ=#g;zEAT!?OmCUwJ3GhHHFqN#uKQg^plITzDuy<%ns9rgXuvfRwj*;sJiZ
zCbcb<Kw@J-Re$fxADIvHvLJW*LB@3j0z#V{))KpSJ0guv0*T)9*i98zCbIV<&sHHR
zE3@X=JXeA{Aew~?xRG~JL(E;_T+%K@8!itLt$D`jnxjl>hv)mqwlXR6QA9qleGLul
zjEVR!(ZNJr4P;ffA79kPFGM&(Sr)nC!6N}<I*r4@VXq8!PPDHNpW}a1<j4I14+6Q5
z{~xLFzd-LlRLIQA@ZYJBo%w%g2eAJK75{hbuUZ|+Xqpbh-q(7HyBURVC2y#xAgw>K
zXAJZELqp(O%*LZ(jD9fdKd-BG5R@s>?#y>(U0kV@qCSZCBT1}1jYIx=y*j<$ACL0>
z?_2fZm+o!p{`h4>Pm}PIRqBomYTdKp_WXE1Pg_Iu^zg5*^nJ+XOX;_EeSP?4kMCac
z)Z6}hKR^G5XB0PS8IpZj!`txT^z*Lzj}NZP>&YqSu1Z!k^PBnbM<ll%7kuv|__LD}
z_m9lq-W}7(iD&)&K8L1`u1`MO1KaR_KQHayp4R-o@A|rt*|sBFe;5qO5BoLNBlqpd
zmt39Zj>;uhwvL{~x|jo=ANtAKeo9K!w8p~~Kk7Qv!XCr(=Inn9>;_53+$p;p;Q6ZB
zVV$$={OGUHUWbE7wm~n3gKNlcKo~a~2yQpOr|rzM`6$-j<8SZt&>c!2*xL_B4yayW
zrfzR;eVmH&<!$(!+rS<9PP2o*+f^N_9bemA_*3)H@{sAzl)GKK7k9Q!KcBKCqVxY6
za^Z`Vob8d_alBR{dvbOp{2R%Ezpv`*65Q0+Gi!V*l9`q`Q<|&KQb_MZuHBDdGTv?!
z>(ev8!h=W6zYzhNqsFt0uYNm4>4oLCU_Fc7>{eu3Kd;#?H5i!3Vba;QyTw${5xL$f
z3968IWj=zWmsGAYYA!G%ux4|nzw9iwF;J2s4gEA%lHvm!JJ2~?dFFZOmaPg(vO-C2
zsCOeEgL6;`)Q_Xr?t&K6o6q9w_112hDmzuETcRIX9U97I0%}FsgmfTd%T)VfIAr)X
z3UbzX^4^xAqXR(92!6J5{JANteOv?%ofaevIX)~7y?28RQGHQ#91-p7DCpt;`I_Qy
z+9XlImX=2k>Tp=${~pe4Psfc<D4-yLIP0v`=AxLsp)jiQGmqP4#gb-uqbB^eQ4<^!
zC0*ebeG|Y@$@o)ska(-KeVu|ZFz+r}<GhrauoO<y%TYN0Ml0%UPSkaHwF}TXrEdp0
zk_(FxBW{W5Uo~2L_ZB{yd)y9S1e?UkAZ5et`{WEnA1w+iYl=Nf^ZqzpMmda5_Sop)
z{2E?0I<m9^FcZ+|xhZ%gQ2<kA3u67MHn$XebAN$zf$d<>?SZfN73O{<d^eqU{;Z(^
z44>?~9}I_Rk%$g{{Cc)62>KTO6<GEKxHQQ9$IhGF&oEup-+;ouKZe8}^DB^h>a?91
z{wS_-vm-|==e57grPKhxkpsgMSNoR{vn10ZxLMF3mIQg1+Pl$YK}UsUFW~cXo*jy2
zn+q_AnU2YdF^ZXv(XhG1K!7E{kxkAjRux?FzS1Mp<R>+LR6n4w3>*VtiMG*6#JEYg
z*3Nu<A<?}X+!+J2p@k$s4Mu~r%l_XKuw_xcr2O2CdDXt-nZXGQYdXXkMUBr2)>Xh3
z7455|_P=G$sxdOqboO?XkFrcevk-|gkoP-^zT;--gK9GfVYyh-31PHRkReOfNhmxN
z1|pN%K5&AV$UgC-@gIy+&7WIF(oE`a9YWT5We{y)zh5v$TY@ZF2^{*rdpO9vX-dbr
z(!G#0F;dFdy)5$$Ss;*!td9yc@%GN8a2t=YK@2^gF~Me!AJdli25l$C9~5<dWOHW7
zs2cAz5S2OY+X!lyn&k&-$xgeNsv8uNYC*RyB(8$0UJ7yOPLWWl7hc*|NsR84lkwD`
zj}yBP3`5IxQ^c(!+K}?eNSx?Kx>)Qk<~mT_Fx)H{+@`g*AnwW%f*ZbdK&04${djgd
zGQCe=Zu2T&csKgY>pc*l>{hSRF{KdPr0bdL!mc*(mN7Ln9u!PB8ZUShtDq-1+h_|%
zRr=4bvBnj%oT4v)*&)+ITr-dvq`a2wA|Um2rIiEFr*ZQ8A2IsF>z3M9O;go_;Mn0x
z?zu;9nQ57cTGpA_6NavuSlNHoYMrh1o7GDFt|P7zTSja%q4u()woF`!`1Cj6@Vu+G
z48FVCJ!<TfyWVK%@F;@KnQcE{9N6|}0SE9_TeXHDMno8TTs)kqsf?|tmZWbw{?zl9
z`T@)-`6`&F#~aX|S@2K7PCr>evev4!l#);hi<BkL0yry5g_Z^+R%R6r?<9?u<)DP3
zbW~69Bt%BFnR;!72aMi=h716wUQPxoBE>4I+9~kpJr$6lJ1(Xc5GGDFqMaU@$j#>!
z&^GHPm?>oqFl~~1aBDMO=FNqgZx0P7(AT^uXbi<A)K|gk?E0w<j>ZvGkJ%;uU6FB!
z2bQQAQJb3f>=rlt7%wZ~GyzAA6%IY7aHUr(ybPXXHUdQ(t?ua|7DH>o!9-NMB_=iy
zM7>-I9w(ZrYrmRYGecQ&r!Xd@2OW*hifOTHso(18s)X#;7$2I%m#s}+7AFA^fscGN
zLu3O-I-pVYQPTHE6tN^6k<OSsx_Fr1^d)Xmf0D|gIqm&O4BTn|F8CcD9c;B{eHOPA
ztxPLLVmk)2HHrZkf%wxR>T0ntVJ|eA)N_w~48r<GpUR;S>L5@XTpAn<@<=C%k2ubB
zCo`byUZ5g}zaBQYfGN43A$yT#IyNIjIO0A|TX@GBg0VURe9pGXgXt#kJi_U+(>fOJ
zn5j##Fa~}*j?@(p-_vG!eX5XKM^BX)+vWtoG(V+rUNrb@%Xt;CEwBL{hZo>&5H!zS
zrP10Xuq+bSn?n2A6Y4(Lc1N^-lwko|o>Z>%VPos0gQq@Q`W&SnT$}Upkq>E76#;Ep
zjfQq7RcDM4VuVl1{(Kh_`n$65nKEH!WgCUub20{yzxjlW=H2X|HQL5#tlf5Z24EBX
zq!mYk_=}Tj7n1)4WOO7s8|NPj#nxN63jM)CcV97a=`_cjGT22mnbI^jz5#l7vHfmo
zuFt0tvEPf)ZwHOw8qt(Ophhq$%U;khSca9pim8u0W*`S%#3`xXL`;KW7oiCGv@zi#
z`_sw*`odb}Y(@W1Td2z8a5QDrb3B@H6y`JNf+;ry(Or(`xJA5CAxc)p3BD2w(@R&O
zsNu~H@V$as!hYleTPCo6{Z!g*M>DB*sM9~lX<*HGbt3dWI=<3qrV-DOsw`o%=`uow
z&Sl_=?|506$*kznP8BghtD7ynfkm0^IXg+1-7PfKT$FLWe)%?<K@{-k(A5XMSCoy=
z?_zjMDcwVBBaPeXjaf7Fdm3e6618At=X`fJbHz^%NTNq~9S!Pp*v_BnYUkDLY+!=Y
z_Kc@};WGzZBOn)?8N#ad8HGbiU<qm>{|b)df?%H_u|rXHu~b}BnAvdGHh6DQHjQz*
zkDU_<LTPz2ctvP?J%Gerq{<AqH2;h-G%*X)a=9Uu9Fuqj4A^mR+?rP#?d+@zZ;$u<
zwe8fa`Fv6#BQn*DR;ji!?n{`{4HU?Z{mP=&S*&%n!vl5rUhZlDuX@H+?xn9I;h1;p
z#VZ90{g~w~Tud&*;xp+IH#rd(V=ogdJTmQW#eEIuh++G;TC)J(jA_VF+|W|6Z-`+W
zojS|u2q4bJL(UR5@{x5&p~im0|F|V4Ez^An1{EmuZbkr)pqaHetX~$W+(}viD@2px
zA_ylT{LW~l)MR-foK0kZO-MmaT~EpqOX#jNMJaK5Shd*An6KT)o9M;DD*(E+-T)pg
zW=zsilrrBqHkXyv7l(+-|Nb1v!P+dKa1^af!{-qRhZMU9?ZeW8<;CE=_b(o;zsBC_
zVthf8Q>EzVsAg<*`4R6N4u2U;15Zj4yC?PvC0S29FV%}t7O+vh<z*UcTbL!Ltqlfh
zruEi2eF65~_~}FtiIISC(tb2=kHo4E;bT;p_gXA*Z=3kXbaO31S?Ze}7U;s-0OMsj
z4uad-z!Z`M`5P_TM~=1?z%WZixD+f6SY(%X{gK)@YMl;~0$@TqmmbW;&EHCO&*xuv
za4mpDLWVzJMU~~V2elmA(Lj~&7QGpi@;VpSS%GYXXLrAs7PDf|-MyKNHvoyoCSHb(
zfAddh%pFxyDBMqVR{IGO_W4&Tn+ItgS()GjMeOF&5J|`Upza5`YiLt}68WX`Cd$1D
zRGK57c!P2D)`p2pkY7X7MPpq*&RZITsLUXDCC7GHYzH^1l&f!z-Ws2BaOJMuxXHbe
zd;_m5Ca;_^Ln<`Ct%UzLh$!g%tKo;|!~ie$n8WbMYh0D~f;PCIq3Cmhg}Y>c|Kw&>
z;)t_aQsUGAn%}&Cdz%rmKjllZ`>4q37tH3e)#nEfifhB;mH-NM=mwnfuS;{NNY&kD
z{F!G#L$FsM3wkQ=M<&M*SrrzmKIamzGUe+4={yuw9{|IA<@N~4zCVy{$Db=fxq;D4
zB;rUrBuIOASamOi73KAU&G9M=&i0ZrZQlwbzC2R5FmaAgdvg;Fx%lGyLnGX)HJy1o
z{_M^D2R!}K6w}Eo-C1n+ks515({lwUJow+66g$dzXt&Os&|ql`I#CF-+r@aq^lTcO
z+#D!2e}-<^Ui$(DZMpUZ)|sQ&!E*T_knDT;Z<<ukxFiaP8~6jW(-&lnB4Xv%g^x1C
znxZCB*yS`0uy?Q^sVoq1+m)siry74Pn7HQnMDORanyWK>Q|&-%)eMKYLdfb`ci!7F
z4B+;SE+$Y*?%YeF*)cJt<=a{<drIAeBJC})B_#d31k2<f7HX~J--i~a?+C)H(G?P?
z1U=>)U(oKasKkh<;{?}9?9Ogm1k^F+FCd7$WMBR;AL<O9+u2?d;GA)Dt(J%fP?Bry
zxpX(I&<dgcZh(2aDh*)isSSM$2^T}Lr8ENPdm^NP8}3xA7ND6LznZAdlxf&6lbIUy
zpl2K2p^DB8NH9tmy?ES7FcbJH;ibWtJV*FT{EpLL%uKZVsIWV}{J<fx>nVZK6x*s)
zVySDssCvnEomF_!lm}sT>N<OHcY2uqL%k(mwSBf7Zpx_%na{Xf+lS4M5ki*=mePa3
z(WblClo%{g-+Z3*yobyD8E=m9(Ji9sG(r4BXyqrPZ;g-sbwiLKs^QWf?Yj%!LHEtS
zJn3UZ*RC!e9Qvo{b%4|^R+{5oepX}2&$3-UYkgMcA|CwnZ4AxNxzM&dr16foi=@i4
zl5N@VUP>P{CBJ^W;7iMJi1&IvPT0QfXVV-t{{C<L?A7vZ|08n$7e)UUa&xe<{J%jg
z6XSmba{r$~KGT1hh5vWRy`uBqoD>W_skc=BoD?5{HZ{Qp{oy0v6Pv7!)01iFHoxBD
zy~Iq+RbFaSTCIhwTgsWKnC~N((c_tMhj;bi?EjP$UkBf9{y!cb|9o+G@k1^daSsM)
z&MM$-6-PdA?>h(aeY`#%?Sr>_-QAzBV|(L&|5Kiy>+F61`0AQ6<jT#Xx1{*`J?rD)
z>EnSYj62;A;h_spzlFEAyC4`oIQiaEo&4+LblIGPH^U|QOF5g&Ip9y{#KlWjogpt&
zD<u0bj8zBBx5~}?n!Cf`soS2Yb3#gI5%++>b2z3%<SRd0O3IJWx5m&3>o3nSz{<t9
z&rf9Q=B+33r=>eYD-&QI(sR)r$k+4xb@26kD@%+<LQad~>+jRwt^cr!;k$hNds087
zC<Sj?Y1YTZnmaj(I!=0960!Ccnn_{_Zf!^6nu#L;DNTTr*zXh)3-vc%Z1C)`4~46j
zgm-_@gq^=Dx;$-mwvS;Fy8b%Hgld`!mG7PC@U4Mgqm(lc>x4&%``|6z#1QP*uawDP
z1frn{a9z6%$2CU`Cj^dZ^@2prn>*68Wi1(@x(NW-`b#R8XCNF%v&IcFpB;gf2dwLb
zJBXgf=OE@6s5fjcG(7i({}l1vok4Mfr2OA#a+ju;kA%kOlg!<}w}rrli6U%~F%uqn
z!63e}3P8Q>fk|kk6?WbPN7Q;WR|86^-}D(yK1calDC;;h&%dcm!{(<!IsNvhicx?l
zem+$PQQFx4J_*oCMTE1-X|gSR{%{Rbj@>7Ol>%m@oerp&8vro!83n)C8Ma9pRW*}M
z5268u+=YH;uS8)g48IA>AO>;n0KnA{M7w5nf~agF`CN46W5{X{)0!|Kx2BrKA@!UC
zA5tbvP!dyf$#XzxW!BDnLHp24kIK8s?RX&vIMm63MZ-IKM_i>;`^wSpgK&6$GgW1c
z6%nM&9NLJs^bM*Ok0LPhf*!Au9w)~k$|le9)kY6uoBd*yA{Rjk&6!3puTq!`og6?`
zNa;|$;i8M-l=y&igjUjZ(N;H*jfe~C$vnCOb)1sYKnf#*Yg`Fx*sS>wTr^IS@Elp4
zg=Y}z<~u@a5%%T+Wz)XstDqj1rR3-JehvfbWIz3#x=|qdmvvRsVu5cda~aHCVi`Uk
zXrl~4n7df?5ZGRDy^C(<Bm^&z_+xiV`f~BNloP-^d$W~+&_MEq0Zq)`49(aFX%KO=
z?tNnibE0<+bO(sT)QLZtOf>Rz>H9o}Q)kIe0}->kfKqN!n0ctuUTihIUD~+f@1E-H
zXOjCA?%$QBrRHWs9?F@6NL85Kj#wh$da}{6LRDBTOS0Z|UdM%1<d)kK$Ud&KmcXaE
zvwm67@my^o^~NZaQNhuKJ$0WQ&Dbe~t1|Q&R`dFY3t#clD0^~9{p(n;<#m^p(HNP1
zvg1H2&t1<_$iV_fg`SXzIZyf?p^#RCqm@`Ge{y%B?S~RD$+^oN>K9Ch%8i~fU?_>e
zhza@8$EJX^K%SbZLdrpbNelP^3Hfg!fFzpxF?s@jxb*yEf4&wR7JSn~QN`Q!W~!`b
z9>O0d|Jtd3Q0b*O-`91PjXz_sAX@W|m1hktWOxkP+b|Ebmq8>$U}CwXe24!n31Vy%
zh^-;w93^X+7Az9+W18CxfutbmeOf;TK9Iy0b^qaJ3|=@~2PzYG+He(X)az29j!I-@
z7NULA%>-ze+`U?{wBEjI?$)wJzq~qR;TXAZELAyDEpDa`C514daEp<DD-q)z8Am)*
z1S!TmC4jDn^73e09)Sg#OKgdpmx&eyJTqn`kzHNcK&q0ZDlsNqJ*??jamNk*gU%5_
z?F=Heu|UHuraLRXmWRnl3&%;ABV5dmPD=oXMK8o5d{zmjgiZw6-7q6`6RVgXejG8h
zI3#OU!bgt<D}FI!qYWl^nrC}k9n%;!yFwv5{clla@OXn-P*&DHonKzUT*nn5XCeMe
zv)CJV3jEfji9#OoscW|>VlW8Pc6hmgI8LBM*;M?6YaNR)c;IJWcP<fr+z06tPQ_kO
zC!%j_+I@eY3Nuo3|0#0^dUmzZ)Fl_(mVMZ<*DTBhB{Er<LE`Z=29$*PtSGgV+3+h1
z%R)qv#gNDCucRF5Y!Z~HI86*sz(@M+fQ3^2zy@U3d<WKy=z_S3F9i5TB_*4Ite=oD
zZUENdXuda5!$hT(91-*`!}C~(D+i&I9|ev?PWfVVrk(yBm7+qU;2zQ{SwS#SD98LY
z6%2IT1aT90KCZ*L=_Ja?I=Yf&GR)y3I+Mo4DPndKEzoi`(zt+%@D9hYA<yFnNXH`@
zg8|_L2#)fl<30Lh2%=>=2JYF8$;Fua?N45EWu|Ny3rP_UE|UcAt2Eb;4YS=Tm)=d=
z-uE?b&Fj}vc>FD&&zHI0<6!*;3EVtx+PIId?<yUkZ5xsd{9E4lmr_i1Hp1h~9ndu=
zYmD0o$7d;Ta-<lFHiX(d6|8jiRFb^TI6X+NsRXL{`1FqpjxdW6Qu;i1FiT-+I6w?Y
zmT{M41kK6}`VNB>9vc*Iu&Ap{Iw^?TM%9*Dv!mt_-#%n-OhxKcq1tGk@~k)bpP=~H
z_mJO(&MpKFns-tVswFh<7X%G)0(&0e&W2EKMrf`V>3zC%wloMv8N%fydT<$e{kGe!
zV_}9*3!b@L8SOun!xJFEVa_K?5bC+KI3gXvY2iwI+XOBNL~v{YQ8^vU<6Ks->o@@6
zuFH^CO0Ht$Z(M8Mro-4Od?wMs8d3^J48~;D!2%dwxSR^@6?qwBT>9|7Q%|lan__WJ
zf$GaLmLajFSd(-VJ5Sp=qDtMOSvGM^QS35;9z^w_^*I6ze(|DMX^hA+WZzoRD&j1B
ziDr=6dJ7Aly#cOO!;F~)m&JdDxmAd<LR=9Q=kAPDa5p7r(d)-7E>B#frBJI-qfQ1w
zaPu~|vO1iJOY3D_>h;_ym}mMydgix9!vX2UwDsNB>3O-iV#?-mo3xQ6cZ;BaG4BE1
zxY1N;eI3aYrAa++W7N@&5Ear`l#Y2CQD#4Ez`dunEmI<TbWhd-OY}R{>1F5DW9&zL
z)PG>SDL8j@eI639P8A-kRu*Q1-WCW+zTPBY?}~E`Cm@(*UCw(jI-_fqtvKH4a<&)Q
zc}aGo5{#Cc4}^6PAQ#;)bSeJG0be0?(5F)MgCtA3?j#AOuLs;!(}42?M-}3tF{4*d
z-{KcxKW=0CG~%Qo=}C(hb%u*wK;ax#7CKW(`(?Tbp<+SVC>GfUC!4iZ!~%!Mw`zFF
z3{YrKWr~`gR~+_qXob1iQB3OQY=(ud;%rg6cm%r^`+A@wV+@62<LVfHvK^Xv5Kd0u
zKJTxnQ?s0Hl(2Zf_z_OM*w+Zm70+<D^nj7SvgtllIWK(3%o1oNFQZdT=~KV1&&PSK
zSTI7cvk?9CaNwZ49s*6Y$8l1%7eu)*yL2gS6FR{Uh`om8b2KO7Jl-2?QYqFtGZpxn
zYmR*(0%2gkVHir$NXG8s`6QE*D2E{Ui>baM@l{N0y@#5lKud+-%EgbKIBwpi0cUNi
zV_?DNW#zz}b+QVK!MrrMSJ*CKJZ&~6X5-<U-rNtFtMhGNwm6L6?<@fZMj?^3xNx43
zEWry6NW%dm{(AXq$L@DQrCwPxY_cC61WC-=C_Iv@uY|D#$#9uj2WOjSSBE6(#e-8%
zkzRk}KIR4x9M|opAxrA;#Dp`&WxNWLhQaM6=uku!j-b+)wk%9;D*@T^R$ifS$h@U@
z2>Nt|G-u5v9uL}LixSk+`<mZ%(Un<_Crw|PDYr_>f-95ivbI!4p<&%)zpB;<Q-K|s
zRV{YnAJ-4IV6EE4lr$+{Bq1!gw@jrp8a%RBFcQJbHXO1=w4|BFlLfI$>tGP!4!c`i
zQ#`<>C>EeU`5n{NwlxV8ZVRK_JkTQeuj|eVQR;V#MW3sjqOE`)PBry##&s+%$((t{
z2Kl_SR$ot&WSh-C8Qh964u9GXxHTE^$mJZG!aD)iRIi$pw{8)lR3lrM=C5Or#uhyq
z;4Rc0WsBI1Uepu7tfnNIC5>Jg$p+dt4XJ+9H?Z+Z*vx&>%?{!>D85<vdkZw%)#sXp
zN1_laiamCB1~*!cxGm>1=MLq}Ngv+U`Id6$0TYd|L6?5XV7n}ytko2nxNh|3ZB?Xf
zA8kgeO3|eS3+_A+<H~9Jxd$>}<I2Or1fNkpJK?D%voBtQaPMRyJp{Hc9V|)hV~-RH
z1}Ik)9Dl!3SqG9)d16}SVw(tXuE>A3w|sv`VFi6!xlznagm1Qbt0XTxm7W!hB2vX%
z64WP3pCk|AI>eBb$!XJj(7k($z77u1dyL}2dYe&}L=e9Lm<er4cMVTso)R(jlw=*T
zl4MGwSg6BcJcKPc#xC`Gh05HuQIsI`J%MGSRWJB8{UF6YppRXV?_fXjXC-G{jxch1
z?;vlzjy~zW_JizwlAvw0ZGBzT2gPp9&x@XLiT|D0jXfIA8bzPW2!qK2idPaX%P)io
zFH0Or;gxcNKMIPOEr2a>>@NPd{pG;`h|Mdl@Q8=Wy(%b>vc!q*HE^=4XWxu1+aE0J
ziH~En8#CRuP&I>6xln7X(o1lP3YuFtp*h*vhRL|i9hlKi*t88QAOT6ls_Dg_eR=-l
zJ5@j%kToZcTrbK3=veh9tS@>&PwrS7Khk=qow*%GpedZm+L<z|XXO0XLiEiVh3yL$
zD)WZ^W1Wf@yRYS0{MQCEMy7on{_T%}LkG=_XL!`=>QmjGd+q&?nc9GR7!<GjbDzFA
zdo@mL_NXZJhWKE;y+!I!>&UoGa8ZlSo7^KD);%<q*5~UFKWj77IBv<hg(=JSZ%u4v
z(l0jSPdyW>twH{7237dA8KmT)YwW_wyE=PmtNjO%tbTs|B}WJQdI|3YQbY69ra@#I
z76M|3bWe-Qxm(7wH{<ts<GJN{^Lu$VPw1|osnw5z@-O%#MTKsM5<a4B4Lw?FlA?|O
zqZ$*6z;Q`RHx)F+K}FX_8mDcRvc8c21Z`C~*p^$Xm|S3ga7PgKli$3o+}P_Kt@}M5
zs_t{uzQ4)V9?lOm$<wm?|HRz?3#0#U=KgOnHxt|cAUXM`LHR$3xp#E5t4Smg{rLNe
z2G|R|AJj5a=UH;<Zp21>5#Zk#-Wo1vC#$9}xC(x}i65{$tE=*G6-^2`m31*aBO`93
zBVzR24#WMsyS=~fmtOaLzr*FjFV&}}_WsqM<qjD({*u6tPA>Vp-47kO^Yi=obPT=T
z?(%&-F3o{_o`&21y7KjXTD_lK_tT|c(!zxP`h6WuJzs}9duG9fMJMxi`+9r4CV<bv
z+wb-8H*K9z%=vWUlrv}3EoIK3)6E6x#=T7I(TgYcg~-#<-)S5e{|3;aD|ZiEiH@+N
zy}oPp4CseGDD!T=s{i7tw<FQt3ZAMSNaLmnmot8mnRo$*b9em2QoO41#YBgTv-ipN
znd(6guEox4UJZiq{kyDf=L?=&BVpq4^Pk-A`8_-Nd%w$;a+G3P^(x{>d4DR~izu)P
zcTtK-Fyk2Zzl=k;?!$<mcV#}wLi1u0+C9{zwr>8XW(%wtbg!hw#KIX2Rtja7(8|qZ
zyvuwf84P@$$*xv&EGi=H7!Fr%6HF$EsmLEJ?B*vroE7Y<6w5*o_{gjgxZ-Xr2E?(p
zV|u+;hheWim0WimmCfvjhC4i5>$Su>jNUECg%7i9Zn$slG;Pp;^hL>;jeQQg_n8~0
zoDn<&Mu}XvpH-4x+z(~9KQwXut-W7Ukm5py=rCwj(U$H^0}8=;3#7PMPyd;Wa5fnD
zJ&Fgy#Dwr}3#tzaLf8*vSG1!Aox<Gk00Md^Fe4mq%6uMeLF<()guFPLFdux?AB<w5
z>)z~_X2UU<r(!>hK-_I8+pR-DQS{r1*0bh*6YeY~ZoX%bZaG3ePzvz2DS4Y!{b@l}
zd7fcbRWW{ySKLAF$8^0dRySuy##IHvCza;sW_7+xD(g~mm6RxH2)^(^TnUKnS>k+i
zg!jQ8Nedo7LjSJGlh6ufg;Hets9KV;2-I-fhEqxQ;TOl%C@d!Dn&VmWDcs-za;yLg
z9ge%tAuJrTc+E^~4(_(tUQpfyr9$fQD<nFdW;~5{h0@A1l$Ho>xTF>6^#meQnpoGL
z5GO!uXXG24YQ^5=JrEIncqVxO^bA}mE8FhoD~<@pM;7@D=9l#LfS9)lEx&gZId~J|
zKc71kCOPbc$oxQB1Df7KwrGc(iG>dp0@nBf3&_lYMG4Ek1krg}Twci61&KE7L8f7W
zV`ecQnOIEl#}sjpE|WI>ZkCvHU2R%J2?=Cc+#4^nBCOp7Ber=XWY`b13@#FRVvIvK
z_1N9H&<ZHtgD*@8Kh>kS(3V61$zQ#A{#k*4*&f&2oE>X_d>Chf7446p<`NI^uo{`k
zc9=Onbp>C)-2GOJ%Z+UCJhnSjMshF=y+Vizu|L;|BoaC5By>lze;WXa^kb2n9ijtg
z6Ef!);s-jWnEM{^7d;z*p4nf<%){x;m8;p%LmEW4%N|6j?hXKCHHiG!BTwg(DgYa^
zu~t@Lj^(V$G}}zBNwF=0oBdaC8@;gA25zBS&OMl^dK#K8X_mOCKhpKuNc@ka_lj6P
z)sED-$UyNkguY~5i}U(pbW9vNjLcqY+u#7Vyw(89j>F@{f?<L{9r^^`LJtiRWKG@(
zea`t3EIEE>yP%jz8xZ;tE-8CLhC?bcvk{cFOluAKVY+lJ>$$D6!mZh4OG2s!U06H@
zh&Z~Ha;6^Qs<a>q=}z_?+id{_MpPF8J6NI_){$<>>cW5j7+x|p-xSw9S}8YG&e3+6
zK#H3oB$tE~U!K`{1BXRH0^bcYa4i^(VnY2$v!Qtqm_(|!NgR{pjaR-Qln+~8tWTiH
z2}<mQEWyUun4$b#e^3g(uMA79qT!E&*7TeDC?3}oYg;gG3$)-gj(!-yjr&t65b%f2
z#O-pWUFqMpQOfz-au47=s}I)_m-P*wE=qNGVmo++9{>%G@t_1USQsHR;^FkvK3flo
zB-&xQ&)aPrTsvFf5RANl=EAu<D2K~L?;1|_qEiNQLJ^u$kVJ!%@ZT>%sdmnn4T?J!
zjuY8gv%W_k%X4So0kx>w*82!`L=eB3dBV^MkH4?xoxQWgxFQ)c=ayCx6mXUC1&}Vq
zpD3QBkYl9w%*hxLC&3J0%yWch5)5&xB5Vx8n9vH$t(18OHWlo*M?c(}240|#nebM)
z)oiyApovL8V1ZHHua@tZ_CF7R+t%*~N9FMN{NKEt>pX6Zv{OR#VR#Aer$+2sF9zJb
z=89STnm**jO82^dC8b5B?_|2;N~RlA7Hj!9ccv@cl)+k9d@;;`Qs)wts=z~F!0+Nm
zCC!M8xdpw6YBsXVOFcNumP}K4qu#+rN4nN*b~{s|V)Cx69Ubqk=#h`{9uIe*6AbjL
zI^Z@N>v;~#*VUPCe{*~lFFNC#YDU*7px+WA%v9+>s;cUmqZ;Q^KQDo?C8ilCb6#f{
za7n@y*PM9SUxLq3r5JdVF_eTDh&FZ?LQfVZm-4uA2qg*Yvumy-9HN}`u<Rg66FA25
zrOXynNrvM`T=A2!(p#lu-0Q|f5Bf#qgGS!m<Q==cY3y-F9t{>~MZtL=KlGfCX&xf-
zfzW2Uf5{C5g}EY(>s%$zw8CRqK((u&(ZSIL4_PtLD;ZjTBuLZA_&ej9p}x9}L9yQm
zYHcT<d-lIH$JhTd9eIOrMsJ!nFT?wWyTCYr#yE?CGg+mdxlnT)fSCQH?3KJy*F#1R
zg&q{CeT^zn{u<U#v^3cC|1pt7=;+mS=uK@%Y}Q1<!^ELs!(!>knZ%QhK0f#fY<+*S
zmpNh`g#wP*Hq7cr#9FcA49?Rwk3hY6_;QZJs#mm_U9yMrstakuqT_gZxNN+k-obGs
ztfuT1Czfz+rl_TQU`Y+MQHax5t!FdH`wM`j9(g=$Woq#RiM6Tko=P2cR8MK#<s2cu
z?wF94{3yxXv867ahJg=Q880#&F?SueU$D*TxI+2M<4zlC>UkOkf9R*^rcVgI2kCCT
z92p%#r8Cf$4klOL_w#d<pUe~;gdRWQ75sYqygL^Z9n&oQcz*h-@ncWgOD~a%RkxQ_
zn1?BalUX6nQ3ZY0VQ^|ohT>)?YS^`v!2)xRNhIe>afymYIV1U8{BGCCcoC9aL1I5^
zUi-{r^L8}-L=OMLY;&8)5CZenEwQw&B(-9zv6p>%=;2(ycJ%MkQI-0=7sYdsIQR}U
zv+z)a+=J)t#dy(~c)#7cSXt|$qPeR&k@gL>qLco7?Y^ce3{T(rZ&8DDsTNQY-DCw-
z(u+g8O_nf+TnwYVN6E)G_vMK+lbFBT(heKci9^6-Ov_z^Q<PMaE(dyii$Lh_P>D}M
zB$R!Y@D=wZ<(Da;#+etQjP>1pSK7@6af-pod>uw>zdI`{(IgIGTBc_AXQ`eNl~;2Z
zrn&uEgW=X-84mv#wFqPIY3{&t)ZgU+Ynzh-XeR5yRVL&P@Z4!?&#z@&-mOPrK&SEK
zu0DAE?n&*F+P?40HGE}am$n9~6#b~UHH;4f9rYc}ix~+)7wJl&%z+y=F69vtcl^4Q
zVmn33-uZ<|hi2k2ma4W*$Fb9CuFD54YPe1Xt+swr+FzSgS7@!pI%=B26|aP14z@ox
ziU%*ZxD6khsia~%n|Me%8CrruHh9udXZKXS?e@~M&DYX9L{Mi?r)bVv56V%P%hG1#
zjXNq!%_v>p!oPl<$g(u}^)}%H)RqjFp%$X^dV7*L9c_B<d~>U|4+w{(Nv}y#5T0JL
zrhzv_(xX5l*lour6Wf|G&gO+9aib&>uaZ|;S$AbG2F4->(TJuq#Z?#}uB!Z{5RDJF
zy-Ehn#6Q$lnj>>PCdFSaX`H)qKw_$<*>L@1i&WHEv)olQG<RpjC@x^`TiLd!M%&ax
zCRG=HZu#$uhQTv9d7WqujQS=QIP(9bLlUmBM@j}q?JR|k+ilUswZ#BodybcVLu#1G
zo5niA_-bNgK3LQ(>BYM%I&`D%A3;+yt(k!M7_e}Hqp#H*)TlUND|@>@V41kJx~CU-
zf=zLvWLC+LZZ>uOO5zU;)QhF2KJ^rv%HZ2uADo1#?z4~~GnWJ0-3&^K*xl^quC+=D
zEiPXY*r8dYq9;q{c?g7OnzETK)8kHB&D_+FrXMvWMgFtpajLJ0zc^&8$R)Vfn0BQ2
zF)Ngst^*ud3P<1Yn0jFqGpe>%I%tgp!s!mGwW=t-;;M;NkhLAs1SH9{Bg>*G<+P+$
zB$`olF25(Vp^hKPFs-A{A!wt|FmP2%`cY^p_Bkq~)Cq#ZYW;QS=4N?nHO8PXnlXfq
zaLub5ze1Me`s0r2aQPb9;yeTBCSPawqV|CLDfDi8RH!EVx$cs*Nbh5O-kLyw#hkbd
zVW~uo^B7|>@+Qx8&dmsGBpZs#A$^Pwg69x2Yb^=A>aD*^VT<cAv$8WcEF~b4!A%aZ
z2c98tQ)=uIa;cg71mpt^GIk}_!Y};t>@=$jYE~8mn{3gZ{&`QLUi4`PE&|QTq!}rP
zaF5d`asJM4?4I}`OaCLV{TGA%7qGD~{I`&lnc;uvB{MVppY)PX{u7e^KfPpDFKSRp
zL3dNsRzrAbSUwDVo7=iS@N9Ts{|QOYX-kWks>^qdz^7hR)XPc~C=R2`vvS`KZsqgy
z`2F9P<oiB{(ubzp)64sC*8_8h1-X5bz%P$2xqN=^?=JK4e;!;y&+`2WPv4i^)Ai}V
z-T3-w96`Qb-{a-!>*bTf2GXE0zCMNymTb8k;P$$Ip0YP8nzCZ~@ULx-HK#AU_#QT_
zzT7zR56Z{sH5^x)4&Q=04%;q#mYe<!m3;AGkmAHC`JkmYWta`jGQ0%wli>hRGx-eT
z@^Q%-LVAEb9txk~H*&!JWoFNLyU<rKr~4vm%DoE*5(?q|eR)=wUt24`1-91n{~Alr
zhkW_$`?;GNCYE~`2e5YCPXxj9gp&lcZbApkMrB?y{cz(k@5Hl%r@MQN64A0nBaR8X
zRvaqjt33E<D9Ow0$89>35dNu{bvxbUf8;+hzub%L>(1H9sT^}(-YB8}q6uOI*Qq@-
zRLgi&oSotEM0&eGqCi3-M|ZSjonnB3ZzJr`+N}qDoZ`3w(>6f=-4+Fcz>_SLhfQ`p
zL}YKE<R}frsUm^kAJFU5Ul-qHVvTGiXXi0NP@-QHe*-^G!?NGrVSbU>hrUZA8(^IO
z281Ng%meXq9U&n-s5<iorwUTTAeMW<6%h4O=r}>A8H(rWL)Zna5R8r20A?AQ!XoGX
zU@sYir$k^WiH#5{f*ngwOgmsMz^;t9D27@m5Ji5#>gCMR^&qx<3Dn>MviFLGU!=r<
z7_YVP^_Y4fy=Yw{^XBW!1Wt82rHe{^Xw<dz1;)@bB(|a%Z|BhqV|4W4ZR{pb3L9%n
zGCJx)Cm9zV;fGoufJMmlEIgvB+yhETS)mV{U^|zJ1p9M%Sd3K(Q?;~@0<jE>Ew~)J
z*IM($BF^e(K^)~C^5oU?2a!}~D#DGJHpqJutU+$Zb|Ya#eO_=m5_YN#Q+OFWIn5Lv
zurMMr&ZPKGaY>3Z2Ti>9$CHJ~BIk)<Wl?dX!UhCVTWdprkm>*oyYqy=Vx_JgE{AZy
zh!Em53=!qgoIxG4wGAc0J2!i=TEYbwT(9w4ywVWAmUgwN`OS`cCsbNf{E9|XbY5k`
z7p48!)?tELoJ7W>x(wEsuH-h+qOIjusbQKP6@Zq%L!@qe7Ck9CCm<s0LCl!<q(ra%
z#RG2*#+}JHQf9vnE972h)=7#g3~RQt6vHRTFgIfb3!p|Rv@e=n%-u(1ac*S4REvfI
z7GUd>E`*2z{t*}oQp~fhIq{yPwW>u$A9kAv;MR(NpMU8SF{(}G{G|zP030F<<j_cd
z{zpPYC`SUR9D8pUbw2Jwm3Z>Ah)V7k;lgw-udC+iemS~WH}j<>8>O2tBVd))P;pJI
zdvlSsOnsE0Q@Z&Qjc=;|32TssfsomWo+o&0U69bHG>S{Q@0#Ik9knxsSUZ8_4flA;
zA55kPo%?3=7FQ{4O-|Z=gel5pv}J|-$M8=~nuE=#VTGaZmlLc#<dZI;-A05fo>YxZ
z7#ClCQiR1LmBjPza8#LRwX781_y5J%I|YdnaBG%j+qP}nwq2)e+qP}nwolo%ZJaW@
z?!6N|JrRGz^jl^`zURib*YX4B8g`FOW}#M3e^v6g8n;$38Ca3GN_av7-)Xemqw9x;
z**t5tngR40bc)OwRy<-uLi805#w{-JKA|K;f-J!5ccR6|MyMRP*IzIDn}9~|8D2iS
z5@dGdiqK~4t`rI_r$6F0z&W#Co1%+dmzcodWyfd(=BQJ?4MHnSo!Yj752WRo*&?(a
zuqq(LLq*bm;I+{2Vp^KNtk?%z+sg%OEm=xc_AT8&C1L(rh_+im7|UU7V0Av~5c%PW
zrd7UCA$21F>O|^<1u>ppL{)<Hz&i*Ax*tt@+DLA$AO#nf7+FKrS1Egaw$tTF<5TD%
zJevCoz&O7{o|9BzOS>w}-mfC-ZIUA%tL?HUiJ^s@>@7hL*$Us-DCsV(GeqvSz*-VF
z!WwAw?AyF-hqW5t0w+_gzGQ0}Rh+(oh@VBPWG7QN7JDHcr-})#$L&*XN0}X?j9UzB
z)Q_x*Twmg3DwTq)bvmX+9EQ=CX{e3_$^*)-^PEMl*v?FA(UnLs)gt3QOA={n<%s8>
z88Kh{1zw`Srdu50n!sXv?_1&>b{jt>npZGS`V9%k3_?LAxH9%4S*!8c>DW3pHFwiq
z3*EFK5_7jdJKq9XES1)Xjd9I}OK2GFa2;1lFX&Z3KefvSE!IZ-;Lw67y^)KC0l8Js
zuL;3{R{#J#yBHss{(VkNJ{v*HmHY>y>lgMc!(BLsh_eqWQqEDk-|h@|T-FoJ*$e`Y
z2u71~NX(SNLFZB>3L$6%yp~zZA`zkH+A^3LlgLK6c0z_@2ackm!PP6+9C0l3J}}f}
z8`gKt^6xA_rq=l|U9w~$&H>_Y^=jZ9A_797mHw~1gadEVpZ1fJ*R+8^obog{<Lm-O
z1nu5RW{Du((b?BLE|T(sLRzoQLTz25G1^;#$&m&CAKHJxtYmLW;wP%bYlm`^$jmG1
z2lc@57BI@X(t7LCgjx1b!ih3R>bTu5t5i|?d-;#tT~+1_$Io3cY#BCA$#SvugP})O
zN)n=Xd_Km)p+YEAo^f?I?`DYcPZ4K6QXm^{*t`jm)$v+SC*J`qZ5mmbcvMT=_!A0d
zvNKr1OdV%D&mw|A;<(E#LM+nNiwI=!GMmm#A~iSj?GRhc{Jc6*V4-F)8Qukfd|NGM
zC)Z*VUG)NGa3Vw-@S5F~v>tywiKK5*SQM9In-PQ+j8()M65(B@r*ML`b9v7JT<Y8#
zRGzBBQ~jk>EdiCV94L0Dg%rnjF-?b8nwage4Wt?YtrWTUpzAnC%<F6Lcf%4sX>9<k
zUEDH0=XN<2=11ntjpgemSC{x@AFtq(ZO(Q@j5Z4WN23YLSTVS(SsjK8KP72)iH1|P
z4?iET8h!j=&ehoxL&?$XwVXT!A?<~?zR@|GzM&44+BY|=+M8|Qk^VSKTa6iKrQ0=4
zeyw$J*zM`dybrceQ%a1VKuguWo$~ek`)%!pDvOSrBvc1obNj?zYo`9L1Hsm^F2usD
z^6~j!u*juNqB=>8x$XIeE9;9^WI|M3fs7=8uB_(u@fe6rhc}_UucU(F8@Un3&K@y|
zhQTU?&`m9^o38L>)?6-EKuC8vyHLJVGHG0r8MM;|I3Dk=8f;_)-SeyE&fX0HHN&dN
zql+(u&+3hFx@{es3?ft0(a4gwEiwB3U=aE=xumLYyO}$lziZAkJDSx@%aAxiESLx3
zszN0z!WqbV?|Lev^<>Sdxv*&({@|S#`Z8t89MXYwYF?F`O1AS7PR#060FLBUf0ro^
zqgiLDI?InWxL396#tO}*3(jEH=}K=yZgyIO`=D6YQkA5rE9{_JjbK0N4YlhPeS-YZ
zC#R;ResTcRBM!QN;{L+1cP4gYjnj)_UY^`vtDu!>$G#rz45ZDwBMgAwWj>^K>5e~P
zkQ8B!7X3wm@4|IXLTIyIZu{}yRD|`*+GN!Fsj&rbi65>4Sr#H17)n_Xzm&@)iiw{{
zoHGC8)7TwxLUuH~5ow6Lxm7XMiFn&4+iq_@7*?j2&zFMlV|u?}O^wdvbl0*(n`!M*
zL30`wTrQk%%+~7Ubtv75-8f%7xNy`Fxlkk0%F|KcZ<~%<dwsF+%MJau|17~`fi3QK
z?1oj7bvg~aPLNB!d4b?;&-4~yhd6*m!IVkYm@?)d=n9Yr5Lg(s#Q+ZIR4zQR%KFRK
zh(=0yDN$$jvv9g1<Mm2k;;8GH)Rqu`1G=|RlVxWc9_({3Yga<;d0K<CRBBQ9S-sVD
zH=GQm*b)8j3OIDffmYPt1zGGiN({Be+FG3oBG(|bTIC|H*T!wM#wG=-bJfH}U7gUC
zgTRrg+~t@7uUnXEJ9vYcYwCktV9#ni$_bG$ei=5vEs%=#lC>@Bcq3*<9WEI*oBB24
zyRe9hIs><M<mMpp_U?jVS3gq5?{EH09x9B-jb^^nfjj9tUmRYraXK5F8<a?n@Qj17
zs)}ZmuG!1&=&Q>~Zf~Zx3Y<hZE(;$GCFAre#VMou?jJm2$|9S($kZ&fMPA@7^{o=|
z%uvb_xl>6eQqW&-i@~4Oc1q_Cz<&i+>+4K`-PHCTj6|MvcTmoF3YK4Zz1~7ONj6d0
zhWs{tT8#|7^#MHAG@}!!;borVwbDaM>V-d0098~H(5a|cD`t9C@|R)7nTzEe`QJ@M
zPk99Qzqj=Rv+wdZ&E!T#(No0LmO(2#8_w_z7$F8)Xg+8I#VG0)24%(cmJiuvGZkp?
z%j|V1Vgb;Agarm*Mt{<wk=tMUHBD7D!bY5~u>-X$%_vP0$hMwe!u$ZgtD9l}Qw#M!
zUD1EHP)wZvXA8yjAHdJdO#e6F=W8A9D4I4z-(7vi__qF;dEM<fm?;}cAYTT}u^~cu
zxhv#EaB@x@iHBR|&a~o%$Ezu8>w_S}?i*Xll1^V$(hQro6McF7=e)kpr$slv??z5<
zC-3*uP@6S1>&NOgM<cV29JV~awa@+4Ed0EgyYHb(_@D0w>Vfaam)oBv8vI_)@8@R2
zuI+u4utEM`^O>`|&jOg37G3MVlc$gAF!YXn?|<*-heX4%^jH0V<!G(@ywIQ*yUcnX
z;bZUZdhRSnOZ@tW2ZuI+mG}Aob$w1u|JDCIV;H@{@5%^X=baQ~@C}5w#@zFz<)=*T
zlbO6a8Lmk#Kk)L{__}{`lRsT8vjdj){fWEvmFeC?p$|@P#Y!(|BV!n{rn!54S|pmj
zd9pL73hWBZR)pd=n%xoTa_ovWzWv9y-w=@ndlfJWb=`Z=`(ekw8g2GZCyID*weX#5
zV*hVkdi<-x*wpyv@st@k9-xrN`aNXd<WWD*Xm^G{@P}wu1oEir;ZmX|;UIKHp^nw~
zml!GCWC2{3BnX;({~!96xG2Sb_9C}Gj7Yvqm@EzrxppTYAQ<u~KmCJwmWp6t<%@E3
zkzIDfAby$5Jk4?-3=n)wL^E7nib^yG?MZ0Ks4ycq+p|ZdE%hW$x34%mA*6dH7rU5;
zXoaI58`Dwb%SnZ<2J!(H<6i)aQ$#1B7QwNVj4#n!kpbWmo$+OLquNa^?%mr{0dHn|
z8N`pq!SnTR1MV|492}AU2}2I4NT`x+zWrkVUeKHbJh#@cK7pK0&z$CX@}qZN{(5w;
zB2~ZBoG~?mW1?hN8Ss#R25tX()Su0s1AstO1N{QzqDSPBfcpKtW)2KKRji*q2T9mb
zGzmtn#u9f@;KnPr<fW6`6bbA7#d!wV1NH-2f<RG~S@D4e3^YuEn37&>!5o-P^~kCe
zD~yWVBRcQ&MAO2A^c+13t*N5bil)uiq6yC&p%=Iz#i}tGdUho4dQ(<{b}A)=p4+(A
zS0MRjvo5RUM=Od$Ek1qwow{&`=Wvh3vq%G>E>lY?0m3`fz#Gl0*<dmb|0pAZ(s07t
z5Kd`7PQ&{XI%)Mlc4J*Hgkn_vaTnpiwwM5@BmoT^#i5T+kq9RZC^w1+&wT?!PqQCT
z_@b$hwYng;0eA8@YrUc_z@}$}zlqI2A4g>wBME0hh!(*yCHfUhGFkJL)0w&nV6!11
zp_VUXBY+bX_$o+SV_Duw7)1$&=tIC$MlRS6jWUhT5nQ4c3~L4N`mQASm-DT`Ax7h5
zd=s>X3Mz6CkHh5LO+nIXC}S6JzhDn*(2(+ty*dD(Ku#5nriW$dYpfWJXvP`-qt%SV
zHRDC`>NDkKH{o4W2y0=5AM-rPN&jPO$kQDZ*AZ(+*c0zU6ikLiA~c)iRXA=8zEct{
z)<LN|v1rEfP#J8B$1Jwlg@ncO-5MN9w09am_oxW6k6RC@*l&mt3S^Hf4eeL~L}lX<
z5^gxsZ&@n}01rG0pch!ih^|3f<5qr}6WdBH|Cno)Y7zx&yTJvaX|G|xo-X;j4>&+G
zfE=j{F&jS%3R+9!_+`|dWogl|*80a)xof4@c>1$*fOV+|7s2mNT1;OAh>Bny+7_J}
z-_z9t$jojTJ(+yQsL3PTX;kqWG5{(JR4GD}AW?vB^R>=X5QgP1>Yynzwnan35oe@K
z4b0P7;iL%}`bGq!%@P}d=QAx5<>F*OZr5>QnGl|nlU(z}Bt3>yhPo0&6#E~eydwp=
zc2{=aSBSQc<(Qo!@KC$sXTt%c@0v9Wr{siU<Q(iniK#bTD044_xN_mKr3mT`IES2Q
zh162ZJCGVehu2!yEp+=&Q=Qff=#ig>T*YH=LEU96J)76f*gHpY=g+^E>yg767zN&F
zXm~+}u-eRsMI>dwu!|e*(c8B}<Z^~N<JAHZ;aOM6_GQHwix+0gD1+$`0J8m%E#qcH
z+bOtw^x&+d&<jMDBwC4o96@zd61#ocK7$5InTi4`lgPymr64Ix%!XRjngRt{$?s$$
z$^vQ3zryMT3ZP6qRnU@q$r;iXY0dPsGiXT3rl^xElnjdkFSHUfOtE6Bc=or1Q=(S4
z|I;5NdORW)OZpv`a|mmqtlUgIJLZt2-Ub@UW|T(xllF*__Fg5wZ7pRE&e+d;Vz80<
zgK3he18PrZdtH`r^dogpU9PPZ27oDF?PpaUp}Yh@A%{^wYwC2D3nAC$#u85-$@Hxc
zWhR*KU`i&6?O>;F;C942yDD@r>VJ)3B`#G{8t7G4=^7D@Exy+(j?sGODtc?Z9Ge(j
zWaqKRoed>us!v@;V#~Tqus&)TwLf0fq$@$`<~Dnn@4|FDu43M4E=j~iJKVHVgpNh-
z%PzQybzs8fr7H_d)j{34Y)<1joIR6P<Xd6Ul8@13rZ65ry4a|w3`X*b51^Z&+VGM_
zjx~^~$1~lNOtRIh+E*RHry#x!JES0;e)pRD_@ra8U!#(I)kJ;#&<!{?g5z7(OG$(y
z+tvQQ{Kbu|M+xdfGqj@`bZqpzS=NwqvP{|5_qazzy40g|IL1UdhNk^9aVqn;p_%v*
z#bA8QZx38AeR;Q|6fAgXM?I(j!qW_q#5L>~$8=xm=Jj`Gt&@jjC=xkFT&zQ9a^aa^
zB&3MY6ik++Bp{v+Or>Hg<3KbC-&79<Bk5CI3R3|spuq<{KHOuemjs~}%f%JUx!ij;
z+G<98LOrEhE_!}o3efyTMho%+;9MJ&+ap#mFxFQ{VjY@R<(a;mJUYi1npQcW4x-4h
z7i1PM-&!d-M>nYyqNM*GaY{hbK-M{Y3V>d)92`b};}OYiQ(p;#QUi17G&tGXFOi7W
zU8I+P=qRz>1Ee4o3HGi5F<M!CR8~vDzTx`>rPgpgvy*Z=#9`}GJ|>M!5tGIBy%`>V
zH^R=Oekc7sb~1XM{6tO6<sl-iRlEYyKd9WO_6Jb1)$kycnbu<uatfd)4>_KiYe`k$
z!J+x2c#fiuz1AeeIB6!^B3!u%bETnX6+oz1h160*U3sQs(aI_O_z>AHP-n9(k8U8(
z0a?rO3GYta(H*ovYHKk(lEB<I@0%H)J%70RR!GqN(}p6PXs?0dOgB^1qv9Y(5v32O
zH=3Cy&_UgxL~;&E_zh1JQ*eenDXcP@(rDHJfz^AnbjH#Puxr@p;nIfEZP)Xt@+~oG
zUFm^-Iml`-%@nypn;LKmSNY_H#gfd85_tMy#|Nv{)GU~HJ??7JepMX9`hu5>wMb*|
zak!@z@A+hL*ypb;tm3vvga@F5q+_L$#!}7vt36pIa7g<6v$B1R+j2qF{XLZ7QtMEM
zeiqfd*QbaqDoOI?CRH)XtzGp}*tl@<P$dD0kH!!+FIPjXbc<_thvf|&z_XX;zrR|}
zrdpsnG>kadQoVQ8S$v8LnZ0s6P<re}@4mGuda#tCDjaj4w7G`f7ZMWdmy7u+O9IuS
zT%qwB_Idey^)X8*AzF6#eO9FVM$QE>$(kuyS!qgSb_}8#<#Ej$B7Z9Jw8PrnXBb!#
z!jYfV+dNfN<FQ*k>6&#QiB@?6_rC7Od!vGhZ9_1XL1$WVi=lJ(ZE#5#`OXN|=&vst
z2{tVXf=JeE+|tfVlWz$WVM@DSSK$^c!6l<_3++F`Hz#in8uu$A9fX%jboI$>DfGL0
zXxwJm&{gJOP24k)yQps|q8zefF7HW?SDK?xM~Hz6n?yoAx6Z=Z1r|;*OU_u8212>_
z`<<X5<+6p}IT><?QpP_mI`A?d+D6PyG~~~11^35VR>lmyJJ4mY@0*g-KOr@G)czz+
z=-w27EC3l{wG;@$=2Lr0s$E{iJefJJ*fOw8*<tWQrKSpRY~C7@>NtvSHTLL5L76|L
znRiKhZOfh+1`Lv3ho`qi#%lvd0JLNQzRJb#s$GO81yw$;f<o$(Pn8#TzU45LI~HOl
zmb`1(t~@1+s@c@S5O!ftXM236PzmK8S2za3L@~lk3$s&-x>viJw5SB6M@_h*Z%~#q
zR+o23pZ)$AmJ}Y_Y?O1Uq*{XjN;yp2A^lc72KK0YH#`N;!X{cb9wz&tJqx5YRh2K#
zJ0FOzX|NYdHG39BVg$VrYCe7@<)&R3G9l{S%h@F&0Ms_S+6)R!f+Nr><xYkv>gS38
z1293=sB|G*9F)@6nX0C)qKbwRvlisuX&Ld+ZFJt|U+J96cLtVx>3+K-GYzv!x6kX7
zK1J}R)&JP-{C5NMKiv)k=YM_iU(ZmC%&h+*;m6GSf0OXL{{JkDcs;3+6N4)z=&XnE
z(6GEUyz6_qM)=m;G3vi=aSO~SNL5W$)o-Wz8x=O+=BQB+chL*R3}-*@^8PEi;q(15
z>-T+mI&|LkZ?O;lmvA~P827G;cSVsGHdK}e=l6NNpC?a$_c?UC#NzXM^Z9YyfAZEG
zjCQwM*2kNpmj?zLLyJE5`ZPKeHfg_ybJP9(Ib^(4O;&VTloOpjT&#COoL4>4HR&C!
zpP*O&XC+C?loRu&7Tg-4cG#Gvn-Z+sJD?BCCmiuZ!5isR6DG-kId2Nn56qgt>;~_C
zp5O7X1;3*s6WSFTc_m4e8Qm6wpSnFY3FDN%=X?MB`03n>zH~M3`{Rv0@atHg|C@dy
z%I(-hU}|GhI<Pytx!Av9JpvLZ$tOGR&mSx@$|>*Qdkp<olUC%_n-0Iphma1dm+<vB
z4mt1ij_lX5nKe-LwM@!Y-76IAd=NtxQQMBt-i-LUCJ6dLdKf>s+k<{zwF>%d7^o!8
zmuz~1aUS&Ztk8}*&7+s#^vE_54YXdbk>MCygjZC8n8~TIxiBxNLC!Gg-JXfU$itE^
zDs~Y_#hY;6Xgwc&foc0wbmC~RkaL&(;U)`PO4OF?3EY+9(q?U(VA`+8<?1(*6t7W9
zAHnfp)edY$buQ+`MAnlK8~vYo&)v(D{@l^0Uu``I>fR&|nx}@HveCX-AH_?h#$2}H
zr6Ky)j#GrEf;j+u&H-+n+I|D<;ae4>d}(~WU3v)WH;*Fgb7cVDUrL^Nnfek3ONuv(
z*rw>)fRd1HF0o684GC`UQ}nSjIagZ)Xn0wjIZoC{-GuY5EE=pOA$-uqBx4B7t)ON(
zCwqb|ZVOMWL)LznvjJ#W|JDiaP!bJPb%IY~&VH=K&eR>opzt$pQH#9gA_0&k`#TK>
zcFX+BFhosgHmzAA+kR$#ofvHKCTI?0eKBtU{eK|=huE&qN|g4tB9U!eUKR;tEv<%S
zO<|Bg+Yn55E7@pOO)4;xrOwW^yT)!y&ZgL#b3qWM*j4L+5T(@N5M6C0l3djba!Sx@
z5czs($_u|hO4WYTaT(if$vZ88=wIlYIc4RNe&1kHP-wA-L*_U|y{1;EU3!j}W1bvY
ziB%gZnW(irJ0+S3pkpu|HZC)dhz)h}h|7#UUp{v4Van8g8g+9$Vmg=;I!adK;Bf%c
z%`|mC9bnai_+9s;@=}wH^>8SbWj>qZHH>1FNGc*BSgbRM=jC@dP!p(h{gLUQ1JtPc
zv^*sFIx8<FOWE)UwB35XxGW~Qc2h=smH$_OF2T25K=TDqJlg@Uz&m>QW3AwGmN4%&
zdU~QhUV|U(lSH|=>rt;lT}#Pr+&BBM4;YUH?=-C+)!QoK%leuh$O^*C{+;OAD%9-^
z^{<!;Oq$S@_@*jTf4CRu&hlM(#HXF;!JGQI$>dCZyc78&1L57~uMd{{9+o^l+Dk@l
zm`YF#W~8_P6nQ@&96la!X1+~W7e+2E1f(q@E>8e9hX_Ej8xZU!I;6;6D=^kYXWXI8
z;>r5ZK1t2agT0Pr|I5lNu9EtjLFBJtX<GFnc<$h@?5IqxFnn@QXj{9pmWIX-7CoS?
z@ut7me!sclc*>Cg@)Q8ooNHEM(~K?XgvH$RClB$TD)U^HCh)VO1-Lq1j0h2=B$>;l
zjBzzU=|<gTp6M_|Dv5FngcfK!3aWLCHRBGp2uDOC4vF@}wCa%7068i3bnLIH42l3i
zQE6|IYL-dzJ#iHQ@wNxgBBl*VRthiCR^+I}sbPghF5uI%B`z%<<Zb(mJ{&m+^Z-y}
zoPWjr&QVV^u&U(q5IZ>Pa|dDnV2N~I>4eECn%jdIZ!py{)SVW1=l{;VI0=o)9A@eI
z*<WKoaKK;X_y2jkyp5Stj;3zkiUAQd77PFoN>epwM1#i%LpIX)p89KWMVCG{eH$Dx
z@~V$V)~)qnK9q$(NV`+%twTuDK=9(a*zm*@5S^lp05FtY2LvXbY%w{_$T1qDJm)mz
zoJ{3LVoM2>zNxZqQz>hvWU!%5oAnYG%&7Pdq4vTAZ&d{7#E)gR8{NpoGC*5Po-;4i
zaNya3+9aL_`T`%+^LpF*XW^5N+BW9Lox1mkU|xyC*<8E$90ZbLV8w!*a_u~UV~8-&
zLIT9N|EmD*v(653@Xy;&sKA7B8xg1<oL&54_av3&L<G)3b7!apVJ!KgqJhJi5kc(D
zD?0Hcng`(boqGX~f#kU5ErPh;)>Tr!eN|dnWrhOr8$3@BK^95K;)I;$fd5GLitU|L
zXpspgHV#sbamrykmTGcVT2UlM0lH^`GWeU=fK1bfS!EiM14~Gt8_zkiVl5qQ`afLX
zd{yg#I*TOx(M}PNHmuQpfel$irDuJK%Ca>Cc83jB73-2@H6{IK1@xL_XdS&|MKhNG
ztNC@UVYMC;cB#P<_GLI4#^Hl$vneWo$*q}J6yK(@1t6!WC#qHztp})9Mb*l1Q)<qM
z4&b1z?U;*!5GS>mbLW1NUxHyhU*UN$8m;&BDyjsX)v&uXST9WTWV>|nrw+65nU#-@
zAJa-3OPB@8P8Cb>BowxW#3v`%3<Vz)L%!7#D)W#CT`-6LCin!yUaEGzSlbi2)xKn!
z`$TL!KDOwCuWB#`p0e-SUS{Tgu@49)Q)D4e?t3JM>Cc*6y6?a~T&!f~?kJ=7q2D4-
z6JbIY$4RKbPJmIM@8J>>V)fWWB#h$-1UAX}I30Gg2R;S1b4PW*!Adj(r~Dx4VWyo~
zFfH$<zkC7al^AoKyIdh1vNb5oQZUy!0&jRpM9<W-Qp<2g>8tg?qiaR6zL(xa4OIo0
z|4k`{t%>X40VdM<1yxg$y&Z@v`(Vp;2#Wx>iIbx~Y1brQs0W<F1H;ee^8SiY8;eG%
z<utE2+D&>;^LnKx6>v^lW3z8g@Sc%s_!G4>vkDz=YH5qfww!-lob0}szxgtKnnI)O
z^m|yBH^y#AI&4y?{!uAihMg{5Jhul&Wr;VcA~(9kL^zLZ5*yjI*ZQ}Q_~59^dEHOq
z@b$vZf&LCZ+DWRasTXh*@${{cL(P4k1=?!jm<M?j@?I%B$b+;gRKr18LpJWZAM>+{
zw5s?bDwlJlG5+Y+vjRU`s#ga*M@Op*rh3}Drk3klETym(|7X85VMF(~2O8@5&LYir
zs!_f`@q#5Wae4f6eC^H@b_$Y7oT{GC)8uD8UWaXGiNeicVB0BkhwjtLpY93@dQ<h(
z)ETstbMlKgdC=?gkMV#sr}ZJmVG2dxUkkN_=?`+d4vt{tvC@RSJfq3ev`FjF&Np*3
zQI+V=UiE$_yQ)sXO3O2y`{Ed6n@(pU3}IXD-<f>4C%-Ejp-Y%Dild$)0rp59?=^=W
z014L9RucoICD6#MSR0o1jE-}>*^%`*oEpJ@b<20Rl)C01I+r3)Lgt#N_0tf+7z1A0
z?bZda%zce_H|TWSR#!T?t(nN>&3_lYV~2mrm%fafFv3o6X5xi3v&G&LjJfEUtCYIw
ziY}&Iz>Abh&a(LS0;8!ucoQwcrRHAkCk7~MEUXsFXGZxnVMwzm-62T@DkDAWR31~r
zS{L)*G>V+kEJ&j)nQ4LCII)xewp6KY`9Xd5F7KwqO%-i|X>BXRE>nQG=$b`pln{KO
z4_+St;PR~%ktQ_c;$TVUmf*w{O%5)&aDE){Ra{gcxmouvMANGNQ5_au$@zX~O|3h<
z))TVEa?T$EIpLc5BHNISUH$<R@4&%sT;p-aweg+-_u~cZhtK(IEat>WA1FzwR~*pd
ztXn7PlQ~zW^?9EA(lKG#4>l)V6b%+e!?+&+FE&~IaQNtxi>5K7J>!|EWa=6_`Tc$8
zS7Wk@{vT`n|1R7AtFHfDX#5{4OXmNrxcom<#mxUru>AicXH5S;3WL1=QWyk!Qr$`+
z097mv{u&I1VSO<^>z`-RTMS43Clz*t>7km^iQa@4?<Jk0nc(2<kXlOa`ufuKl2*6t
z`zsUH@58O#rN8}lNrziR=BKF2{X3v>&w}6U%kz2OHFWAWd-wH`7Web^jLr9TJSqRf
zo3rEB_j%)*K683WOB3R!|MPtF{vc<eVS(Y-7?zd?cl%oiuk9Z%h9&Kpxn|ZP^G_~1
zbK<{QD4iB@Ir#8JBIm7LTgzX?>NC86ZbjsUZtsme=A|`3LYI+R19^o@c80Xw{XA43
zzOY@9$_I8pOS=ct<n4Vw{B7q2MpW-B>N7Sp`rKjQ#*~lr+d*P$-(Qs(lKdymaS}pJ
zw|~pu_xZj3Z?X%Ysuz-tUvh%OsXo^3{cY-1lKPXSDIw9qrdTZ$zD)^<WGgAaj6?~4
zJ-AGB4~KP95KZU=oCEcBXg2Q$(PY-MF%20QHSl_$WPbqb=hOKQx&wFLXO8vCJo(P<
zB2UGP;T_FzXkUs0KI4)!uT$SROcp>zY#$N};2Ja!+8truthg&vEbcql)j}-!4Vb~3
zV(t-cFqB`Q%xROrTmMVFKco%-yE&d~vwPMad2e<IASyrpX_B5nOYS}#a9q|Mx9L4M
zTI;PJcr)&_<gUZ1S-0Rp(SAX_wb+6{^7~&K(nh$n<8*E<p8J4hF=CAJ?0Nan+Sv)K
z?1PJ}6Dz7ofr)DA{^G<hrKS9lQ+k9f)^9w!!w^8PkQekV+kPEvhQKRf|NJI+JuUl;
zMVNj(l9@U*-}UT);l*r82zTRl32yf}>OIRbb6eQ@a0aQA=s;wkD~9GXN`DezPo~3H
zlEM3Z{+lG6A_#5thyY*`wivc~%X|#zO1iUmL{<%$)vSwl)MO8uKF&{E8^crbZDPRY
z`2+^vPGcW1046n|N(6}*8<{(ZSi1oN)_@=<g@aq6ZV7vm`@$`dqA<YGF2Z)G@F1m4
zSWeF=I5GhaJOAwN@09pO!aa2W&K+|4{8c<cTYsi)@Mr@e*?d!2H-Q7W-J-*4Gz;fO
zqu5uou%t)?BKP+%a&(f3$vyG4BStv|*WfWI45A|5UFa#9tM(-Nm{aP3{Y-I9BD(0I
z4`V`^pJ<Htc>lR;5#lA7<?J#6W@<<gX<)|kaaT^MptM|78D-?oYm{z8XO~9Ef?EUh
zhpGACq&GO)AlPsO<%QM!nvqFb4%UO$5vnL_XEKE90!MGiWnGwAXiPjp;dI71s;Rm0
zJ-O_rM@&(srefO@#F!`eUm^v-AufB>0+2F>n{jwq)(BK!KOjz;2*`{bWhaXXKH+?S
zcX`#(@U{c+RDS56lo3EZ;uTmEm47gph9TerFiB%X3KV8t0h9h+A^x^3br64(reNu{
z<ejI*`v#4jDVE6?2b2UKmAYijY(jS=DgT+8!D4~UWKuep^rIWiwV8_J`LOveZw`9c
zjL$Lu<8(h!H$%XQ=#SZi0qWt>TRWUNWgPnZN#-WE(l?Xy0`ZF4?xYn*U=rQ-`ixig
zJiMgCEZ`4V1_cKbNq~520b7uSbj6?Gk6f`6(JJh`|0lI}$3$N>&;qb$peCtNo`!Ik
z;IBwcNBjli&fq+CeaGMv(mBLWC?U{jqqdVjt;$Kvou!Xngt^e#Lwr0&-kgv}jdNTG
z+CpJ5_5nD-HXuGX7`_02@-;Q$<4O&ymv?4sQhBM%LBJ$gNEKPuH{*>HE%9)VPAgDH
zcAQeyV5);W)^f!Vl>8fOJ_6^{0;KtnL$@&6y6|cN*59F{U*oCuGi>OJaAJ-I6n8q6
zkv-S-A?~2NdMk_@n#(#9F#;_tDvN<7Gh#q#Q8nm$=g>1Ob*kF3(x41E!y5jILdk(9
zZ4<&+K=&NX^7KNVD9;_VWZ|)nN<zszH!p34t+)J6)qHqidJ5sVoxtyqhiA*LB!Ez~
zawL_jl7*(i=sCq5N6Db4y0~A6;jRX^0p?HmRv^SQC{px@$a?;5nTbFqHVdGbE5m^Z
zR2232>^!3n$|Lpqd=qU;wny!r*~<Y7fu;t6&SPFDooOp?h+%CL3b|IJqbRq3x6R1r
zOBW=Yt(;`cb;5-+`_i{I@Rh1P2H@n;(XuHco8@N1inBnL-B1`K3|aeb+Hfu+vg$I?
z^Ms?RG|a3LPYIb6P}15)29+a_%x%fmsqYl!TZtG(Bn0*8?->`GYhsf{EHWMtx3H4v
zpE_NPnP4OBeLAJk+wrEQ)w*D-)*>Nov=R*?MS<FDk*zew{B_7&sn!EYADgorDr-(S
zW)jE(!8jx!m9e41vjvVAf^||%!2zW#)u!rWQREwtd=M68Kh~n(LoJEXL@{{9AenO^
zE|)x;qqA1F9+VLCc%!8iy?>~h_Zalunsj+IW>EKyyTpalPL_n@OQhog?=A|f>9igX
zqkiA7oQy@ANypxy6napgJPuoP;D?dKYd;$o4~@27sn9pA)|gw+sLJzdYQAN*muW49
zn??fbutpXI=Odz*9W`}oDG19V+lXa>klV@-XmZHlSZJLs0MXE(=Kigy!3(%@wuC5o
zS~?In46vrb(5<xTIu)b%uCjKJJDl*#LsBJ43fge^+@N4-e(79a6g9D)ZA-lECi)0)
z>wCIM#4b|XqN)2ZPpZf8kQTs*{Xv|0bLKv}fZu&iy+Bp$R``y&UBPx0RK=Q3+jy81
z(|hAh#a$8*==TkuZ0^-L@9;ek+TVw12WOm2fQjCb#EO|^p17adIj!e#Hue!U7URaX
zvmXxF#aA@2zP4Rmwso1(&{?f!rHK_2XVzQCsA8kJLs^+SQ!ibHs6(p0cOxkcw6QDc
zQFikG)={H{iMzLN5;D1Lv7;_DitKu0Ok6U~?|mF|!JM8|m)G0j375LLZ`_|ablaF!
zLrV#d+%nD*smq#?GKGc!UdKqVu|<J?Y9~fqa)|$s!TLiqvqY$g*kKFwSn?#4m(|c7
zg<EUvnlo<(>@u1t9p^MVZp$inwpDU(^IsbvIh_4Ngw$eP2T&qhPP*vIZfKiF!%tCf
zWz|_wDVg!Rcj!GNBB*f&1JPnuiY;}OmVy@5cPpAY&_auPv8>TIZ)i2QYe0Fh46ocU
z%Hu$G<vzJqtLb3a=H)+9sffJeM!c~k+pHs7$zZpsLIaFZ|IUs^46*4vMw57?)ZxUE
z-eiamL`VE{lguscU?`!Cyki5@NS_aj?B8AFdfCNLLPfb6f`xc0I`#nMlDXGd9$d1a
zb<ud54o&x##oQivr#wP18_64g^Wab*BVep(RqBi-df89}A)Ug_gR!WE!*zyOkCl&H
z1Djx;o2>x)r@CJL0ck=K@mZ-ze7oC$U>=W4&aUfZEf|)$MrYA_X*l5OI^odG$L;cN
zWpjN7>=LGH!rt3%09(um6)w1{(WMruL?azMfF>pdSvr26@H8PdkN}>Q-D8?(jTyLz
z?8>JtdRqvx&Dw{c3WP-oU#@9@*;{)Wzv6X50C)AT$g%@Y?1&0pbb{zLZ)5?Lt=jLU
z&gNcWwapT+^ii!&Oibh*Kw~ttg}3kK8oB0ACuag4U{U9GEGHt;!!tFKD1DT~9hbW~
zCI>p9lbx{+o9g`&#uB*n{4{Dwj#P|PRpGx1y>kYC?9_v(23DlSYWVf&NKhr0<6iT$
zn;IF1poxgy3E9(1bOUoeVku~Ci*Kg2PM?0Ta{EO%jl@Pzs*Hr>V4#x=4k^s*7%691
z1$d+qm-5Y1_7$Q^Dklaek_?pMz#ftmC>JWZ98DgxR<e1te)cMd+Dx%v<c|@KvqF~d
z*}+{l_q$&Ik}QxjsdoLbtCUmmcbfY59R!SB6lP0kppsm}bAJvbU6@k|uc)?UU6)dc
zGz0Z#61rxP{im8a0(?z_#CB|ZqOwgT;T0nKKue`ag5^sq<e`0DK@UM7kvSjctns({
zYXFB<;!-7}y6E=#dQ{<?sDjJw#J554UTk&KXk$FmmbSAodrnlLNILk<VI9hiU-<pP
zG0wE7Ox!98Hq#7QVmK8Ojt`b7WKn*IVL>(zm0C6E(Ng>%A2en1oB@fCRL08jdoJ`A
z)|yrZ$D;GCZe1orl%htQo2H+iBwV4}jgvjl4IsKWuwc^q$<|N>Kn%Dn7Ln$~#?)O5
z8&09lDj2V$j8KY|^c6gVHaKw44hE$=9Bv4Xa)(e+X6Gf_l>&=II+<qTJBlYC*_I;+
z(EOiAVM(6DR&iC;9bCAH0~~X$-t~gP0j)(39IsMB1#Y+ahxq+1N2!@84BKRv=Zh8Y
z`Ydg+aldB33o`AEp)|}F*TD^3*Sn2jV`ha*%eAC}`y0>p?SP1yz=?Nyq-bZekxnK;
z4|F1V4xJ@#vjl>tuo6d9jul^v>6+SLB|rWoN5>T8IB>nF3%^l$m>pe=UZd*CBz`TW
z_&va7tjl10%xdCA@WI_>Z`%?gTW(_;(F^5&l`aWnwkrBPx$y&I#eny?vww1pzQEa^
zn~$Z$Vs_-t`Kg1}fGHTiJs{bl)IjYUoBvtTBYJSQvHIeh2M?&Q<irzU)3c^)OVy9M
zi+=Pp(=SSfs&!MgamdQJBj;#(yMX9pGbZv|L29<luZ-P$x6U8yxoowgD&ZO_`#(ZN
zsRt@)7JJwkrMvD42um-7W&|J@H9fO}f>{xW5PDgMmc;dj5#8J1KloFyP?iJ|JkZf9
zl(8;CD^M-#?h=v##V<|eV+hs{wN1HnII*6mku~d3%AvK+%h8j}5-%E<e+*$4TlPE*
z(xcz&9{ou#zq>8!HO8ild!i`HW9Cp)@RVL&OJSGQ2=mdtC_QoIs-_c?tqN-I6OiFh
zVq=$+mGEvaw`(X^<UPzU@ACrVPZM*rNQT*Vqh9wa<6Id+s_pl2OAj>M@*LKNph16J
z19YuloQ&}!gD5EY_!jx~<86LSU&XbVYx^m>)P~NFNMJ63?9&%8G0G8$aGHaz9VE@u
zbs5MFp%pz!#SC@S?+j=s#O^3f0P5LMNyPd#<@30*>hZ|ZWj+%FlH|F&Yqe$T%Er+*
zp0X8M`bt>q+INuacOUr`#U(riu<vvl;WjAHI79jVJREPH((m$-UE}=-z#sD5o_spq
zZ<?qwC$_wF$(=B^GVw<Lb&JA)Qx2Nh*95f5#htOwp%2M21|i5vk5<<`!MlBgzlT#K
zj@*ap27L8|gx58QaiBVM)7a|SE4qJ>DOW}v-jE$1-R&T*isLW_ZEHG5DHnA3=risP
zqUC@&qJ-JEKE-q|x|814kp5)ZmlGQ1{Rj3NpJZR9jb>HClP_i(d02~+C2nfO$gnZl
zu9a#$3E=Rf!wi4=EzpiWh>8!$xD=sAbql7V;5%Nqkw$NIX*&=?-_6<&q%@jHZaRDJ
zw@Ktxu=t>WdX2S$G(K(9X=DryioCgy1E8d9Db<67AfmwYkXd;yBh}mU&A<61HK@*W
z$E7|Y-A~YUy1G-=0|dXPKEYrfz|rmzz2P=Pl0>BO+~z$!Ip7Wze#jnfQdjwF56unG
zF=8Vc)GKjb*(_*9^OzBtM{%u*OQ{*Xq^Fc}pao%ZDOX6wIPrXXa`x#PonP<L;XsXv
z(y8xKz*7a;vSTWdI&MB-eWz-HMXu?qQqPQ>t8JL+odbAB1v`uDld{#%><v7EaHNIi
z8qLFHS;^*s{F-3bM+w7n|6sMUVHgTvurlJyN#%t^(@MIz5`X?ONv}a+muj;)c!fJ;
z<RMTnhvYvq;_C3>^Lm}Cd^tYhMacTD{^PXee=9&(nAsTr-;F8@!++SQvM~JLY*eTJ
zD?j?nOv%%q-^-eFqPkU`W0_KsFFN3(fq5n1EAOJNvj2PR|9%_OEp95NqB@I*rkl;F
zyPT3X*6w{Tx+F7u@OWD$PtWi3b|1$7^E7$>l=XD3Uv|#IJDH?8)x^~y$~#+@*USI4
zzgjjcZ)g9r`0?`d_CU?~b)2{R_2T&UIQ_o4Y0;^tZ+EWvdi%Ru?dj#81`~4-;-fEn
zxs}Vixghy_{uRcr7u=CMZQ_~p_(VgW)G-JiM%NkT&pokwpLV3GUz+x)+D>r2{9bh@
z?*Q$#*yPgg3ii6<j!5@){^cfbcPqc^dYQWTcy%}UBq>vW7qzlsZgS(<U^k;>sNSVv
zbMt&dW|iGMXwmN2X1Ds%r%X(3v6&DhaWM0jw|XifOQTMDr|A9z{^!vRqrm^K0EJaM
zLLauB7~t#t5(?euD6S4hFic<!x&cRs9LcxdWk<e~^k}^onF;Z+497io2LjQ9(VS3>
zC7VaewrZ2<m!N>-L!jQmd!fG!wUCmVOsd+N70&ap^q2u<6lm2yEOt7zlEt)0h(N<H
zF*7fuYF^DQp3C-mOtuSlSnU=pHA6!sw}uNU`uA&3H1tzYTf0@}&*Wohxxs^&M}2>2
zCO^SfKRWgH*Aw(K@#OChd;J;pV>=5=m5x_C3x|YD)fv4~hN%m`sc%3R)csVAgPMAv
zcQuWko)5zzosC&6HO3G8?;;(p2E=cPhX>}xrt6s7lQ?iVG757J!-~Yri>f7b)L5-*
zMcQJSNIYwlbEI3P;Q2l2`K_Dgzd_nP00L-cub>Nixou$G3?0wrHFrE?U%nxE*j4GI
zJy0C+!c`iND^!)f<X-xb7A4v*7l{y?l?x(x)A|VLfMxX9FKDIX;>kT~EaT1ty0cM!
z3KSDR#nQ{uC(5vDGM$@u0f;eLscJ08{=2n6D64B(DfwekUWUv;<{b<VCOBXPZ;`9s
z$MSvH=x{qxBzW-qKRVcKnG}NI&95>T2(3BAbwgpWJ<ih?l{Wrjp8NMuoYZx5OCzOK
z>&?OI(w^DO+Ccne*&yUo6%+7TK<x1>*9VimDPahEmjcItYE!<VcM;fNI#C3xiz7CG
zRJHx1YDE$b9Jt(rNQ*k32CRcHy(q2eP<4?^?XX5s0}Sqf9{(y?K>JW@Hn|&)18uN)
zdV25p+!n3O(iDCX3fP13KwE-1YBWI^XlYBfjM6$RlZ$*yya&5XkD##K!<e4t7&8bJ
zh5_8Q`8hx?&cn7B`AJDlK5XuXOp;PE(ZxqsebNz?6sNU06z+lPPD(gqXalutoDEXo
z1t9Tg@-=&Hm3wr-3>Dtax+3wlb8*JM_*eC1TCubMN1R^hot~&LeSY8Xn~z!j#=6zy
zx-bEdE^u;I_eCQ{J((TmmD5d(x}4D%#rTPaAc0)sdxEY=B7#RrUoGYmiw?*qkT;-)
z%c8Ln3W4RNN6Y68r01&B9MQE7)a}|zsIu-$%+lf7FzCln*hf=5<5wtK4@o`_kf$N{
z!G}c+*l}xaMSBlYClbfLmi8Jj_3B~aeUx3p)v)PPBgA6UB`a(}Z@Or;=)!Q@EsOEd
zC_h+R-p<z}X@z%kl{j;Bj?lCtcc!u6{Q9}8kf@}Q76B?wj#{!G{6m|E)9aPm8h-{Q
z{Yw)VP~1{bJo$=_@+vZ=FxSFbMkJb24}dL%fBx*^j{x4h4;=9)3-ZCArrCw}K$H@z
zkEEmZq3{KQ5jmB|!+CqJ{DA}5tkO~%s0^cJJmz4Q_uaOjg`yZ|7m$&kIoan_Q$mc<
z65D*}{Vkyi(SI}Fnqi!I$6T~}HD_}<yEv{n;wp}}Vp&TiL>1WMQmjWE3@>#Bk$jk>
z#-fo>Cw1qsn#-0e<GEnGT1fR7H6eV>qXX(dI=G;J)Dv=8++Ka0l6tsNYb7OG+Cil_
zdO~#efn|!RMULp6j$i$mr!g143YXMz82Jc#kqF7kCOmUa_5BgEG#f6~o8VaJ>xYt~
z#`i`oW`a(+gPHPGmOfb^wJEMsO>G8`SBaDUpy`}j;vc>(QGhfGq6G{Y<YYLfCh(hS
z5$md=^(M*?1i*06+l=Aj6o@3d?A=Q6R_;-Pmy=y?37|lTI?Hu}28D#e7pb{7p<#w%
z-%AkhHRW$Ti3?@ZBW1VIC*95HN-F8PWp}yS!l;e+dcw+Q-5cnhPIr}u)2<XbcbDxH
zUj=ay*T*m^!%y*#*sD<4vvdl`Q7-RY!FV9*;}B38KGmUi6pqPJEYtc3P@p3c1K(^M
zrU1C)qRJ^|YHC(m5G@(X`}Mb^<KaAZonyc*jyINF#Fl{x8`@I?mwUEN8pHO|;)F8o
zku~a9?IOTxE>Q}Np>ogkk(v*hfn(%m;BuCYxIJo8h;Pb|c+GgqbXkXiksOW%*{~p>
zque{x`TP+(^$XHcXps~1r|EqfbJcmxg~DbG4h`dh90$22zaMDBxChv7xMPs4xNpAM
ziD73E&0b~&MHu@~#KDFLag3(nG%+w``9ZWMtS(C1Dz%|DTOv4Nb;ujwsn_c%*B-60
z10)uu{bpbW$B5VzZ-d={Ai750R_sH66;P$#@EpmN3{lut`6}w7RPh2cHQ!K?_oe2k
z{ED9z?`|}#u0{P4G)h@qYbdI3D24G5ir6M&5S*WQ@>T>tW-MS+p-K&)v>L1MPA9hZ
zg)E#A#3n7*P2?SUh@?wYl0a|I|AK?-C6%IGRG<Dc;QnC5m;xJ7+P8RA&ezoQ#=;D-
zxLPQ@Q&Bw2mLi=&kyR3z{Ic-kn0g^DXHgmN(bEy=(Hf?tI^fnvK_1GMXG4<{X<}m-
zc3E`bFQC1SGq=)1;Z~LpDoD<}2dpD_XIq}X&~4DYc~AzCnO5JG-O{Q7N$LFWYU6lK
zR<c^8;-KVatq;iosLTgy@wUeA+Hv_1*VB|q1JzPu-3o(Yke6C0s+)I_4iSKo0Pi5e
zhP-l$ht0vcSPG00KIO0ekek#|&5mM3WgAB=fy+p`kEEPVOe37@+Xp`XPZ5Ukq8up{
zBL(1640ewMV60)CH|dxdss#$CslnbR9eyuVEaoOF17EN6=GtMPcgW?Tlfu!ZBWEHK
z0XMD|7`n!v>e9cRal`-yt4yq>qP>dDEv$yjeFaCgYfk6d6HrZp#t;`ruFhK6wJEEJ
zGygcw(2NPWXCN_5XJgsMBp+XkP!0D7kXgT+iyy)mp&V-?l$?#S1qK3GyrcD1gpcyo
zcKB}GR~pTLm2=Ujz*#YOi=q0(ij)>zL9nQmIr(pU-UBR^gclp8TQNEkO5^N(4^IYz
zY^>-8EdD|aw~=}kVWRw*HUB%deKi2kTe#{;Y5!KMiX^T+0GC#6^<))%N5@}xo=F&%
zF3kVhL1^Z5S7qIbr2zY!*o6{pmM@#~G)u{V6(D|5?JJz5tu67mmn|GLlYibqe8iUB
z?CClr^xSMiv;k1T6p27fj4f+A;Nw^Ci{ktOgObCzD6Lq14a_FlF}~t%Z{fqgcQ?)K
zcr%#|ADs1YH%euAxK-0-!}#us3nQ8XFmLf)L}ecGRQFh1bCjh#EKlsNx^d!2Akp4$
z{27Vk(wLS!<W6eY?swGhxJ2y9Q(<5xU0oGG*GPuZuiByLIeOna<Axt+)_b!&`FJI5
z6I_azlNCZLI0Y>RkL^=a09lu3G8!Nu;S5Gv&GBZSrDY_k&ig02({xFYb3-chhTv7M
zP`g{ey2gPkVM9YXu@Ien=iL}<rS1F6Tv2rz04rXB+2s;Aso~o%>IoNvjK!N7wq^#{
z<-zzFyLl~h7|768BmG5V2IRtY)X1VmfT^D*a>^Jf?mXs}l#}QtoOxy%Y<d9zt#Q}^
z){D#bq`;veWLP(*(}j(GTzX|tV^ww=C6i06EJ$Lr8t&u3pS~|&H@OK~3SPksiX38&
z{2X<1`eQ^{3MWqMPOJsMq&_YqHsSgJ?_3<>J7o<$bX331^`FKO!-_VGL*Qs;a|^6(
z2w!{T0X|)nbunLPy6x;QQil6GS-}ARLDs?~*@T-N)L{4IZQIRSic4@Ah5fbp9Z8JT
z2^Y~6Q44ELIgt5g00VZ-UYJP8&Da~e3wtZ{dMYuMKRh^s@!yn$PPd^36VT64-4c>X
zgHzIcqxtwvd7?>&wibkrCZA=ElCXsIz4@w78$*B(=iut<9Lseq+cUAui?P|W6RhxC
zb|;w0vkS+pO@07Bj$-k?ItK`_EdsBH8#7e+vYy{qXtr86YW<IZ=UCq(!O-L%eDCvs
z7NX}Gv|ZWgQkk>)RnFJJzI#$Q%bau_tcd&2rs`-`wX)v$pd7{|iQFnJ%VhMEvidMm
zETk>r1E5U{w{MElknkf1VEWEAWu|WS7l1|^D>w`jhkyW60JUP13|gJ{UyOvPont1T
zI1Kg<^i>kh2cxSV@_HpT8eBn4zO=2+6(&jLKgy7C@aSwi7WDYM7uAzB)8OZHd0zat
zmP6%pHuXjmCw!-9L*xbq%(@-dZaL2|!gvnho_rt6OPknnw*ex=FPKKv=~mp|q_B28
z;8Uvc@&Hw{td^s@kwxlbLi9F8UO~*q174EXU_xY@QG`Fz=+2yJ9=xrd#E%#e)^pX@
zHFias>yiGW-L7#Pf%AzI^;=LucVuXER&bUQcWn`}-7cdh?`-BMxJuKWwzwaY$D_(m
zql_s%TP0)xx^?n*uCL&X+fg06jk2Q$@JCGS0PYeeKJ4C~=U{{u^W0=AXBWvEAeuzF
zRY``+v)|~9!_EDKL#Xgf?8cQZdKAp9yYeOoFL@#Uh18)wFp}f9rLM)x?|h{7Jfz}r
z2FY7Gv<BBwa?{7ovW<9}p1X$wbSN#gSzJE{$y>QTJ@qHaw>jIFfI?E_CFbI?UjzlG
za~>|so6Q$fT%qO<#&(Qvftz)UvrE27tO12l9B96Zsv|<8#rPz>Ra&PH_sLG%k^xqz
z+4@>!?d>6+D%i(fe$Zjwp;gNaDL!4|D8q``Ii))MRk>f(T;Jl^VM8{M?4LI=L(Wa6
zQdy%5Z3Cj)0Z^^$Xg^UExs@UA*{yMRBM0T!4{Tkx1?I5pO8WR3+UeH5|Harj1&P9>
zO}g#Vwr#unv~AnAZQC|Zo2PBtwr$(k{$@5}Cw3=d|J%B(o64*=^Le>H;ZE{xYyO+t
z{<netSALnD`9Jc@%#8mS>wnJwBiq2t_zwl=|CepJ{NLGz>wjk(?xrZoK`d}qhTdyt
zYTzP&fHzU<SS~m8dhgr638zOYBovxES<?WeU6pa;?R^k1ES@G@eSP2TKJFe%WPM-e
zmp8|oOG>&gS7Nv$vvVHnH&)eoWZUWRT(^De-(OFGu6a9rK8BZdA)kh)dA}UhdAvN|
zCf$c&LsK2opuW34UVmc5;#g_st!_E4)x1|cT8A<Bo988XsH}JkeGB?@s6MC(=lwc#
z7s022IzdK2z9@vScCoEo7q1Or=YTxBqu08=?@sRCZ&hmvkp`lT`!FtAQOv52wPR+#
z)k$bY(pS}(G>s2;AL%-iLD0O{;xS$B3U86_8=%?c*oP2w-7`vnQ=#iaKe2J&3Ffe$
z5OY^ZvXuKM>>+ozTS7n1P@#U~9JO@4ACS4hlZD>?paiATyT|^PGRpg?Ll5Nk$5Fu}
zn!JPWD&4@O)LM#yh!>mlm3x;s!WLHWXZ)3lOXz~>1Y%S=QV8>YDibd6=@;q|+kKVW
zogBa_ir?#z?=3(FJFY)koqKg*Yd`(d_SQ3KFeTy#6`A+M1pTx@<TpYuJ}o&Xl4tq|
z$t%+PyVin`a{PD>-QEuVbcL}5qtpVnIV~}LNMz)tUgLM1qEmi4osuI{cPOf2Em5uj
zT_D4hh98@aIr<cfPliG|=&fy1?G`%Cbd>c)m5Hx+(%jL;(gK56rrByjSV9{Wf?l5*
zp@j4~VwrN(v|Yjl(1$$~99;=P@Vyr1fHkV^1dM-0{#3rHyg$)<!1!q@ni4`e6D5;k
z9U7syUcIZHMdGAZem^0za0S@!BQFM|6+~UX-GWyMqG3<dF$;+T8M|{n2Kkzdeev-U
z;#eaAl^V(okn1Q?;#eD!6m0Jd*my59?;EB#19=REmAn+dSmk^Q1OcZn^b1NM1Y#kC
zw~aKWs+zJ#Dc*Ax>~kM6``-zECCs5b-y`iHvc5=B%^$O24mW?eg;(mpUYMOfpb<Gq
zf><KNkQk||Z@~Blqsf;kA6tkX&}|YbkbXIY*%Xy1MC(t;NB7Pugs#^EnjUOS7Uc`l
zDTqXc$^Pd2O*Z+gga#l(s*4n3q*==PAQ6u&^H-6KTe5hUcZHA^op74LA{Kd~F2<{A
zL9$FEixxNcH>u_T30rxOkCGcnRn%0;6Ei-6CS+K^JiSM$ZqlwzhNG8{t;9rGY~ehx
zpNZdNFoYU!5iQwhxiEzDY;fQA*P<610E!_1C9}|^s6ezMjnSJ*Ax0)OK=WKDk{+lE
zS`wjTgLrntNtS-%*ch(0WUZAlGL(m=Jq3EWif2_HY(j>GOOSc8<61wsB3f@4u&Y?)
zJb;|gL{wlY;zGJcVYLhb27|Y#=0X`EZZ*5jAaZ_;3QE*C@kJ1nK8A-qz5C5Ue=st5
zD7^|4rMkP!2;uH}5|L{xr^Lew2#03-X$sw*vmb4dS0*p}U>nF|d%s7Zz}0}ap&RnC
zJbY3m+gIM3P^}|xn#ec;%x#5dQHYsl+H<~iIgd5)^^+w^b_O;l3wL<hpll8HSJYT#
z&lq0;0ZYnF9<APXq;n{nDSM?oqAPF@=+$CA3Ho3E7Mp$mucF;&$Px-KP)lt))U+TN
zxM_A}shjp*J_%e*1c)?y;6XHd&M?SE?2XIQ9j_{Z*zrv&o_AGxmEW$Fw>WCg9hWzY
zX>1}q%lzyr*k?`?npAD3L2#;j_Co%q3H7n9z7Kf?O3I448}`PE6OdNM9#}owvF1#n
z$rIU$IEJX+Pcg%xrza?VOT&G&Yn*c>`1p;(;0#)Z@L`xVMv4dSg0(v<LZp7Y73TaE
zz*t=hmP;NF<w~mb=rTEOTw-@M^vtPl)Myg->G%#Y8x(QH<mMC>**4?J(ZQw5+!~5a
z+GUEPxR7iH<kaeqt<bfzR;B3`WcbICMm@)yY(#?GF31YZF+g=D^%N_~7uls2!(h;g
zL!fPK@?^@-=y_u=7P^ZF3T^tFqWi6099xLkpyKrc_Otdd*ie%~)5v4xgcR15rR4&f
z{PAR^g<yX~KnA~t5glO_xx+Pb9(T7C>P--lJJbRC*E8mKnY>))20bI^KGanGI^-a(
z1)w+*iG#?E!w)-ii!n5ivp0=Ma*5xvyy_+-LK_}YsSrj-c`Vz^Rr6~m*dx?n#5zg=
ziG^#K%Q<0Z9DwvkB?wZ9pZ>(Y(%K?zrRSL{%p+TN*oL~!_5Kb$zy|4mme|?AqR;vP
zTNO&9!~W3+u@Cs`*Rq#gu&iaj3qd+tid}@{gWu8t`nbw4PVITr&2<*Jn68G#^MI)C
zOSOwPoDfSB!Bt4?%>-2$xiEM+N%1Zf`q@*<x+5!*kyTPZM>sEn5`!E?X{$Rk4_Ofx
zj&mObsJa5G{A_$N$a0|mm(Yrjx9GCo=1Nq{uF2Snw01&eG5)}1HW;9e1drc2MgUrP
zlUcP{C+H4x7b)+4>xQ@|^yZ8Iee1IL&wSX;5tKn0R4uu1X!wrdF2(_(A4s7rQcFZR
zJA3&86D5DBYO}tHxvJVCs}3;_xd!7sn{kO1Pf~7c_8)OntcpJT`Br*JYOPkXi?YWQ
z9CGF13y3>a%ff&uEeabYRSGEOwk?OxCg-}q$*WQuQtI?eHo~RfR9QvV@Eqg%kS^_g
z7~`4AgjTBT!P)Y*niyM}yGdH9V>f2O_c3Qo;<^E75j;mUppvXrdm6{Y8B8|nVN%M?
zlXJxghe29_++(dDWHD??6o6HW_dB`e`1993Z?Dw|RMOm)#Ozs`G8|aLP=RFUJ^Y<?
z>*!WjRaEqk=F^fK8ojzaR|$$y!<w7T`?}!blTq{wdcWrNr6asDUmeC~nl-zu;^_8{
zuG;;&wgKPn>|>L&gpmIFKwg}0cgOL>p>iREdG;?Z7teNIs&qgnJX;4Zyq=>6{qh7E
z9EG$@5K?*0XCFM|Te0P{zh0OwHt8U@g>Bvv4S3e*U^4HtAe`KA(fqV^?n01UJ<qqa
z*3;5%`P9j_HK0uMfJRJ=@}Fo+SfNa<eCRZ`Ti*(>BEc!6`7054efG07@mxlRoP>aD
zvp;+xF6FGrSWzRu$1>Zmss0emBYurluh5WfrIL@ivD}m$1C>KV8@=VQiL!mW`Kh(@
zT6ms2T7lhc$C>rbPT}&8YjfOrXta3hMubJR0h5XHTkPSw{vc*%foArK0-<ZFHo;o`
zbaIt&8N2V$95;wU7zL9nqts0Ia(wdmS31tQw`>`R*8Oi1Lc^SQtIkr57VnCb>8VfP
zR_qHc`C1DPz<zX^IIg+dfnge1g*5PXOYL!_^e^4HJ7%Gj@_DJkFI`wa0PcMjH&KKu
z8@B|o&jC4-FX>;hKt%TSrzws=ejDs1-(urPtFJ@FB~wwM>p33BU3rByYcCHx53hE!
z1-ADtQL*j01H=ZqN0Wzu<Ju}YZP@~h*O+-5Bp3%*?7x^^nw;#$i&jP4`37)k?ZKJl
zV@TVYU6a6ve#!Smt>v*gt$PDfP5NA%t6m=2imCkOi0j^7uC;bsNU<_M7RcOxJi8{k
zms2~nXsOetMALW-jyF_mQaoleXH+Yq=ZF=n8DA=;s_E~qN*lA)I^WdHE~DFSFY6t-
zgw<?8H)3TeVD;*r>40?Z)zt?D_fDxV->pK@!A(%M@GhEEaNUf7?H&o*K01rTVLm;}
z!vrxc7+94G$xLLpN#qf;Lmv8d7vhFdjy>#gu_G7VrYtc2M`;Aa*1Qhs%n*LjR&vY)
zs3DNBBw|gW&lI(Gd1$$CNwd<XD>h2c+D%(ejsT0*rp&0Sz69QaFHF_3Q9z0|3K4{~
zO2MxL&ku|{nQD%&4OevdmmLt-L;IjSFW&$@YCi7sc%j&n+49YnYw`rGTV36L;k>*S
zbJjtPhwG&GMt*-uvsVSjqz`pzQ)aiNoc9Ip_9bW)@dsdFP?7a<#x6oAg_gsb-PMxF
zLbz+uQD-ZKMt6elIg?qE1LQ}HIMwPrDt+ACOrSOY!TIsDuJ6~!qoKl_y&^Jrfy`Im
zBI9ekE*S05olD33nRkm=-}h~~L+lo2Kk&0SA~u}+{wvBF^V|qKZMVZVEHKv7CXT+1
z8>)|sOwMrYmuYvovoPV6D-dPU_IRxS_9pp4vx|;+Y$U_4+F`yBEaZ^_p>jJfoHPMA
zRqluGU}J_`!Ym2oP-EExDMmt8f)ocf#%x>?T+S#;baAzvG(=&ihtA=6Wq#T|f2gs3
ze~^~y-E=XC7TQb}W6%|STj`3Ve)<T?)2}1`yoA^=oGp^pVpB%@c|97mX`5_fJz)%C
z#aqsRqWDUPb*N8-SuF|eQ4olI6`kLKsg=Ku;p#3<2<I&KHRx07sjKEv8+=cTo$y(`
zKa)M>#Ysd{9R)PwEOYb&S{5+qV}S5I8RLpEsPV*tKu)T9O9V|qoI!-n1mVIvr5pt(
z;38SWf};hqcwl?xY-oO}rD!Xr8o%w=1l#{m&phst(CFBBzqY(TL}%V_Ug<u<W?1}J
zyY?>!_Ak5k<J|sZILiEA_@vCt{}VpxrIvUF@i0PH_dmnYJWq#dN^+>;iuU+loDjGt
zdR}pr@wE&@)Nm_b&oLt`4(De+M6q7<0SevaV-q7IYF%m;E8%!wuXk6U)45-F`>wuk
zPVBy&ogbe)uouLz9!q5IHT7K5p}D-+U7we``{O7%-R}}K<L%YW+uE>J+S94@KtJ`)
zX}aU(RPlbjaZnha&)u6VRvh-w-_^Wd`V1Dzk+bKsv?5go^2?7SXcf0t#@v0%g=o|t
z2azfj@R6;5wP-DLUJa^lLX;~8mUqInV==cEBX?h(n{Z2nPZz0O`nugUCVn9z#dNgs
zW0KJ<qcBa83=%deuL;wuA=vC-Ayq-&(|Zk>dVx{3ru%a#BOR$cOHQ5R>H2;<czeGN
z-CsZUck_IT)Li?%?QX}%dyR+ze=O(3Bch+Kkb}kzPD%Y0t)<T{p&NEAKDF~q`y|j(
zg)KC9Wau+n*)(feAY0VNOId(M8WDQpnThi$U!>J)H@(92(R`M9+3%Pdr+sAly^8zE
z#{kZewnGml2%3n$tUXoBhpu(Q_en~q{Ph*$WDgI`Ljwe23x$OM78C)z$k^pLuK74o
z^8pll(PvWky}Ee^jAZDP1zBZ>=_SBmia&v`)>j{5OFi}1&faT%+D-fd7?ErG_AN(i
zKY`w|794EadgDoW#7QIqYGF3s)DOS+1r#Fh+OiOpc~}t|?h`dk4!}P!aW)~>>Db8b
z;at~~r~^^zf>~8G9oAYEnmxikhv3wonavRtMc8~!hK%&Zvh){>ak*faQU&c29z`oU
zRVxD7J%&V1Xa%t8h%8Gc75TGKOMFckk8Nw+X3?fRSa_y9V^)i(zWrU=!`3<g)?qxk
z4@GkuH+?y<yj^ek6u);^6>}4qP&~)!eZtA|Q=&Vh(Bgv;xOPxQoI2XWUf~+T$h^ru
z7wK0AJmJT0eH2L*yqxHUC#9^ZeNrhICI}5xS|yW6BAFb0tf1D}rKED4N{wsMuXvaO
z#cjR6o`ihU-0Lh3#iPGo%0ff<T%VgwAr>~ya)qI0<lH4R4ObfNr?jSnPe5=v`qv%p
zG->Xyei2Ak=&niFLv8@S@A-^F4p8CbcLx|Po#jZ`<zd@|2D?5Ih9%i2U2(`@!m2`?
zS;QJ4O);(3aL1QCdLkyt=7^5aIN9+t>FMwiUKTO?VUUc~ZtgRoFY1DlM3~RYJnn*>
z?KQQL?69x_*%4x|81f+$NASrL$qW!6Zu9*a`KSjX+k+mP{N_?nGBjaCC3w!v62tux
zDO^$imLwcZ`3j9Uh;{rHjrfKZtK~??0nZ~_cbhnlBTV0Qj5COh3ysgmrEFz&Br4w;
zWXIihT^A~z9ai)!>ZlJJ`h-oK0C^`g;tFO5H9b73>ardnbM+H8XQ_La9jS!|Yy)WU
z11J^(&@OFXJRpYft5EFW@B_pE1z03W*)OkMjukwB0U?&;^V<VxJGU-%&UfYX<ShBM
zvMq7k1>Zz(D2?#O>`mJ=6X^ne$ki+hG6<7!7JXL(01xR83abG#C#nm=xWW*t=4~Sj
z5W@UoZI`G0o(c*L2V`ca^(?qRQ_e1f%MV~yj+dMV8131&Fa@Mp0}z<zgv}msfe3a!
zKyca!`WV=rORYu{Q+SY!bCznqZ?``b@+BcNMG6-~RBy_>Q4~(450K|tQ(?=3%=9N?
z6D2YFmxx<UDIyZeHq1*@|D|D1335T!rv0SuXsO^2awti9l-g%!Y_gao1bE6J6XO?5
zaS_K?({7V<^DIP<^?vl|tZ6ZcMHfY=C>4I>-)LkXT%-zRn3fRA>mJ>@9{!eNAfVKA
zWI6)aZ)bbj*~1;=PRa=%idg8xsW#CaIKpyN<RDaYD5d_a2f*u5d8|MpY&dZ+f`m1J
zSVVvxR13VNf%gR09tRVcx_c2sqi~MW5*Ah}s~~B31N4xVTgc&!g!#WaVFHAX7A8@E
zg;yh^uwZgfwT{7nTof(9{QRhZGL2pf7t?l@vLg^TjTGNS-ZSw!vZJ_oVh9{%`zcEZ
z8{2|6Bz9TCAB*8BO_aorb~6|O6d<lzoaC}hiUivA@kl9<>-%7?{)l+XXGy?^xzR~U
zFex$b#L#M#Uc}z4hvE~+HE_j-W|ZJS^gTSHSUod>MUD2>(o<Xl14Ecg^hUa08Eyn1
zvqFcZN-N}Wt{_Tb)PIOwu6mO+XC4cmoF4?a+!^)K15~gLJu=6Il8@A<-YCY?q<fOu
zE(%W!c{=4^(GUHIb=wm@-Zr0o-vLD1KOb&?HZ10T#mBg6DaWfcW6+%MJwwR*4|oHf
z9nrN4tj0H$8S!&*mN(&-5)m03SS8Jhlv|2S1%yBM|IFm-jYhK*${?;x`|fKg<{8-(
zRQhy&BUgoz1ZnUv7F~#2BnVKJ5gtwl*a(}l#7b?*(GR67l%0<hW$w6(vA30F;A3N=
zc}lR~g-Ngj`KRge_g#gB(j31c?!|w2G5Ak14GBeKu&V$mdAS5;Bz-~{AzsPN=NQ5S
zyfFuUqYD#!7`0bo68joRJlscds7gvX!AnU6%z!<_AyMvZ)93f^X{dgLpwmKBB1S6{
zBrh>ApDvhkLyfanM0v6ZoBNQvtlPP}>Zx<CFHhP#h(Rr8wFyk{kFW5>$__r`pJi`^
z2{j9<h?Q4H*WU(^6m7vYJD`(6(~hT8LOx=mL^)DXSzGVmuJ-AnR*Slv=TyO)Jd39&
zB-P8k8?Kd)aU6=o^_pS=r=Xn2K$ihW3S4@eiSx^9#Vyo8wvqZ95EW+~q$n)dbx&>H
z8Iols>>Qq-@dG6)m)<2gvQpi4qDX;onZ~Ot1Q?!NB^*?o=L2(tD+lZ27)jmrJ1N#p
z?Xo>KthnV#kY`yL>etw7`CXjKAsKDMr4NNGGSsHseN_iZjU8n)X*i95kH*o#qS(O1
zTxb{<-X4MKI=lxp9xOC5^C0SQue7ksL_zki>qOJxXd_70ro=?5bc@Lf<w?6P21j`B
z6948V>9hj%S1z)q{5ug(T2Bshl@h7It}LRLP8mAeQvUIDufNPbOpcvI<EQ4}#3$F_
z(NEiIlivr7oM*I2*AQ4b8rIydPcWVime%Hr-{`mSX`wmH{7C$24*tR}hq#X%4&O$x
z$OD{Y7E(8{JSRkfy;rj_q3<mq%qfhAARZO6^9(}f#%7gLmsR2!;)*|dk>E+;uU*0r
zfliUim^%VpOe9UAuahKLZg$ocFP5}fmV1J$8C(PK2&1Y>pBC6MTIxXkcXzwOf@1tl
z@`}0?!*kq0$EP(chO?TCwo1KM&(6%G;(|*n(^6+@j+Hu!cv*Q+^jvrH*WOy>t_fCE
z^d#bwv?a97kmnEQE|(roo?hB^qciQ$?fH#c1mTEPOBKk%XML(@uRlBYc{%$4>zT@5
zvEVZ&cc+EXmfO*I$kfM2Y^y<Ub8~;L009VJ$8_NH1k6t}bbw5maccGwf2?+RleHL@
zKrDo1gbZIenne(T(`O?aXO9?F+wttWBCrrB+PEYU-jtGVjFOKq`*dhfv@34F()6DA
z2-j50F^G6*)Yaw){q740A>sU@5k@c>Be&>jgYyW(YcTjPYgzWt^ZlFL*rwC3Za9$N
z1{<RjES6`v-5NDasW@f(U+57WP&Z=Tp5&ZH7G_9HIn&9E6kWH?-ow3r`;v-@n|st4
zxP|5>j-!IrHx1xYC2^iuz~}GS0|k@|3!p+^Gf%BVX<e*{Qkxh)fBAqNAy*2Z4nSc>
z%f{}*fq0b{<(lGoV=MYx%0oep?!D-Qg(SS)M-0s6v$!L378)&xoCzgl<EWPReJ7Rw
z>0Pq<q&JF<_S7KBoU+ZO$M-a|)Lfx_Q<LLCqylj5AR_Y&0EK9?`4k^Cp031rVmF;;
zF6j|Sc8|*6-8o?%PwIs<kG=JT8!RBpP#U*&+=B#vE5G9-5+v4hc^W%<aI-kb%U?Zl
z>z;95rSg30ioTaGl+L<zc|vP^uhVQ|T?-z)#&Q8dGn<xWJ>GxPg)di8coKpJ(3}65
zue(<NwA9QuV+(xWsQ4<bR@62sYZX;Bop<ydXqyRG-@L|a`hna%UO=gpcVSzy2|D>u
zyURxgs9F_uii5LnX`D$_*u429a@V?06!`GwE_|&67TK*VV4qrEuIXKe+2as@0pswQ
zKpdG!oj{NlwMY<^=o@jQGnYU*mPb}>0AIfFg3d0PG)!Nsr$J*i-}YLiEBj>IhnAwE
zk0vVxHUe|!r;pphego!&Q1Jg(+w(6c^Do=O$iV&|wuk+{WkT8iCz;SoP4!5kQ3RiV
zrc{~y8Ds5;5dkR@eXJM#0{uKNJ}Zw;n0OOw`(W$eTL|tVDkf)Uk9FKp=I}ISjEsy^
zbcBNaG1gz7H@mm@<GMa?U$S(WpKPI_zBVC~HTzh`i!xSGDDC$5ukQDowrsh$F*l!~
zCCA?#A0cqQo<3j0Kd_ynn|EWTiF+SN$=&PwT)Zb)IEj9V{+B769G?v@_V8bZnI*YA
zG6B<8m`{OO&0d%bmBqV$-;5kgEcU&j?v`Y%Q`lW0q3B+X^enc!y~7^SIb0<6PO_yx
zyB>Vq*m=0UuvR|5Lc4i^yMN4ACzr3stLj0zv-^_Db>Z=<Ri&Xip6N~>d8b)b@@~(b
z1sYuvp3m29w>|LInjb^0Vol)2sQ_gn{r$Wyckd$<um&O3LCCKb0m;7&aiU`=z8CTs
z!r~;BhC-0#_`l=6!`2vphh-Bs4z1*tG!bxvV@Y^~w~T^4gwsc>AID#MWKN0P_RWov
zAl}ixL%g8Jn>Lts+ye|%#!DH3K||E(v+egvR_nz7;Ed{VKr1{;dBX0FjN~=b5~t&C
zdNNTx!NjiW`Nwy^uq?;81BZ&SDo_f>0J97CL+E)=Lu9Q+QFAIX0}(xp`kgh-M9}R)
zi0J<W`NfDl8Y(HwNfaUG*e6&cG(ec_>Kuke__ub9^RJCH0I>$f$Le9i-*bFNnZAk!
z|9&N_ZtUwWc3ls3hs@63tb1f`f@@q+#n3HvHixT|o)p`FJ5kG$yd3Lac5_$Yp+kg*
zk%Oxi(06z+OlwJnxQ0V4EnJH-OHDt}-xlyjPKd5@b}uOIZ3JEWeTot;2`&k4dlQhY
zr9^8x=nkrI9m^?8AY;qHq~BNmLB8^E0nE@%cvs<Ix(uDJaWnWJS2NUU^Sh=JFpAY3
zjOGm36#+I98}1+yf#jBxU>4v=4nA=@Dx9@DHCIyIVXpd}Ct??mI4D6ml@^ef2B6BR
zARoAuenyQJEgXdph>82y3o)-f5J|E?l~30XUD(L-az;Oiyw{WgSw4<SHIyQ$`g-^@
zGpITyOe9M%VF`sIm{pQkct)K6_8JaH^;DE*m>=7bkL6CJj_8XM&WWEL*5rRkeUQE~
z++ud8e1`t2A$EsfMzUrp!7S87I^+fo{V9)&bO2;qx2g>>c6+nV{^w9$2_v0y^7PM5
za48qpVS$3Eb9bV=VOs?Qi$<wtmX%1{udi6dlpd(!WbuM8VkJlzkeK!pP_;Q5*Jpq*
zA1e9D{X*HAF_;$v`=5>*rXc-5<zIXCtb(V5h?MPdLK?u9TYBg~mpUAK0yrlW38);o
z9I|GP=G4E757RawYV}IasIogWgH=DJ#BIf<<I1omYoVYG$q$-~U)7gJ$&~B}VVJgt
zTV+c6Hn5L|HP54zT%zLXer>-s4+lgk=9$rD0P*A`WKe@9{FjKQCKYOb-U{(hpjJ<)
zJP<L|9U?T&sqEwm^EL`mfw3~{{9LCF1Pb7B6$Z~<AyH$cG{uGlVhlnBC>A(KyT+SK
zX@f<_;l4h_p?;<BA<`xBziuOW$1Y)k?70w>U=CtYE++6q^yrLHFx*h^MNXOvRFXET
z%?mnNs9F6W^qFv)!8&KZapm^FVMs=zJ>geeWFv|qF_-cRzj~Stl1wR=&h0JJv296w
z8iIK?QdVNhL0m@Diq@3f+QBA3E0|kzM-PgL@oq8ZJ9M3xVC_l=k$Mv`mf<Hb`WWny
z@DyYQNDLBaXRP=t8xHgMBVS1_K1NVd+5C%Zb3@p>x;U%|jdbC%G&;PsXGUEfN&iM{
z{$UH1u}Lm5*tm!JVF5t2m=1gc#U+TLLp=H;LjzQT7s6+1`xmNp8`DIWWj%BXQXm>m
z^A+4*&e1_(l02;ViMR(Y+)HHtVUorHk!-x8Gr}k{zA!inyW(V#yukP^N{26hMmUoL
zJGu~?=LkrMY*l8k04kPpf-6>+jJAtj+tI$0_N&r_K4o&FDvA>GE>Eoe7t<xVG<mSZ
zIOm8q)CE0`=O#&D=XLSfTGJL#*p|g3R0KzyqYB$!6B}dtmU}~i+IT9xGRw{;_k78v
z3bkZJPfh~2{QdzmIgE5-|Din70|1Ba;{o`SMz@Gg?P+K<V%%!2k~jQac_5KVAxB2Q
z0!z`-0^>i#)j<(jyCk9{NF%Nq{{D<a?bggZ5yjM1fWX06p-o2=gZW@u6Cz@QFu{@Q
z3>OzWdyi`IkJsu&@X5ekfNI1)H;bzIbF+H!EZ5bYdtkVhwap@t68QUS5=0tFrLBL*
zHd$Y`4ZC=x4h#drTQ`r8VVx_VRuEKRUa0G9*+OB2^x76day(RUcsij}pXj&-$=eFx
zzlW1`k*i>0YXrYTa#>h>2=IvLcQ1eUd0Y5$zPw=KuLgL4tRz8pmu2*87`=M|9~0@?
zzbE7yW4Dmk3KfK>0jShry4FBwI09F&o;PK`xQ)JQmp1xKWddow%TBYiy8wh&RSW)A
zuqc(*AiXmwZCsZz@w+(7rc<xStk8Ue#eOP}rqmdl5WQBbm>^p&d@ABr$n7%ds^n|q
zhzYWWZRi%+-^S2sk2WHkr_R@$Wo&lqT}!yFp6k4{I7IoSLXj1?P&bQ@6?y>nY>_zp
z0D+;trhmiCsJ&39SynFeDg0=v?#Mir8=bkPQ|>;Yw@UjoWYD0V7mExKx|%*WoTjEJ
zZ5ZU}yzM(u8(t@P`;g5I#R;#5k~|qlXf8zIeZ15=|25&SSCIv<tJgz0yBO}q4{X1C
z^40pY!jR>9?9&TU3A5rgN|MOIXb^|U;jv4%FD&a?EBGcRRO{6f8uhPwxS(WVfvbAp
zCzh|xvh*2SX*SaAvg#CzuCDs#MmNsBhg%{bO13Sx%;}g=TgK{Uf!-};9I6mAXT@H{
zvE`MT7NC!E=X$r|UP5O@e3FSEk7-qLNeT@kL|og1SHh$RIqmem3o+WNRTcyb76$^5
zo<KqrPH?j}e+8#)lhL02=qi$(73Drtjau~VjdRgPr6*CsXs}vyP9KtqKdkAH{0*2c
z>&33XXV0tJq*zDncFfJ!C4np2=kvE);VSE6S!TUO)v>@CDb<zO=4012sk5u7=hS2q
z65%FZy3jH&o5E5A)!!wL!)T+p3iX=9y3^Y%%hMELC++cdct=6%3K_*0j3~zo#2e9F
z!s8Aww)GoFbf(!Maj46TqX(JGuD4n7#mNW)8tRBUYjTPV<tG~xRYk?(Dx*y9iSxDG
z&T;WbrVF8&+pFQHDiRtxG$T5!I{z%dGM@UvT3SyLo7s4)c!(+WbZa}8*|DJ`7!{W|
zC&fja6Sn5By|CwNnl#+;TJD)a6kg`N$s8Z{JRLX`?TA4m;fO&Myl7+rJ7=JqCH22n
zt!)v#(WhTgU>&wv{ve1Gf40<z+JcrN)m#-L1D-XJrDD1V8u1C<-}Z_J*O%qC7P{eS
zolTrBC>gHR1Og~rXqz^PO?C1DSr77MH3C>+U+#Ga$V7I$v#&kWfX%S54?(I3+w7sl
z)+5qm6X!}d9@ZHP$+>8F{FVWCPz~MpY}vkn`3od^|EtvfmwNq2>N2waCqAErk?sEt
zWU(-^|4#y0nwpVR!~fv(2}U&eIOny!(?j(2isHq70Q%G~1P8q_%LHgKiHX6)-#m-Y
zXIJKv7L7c&1Vd_~Oc`Cus@{*@i}n5fmtT)RYIlA-*Z1WqmactYwItN{B4pEU=ePL*
zpvzj1{)V^5miPVn=5Q#}*VitaK?aYP^V?+|*3oNA5bDcz2`@KxF0M#;G|T?V%jx@O
z=y;1E%r)2N&AWKGx|GC}CpSgfEAiBQj<m*F`*_E&Y!2>>S4yIsTl6;iR_BDLIbLF7
zQd2rTQ|7`d557qnfECrw3Ju=v+V`BxWb~z6O?a*e&kyKv6Q;)2=7^W;^J@3w;iggd
zWd6Qe*Jm*F+UMho*M6|F-5@w5!DrBq%H@1;wZ@zscEg32Ys!=77b05EVh1>O2F(TI
zd3ft?zhVZBU<ayj0f838`>4zpg^4QriJiSYoE}=%G${|og`Pgl`mCKpbLtG0&+TX1
zEys>CE}$*F3mBU&Sd%QS$YbZ~^}!S3TNBO>kCq8*2t)t%i<#N^&<@}6Ne&FJCF3If
z6b0Sr-$c3=r;ToI*uEhQ@PV?6(Yi%?e+VRDxQKRw1o3&RbnTYQv7np_!3oUK^=AfI
z;Pn%B-DRY#e)!~julLREoLNs9ULP;_ua~>&6aJ2Cehou*PPn<>`@lz0RpIw?k$Vyr
zF^U^b@@iOqkRke&4LG51Cm<d^Z;{tEHUzV|;?T8*f!29J2~Z$Y)YB2XE*|{X6rQ8C
z48=6hA%msHF5Ao8MaKlY`76rJnl}4hR1de3EylwbR?9}f=J+^)l5u7jm)>}pLq046
zkF&#2sW3QiVtc~agW;rPHiD?v=ZsqB;OhiJpPRl8X7uE*vaRw7_krq;@E1kL_)|s5
zyrmYF3_<9`9d(I=C-;^RPti?z@5TYAWduxW`N5cQe==i4pk9;%l|*L3tVS!T-jO;Y
zTELkayXDYH*9k`dJhJWw(Ac;g^N+{nf<;e<2#;+&L9phhhu3lotV}d^{SFXZ#RuPt
z6PS8;xrx?$DPZ$k7icG<SHot*fet}7h%j1sW(Y3)lRaM?3mMp@{+fm*Q7DyyD0Bmq
z%3TItIO2vQ70DwdDDhy91h2RU<WWOi-NRV3MyOenr75H)!p@pT3j$#0&M&cGer+c4
zn-I_l2y;QYx+iw(rlXn&(kw1T4^6HDsC`SMkyQDU+W`L5R3o=0iU|f0k-uk+L|<sw
z9wWeT_SD0tDMip`^<2n7>e`a29|dV5C1*ts{Zep2UNIaBMm3C3qyRQGXvIClq^<~<
zo?^~&hc{nn6<Ik6tkuQ8cgQLe!^#w{-eG3*Zz56bu5+rxj0(<+B^4ZqYX;y(N!qXi
zv5;}z22>43R1?;Y3W=W!wIht-%I>C<P667`7bgn#16m&1Qk}Kgi2<JJutJ7QjpwM%
zvUp;k3`T5?S9+pD>h7^Pqs{~!dC2`l^I}-WW}R%2b;~Hn;M%H7AOQ}te{LZ(zEoZ~
z?pYF&YGNFlI~zeCf2ErMFM-E$e5DKaC3c}Kqn^HKjSy+x#}=S);O0(LbQ4f=S|<6O
zDH%72x)LQtir9ieZLO=ELNT5uzC_LgE6JeBITnwp<j!NU^?}vg9xTOT%sW$(0;I~_
z2w6fnsseovKE;9RYV;GjVIF=!R0dSr804=?H}+l*x5%@)SqCh0qtClIqjF-nG-+h=
zTd1QE6-lt(U+H`xt)ssjBSSc2QrLCu`Awu&`%Ue7qr|ilc?e&~!ept3w)8MAtH-i5
zf1uV4pDf#*3F^YxN!vLx!ZN}GZk=AhzzQ=cxvTJc4mG)!guINC0tc#x16e<yrtI>b
z&f<O5fje10tXZN2x->2pauJ4fS+?NFa-(@wRJ}@gq9^IH-n>9ALM~eE@apj<B{{9}
z#RW{BpPdC27peHnYS@}TUP-re)I$`pAe>}s1#>D5G<t5#3_EYxBdE?<gAzeZePd<J
znsVP|By@|i)s8_gEsg<t<BG(b0=AfK_WY_*0n73uvqZ@2Z)Fk-Umk#!EF^7*?%9Yw
zlT(t{jG>P43Qq-*n-m9sM>Od%VF(@n5)h(p_4lep*?N&?UMMN$4{tk8Mt2_?23eu8
zF};wa*s2x2NdQuu=Gi!9kF)-T`q^3GJ$WJa<h(v3CLv;x-J{^)!m+UOQN25bbl?V7
zVH+33!u2CmGm0_0wMk_yR8a7F5eJR)_R5!c*O?mV55`hCzy@rMZ}yyN1t?Fq#MIh;
z>@>~e5AQrm8`~b++^mwXSE9JciWo6Raq=QFsgvfpz{TkCR<Hgk>1sc{xDjFU9s{>}
ze@r(w_dBPlPFD>X*j8fJwRG1*n2l0ziLRixlyJ0N5~v!r#)~mjenYK^l;$d~=dy*D
z7ZO`gV!r30cFde4T*(}wq2%U7b#Byv+_RlK^r?dU&q8Lz348mnoby~++x4A{7R@G&
z0gP=!;kMj$aOs~yP(*`)Qo7mLlwDSd@WFAQ9I#Zc!?gzV^Ep=a(M$k|qO-gSx_~~Y
zkTqlY8X{Dhjs`KTaCzrB5m_AAr{G+dWw!Eo{5)<z*7(*HyDB!~6wUr#8`wVrFvqD3
zbF=i^VL)T~`}%li*(xuJ2=3H<9pzBJBJYiqq7H~A9^)mELHud390=!SXwW-KUbFyX
z(P<RK3;6vE&MIkNy5*nV%M9ISiVfZIG;W2$J02Z=&z|H033d<Qi-bVdWv`|ng^SSH
ztI9(N^*9aS5REp-ZIx(1&a#Ei)g=HxZne?I`XuZ(ORr75+b#oQ<#&0}?NuTQyC4sE
zJA<3XfIY*GM_lRjC%AVDjQz5d73pSAks7^pU`j1YP7m(t(+hRy_CNegooKmQeYu}k
z-CDlZDt~70-L06LpI6l^Z@mNw{o$;3HSK>1=x$5ty6ZYS%1ts1zR#;_tXyU5ZG;0m
z6Kv=MiYp1bL!dG~(^psepSsK`SE2%pu8LiPes!eJmEJXuLZOaenS#tOrC!yB3b3!y
z;bJ#D{fUxYN`Fm?FzV`Yk&wWjCFYIS+)7kJ{f)W3w!@Yss0iAT>TjG#QhqRcXVTgv
z=C>tr2ur*y-Cs|uEFnelW}@C!x#F$awMwq*a*wMo@#*o4sZ8fyM~dQe)n6e68ROYR
zuAE+EDo9oX=Gb5M?<YauuR-B0x(9lijQWsowzY;|NX?3+UzwUxV@>(r-9+-AK(N5~
zxGa1vcbG81+MkQ#sNsY(SNQUmE!}aYY>DJ2k&Hu9j!w5laivjE!Nruf<zC6LPT<h`
zoLz7l&5@erk!)vPZB!=RBE?R-WX96fukVQ)rTE^U@fx>S0i~KPZh_I6PBJ2=@|9QP
z<PL+KtZv9yN}6|VWb5%7@b8R}OWdaYn^7xY!e*^-oPKoB?!uJgdGk~^6SX9nrcr-Q
z?g0IA`ST<nbehnW&lH1s1`Xb8MO&Wm{8x7iiSewOW>!*-WuL$cW>tK!vFjz*MUgiT
zEA1}<2G?D6ufL#MV>i$Ko09#vIQ_Sh{m&vl3;RE!^`G<qs1~rWbNr8#>}Dhu8@z9K
zw?UpQ=(`H0_eEdb&iz_LFc&iH8~j@wbLt#i0xP%K`?jmdoP}sb^5s1T@iMl5zmBCy
z!RyClr9!pv<MZO<QU52Mt?s9j?q<h|&ZqjKa%W1i%_An|dS6=^&xSIumv(3S+V1u8
zc4<|+Pwl5m=~-7d1`z1i`_290<Yh9em|n2Z-a6ajV^>)apG&i?u8YWHIa6C|HsD8r
z%cq2s$}`nwdfqVaoOdB8DsQ<=BR6f@5+(xgSaImoMH~U6oKWm}y#L-q-KB5G=aq%4
z=VNE;=hId0d$rN$+h?Zluwd980ZfkeyC48=9}Xa~gwpmxgM8<yYF$P4$J_(ei4jdm
z*X2Nt5Byc=T6S5JK~M1Qd2ut5KF$icXuWd<P}!j_a=aC~;de6uzs*MV?yIz3kr-k3
zsSBbKOx=|#x#7H|7RUn!8G6x!5d}EMOv;u2_eoB`r8GEZEKxyA_@9*f=PdDXL^-CM
zAA*DtJmR0c!#_Zg!oR;<T%U){MAe%L77zR)U6ksH^5cMFA+*FB#CBu_xnvDQS7;(%
z&K|E_$@iZ=+uz$=pM9ep1k`0VcXY{0{%YVcwBx!qt-*+3T9ZULFXS!GfeFOXVQrL1
zGxNK&e=ag*DXLAtMhPhAlR_2T5R~GiO4vwfVT!d%p_<L;pNSWs&je`kumjw`ov>4(
z!Hj{6d@y3zH-wcu8lfk=zd&@m=}cS@_))|4@0^%%LA9|CP;8svewS&@G((boSNQe_
zvJY@o@mw5lbhKUY&QwlHjYlMyu8@`bAtucOf#LG@4xIvj`uh<2i-K|zz1SI*JY!Uw
zg^3<vq?ibeFv-cz4ktpwPy>UOsR`(tM4Q@S7h7RySB7Jd6JS{r`5%5O-B5fpxn>^v
zC<Wit@o$cDzlM3jFimSfvXuXQoMJP<pYE}=7xN~Uvo%Z(gUc74)GBU5Pi&or-*uq&
zBujKe%Zwoz9y@L{Uo>MlhRe$mCZo5<fxF?VTU$#gXH|R%!rslV%ubRE`)L5C8Jxhc
zAm9O3vum8IAUM@V@I`6{eHnaSqX{xLd2v~aus;<MVI*z+jo&c{#`|^usf6Z*`%pI)
zx1VAR^@X?R5@vBDE)EYYBQOO+P4AUr(C82S`|31soC;T6MuYaIfnju*Iqpz7RV8wi
z|L<bJI<`1$81$0Mk*T4A^1Qi1JQN`_QwT1izEk>=8cZtCRw<ycPLkoAltLRTY}mjC
z0$|mlu%;v2pN4wr4OP*NHZ3@o;J^$-qt22QOF=VwUa7mShFG!yJ(jR71Eh-Bb`xQi
zNWf`ZAU3YZke<gcJm%!qL|t=1_o+yfibl|T%DkG7gQv$61!$qvKJrD4nclq@EtJZt
z8TEzyMR{J%aKOq;aLK&{B)oeM8k17)-+_due-TvVpIlFMTkhoIg#3o;urVCTT)K=B
zgAndAr02>aTL{uP`P9H!S|x|I5DDU>XZkm8)UTU4<lN9Q8j7{@`HqI(jifa+QxpfX
zUeZXVsi$PTQj0-JwnLrFqxKNAHM*`HQ(bIQNyiLH7Be2Xs(yB!yTAyo_M3r(bPUuO
zI8_>+n-bDGS-UWz1k?=+Y`X80X2^T?cr&}$w6I@qpgJH|Hv__2k2RJFSC4uhi&-m3
z^Yk0(*>R?mv)b0WN)l!BPZxY@f;1sW2`a^MZ#9SCS;?AnJXNFpM7S1WT64Ml?Jn1v
zx({|*xgeDQ_K9y=b?@)}DZ++UVL>%BprKE=9wkB`<eg0ft}2D)^$Fkr82siRfQ<GM
z%ODs_YQa~7#|23FJo!Bu*adIn<6THZ{gc(Q-aJeZ+g>pDv5i=Ams;gz<W~FTQpl$n
z^Q@O0mAqjmG_YUY(m?-accQX`)uRs*>8W&GGfi;*GD+Sj<$4Jyp3*7vTg}W?K3FrW
z9%?i^BR18z&<S8#J@U6zK_8q*5AY+#hIHx4UQ7Dntd`73YUr9L@B>)3p)*R4O5zF~
zlIAY}y#Y#t#^bPPB<@W$E~Mc~45XL{NP1|{a*!bp*=HnDI!GM+>~a!?6y4YP$&t_c
z%Ma!+qwMP4C??7VsOys+K-K4WpzjKT_%PB<Al*!Fy&gH+inxziZWEJ_|K%*@2=VZ+
zUIG;6c2!Hgs=;?mC)z~uo60{ObyltOiUv>S6&N0OQq|Zg3Ee#G?SgJSNz|ZJ&uJSG
zK|7ArRg+BCI%>^3Q1(PA75Y=8dPDY1RJTzlX?V}DPnP*G=72`)oZTDE<N@!#BM_r>
z>6POM!payS`hfr1HO)O@&OH*~J+56D#F@Fz#Q@W{jXkWzP<AF)=QiV=ome}1Y_D7L
zprU9wVcohKy8}UyL5)r4i*OQ9V>D_wMCb-7rqESJgz34OIf!{eE-V$0!8veDtfY`5
z3o*~7%P_?OASa5aL!L|v5!yewCB_SopQI}St?etq7Gm5wh(h1aYmY1B4{TddtLwXC
z6e-UIlz;HfBbek!0G0Gk$awdCJV#Fw!*oAHsG)vXfSd^1#(L|c>!9{DM<$&DX;gbm
zh-!<GT>OPXcc~yW($`S|qFEW)GJ(QwW#5(jEt|KHS&6{`;hPPOoJ4CaZq48-jZ8{R
z&yv<DpGMInGM>R03R-zal`$_lzm`EO--^JIq>sL7odbPeH(v}Mi{y94W)Ctgxdh-4
z`p#_5?5+C=UZ0t^`(I_ozm&tjWClG8{r{N_voim)TJryr8LZ6z{G$DT8;qKgw#37~
zy3SRZ<1+ozFAX}|{CfeIHW3r>dC*bg0^|GFQh<j;tZYGuU!V0m)vHfuCECL;gZ*pY
z<QJ*$h+gBBe_yTMRA;i4xXNz(K0jra?0&pD+>g`4?&E@SjC12XOgzuuT<O1@oA&Qd
z((w2?e&1Y|@b<hs%5Hxh+qvDp-jz6`#}410h3@%YfB86eb*B?g<zrkN?|!ZCPU7I9
zV_kK>pV9Z(4-fcDiw?nA;U4eH;EMRO^=^QKp;0C7V(8EmaP18m&<-VjlCWK5+Q_(u
zZm#NLN4hqkUrJs5bzZP3y{RsJ$@%Vnr^N>SL>w#sEP4n1jm0|^+5o|Bx6Aw3{LZ_*
zv9;~B`|u=+urSzmrhvq5EL}?7!Fr|uR3t|p$3yND6xbqsh~2>Ky1WnTOVITPa1i+(
zA=lB7hJ#jmy=WhLhg9yU)xf0>^gHNu1nz9fOlIAAzhQ0yQ)IXD1tTpIl*JF=Gnt|*
z6bJ(Q=6rv(EdB%|sTMHG?7O{yr$!IvzGBu*dcWs{4pA-2J}RTKaX(lL?14#>T<U0b
zHP+>MGMUFHObroTg|Bl8aEQx*qSI?=**Sp$@0uj-lf7Q9Tj+TTTNwCHvt2f!Okd;Y
zh6O+eXQR7Z6<E@aYA3ML@n*dA*F5AQ`?dvYms)7O?>(ex!Ic3Ej`HGNWMNecCmraR
zjFVW$5IW;71$fj!zCRk%?I*9s^>4pX`|2^Vf=-#rBuS;mDY`{9_~g9+8U4OwF)vfQ
zwK+>WcMF&RfjjtL*3l4LTN9n9blbdN@Ec)@Yz98b07xNw9_irlJ^3acITRW>kX|-2
zugQRbRiH%bL~*aHzHV+W922zfKGT5nV(Zt!N9d>|Fo2_FhVGe_I3Ks`CY7DO?~k!?
z<okE?`}6(#^Spss<#c3;rBGBQxF%?BwhY+$s-?>Q37B~uH~>F2e<}I`6H<qE0-ZIt
zpJ%|>Ll?%1`I;)Pa1W?R0<pJ@30&_hZjmieKRZ^#*x<pGRDjgYRGbYI%2(4>n<q$V
zS5zOMTXGh;kuCJJbk}=hF@4)AsFTw0pw9lxbwN^=BJ+iMc69OAxQzA*dT}8%3v{BH
zIU~REN~7T$p+RmIB0S_+x9O;u8Z}FbHsdeTM$jrTarFZi&IM-3q8BU0RAp|s);}ZI
zUL<p#qXC0LsNkoZPE@TL@Nxx5LQwO|?~b5jP_JfpJ6`1Wd&BH1P&0Z(&g5fmB2@FP
z_3I62zh<ls*f^5)nQ0=OS8a&fW%mBuL|is`Mbv5IjM^wgZIQM)ZkrNc@PaHle=K$x
zGX=Kw^WykASEgV9NvT(#B<i@M92<Y0i8^#u1KrqWJ+Kl+<#7}3gN5^e6X%YN+TcQS
z`(G7(1>HhVu<<pLe_v>B!0tzx&AbP@i(%BD7)HO5<O4UqsX>YlHDZ>pI{Lz^AuNxq
zIQXJh5DP}i92W>(PhFYnLVJGHAn8I2`M%z-4?`T97>~7VF(KniRD$7Pqe3R!QY$KG
zq^>`un1qkeW0xLbTC+HCNGcMJxou;Jo^bAa($6Y#6Dwqz)+sCzAFG)8ci)ejQ&=K8
z4NDFZ&vZ=d7aI*gx0ru!%3eH3xUBWdcXuF2gksX|g;o3>KqSmo=N(F7Gq*>{pjF}s
z3zQSpjx1)*=SxI`pEUw)_an=mzDKw@Xsx3?`6I)`TBnZ3Lux9&Q8Xk>7JUO*sUBI5
zLSvrKAhOp~J}^Q*(4@2|zMZ0f5(#2xAC)&_XmR9W(5XTzQ2sMQZc1=ZRT*dfXmei#
zR=J~uLC7$~5<I$wB52I4j*)vFiKbp37pe6}cLvvq2VmO1SS|~Q96ReS=XBOo&81v~
zPCg5EskjY<!oiAC0#L&F{9Zkpm|Cn5(XX!MpQqD$oe<!?Z-iP-^b9gz;i)6BRLM?B
z<gyek*3EYKmB#9Oyl9SzbKb+=O)B3%E~Ys9s%9Jv6%vPf3PdzRod&pe$hjLKaZU2r
zW4a_bvu$~x;N*J1<70~ZrWuNTKCNmtDOk_!MC|9NZl!2jtHQVk$|Co3rz|s`t|xiA
zB96rsG*!CLkG(C0j+&~MW!6<l9<OwVoQ0>6$OrujIAcy3WWuzM2gakqTIA=fhe_c;
zC=#sX@Oa}Nuix8=p<g;QCoA#pkj?Q!7G3i;MYZ5E%yY`3mR0#QpDJKttDEvZbZZ8m
z9B?2E@Cj=0NbV`Pn>&O1Q>*=;9In_q<q8S6FqK8FtZqrhjYk&(TuZYEw&KJ^o>zG^
z^HS+=Bcr#V0d<q*WEK8oz6&5}@mN~@nC{i@dLvwID6w=d^Oj;(?6eT2oRh_DU!2Zb
zI_EX9Er;m)1EG+D8Fm|~A$cZnvlyYZJ<mD>Fr(-p8|_aZS>EF}lr1%&?3wN$8MYjK
zMqZ@IW?(~V?F{c>lUMPXFSJ)&8AFsW7L!3d9bJqMkH6Wid=`6-DbpyWS^L76?iKJ8
zLGfILBRK;gq5_4mHD;49{io6^S$Q3}*zKgDydrfjiITAx5~p2Uk+7(QUzM$R6!w&g
zBWkM6HN`&X?d9F`XM{z<%(K;^FXHhP7+nj91O*iHO^8_Q%qyQqPiC7OH--+m?_?5F
zC2ooHLX}VtoCv0(;)=lPh6(pcNlkL?s^WC#GHIlo<Wn0A-W7nDh1)E?*&0h$FkNFL
zO?+rZpIJ~|ggF~EAg8i%F;RUcy{=2N=U!(yUOkkQDq8vdO``2~`HELrO8sktiHpvu
z*S96igAl~<0TKXJE$TG%A*Gc^+wwwBwjs+nopj<PE)6iNt!oFep%kCcnmcefu_vo}
z8-0^5o8rWT;7r_6kg=qT#4f>l_6+y2>p!wAzMQTq*w-)_zmPqhldw<P_8tjMPC6HS
zS=U`z)S7033#&I;AceAW4N^uDb)CXeT(VZyDp@X6ls#e!)k<ji&>&MEK(}pON~%mv
z3?V~q1n`(io+v*f!!tsr=9yCCq24$NLb^)0i5$J(i?*3fwH7shehL^ah;_6}cd)gP
zUWS;(9a@k1+AA|N*yAj(x`xs(Yu(K>(-Ycsx;YyDvcXy3n>?d7SWTV6jT`YB6Xc{d
zs#Kj$x(4bK`-ns%oDkf!xbZ>n7r%{9%Fk)tPYZA&DI;6EkCo}VG$^fKvoW!D-gSxn
zFUH=nNfa*I)=cM4+qP}n_D<WjZQHhO+qP}nxijy6>vYGhK2Z@}U)K+qF~^u|jHk-;
zQ3v+A8ED8zUp&sYcEOt2@~AinR)fkVfclpN8Y<Sg%B;qg0Yal=roxG@TW-0?^v4lg
z#1kyB9etVASqvv8jE{EB)EHC87&4vVX?oXT$q6i7(tPZT=W!1L6%p0(iDl~wfm2KB
zOqy_pGL->UcJy<4)EG2kdKQ!Z__xV1HKQK5)5j?`&28DwyDn||%cUMJlOhIWHFdmb
z9DQfJxyAN+)~Y{3yxk;<PXqX{#4ty4u2L1MHmtiOJ~kSOKJ(oYyIS8tl^D&I>s{t{
zg{dHEyi~O1DPv@-F7yxRP_Ajof7(?4XZifsrpn6rZ(SR#9RDG__4oMu-)yS?Ushnb
zD`Y}Y%@n28ArCe4TisjT<u%JCOXEvh|4Xmy8IFgFiOh2qxF<S!M}wlGIKsWi5Se+1
zn8VxYU}q`Z-?-J?b*>IvX>CeqFJ8#toj9Ceq?n6*22V^V99<~i*T>!WK6G#ICroaM
zt1eBiHryb0uIet(xA)uQ;Q70NxLMw>;E~x~ydCWkV1l{rN4Q<-gjufygOWs}yZ+h7
zcxlNgF@|yH5IBn;W;*h>zZz|N!Hcg#;yzs_D+4uaU5+;v31`2YTd1|#X3gwF->G17
zYDqZsojpUh9Sd(L|Ann!+IGkZ1g1Ra=k2RA^zm_U)n;Ip?#JT~3Qo`G`=@Vcdg9F#
z33ZwslPSF;m#t|2<34j*d}!&rcxk_+)UlTlJ+rzgPkiLN{~8_`SD-*VicXYnt_cbz
zY!8;rCiM%=u5vr+zAH-3rrggf#E7HyA44uyW|rGP<)I1EKYib7WI<T-kWn8v$lP{|
z_i(7Yo%9FoqAge*1BB=@{NRVuYr<(i>7^?!c0c^@YVDUaE>>V1vjVhK@t@O8Odj1+
zM$mMUj|CA4ZJ@v+j}Vh49fVtx$KVS-2|&*?Q>9LD;=FOmk4e>=6zNL(bb)S1Fo6u-
zJU_+j0~%}W+!q4_dSk=C!5L{Sd9W?}Aw|;F$s?lreHcNJ3XtV6lae$cG{?iuSv`0J
zz&qq|xEXsmGFbBGAFjBfKKu3j1Nn&04>m9-4d=PdnD3WggUQTHu0maevi`safBJlG
z>+1ITrsnSU_H_CF5xdjhc-0>lU~mau7T`MLoCT4W7*kQCK(1P16|Y+X2ts$3lE5>r
zahl`TJP#uGGhYh88`IMerwumxiYhLU>(&uXc}<uzXKtY`$ObM!3<TY&EkIN`DY#4H
zstebZUHeU~(cV&n(YHmy8$c&+KLgTrNe*po3o1wQaI(NeEeeq}Z}+N>a;u4wng?j4
z0v|z~h%HS~R%I%25J6&(OL(m#B}o%N;ty)>u9_8nQ1He=rAU0ckEE#(fJ9o&`)igO
zSl{oqrSAxq_;aVZ9tqDR>TxYJGP$8Hg)Jt-D+~&SbM*H$P+YW^EG(giK#<h>k~m+O
zTc>`JAP}D^9+{SSF@-|C&QWQzQCSyJpE8D^)Fv4Il}CnferH}6G$agOEP+VUP9_}~
zPP=+f6FP!cwQU3v*3gE!c$kv=W>XwFI1oi@PJy?J{`IuTPN}q+y$Z?jz!GJ+`=Pbv
zz%T$)M+51Dw3=wg<-l`Vs~o;PR>}l#3ZlLRWK{7f4tqt-9=X>}SYf$HaADNE3^C2e
z8DY7cj!b$Sm-15ytzbKddd9~%N$1RTijl|^hjX&lGq4dqPXmwvDfei54o+U_r3RIu
z+O&M2j@+OJDL18B|B4UB-12c+a4*MCldPb5d&-T<wct$gltLCCCHB@<X4|c@ov^Fg
zCcKDSJG=?bhKWe{%}giMoM=QD?PGg}0se0_IckZUdHCg~+5%X+_heR-BDI9~#Nyu(
zE4|C(7BJ4kbL|G7t|~)2Hw_+Ks`Wcuir$(<RQW7KWqxqUHL``SmZAZv)|1#n_*k_>
zMOGZ!;zG|z&4^y4?@;?ntoE_Ua_lp0W2@;9`5<u4LR%z)EWuBNSI8*Hd6<{ISj|p&
z&BSowK1tD71LLuz2F};{j?t>i>Qqt#`8Jy~tW3PmI5F}o@ia5)Mz|;ac!piNr73D4
z7LWjp%62aV&w#>YaE{OZ(%caZ5<RY|)Ev~_v<xO?Y0_5ey8hu!#NI24^r#IHu_iPe
z=^$)K@n}N2b~x@L!_f_Y|1hN~xN#BDwVz*&@$f)oo9|+2n{aygEHtE`ab;PXuq(Kw
z`f(SMN$7`ZgP7#@BL}I~JnQPwM{*Cgmros@CrsVABrr(X!!wR1Wo|}cNw__6V+d&F
zig?JHa2VC+Ljv!i&4cobv9kts!7^AT#W6YJCK#LLldn+tuyDxvn=4>%n`!)tL(eK!
z12!`RX{NBUOC;rv#@Sq-e2E9!4&4}wHT)FMy*VuWCGp1Ngx5asdS6fI&Q<}nbO75^
zi~HKR|7pOXWjwx8OTA#0%QAY0ocL&UCJI5+GIr%TnU<6O{LV+KqHiRvBi(EUjn~AX
zfqmL3eGN(QOB69+O-D(J22$w}2y?#%t+8<C^L?pFPgw`hR+!)exWxM@Jukxnz11HA
zI*>6cz2`_F90mFXn}5`ZZC>6DM4f**>fU}NB0x2TeVt`J*DQe-W}v;QB|x(68lWp7
z7P1vC<1`CuW+)hoP)L#xt(*X_cPtVU`bZq;B`;e0iE_^WgeUdgeF^7)V9w$rE8pO$
zfDm=4a)krLWb~uC5*P43KB`r<HY(<i#D>*SV;VczZ}8;(EeacTRJWBnLSq^_Vxr8=
zTC3saqk8p;5Ej8-9>r%z(SKzkaMnE}9A$RF5Eb3krpVhe;*NVGsmn?Jh2<=_@7`3c
zwNr?D<m5EB;M#q<ut@wW#;|faa9%);HcpT7J2u_*7O*TTdwsXsTI*3CVp!ImY<C9a
zq}o+?vnyEuzkVVJyebiExkO4Gib{G<Pt<^`qkJTBGKzINPIdSx{cF~b=*sFLLVCQP
zsx<qxJrevc6(yjS7Bo^JP*dx7HFdCpo??|`!RS0oL)+}nmeB#!Cb@pQIOzEdh&c~;
zLBh&i4G=XMSnb(YNQZH2IAc)#s3CW^SZ&eI;Y*ER#GLEKBDWmH*qZPd(&LK1MHK~u
zzd>Vo?B`X&*ot7MVc@8M7KMxpxg;t?Wl0-AsV7c&hRym6>5p)Ii$#A4ieIHwnrPB?
zR|UbkUvdj=n?!$PB1@miKlY$l5(n|@pR^OnJ<%`18M&G;jWUVN<*gs1+=Q80C1Lq8
z<C%nMPbuWS8Fdw){_wdG(N(9z8Sq%XjLmV9GDuCy;<6qVvfx^g%QdLWYf{lQ&_N|Y
zWBlDaK?bI%4vGy5G`gh1-dl4TE*7h!9!8_L3weg=trgR2&`p+#;9HRg%Z72fq<C)7
zc8(JtXq)7289KpVM5my-1t0wJQmoEX>Wfib8R(wJbkkDV^mNQ}rwR+JUgvG}bmTwT
zOms97yltkS67CPvQfG*N#L`neTCko$RjPJyeg?X{^mV*2G2hXAl6?^1mn@Vv8hALA
zHT_)Y>B<JZpQNM$bOU?{sBN<v$?fmWL2}~=Rs4cygL#d62`nXlJ6q+L{EZSgNga%!
zuWea4WSlf@Xmy1O-W@NJl_2y9v!iyqx-_C0rB7_`iWAR$+rTP^`e(N#is!x9x>cAm
zwygpg>q+|Rr-xj%g>!HlXk6(7nB}SvX1Kim{N+L5Z*+252n?!6sRAmkZ^@WeNkG7~
z1yCj|r6i`9W=3e*-U}n2P_Mv>^qZ%+8%bH(_OdYbpsrWqB*GK9yI5CJVkes1?~m67
zZ7-PsRMo(k5Ou}bm$4>mI7^B;Wm*z@RLB$hnaQ|T?QcjB>)a&|4Ks;812UJA1ih#-
zZ&jJ%ZX@OMOi|O~rqJsiF`bXaM>MS&pbg*4E_>Y*+`BP>Wph<fJXDBAwJ(oqty79j
zAQtG16iDZ2X^y2xNT~R?uh!4h{2ES*8*#!IB_J#2_+c->fl!`ysp+%B9*yK8`o0{<
zF`%A~sX9en>IAK;jFTAMAku3q(>CK-z8Uo6FL1AJ9IWXW%vqtkr`+GtuV+S`39}7D
z_hF-shx1NE2n<Qn)a*+c|D|KQXQnG)EFyv{<NI^?nQMSP-GVGWrUzaYdwD}P#y)iN
z2X*7<gvHz?T|wC03oBx})nqCftg59h#Ar{$c!)z3>}9K4RZN~Nh?4N^Iq0P{HMMtG
zv)x-TgI?VhZrk3YeoV*4Xh!`fjJBR__NF&)i&zFHU1H4b(3|}4#69WyJ8|`AYPaND
zidre5I$%>%bgL;bejP#I_Y&>B(@rnczkK}Mk4=k;Jd)lJhV7?&I>*Sz<rJeXY+~ph
zi#W)i5rX1G1)wC7stPFx7OM*3Q=nY#(kTOo6w~iY3ua(JFWhJgFc^3k)zESBE4YN%
zk9dvf;(Y@fKY#v9SvWd580%aAn;ZTwIq{G7V4~+>`M>XMEdRkJXJh$qT=L`JQjv$E
z@I9YuzZ{^}7PbE*<RPpj$RMr_2I#{PgsxYy5wB0#kOHrNeJVdoEjJvE8`@0zaeFv9
zFRSUQcqgolpUh5gf8U><zP|GDvV^J)p1g`O8-PcjPsy^>D0Q~DcQM=c*x<5?b@{sX
zc=>!l4sFKXem{KQEZ<$Ph4t`7nNxi8d^d4qu~iFD$qv+5&fI2nCR!9(&D{3BYCP`+
z-?Z)(pSO+##<`VrVGrljKra5+ecL#4+v?0(N&0P+S$60x;%1+dxN&LJm4F}PRADms
z+0(g~IN6%LTC*1z8rF8({b`9j9XH?B#N$Dw{WHSCAA1TPm6~mL&W!7ylTab%sQo){
zu@NM|Sk+u?J)v2TOoMN(L$BZ}ew84gkefu<*=J%LfheLMnOYFGcb>!9fyKEc_?KMd
z-JZLjdZF`>>t$Cl^@U+?^3HsY%T=pe&;tM|zdu_`YRF%MR4vN2X~w1d=|y-JR|wv^
zmfMMm4lNDr@<yXM(47~s6(JPE43H^^!~cY_2ej#zmAIpfl5`)6lKHfs=mMdnyY!>D
zTqebIFvSQ}>xc|M<03cewzz*i{#Hx#0^qN;*Hc~8RSospY&$cGq%*yzF%e!kP(=H_
zJHpE%Nwzp%z_KHEV#_Y3qFrO!Nq^eQ@b~ac!1*v)HX;kbh2bUTCb|>`&_2mHG!;e#
z^|1L1Gks87qM;cYJ<-clg%~3y15;CcB2teCmL^!(a%Cn=;TGscM1($QG=3Gkh4jg>
zXg5bf^7uAnj+Sm|_ZDpX32eDcN1;{@E<0@PhSia&^Q`w8X6Y^V4>)Rbijnea(wO0%
zj#`@q9nY{U=`!NPac9crh4X@3+TBViMtF7*`gZK@<-|!0?UPGPr6Ph7Es}4J5^`4-
z6Gc5**Z44-mo(X=w69OLeB!}yXTQmgJ6~B(47n_A>hc)tcu_2yNxR`0<5Wl_Aptgf
zfYPlCyMaaBFTAxCA?aNTw1y=WV1p^a7DCd7Y5RH$O052>R}lKgzsGw&sQo2ix?;vn
zTh~l+x=}LA&K)IehGWY6Sq4yXyJhM9b;#)f8RtGJ{8S5hv>?Qga533DCpHJtV&Sp{
z&O5t;83m{ev-RU1VyH^DS+!A-X!|d(pUqOZRPOfWg`*oz==BIx789Q9CKgq5WM_rB
z`7I^L7)dIB?lJP3a**x{L}{{G{%;`V9Ch%ai0t=X&RMrcGPtxUr~_DI9P@`hxP?;-
z<7Ykv9~T}Fn))3b`S)oi=z@yD;dJy2V5CSk4@gUEv-D|PTAvG6j^-u}tvVm{GcL3Y
ztDd1sbPlW>>G>Jb0p#=qil+sSEy!)f1)pv$-s7V7=OTZ>`i?B-8g0eNLDygM$%55f
zU);7-Jm+3NFN2`o*u1>l+PFF2V?HgHK9HWD+KC#Ak5|_zta0L7sIK&HoEk8YSq+nc
zf);_x6RKMlX_s`6zfVo{ckc@1%M2GHF<^pEb<HbYBS3e00gx>7TXN0DhlyN;qP@DJ
z1*X&1Y+BWWPc}+|6?YZuKN*9_hHFftgJmL?<kN&P2_won!b|5DH;acbh*$X<&Q?wU
zKOFGX)8>D^<Bi7~=}w3ypG}+BTkDx!jRRJH2Q&dlB`Slqad|e368l|s+yt$lX0om?
z5v}*@cNODBU+dR_fiy#fwqOroWh2RsdfUyiXhYG=tZ!IOky@%Ezg(W!{?f43`cJ;k
z|BTarW-kL1{lD>J+1UQEc>dRgl8ue!zwmv!|M7kPmiElnn%&9JHzwaonqhi$bi_wH
z!~Z3k{8QQ!PjWkP2{`$)6Mq}#rL1yGYm(nu+DS>p#CQ-%hr7Or#PxN$zx{r=Im_q$
z)7m=t$d(%Fi&HZAGz2$ML1s^{`WM0;TN~Qz<?Qxj7ks<xJsmshx~uiwhF!9F?jG*i
z*Bk5W>*nJwk7+}n7_gd(2X|}p=-=O&+rwqyt|(S58+%9Dv>a*jK^U}0MjP|xU~n=<
zM$;^~`<Lw3Dy`dWRbvnkiNUM=BqLS$Btk_b>+Ai#IQV?Lze#_Yy1Kjj-B*go`}MZV
z?9H0hle3%%xrhcn^7W*jbH&ah_wY0pn;6hsC-oM%{U!GGG<Fm}O$O_$^(D4KlfvYJ
zlIY3yKHNAtj{CZ8-ZtbKa=QiuSCeBqhc6u`u$Hd<PQuISWvK@li+Y4n6DGyU26gyR
z^r!D`J^}6KTahf>I9?5fG>r6e6iVnb6MYNllOs4el<FO%HH5CBJV;+!qrp=;E=?cm
z)UICQH9HYM`KQ5(cU#-s&D3$bQ0IHTlh-V8Un0Gc)os3yF{KMW95)sXKFI8VTkIec
zwJpM2zW(Wf9en?uNllBCAe2STLg~6~P9aIhPC`#YJpy0A92%NIY}&A;5qv*+r(MZ+
zzp&1a9)}KaWZYOm>CR<VfEnBR#ZkV%4m_s-4@XnYm=SW4M}0t^h1#<ryL(3w_PQ^D
z5*$fZklThuhrlZ49t?jU(rV*N(OZ5xE0f%7-!*DiR`9bwJ83>7oMRU`dNVzu3@kLC
zr9E05gv5Tv=X-u)>o;tuE!kv@V9Inbnww_bJbZGvT;p&L4D?td<*7`T9?%%`fx&xw
z4%?W%jBFN))VO9J=og)5$H_><hI^=cb7TQ|l}llK##`cz*<8wm#G+ei-H>rbK3jV4
z;Ab6j+*9$IO%fzy9Z<8`@j7BSQy4!I-(XwZlKFUDV;-3^0-z;IYiZF+m771gyrw$x
zSrTmuBJHS+2iiBiXpr9(umrMGYr0t54i>jdi5Ye2`~fDKoWyvpug{N^0Z~?6JQ*ly
z{$UN4%UnP(PAWJn2g-b7{GBbLsm~!B(Nq!7{XE-S(qQFEgswmF_S1lE68&*+dy8GO
z-=!Y&+fBmqjNI+VUx?4w_3A3K(EOoPz^04C-uyT}&I8HlQ6xlN1j~c7OQs(n=>lf$
zQ7S`qJ<TuUWE{^EJ#_^Y$m1}J;Avn5A%P~>nTxC{{i3SmZjaWh-B+!~a-K(^0J@Nz
z6F&^a)j2UM*mt*{J{FrNL9`%GWcMIE?gD=yF_jhqEx^kj5L-s40U*HyRp1tQ`;0zU
zS9Hvl4<HkWaNKULm1zD2VyKz4Zpb6oU=p&(IfO3won4ski%^K3t^I;rnzvm}Fbwf{
zEMQzvh+*uiQE1y|MPS)2X2%ph_zJxYSoyCg-634h$$?=n016K$A+4rL^Ew6nIz0(B
z()sj*cq*4|VZ3c2ym2Gf=`f{d<~$KE^??$z{oyPKTH+M0Bk-$owqh7d`A6t@&t_X@
zClDN}HNzNo_I14VDm&*N83PkSre>1h)L|x*8pS-;LPdCOL%rC3Z!}$8=`SBsIHY|J
z(qS_+6V`(+0zoEYSbr6T*V}VTs8-i4Zvr<BuBiNpw!M~RKbmBQiu-me2f;o-{H}>}
z@^uNhp&63b8GV3oLu7I04_IP)9%8)=p7a?^d>wcfB&ZWyRQfPrPazNHIc2omejc}A
zxz4~JVn7*7v~#8a)aGR6^(24MB`>xSGB4e+Xu+aWS)=95Vu*08BN+kknRI-yT(Msx
zW7o5=XPj7V`OO_69EknbC)Ct7QsWUM9VywjCXDm2?^Owi%H@P)YGgK%U!VwufqO@0
z1()J$i}_K2!+WGDY`Q1*T>EGv8EM#Kg9}qw{WRfkHf@!O)s})6yb(kt8@s5pzII1)
z?36MLNu_&j)kt_&MLc5lx-gdNX*(u1<9P31ensOD1Gw?ziWz$1fz?8}qV_FU0!!)S
z*u+lT?)+zt^g3*fOh6D>P%*k&76C+<3@<89wmqAc1E}L#heJ-a>=FulO<Qrx^38C-
z!o0$chDS4CuB!>%V3}HhqH8Kf{Cz^Nhv_KR8QMHzTggU>Q$WOQ#0yIpYyFVjJNgkw
zY_M3NVitjhrg^J>s1=g8%Q^D(3GeUElJ8<Z${NMcl*-fydz1F-=QH<JL<2M@u%XB%
zdUw_8?DwY>d{iU1SHU=&(8;inn8qlirYI`4#{gW;&7Ib>C|}i5nK-{VOM@@V5n{AU
zWg*730yyJ`L_xw?g9Yq2jnR!FPSXu<tY#<!5`tzj5ES+aNthi)ji@Gh2Xafe<3aUB
zVG(v01b>~(pY}B%3BnNp0Ph=AiebIb5*V3XZRa)QQvS{e);9#{3Qh5efNN{DV;67i
z@%mfuU#l0G3U|A!v)lWJYjeL1=n68J-1%W!VUYE)u%7G}ZnP7qiQ7j@@uQ7hKM08V
zf^>BGt@Ir|0e+7VaFi(rwx9(5W;e&xnx)0G3`@CSdJ5*!8%;b7P^8cm5f<UBcrsp+
z<I7r$J+Hnl&#1YU+nORM)H;7K`vK-*(4sR(b7&+gRDKype4nC>tIKB8JPVIyF*k>+
zvx(J;!lbe$^#Id$m2<K<U~)ob^6kr#`LA9&VgmuKjKe!(CK3X*1)wU;OgndZ&p6J*
z3>Wy*fuYCnb0SkN=r+yLy+)^()i6}s5j$ZPFdY3%4Tnt^L2^z96lcU@w3z*gJ&pRm
zVJgcA5G);sUdI!X#URAHGGIVC7EQ?*<O7Xx+7Nu+ls<oHQ(+A96L>RmS`ab+hQuAX
zW$*BU8WMG>7^)QN!Y0x8t86sNZ7yLfApb~6O_lYBTP-&Bxy?m^KM>fq5b5$JqbUQX
z<L50BYvNFWZi*cRLE^=_0Z{%-f63y9WPpUkH3ntIR}AeA5>CWHT4Ki|U~=U-`U;c$
zA=rDXF2Ul*AyB$#SHu@-MrqrmRZXaHGY4suvx>IIoJwlW?&d6cu+xG&xiwFWWifs&
zONd#@N`{z+vWagPCO2VqPyz^)r{!2Hf;nPT!8oE^icRCoJ97;Q1rij=$Pa|o4!1Rm
zG0HMboPyOBJ40H(l#)?tMm9)~jzL!FXMF1!aTdF;y6*nCTzkZPQKwkDns;b}tGbR7
zpSzP{)=GfPzr_sr{_Y4%YHpdNLtLTswA`)>2xp1$1qF<UD$lwWrIMb3Nb2)drXdHd
zwT@Y;&U*_EPj3x=Ct0I*ZZPX1r(&3*<M{q<m0o1+fpI%)&cAISAj5Suy>DuOYsP?X
z{OyZz9x<%;-qPXMNERAyQBwG&kw`w?_?tUg@b7>a$kwgL;n}Do2lQ7|!XBs`+qAy8
zEAEd1@ay<UAOuf&Z(q^91kLz7l7CT3Sjh@fe}A#rh2Mr7s4ZYQ1M)|iE^~V|J#oZH
zPF#fgTih+NQ;bAF>a9f=RM}mv>}r%6l5yfCS;?-M0j8j*O@zyK!6oxRJPZI5-nCY;
zKH8f%v%x7ikT0LGw=mxH)Yn9qW8Hi6D+@XsXyLsHYVGiZ8A77^V9rLoASg|sM7)8b
z*O=eNM(%lfigvX4S|div40xxlQy|yGYI|tGB;DN&wcqKarP#Uw;$TH<ytL)h8xYUr
zh9WGg@)U?LqQm3+T+IFj6+QeiHgF^Z{>HX{fnNk>N@7E6;1maEJRY6oXPPu|$<+Ig
zVP^FdPP0nGL%k7|Ok$N)C?=i=<|zx8XO}T(6|KsfO**ypkM#O9(i1HC*8IcDYnp)1
zEK*EwM3|im1=RC*gI#H&@2G!v_8<PC0&wr_l43_hO9YdYH|Uutb2X4<fl_%zL&}=!
zptS3<p%k$9m5FAjwQe5L3Z3J!yMb<7s@d7}vXisI%UwK@*Xp9eCr&4!l_rbxGT_4-
z2n4SIe{u)H?r(Hiyxm^Zck#itndxSUpd6gvV-r#k?1d;{YM#l<H}LBUx`&>Q%!uAz
zkGI-*%Q=lXURoE24b@&ZRf8CznrGk3)mdVi6dX9k1{4r2wDx!wdVR$mBf&75`Wl?A
z0*);grtkW?XVBz10?S^?DGD8PW|aVDZQ(F4)hViX1Vc!-k-p_04>t$EnLM#8&Ri|C
z+W@q*591aU)(;lQXIS8ZQ>#tUj+~I7F;xH}o1EACD7;S^&x)g$?W7<aLsIn>kK%2t
z8UtXQHYm!^77#l1FzXEoXajvXYO5Z{P&2>c25o$D9ivGtfqhUZKjmAx_`IqAj7QFp
zjy~P1P_*}XQbkJ<SH}C=U1M+C&&^lmxY*A>0mm(X*^`c|Z|VeLAQ73`(4(EP2(vO=
zgn`Zh-?m*W<!dpY$TDnLbT>Y+A712F#F-$A6)FnVChN0E2wIsmrU;|^iiO_3d;2#h
zK2)<>`6Fd+5FTn&*5=%VA-cDwkMO0b?~u-=Cb$&<TCSj~YLb~#6>iIAKDWFfNK&)r
zSn&u>OtjpdVXkz0whQ#~_U3dc@cgk1)EyKl1v;k3&&}=sJr?GFTUyPLsZrPWeh{@>
zDbb^<&5E3f(dl!PVMP~jG7iDkFDudL+7fetg_$P^2UH=>BnCRwabWdGK<&n^B(}69
zso-ABmhzGwMOmn7z~NJ1h@|oATF6<vAaIBBj4Q^35bERZ{fFjIzIC1aEZhdl{dEZO
z?0Yth#G~;IsD9|~x7CYUSv9+%NEt8;CKDI_u5}wDt+-M6<eE{V6@G|%|HnLx2;|3*
zf}-h=A${yEgP`(setP7SC1x_X%^5z;l8@wr!($nniT0Va3rgn_4+x7)b>u-vTMak(
zx;==KOapx0=$<B*H@AS5kZ3`!u&LVU9L|zotBkX~jQ!sVvWyFZ8J>r}(Mh`VG#Js9
zFut}|Dla3gW%^NEmQh)4`>Bxw11BP*xsOq$4jiwh*1TzF4dmKo>-VH)*ssYChmUEk
z!<E(<mxDjAWe%Tr``3R$TfaI{yteGe(W%l+v0|bg5GvT=D{8^rURy?0kzG^Xdgg77
z;&y@N5AlHOm28`4KRMv-`V)(CVSEsa;;nmm#9YZZqIkNMY(*xUiTY(@0}$SQY*#Ce
zDy^rmwvTl1)W3F=PWUPQ4Bv?U?&*!*tW$vfI!sZw9eTHDGl@9_u;QRX`_8o6Y-8CR
z-KeI7u^*>EoY@*#E_vVn+HxcPQPSv&CUkpphi-i$(ZPn|rXC8!2jH_8Gk3al-pu_h
z6a{3jRI*s16BcJ6#MZ+2?c6RjIxPOA>9zm*0WFWl$9CxBYyx!LU^nip)$M$}+>$=!
zDpo8f*ul+!MxVlWjz93*3o$@<pW|^O;*lxIRBNk0%x~H*|8jJ7P)_&Vvxnyk&KD$n
z@;|x?|1t{xaSxd3+5e4`%1-}JlInlC3hWH@|Anit{g>SG*H!ozCzVZTR(0nePU@4t
zbrpEOA1*4N_{!KABb8_O|3hves<2QM9TTL_IIrm<><xQ6D9gqj-q(e@&Efr9h}Bv9
z^L2jrHGI5}7kW<5GZCmhRmj;U!ZY)at5ECX`F3X)c)Q!(_5HbMd-OCN`}g0olgI1u
z@$2fK6EC0cq5RwJp)PKYE^d%~?8#n`mliDDF7D3uvOw72r0cERqQgq5L~iT@ag8E`
zBX7py6L&h(*Q|smZ$;t{k?&zH44(F}6E7_pLvAo91WM^&QUNdReQ8_B=<+-HNn%%S
zvD9Mlc+OpE#uu5-zSLT5TafvlzD(*!>{rIUK<K4-FrK9QfJ{H<UFc4?oU4xPdma0q
zZMtV@sJ17g-;=%wtiq-46N=@tTT(RK7p7r`hXCaR8+C9{Tmy8$(%{jX*t%o6I^TD8
zp6+iA?aqayZMWYm_Ft2_Vnl?pq#)YSNQ6T03_8aS7Dr~X6Z4OL;)UpFzEu!4iMY$i
z@E{nei=+rT1!W5;!Oct9YE!2tNdi$x`s#mMoMw>76ZsAkiU?JU1x1a@#|n7%R~AM{
zc4!p<+h(YS!z%k$`mlJ_`86oVXr`R$=HP_({R#J7DBcKbSIYH=ra83rwuVS_PH}92
z!GCE}sCNmIIT!oMYQaM~L}U(kDsx&qoctM^|1$+PXIc%CzPh0LK&`=K2XO{*@D9;A
z!<HCwPAs6N9)!O|J}9NZGLSuyh2ZE_#7Hf0GrnS8`^T;u7v=mUEdQ!XnDLi==+F|4
zQ!x8SxD6+zfw5g8cMuZPdjT#%`EHow1+hK-u--98CCH07%uQ;mBp|%Uc~)u`0{jrI
zT*R-&og+>`#EiR^viW|^iJ0>>2uJ|oSRLf9#?L5vfYiO$@%1MGX>#bw>Uv2_CUY8F
z7ZYKk({@~4Y|nLnsm&fIRIUsHW(H-H2Cz>&{Cd@AX^*YJG$0)`E#H(KkY&faT*dJ@
znkCtgLUKW^ihakr;sg(S)Cfd@H7Q%DhzaL!2AjwVO}MzA41A}GPKm^ZCT>J5gE_z0
z-&Q_TzvXZgl=39+=Vw<*^FTy0g$uM(MUxZc31z~3Dt5)6LX+ts?#LlFoQjm~C}~Ya
z+wOH<Hf9Ea#9-v>K(Wg4tf4ZS)(i5QKj1a`-zxU#!y?TYz)NAH%!Mj*;Zc`bSua*5
zqqha$(9sVS*EC-wQ7FrDbO>o>z#-X_Ch%8`B{-3SEwK2FYA?TX1_;*=b%0x$hY+*^
z6O?n(uWDPJ)vx6@48I?_lFecb%wyF-)*NFI?BO>Ig*}6~x?ns9b*lp!xq53vyt&pp
zfBt~Uu{Te5F!y#L;RtIk&XxtGLF4FrGIXw0qP!IJ75lR(Vb8l5w1FbBxtkot;)YQU
z|B0wTrW2OW9$${wCDqbeHKVa4L@Bk`pM8T;nublC>j2rP?z^{c5xjjo9#^Jctw8%U
z150htzl<_}AA{sd78VgxBPHRX+^>~UPL`gY1996QqF5k(auME1@2G!GRzuf9gyR*y
zc?71ShzYtuG?XJCjA0f;rV|+y#C%1e>fr-m>Y@NJxyayJN;MNrq##9D#K&$tt#TOV
z@3b-n4+wQkaASRo%}_KZn3Fdn?5Ui=DBi1PC&y2Wcbkt!&P~8ixUGf-04p!6W0w?w
zuA#+=I;^zD{w?CFKZmH#gZ6zqs7Co6u!zv<G?c~s<VAxY^V?ui3f4;{Hj!o#f0J60
zQG6*AEpSa6P(LByZ|Hu<CKDG~oG8UfYq^AHVr>T&^oF^4Vkt;(Ac<-Gs=<c*EY2I=
zhjv^xkCeWq`ga*Ju=kvVIZb7g$9R@gi20rCTI8}g&R!dAd7$tDK-Rto??5TgPfy=2
zWHSm(sL%l5fFmLZ^pxPJn2Z4qtIx4%`#waq&?Q?g3T?12Ru&7bbCx|&VroF|qJ{&f
z#BVHna7PYo0I0WOd)sB8v^AR9kn!7ZE;-L94CI;G%M*H-D<r}c8K^Ti{f>79Ci!A{
z3Q4qZzsl<dDSZ*^wvc{()3z`q?o|x63UXm0$%78|T&b4vWC~I+0~WGvw-wSGY;b>q
z^OS03M#=fSRB5_-cS+@%YY6iLuq1BHa(bou_VvxDtQZU4Q5WnIpt0dde#2dGEucM+
z4iDv`P4!>I#{!9ar9*J?lgtOHFxaVLEWZI1x(%58g<WUb_Qg0zE#Buf+_;>Cf_`%+
zmdP+FVD--~6va_VW(0Nt%E7+g&ix@3Q$du<evro`kzf~fTkgIh^7sRby03Qhf({S?
zDdkOTSRJ%vGm+Sj4y603of<UMtp8p7OT@wODX3u|o}TP73x&UGbUMUwMYQ;>QN|jj
zLJ|NGsEBm(iV`?+t{vA{VNFs+VNyZkFS+wvk}kI-WXU<{xr|2I&lKX_a!wiI(Mk@G
zM4UXRcP=XSTiDLV0*1_Et-UXozH3b03>ta7%#|ALfDAKHdZBGS<pHn{uC~@!?#A|H
zJ9k05+fv?NB1LGgTY<#<#x(k|Vv}9x{Ufutd%%Z|&*$ywV}FrvF$c|O)&T7B;`Is^
zD$zI1LWhMCD<<+x!;inI&UzmR8ZB{l4lIX+NVS15(d)qBi~nd!Z~L_vKBEswu`Nbb
zZxpuI<t&S{hlR1SJn~{$lTFl{gdES<K*Pq+(vgpr-z_i+I5@kV6V}7vw*u^1CTRqB
z9yFvnc>@RpoA+a{hBUuTYIUgdydPill=X%?u&<HuNNz(Tifm1u>{J2nr(+)Nj2}fS
zE79jlNL2r}ro*$ADz)bprRyn-M!_Y!Zp&vyW3U2gLP?{sbPO_O{G;%435E^}H-Dy7
zfT{XIxj!hh-=Ks4ujX|p(o^5K5v~1*_3(Qw2Hh-WA=e?x&z4IZWFSf+RS#fHztf|I
z<LZ|nI#54Pab;?CWckg`ZvCoDA{hVvn#E4)3HnpK+I5%UDw;?|QRe51HUZ0l5mm2@
z%F}m@Dk&9Ua-=4;9fGk=-c%l4wL_egtWYWwxzx+J%j8gnpwxr}VIr^;y*Oy2=s?dV
zB4{fN@I^HyF>eoMBJPO<*JvYjL$)LUTxCckF(E1OG7#Nx3Ir1svpg<shsRKA4PDC>
zyxyNXA=Pq9SK0!*q?WSIY&%&+@p>8V&~hH*Ej!s-Y6_q6{(1bf>Vj|9$%*Gcnx&d!
z<yiB1HdwRJcnx`GR=wn~K^;3y_Mlwt>TvnN$}4TB-4cQA^vX`$i>c&_AsI$Xo#WU~
zM(skcQH#B^i?{Ni_9*&(_|*c5`MCbDLHljt2~5!fO$obW5D=ZI0CAsm&{T8FelSg~
z16i{)gSwuO<!tRN7p-}9DkV7UiJ8L@+=OyF8EOz>fMo|?1lc<dGZK~3Crrm(W}MW&
z|8USJP|l01$czh(WKXLMT%JP?A2`74jwyU>GrqR+JnJt{&4Kw3Y%^J{M-c4{fGJh2
zY3p&Tn*qPJh;HlqJd1=l26Rtg0rw8p;cM+3_G5UGWhr`+osusCdfIrOU9u}6t)9R+
zBw9r`N|!owe<@$}&^3=$utcr|uXc=DTgV+GrVjw2+!Qy(PbEc4ug~5L-0U}0HKTdD
zQg1)!q)sh1sX35xH=C7}nhi{<u<(fBR&g<95Jj||qC|CQ#8@KW$%Y{U_V*RLlF%h5
zk1p?2S27@djYz0bxA(`W5<Ym>NX;toRH+sTD0q#2A^~{|@|~hyos_fa8$Fkd!7nyT
z08VtDW;?J#Y^BgxHUqGY?95fz3Ti=$oW8RFaMu8v#39FP1la<2Sq7VJd_rXE^f#v8
zJ!ewyVo!J)909*?YIru_>Q2{;$xd(Y(VPjQucdT}K|ABjQgE!eNMA?Usad9FQBlcX
zE(CaEkT3g)`%WbT85WnP-6}rTidXeMFA`KuM<7AXNklfL_Q0fTZD~^Apcam@{fv11
zvJ|=ZuJrk)A;;X#d`Ldp)*)3QF_BP-VQS>9Bgh;Nc`*q-Il%n;3yK_bwFt*j)u@i9
z2_sO%UoL=WG#7n=I!k8Nk*BA7fi>e8{X~(o&oDSPZIH4(PC`Uv&U{gGd?9Klp)fs^
zLH#L9&|atEB-1kmqQ;saKDh96$1U6(5%}FkKx49}t)~>KKdI`>K31ye&zpBkw`17y
zCjO!@<mO)<Zcei~iM4XYv9&2|J?S9hUxc2b@>`ecC532`;c8{Y{O>gv*oUCX#u`AS
zVzfq}{fNiaK+j#E2rW)St!99|`NCLAtOlz?TXP&_uWK!8N5~7lR#*9HvO<KUmzV;!
ziQcw7%|}rhZ?D-syYNE3TrDrWy(CYt{lg{Z-x-K3Grr87oB+pl8+b+ss4d_JshdD=
z7=PTktRS}+H3s)hk&n|mOi*Q&20SZd)pTr$WE52dTbGm|jID$M-Ne@EH<|;&G4TzB
zN`sxPOqXZm%SE(Et0B0VZMREfTw2uBT2d)ouFbSDMM6lSG?bb|ZRc1!=RY{Z*+p$L
z!Yw~aNftg0wlA;Vb3@U)UOJ&CBAsDh&kDgb@q#Q=cM~UC`L8E<$feC*^VS71><}C0
zJ0e(>LQ}`;cr-^!RIbeac3H_;zoX<%2U?pipq>L_L!qXU%%6dc?_9{gs4b0m<bak&
zyC&QcBTl>+-|GsWW*`0Zg8}O2Y=-f>Htme-3kj1yL+o#$HM3!&jD_XSd92oc{w#Tn
znyHOuRc4b^(Np;G&^Z0+HBts1G3G*HG#D|EihYjenPFQDtnN?c^kNZ_l^n;?TAc!$
zZk%@9U@z_YfZpVJ+A%l18ph;!A0nSRmO<a3XXC(G$-kX#@$m)oTkQ;KtSlaQN)7!1
zDw=+a{!hyFf5hlN3YCeK_1|(3>@5F?)c>tqS^lYb{{KttF8^(F{=drgRdpv>{y!*J
zp8uCQTIpfBYJy=_Quz=S^+tFwd3N6C^5fz5`gZ?(n%nd9czJW4xj4w@vS`D3m)&rI
z?=liG*!B6=@OjhP2?vMf_H*->w*CF`fW@2b^XKm4VgEUI^5G_P@piWJ+|7$K^!x7h
zo(@iK7EV&gb?~VFD#v%LyE7wuo9E}rhhbpsFsFXl&iYvdix=nT=_@pJ@^P?LKO@z*
zcYykD%Hq)X0J@3|*zh1v57MX32eRG}`s8;I2k*}^-0xTVI@<-Io3$XGrnyFwkjHSo
zm=8*Y7nsIw-65}~$)Xs~;9QIS$9S5=baq~S)05q?LUr^jt)P;--v(3<#}Js;?q0sm
zKYTdXjM;a)bL&68!}AAy?<BH(JRRWd25y+B10v|^eq+}I&+!yrL!{3aCF^uyi^XsI
z+gPt&4R5tDSfe3`Bm{$y^|8BgmeU+I!8dcWPs)5RJTTO0iOwjUJnhB&k>_o#P{95|
z!12QQYlKEC6_N~OFr4cOSm=&Ltg`c@%rOsVrA+D>nhBZ_x~iOE)OZTlD6)&lG+pA}
zP_7H~zswod5FJ}2QPH0@B+HB9RC7oY$?}7h)j+|}t!?Y{c{d%py7ae**U)Z021v?$
zlsk)vORFSHt01aTxDgrJv=76f*jp_siKO?0mgbo(qm&~ImBo6IO@RfPXUrLZ0lD52
z^h5Pnxd}=>Co>u@vWPI{t6v)!mwLLdhf##Ypm6XK8$dEq`ss}=PGxvv(qKx1@;sb&
zBjo^$K%Bg&*cspt_Qrh34kg0xB`Co1E`%8a#pSp8$u$NPn*x9r-7GL!8R<TtBj=%e
zbMHFm?&zdxPDI9uLPyoM{^l74J_3NzwNeo8aNr<#Ib!qxv-Wwq0>BXaHTHtuybq(i
zG~Uj~s4L*Jy4Y`EX7Is~)|^#R3;`ivd)gk@u>U~iBvDt9=OSCMHg`B_6a%HN*+UK@
z?_G3aT5KUC@=RPHw#%AxqYIGI1vfHas7xDXEK1w7L0>b)3~~U8-&kL+L_7!C_oNjH
zSLZzJWcf)SiVueMcza<$(?XTo_v)Rx@he!^!wi*#<UmyytAy8|K5!0Q39ND+;d6Vq
z2TT<E)&wH%F5n*wWtRYy!oWV1a`6k)m9h8jF?nlNG|<D{hYA1+4hcFPP!MpS^o-46
z7J1RCc(&bERaot-ac}N*Q>4k(wdv!p){Mw`LFU6NpsN(Rr;%7KE_o8!1B2jMji3yi
znoMF{ta!!YsHiVik1J;ccL+@N-^LC>2mo=8PVL)$Y4(0e4mPw4ACt$|HgqUOG^|l@
zlrFt%0jnV*1;kF<B;J#ED$e7Lk}|^6=8{oTofI~{?pWsSYP?}||8mRg7Cr?;2zJ56
z>>9tq9df-{+)Fs;T16d!pTQYFiV>&6wnESO^-D(hl-}0gHxBrj=HBWc6*nO6ZjL3I
zG;0t6v8edVu&f!(AjD&vinFrH%FE&ol+|)3*@%{N@Qo$t<W*P@C$=^OS2rE3GO)LH
z9;qk{A}eo(>B73Yk_Jps+P+$gUrW!90YxMaNN^D(mcjBqBvDNWIEYjy{}<a-upDm1
zVmdT1WL&ZUGb)hLh`6E#$39HGA__3bnDc?uzEVB%#f$8^^d2A@iDa%Jx{zQw=NuWk
ztI)f8A)Vz!E$E&X)VdGfP?0u}!iSD2xXL#^mG@gvo|6=0{^$$Pew>FUWItMYEMw5E
z+Ep0LG3fpx`43Kg>L&xk)@jbEe^o(t`0$H9X$mROZ?g2jNyURVN|;$1SUPrAlo5Lf
zNA%6=>0(rXJH6jF8cc`aK;J3KgHfR4L-`{=wG_+zzqkwsmQRDghBi%%2*&GL7or?W
zyM8ut_fr4<q#X@R3k4^rwvc{m{P3Gv2$%A02QFBRS+#;R0jUxMUNEbi%`g|^?uR6z
zhEd<4jlWuFGnY1kWL@Yg5-V`$s>DR<X(ShW9|)q;|L|g?ug&TnNcD$fb#_Unjsa8L
zgvg8El^Fr`smd(Bq^Ruu0qIReD3Wwch!2OzKI|Kn2y{ir9@HhUEKZrHGGY@0IYTN6
z$i_7;J>6(=lR(pgpmu<hVddAxWjNYY5UMFsk%knqD^O$~0Re-=DeKRnX4hde2CJYz
zno80wuHPjGodes;9izd7$@0`)7zk?+V~t~yd7DThHFS+?rvizw9_toVt05}G(L=l3
zA#lG-aFn<-Pz2>w0hG0?zSA%pL{UkNh20=`9xkd4P`gnGNbQ<4uJ%`Bx<vz~%Y9*h
zvXDvucK}9YsD?zxt|4(H*4!)GKjSs^Wh>k1+M!JAoPvn1vs5+1yI!x=Plb;bAt92(
zVA{4Q;kjXnU|^wBAJ{TN71Vtmc5BfV*a}C(b4avz!nmo^F1cZe*(zj=spHqmYQNsJ
z=9oEUjy>WrqrcP?c8LUQtPXjRE-EdSJKr%4_C=gnm<~aQp{r$P+B1ko7x<#?P%P-D
zpH(k_QQhb+xd{4(sf+tGy!;YHdh_I^zsn&SY&_BP^k_D5L$VEfXh!Zf00lceIB0^#
zk(<^Y`klg7@cOAl>9MX)&W4BEZpn)nD-Uag&h{Ig2?0m0pfk^^Yu3cZ+G~nWGAJwN
zOaFuMy6}qX9vgC~uMxr8ZwOX0TAf2nZyLiVgvyxliryZxyeclxSs*p~6Q_|<u(mO7
zxSMG|8ZlZNFp}I$k{|I_Eu>;PTRLDV!GG?!+buMK8aO22%yz-kXy4Hy$ssF2{7QMT
zEjZ}%-rF(xbkmPd%FEr6%;=9|o0-BE&K92U_nj1HeL#=?xCe8dnzs>D>OjrumNu>+
zKtKx-*sVC-N`Vm3GVj!aN1B&Vs#yYp1yvP_rHg&$46>x~A395&B^D51Od{hzRM6ce
zl&l<Q0-(S*V`S_*hogn-=5lHibE8SDsevk{94qOTU*9GZjWro<*rr8<`VydM5@j>3
zDiTdvrr40S<t-`_clO!&X+1VK4^YVx(1@ghdq>|@Wv>!vSLNUmDty~F>lZehg6Xf5
zrTIqSXne=ZdpUk$GQCz^Sjsrvzx$DFEE{UIOY-wpOtM0D2q)wt7Ie@!hc{%=9vQp=
zF&UM=f9Q0lMp-<tc~=Q@VUiebN$YsCPWR-Gw8Kfx@4+V8vR^Ipq9|NcKBOF1vs#Y*
z%?3Jg?7iY|M0-p@@okqsW_Uz?kAt)ug|_Pw#xaqTUFqEEVk_(=8kOQljKEL`=Xo=o
zuTzS%$8bU5@zSy!X(gk+n{$)jk}3#Pb(yrN(lEZd0mE&~d=6K<NVwpdc}Z?;n>Lqp
z$(2K;DsF2Ts2>*lRSt}dM@mJDw<cCtY0R;fjkq0Ar2J~OY_bV`gQTA7w2v(GEbTQ3
zv9g$gUx+-x4HZ4gRgE1SEvIknQplN&`$*LPJVCvf2t_%@zSZuC%=GGNxmC$<dc2k1
zM|+YiJK9V-7?pl=aTlkAwo-i82kXutzqgkFUZfTkwJn1|_>11|elXr{haOb(Y*SFI
z7b~R(k@^(W4$B1TUF?V}DcCwTrsp-1rd~<zEM?y-(K6T4=`%Vdlm7YCqCizC*__E(
zjXINj3_Edn>3M+371);c&B!h~m_^5%zgSopO-w4D|6pB+Fs{X|$aoky_-;&1>?a*v
zy^fxHXc=OTNkJEsEX1SYKnknx#>dyhN01vIJ^pAI$xQlSI(miF-J|G7J%dE?LN@)9
zGPR5-Bstotb4XaC5?cy_%_yoq;?9Sm`JSw4$LNh3NSr9rJy$^~%epYp#<TvK{X}en
zLN!Vcz+m!QegV%vR>#7@@HlB?%^za^KuI5n2-p$=XCs^as30JoBddN3+RsAxm9THB
zY{IzE=nN1fR0D78b}`(go5TwV*9psFKh*biFY(LA-~Gg4bob^PD%xtR=08e<e{K8!
zNB~9-j(-EaaM1q;&<h9se*=2i{w)=I$O_$as)l}6?Z-s;+yFSpZ$M@Sb*1kQz(eh^
zc5M>DOTQ@#-1O(QxGI!_D<l2trA`w>oKT&R;(>^7!T@SnH?wp5@c8tzl~1SQPo@5&
z7zt(luw<(T71id1wGvNG<!x^bE-Sc)k1OYo_dDcp?djhGzU!;Sn@g4O?(Jw@GH)!O
z^-HNtp+p4eR?G6ax3g;!3cquQ@1n$2K9Xnt2PRkkr-rM+nKgI?_;$YV{His$3|zxw
zq#j7GRqKx8sK^7o%;k6JqHE@$`6FlA=gYROX@l$E8yW|n)^`-E(7efFM)d>hW<*r)
zZ4~2%cm^I!ngC|`*vQ|qj7ZmsPPp5jaLBt1AbI|8=IV`%DXQ!yi9LtV9g7|z6?{q2
z{Th5wKnDs(=8W;+j@AD9wYIz8{x$%Ha`|_#ule%k?rAMv^kOWck+@}bP@vd@NsB~T
zW~ltNJ{o)w&cMr=Wo{dos<JHv34Wjv1vhmYf}5*zPHtD{TvZKCFf#0-KvFk!pb7MS
zU&rxxC5;Q%)h%X5aC7Mm03_tzHJn-?Sqo~1GZFi1JHAsN{f4=+3=4$GGLbDs>Vawe
zT><Ffv;tN@#=w=z(dVaxC_J3PMtMmWB}s|LNldUu+{Y$-SbqYHl;nsr<6B8LyAG8S
ztczbA<ygm$itS><#?ccs*{EqEjXB0N^Vg24Ok%5m9dNqiE4&9bx(*@Qs`vB$R)oZ?
zJd}~Ik4_+VA8U)Kij7bZW8t3&Mn)+JV&@m>Eo+fwy(WYbUIv?KfFa&i7%^E}nHS>S
zWYsbZwP$zpR6icmOBy{*$~WjrympSM)9SGT_18Yk(+Xc<p#U3C_yeIx2@28XW1J!v
zjv-fcG+#$WW|&j>POYsnL)mc8{l@$_Ro;|sKV7LV!e50)mB|j^;8XyA6}d4B=pqhc
zY-E+d>ll?apDW##WIOq&8+>uM+Bk^Uo-~G<UWo2Nv#)B9A%s5p(nj$&&jT`26s7Oj
zc$7{Tb)i*;Ld8XN^}Ne>>Jt<-pxvad$n!et)~ymtzZ(u;K_RM?S%pXu@KCvPn0YRq
zFgam-{X7DO4t0nFPM+ZU6FrZ00#6ewaLpe+R!jwHDW4R+RamC3n&9-5j8O$JYig+Q
z7^<pnPkm4>EHmeDKrovgwevP8PQk^|0axpO*bEj#L?BEn$_wW3!e)J^kU8!W0!F~Z
z65g*y0h-nqwQhC6CqaK^$1H0%rfyC8O65&1BmS#L`rRnkgxd$yazbUe%s}NmjA{+C
zw^h4yqanM(Jw;e|4q{+=vdk8=S(2?2ttG%}l&mShvRhY~irrLS6oSBTlG&Gr^VqU=
z!~_a&KHa#Tw>oV0i$-CA{V?bfc7$ZpEHqlsT-1(Zm^x;!F2m2hPEs=b!z?!_M0;#+
zj-Fv2bHyXLpn>kmgDWL-cH6f2|1kDW!J-7)y5_WP+qP}nwr$(CZQHhOuW5Ttv)8`e
z5%)y&emJl7SXG&k<Igd^&*t1|DCN&qyVUk6&?z^uIrh)kX@5U_LpF<j@QFr=is40E
zciRW2RHzGYZoFl^tAKO=U?$@U_@JYS<;(B+>3Tgp`W-;<6+w^C;tJh#Wo25f=qpwz
zmWxAg4`&uIlvFM-VLc_8zHyQavPqSr7p^deBY)JAgToyxP7duP5$kgB8dP-;-jXH|
z<lrz}&20&p*XhpRt`BtepK_D`wvYb5TjPKBQAQ@#|Ir-4`QI!8oc}9}K<U5c0Gxlq
zto45*2irq2k5w~N7Fb=?<&CkghJp?7L-5^twVK-!8h8!gcet5};v#setW3bd@~$VS
z52Lu8hnjgm-?!h-S6BA^KTqlF%Qv6TyZrKpBzdcrT4m<GPSJjO^7{O_eqXmw@4L`G
zzdx^+K7PO7AK{;pI&|&cIDq{6zaO_R2fHSQ0m#T-KljrY-^P5BZ%<d_&8+DcHs#aE
zUu$Dqt9&&sW0s`XxO~{`gUyo{)A{^g54+Rh?)>{+_<Y}I&+bxRUnl9mWuYeyhTQV=
z$aFRGN@1a`T@%e6kj|b;=8UNq?;hs)xVU$6&@kb)+mUy#j|cX>4@z=AK|O$oaI|O9
zE9M8sUY=TWQW2y4vE5x`y@SE4{wb$M^Pb~=Pf`Ap;lH)dqC=S~Z>M!GdDFSA5ctys
z=;IY9Mh2dwC1uiQuYZ@^G0?*G)0lPDb`795IQ!bIki(^fBd(V$CvFWx{+fF&eJO0w
zHy}an8#($Gtn%8(9OnOH$b9KZz8BTzqmT<Z$ux*dft;iS+Al|c)dHfC6$VDr(toG;
z-V%T0NHx&Ul#7Ih)<25Y_Ue+;Immt12lfEql_FK9-BT!wT{L^?pdffuE*zJ~U~Co@
zcZBb1>>IqJM!KseGZ{9F>tq$?R5GwR%4)*vqIbsL@dN1~y3)nH;1EEJH8$&SmX0^f
z3t>2_(KCRM1|!{^o=_r9j8slfD(WFAxvNHFRi{n1B>9HVf*hWf@>u-sBSu6T(&dyJ
zBEU)ea>Ry^4XC}4x#S=24E)^!i;(tcQ;-bS?Uaa)fF3oC9+ce;4iS%<YG{&#zTlNr
zv&45JsY9M3F|2egfcsA7RG_S@U(Qo42{DC&O4mt}nRu6Bz$|xoa1aS1+c_1$3^06*
z>NWh$V`6ypth^sWaYD4MjI@wfR2_8&Wgs=F)e%He{Od!GJgSV^oD`-6LxF2{<{YHt
z1=MAF`EQ{RuUf^FzqzepP$0%3@!Tdr*yn7EI5+?hUfHW89MGGQR0?K7A<A-@C)IKL
zMA5`o5mKuzWMO)RMkT(v_;1pHD)zu1G<BFSAN=6ytN`h$7wdfi>eD$OWy)9bhU=`n
zd&o7(X38PpSzd4k;Nu2}hFd-*vBI><zLoY|cIOqhw95(ZC9j`1O<bJTCDchCru7hJ
zP*(Wd;6eved-7nyimTDt4>vnJ1R;oW1O*atJ$CoF>^|5LVgJ1)-9q1ppR*da7PeA0
zi2j?i2K$#%^+KE;(8BI`wHvpriPQh%=I@{6#zkIZ<AD>fFN=B?A{-hX0Dwtq4<<+<
zVqmimXF9!5R)pdV99fQ7+9H(LFyxmYwgiN+wzP1Hvhzz<PZt^cb*@|3GMXR)Vpi-O
zZq<niHSEUpha6reejZN~;MHSR1lPw~&9g!?N-Q!+u^g6eHx=lmUe&ca`OHr+!iq*y
zzYmGQ*=TT!;V)cJc3NhTlvG|4upCd?K}{^GgTu9=LGp6Q7-!(E6(##GDg=bxz#i&{
zPGny-XX-Xm3&Vkc=tLDL#i)H|eeOpJ1^sqLxV|HzilkOCYshTc+nSj>q&}|Oc-qOX
z)v5@3fyfipo|84U`#uo=SBm5j0;$_p(?8A@ke@z(fT2Qk+hU6-l*wBF<Gi_d8cq4=
zQ#);VaN2QGg=s?}o)W|Uo)tJ-cLdvb)!h(K!Lfj8@Fje*UtY5oip)O7BvnW$x<gh4
z8uvWQLNQwo8kzUc7FV$~U4_UG0Yqt8TpLcZQiWHm`fE*P9wipxZjC|;fvVGEKN3So
z>W==&-H120Lo#kMx|jP{I`~F#8-d?q&EeB3AMC0wj=Vu&=x>u2TrVz2E|-*-G^UB1
zb{a4R2q^-F8nlMSPCf5M$CG*=QWgmly=+b2_bkF@jR6Pm)a?<P147~*9|Fiv*pdQp
zwaLEJz8>BKd)Jc>DCwb+MXAw6kGXx=JD)&#DpVVQF=p>ahVOYw=8hbLF>)t4WH988
zeAjgI;8%l$Kr6-ioAhj4I6~)jhUgV4r}rZGlm<Au$4CRp9$6aaQUn|2<b^T(5pz=G
zqE2Gp2x<F-E}C(isl-HD9#zfB%#cw#`6s<Z^j|*h<gCZC8B=8c0mnW=a6<Up1cPB>
zmfO@ajv)f(!yT;j!z7Z0L25{X>vtuNK}tuNeCyhv)g3eRbRGRFGR$)xcW5%mFZ!X^
zj3P#9-`SvVagpZ116%vRc!6!90k%^4Am&*L?g}!1lpp)Ee@mTyUif&%S)7A<Mds7-
z(XaC29&mlkeu}J-mQiNazXt)0Rngxv-)0v$(>yC<Z<JMuyeB@{<<U?M110n$M^pN|
zS$tHNhGTvb+Z0=`ivG2iU;{_@Gpjy%pK1eI87)?%R#nUq!TL_D44XK3X&)MfGR6a*
zy`--xYIdx0%Q4+-C^11r3X?BF3A>pR`%oMwt1K3jSBf8YUo~EqE>dElvV+Y9EDa9L
zy%?AX#uFh$dGqdN4})yNK8c>TKE1M$3g`CcGzTA+&o~4TFy)K8$%b8qpl(+y5_WZw
z&|}t3M<p}2ut>+b35z}VIyk2ZT*d~Q`bBj!js%miQ@L$vRzQtON2DAjH>*JtwOJ~I
znTnrOaz=5~7RGoza1<_v^^Kf0#`}51S|+0*gXbhYsatI5my1~4l&grlDH%QYG6j4b
zK(HNKeI$s9fbcpI$rGl9jY%gwEe_OMSwZcYJ0YXG?55F0{-HQ9Wr`$7Db}isPM(Iq
z9<?Y9j^kzFSVa5GZrQ#hN33BCnwO<j9>!<^@@Jtp4?byY>XHx)&jdN{qN-}UAh9i$
zMSAz(F-&E8q1YlyPUVcWI8&(l7+XO;7fPP~N_Pn00^{7`G?uoyZdXC5)>xDTkc}4Y
zWq`SpO{IwP6%Sb?@{2h$mIK?fF-S5&al^laYA;enzQqQwZ6ZlKHi8l}{gkA-cyi^4
z^%F|VTSA{j*Nxh;Nn0xTuge*TK0(QOyf@ZSOv&1`oVHG7y9r-mp;pJ#2UvdBBJN1Y
zpMT$fYuADvxT9psG58X9ys9O!O*^ya+zowN#0Kv#V$=8SJA_8kwi|R5GXDyT<n(mP
z+#QAI<wD8E{K%Him5?hGPj)R09M3TtthW+uoU86R@0#}zVNCxZXH~7aI_h7u;et?i
zM{$D&JYb{xZc}Jh`9#;xib?4;J$Ftb>q(X`gf~4J=L3A`L9ub`)RC{wU~Swr58uMl
zlTSPaf&we0%p<xyPQ3o8R>n0GS`bnp8*eZQ$OJ0Yae><~LRL*IoO&4;N=Ho%UBIsh
z=?#{fBoVpDGwt4Wd!$=6){9Ifu=I{$mM`--G^-W`K=WO$lBV&R($4o=nx%wh>Ec?1
z^1(^Gh5=klt07~9U9JA;u<DJXP3RRU#!7U$DCul(p6aoD>x(9rU=Z&MzvRh3g{2l%
z8A@Sb>h3GrWG$~wx!u550POJuspW!|m5%b3C5Dff735rUcP7cYtcY$y(i{A^$`@rR
z;(sV0yXlzR3QA5pZ>C9lLCCBUQYvZ>kxj(Px!z)_%rMyc2OqA`lpY%P2iBdI7nL^w
zE8UW$6Q6%xeHy^jS9<TVitMsjR{_T?)z;RcGVz3&w6gqkds>8fm9fjRu8yUUtL%_K
z=H080I^x<n7L{<8XMMZy9mU(~xhmk~UP>%3bzJsgSzA&=OtZwgis!$H)99;BiF#1b
z`$XK$Lnq+EJNqRqx=&8<4g{ux_N<frYa1mqWh;iA0Cr0*v?uJkEGhK-@w-Bc9Q06y
zX-da`nC3*@dAz}yE<ms)A=YEIh088jf=RBLQNHy|*^tE~+J(DPhq4^0=<Vb&ZHmq2
zBaUK-ENGU+XO(lAs}=u(aWC0g3KUg!O^ns|*;M*vY4R>%wY@AoUr21qp!?U8mwm78
zlo2O@?Mdfe7LY}=W;HeWl;;Wl5<pGzC#YftqtS>ctWCz+OfQ_6g|)rwm{eyjx(4v7
zmEP_=)?+TUeJz%3qqdqY>0tM5EfrYECz+O;2blXgzf&a_g(S_){p6GNO)eUFo6!wN
zMR9zT(!20~f5poaxL&2t*XQ%~|4>WowX2gN2!_${btZm1*aUW7UZd%YxR2>)sv7Bc
zskWyJOZhJ=(zR6*;P$Xlw}QD!lVRLBag3S_yr1730K|8~u$T2O(a!b;lNnn?fJ9--
za+y3R>x`zQl}Hs?&UhYE+4(d-T`oTgH*9Jx9}X2%tD|ZsHY;Y@?c9uhrtPl1HvSuf
zywlZ;L&$a|o^dJPRzDoEGv9QRt1)xVA`(SU8mzG?qsa>HOM2C8@HCqEwYRKK^Dv+A
z&siDUU1(R?0jEsF!6`+COCDqPFr@u;<Ah@ry?HQg#+5a-voW;<U5}7|%(D*Pm%ue}
zpkWaE(J)Q6SJ#=M*;RG|A6W9q+OdQokmLQU@^{0dyRO~=jVr@N)`hOp#udFgiG@n4
z`ROQD(X$wDi{Y%Ws&8p49NQ`n(nU`CP8Ubc*;>QlU@KJwKo$Mcvo*pxy<)YJUqUW@
zr^zu>(UtodC2u7QDftL>ApS?GFht|;gzSsma!yi{G?LT^!_m=n`ue=S9{<V3n6J!I
zg1>hI3p;8y-9NYqf~<s%)$>Z)-h^g<>G^rtZ4dye^dC5P1w{;+A9D~J<>WrmWqx-P
zI)8E2y|i`7sKYNqw}oj>Sj=O7c)y`VB-4c}MJ9#xM32!l7?E-P(+J!Q_N(kc^Pi!<
z{%ffI;HG){Y@ZzwK#vgpT2o2NsZT8(Vn+eueU(5dLR4+s<q^HqCl$iYrDcgR2JwPM
zcb0onm%f8(YdyKKO1wn*XKzC+Y;}eW+FgBLnzyNL9N4Kar#r?n)k;UYN_ar`u&-K2
z(0Ct^vWYnv5)Tu9pRP4~fF!Dl{Tpb0-vNUXFC7fX6QMqeMzxz6Gl$?Vnd{sT80+W5
zdfMzKK2V)!)&cq^FmfOQu52~9BLVvaUgU$S#P<~;=6D_e`L^1H2rCum#~~(fwkX>u
zS_k<ePI?c^`B7Q!xwA%BM(Kr4R+~1#G8M&QX*Y+qPHEQQ>4F6urp#`gS$3&T?``bV
zrj$}lHp-LQ=9N2Pkcy+caFJ|STyTGgeguxrnG}ZLac_e>a==2799zWR&FgEJF9=^%
z_-BVLNbDcQ6yE`5(Ei%omFU$M!@JAC-?~Y<7rRp3)!__DjGyb#d5HXV+~9TF^2N4p
zNvGov-)&;r34v2zl`cSp^#$*=0o>XtDTVrb{R;<0C20}%5bs1&>4uVbTYJ}tyq8^S
zk*V;(yv#H6)xf1P1qe-`P>-#aesQ(8s7d=a4tYWJ_u@avB!(&KCOY;L;-C359SR)T
zJXDe3i^*!i#TAp|;HDw5;f%-msg#Do0S1e#0Dd%b03B!^C#E>;8Ixx&m$N=R@@v(?
z*i0UD6vE|>bfi69A+D#j$Y-o%e<1Fbsr2f6cTTt8`uw=QKXfskhcEmSK6VlRYfABd
zf`|X46fBJY(-6bS{@>DG_Ww=V+p41-eLeOc*CAs9`|z!z{tE3N14D5pA>>1_;UIiC
z&&C562izISoKTW~epR1}`X7?n#^Iscni4zL_2+8o`FkR`U%wBBpOf!${Ql4B&x6P3
z$EW#W2MoPq!<=z+*M?@VOt}6Y+`jM2`-=;(SN@*9@3U`rr?;QK@V~rx{64*32VNL*
z<<qP%q51khA1<E0Sz;NZQ149mdj1?f9o4}I;p_PPc&R**M-G@z7n*qC4^KRJ;eRLb
zLVqnlcNE4A2e*|LjXk8X+^4^rOAZdH!k7R0pe##H6+;+1;30-f{pNg<_nZ%vp+V*4
z#y$EawIKMv&Zu?nQ|(@EV1dR3HD2?wM5KAj^}j2D_lq=!_{NaKc0c_N=)wLlcVm9r
zbIZJeczcYKMSul1-M2~L3x@y-bpuWv5@Wq1=5-DIMbd8#@vp};-Ldx#JX=M{_=}_Q
ze74Tdx2u=mM+st_QbmZ)asO;zd)7+;OOet^(E8@#j&DoQ7_d9%1Ofk8I~2}|;7Yg&
zeP|kd{0138m#85FA-M8I>Y5clrGKX4jTdS2Hn2~(vg7QuS(w)1+~@0y0K7CkfLlFl
zvFZ_stINHjyyP~KjtGO6W0KQCI_Vg^c3?*!utIwhLduh85=fyok6a0dG6i`@c{X`x
zB7MP7{YmO#Dz)LKFyReU0mfj(D#<3YAoDVs!lKhi{m;=n{ax2%L+1o>n4X=<n1$x9
z8EZg$`iACKJeo-|ZVSAK%)r_g<KwJ2(6Uyn=C$}YBHvESy@I%$Grtglv0giPIdEw&
z0FA6V3P=8WJ@R|90G#pBj7mW;JtU9%Owik%?pmJT_k;6;ZqPR!f_q6Q(6h?jCB-}y
zrS=TYbQ;&HGF#bC#?6^zeYD3&ENn}9r3#5<UkIN2LSX3?Rj44{-o{;+u%<4@d;ZJw
zR6UMZ3!+0(tcb8Hu99PL=5)k73oUy_WbPTPTm`)&V{s*>DlnRvnQcLbvL_!T=gNHu
zD2^>|a}mCK(8)~)l(iBZ>g;*2tnk7iOqhKi62^s%Wh<Bw19mtDQWGiJ8YVf3G`XEk
z3kpF%<0U7YEU6-i+Gds_g#U@IkQ!714jaM*_$rXc@iri{r@IqL=qmE9K+h$(TAQfO
z6_V?;ff|}`esM8a01oXdh#3K?r7-1>!{!*QN5(;>m9uWen^2y%6n#k6rU)PX!@`;o
zMxfb_ibnI^JuPXo?V)Q>ov!^{WeWm;7v1I^-;hqy6VIh|+~Oz@*^0?M6(RL+T3k)N
zhDb{&>1%t4C?rHCl;dRTR}h;uM0Q*S|2|OJUg+*Q2&(fT2q;m&*MlITlPqa2q(5Tp
zC2D<zc9`NNAdpxw4M%i?G_Vw?3!=Ft`|jaJ9&&jF<vMxmigWnd@M<V~1-)-Yt_(i=
zzeN>clc9d-YOwR5T9QR!Vovr(i80YKx$XC+Xs~a_SC3!7rLkx~csJR#PtPpu8j_J>
zEP6jG{B>VMUxuzdLXMD)0XpHhptU!%f=QP$HST<mfiCS<bfuval0^+iIX?Os0fX+i
zk||90s^AoIop|0(IrE~(4+$Q>!r7V`(0UkHwnzL#jC15KtxAyKykzs!N5BM0S4+x7
z<sr1#WNHaz*G-yyZxPOOV;Crq5@%qUE?M>7L#iPhIYd-Njvyr0;Q%FTj*b~45ltbI
z_BMs6(v$KgmQ3QdOdVMe^4k-;8z~}-9vKHPO}&Z$Na(PwR63#dNUWGhWupe)T3TQm
zZFkaPgVG~_L-NS`-T<`9*geK5xn8%(O{be1n*g<U>})_vb)OI#%+mJP?z%=WhkUMZ
z=#A2uUHz>y8#_Z_718A%@h6SPPmZVu%x-)P1iOoM3(>~cdUpw;dd6mDsw$N3RKjt|
zEvpO{PQ`MYh8wl_pzk`xAJ`0+Lr<omLqr*%=;)ej{32>xdp6^Uz5UzQz%08Hv=p#5
zE?HtQ7Thd=f1cbht|_O<FtF@&MvFz0$3a~f(3V(SqfCPr-<dqG@(GG=F}BnuvLlh+
z6y()EH74MF0-G!%!4%3p{O5`@m?!7lBl}PF#9`;1$uWvD=OIDQxdp72H3J7fmN*kL
zaOVuIPsp@d`Lz4%;%<wT_LfM$84Fy7oQ{02ONj^!F}|LVqH{X|f*Iox7C~!KC&+wU
zM+k_xcA@>P_=FTKibu(iG=IJ}{7xdJ786Me31^gqVED<<y|>p=U?CP<w?JY&LyTc6
z@#q&#WmnM2WP+>F9Ko2miy<^z%j8lmb?pAH)tYSv1aCIRJX_B{uZ0F#H`Y)LTfX_O
zjM?uCh-aI%G_W-Xmf;#2sd!^w1$|8QoM=XlPz?&2&Kut}18`{Y357cv50gQLplXAE
zB}_xs3PRDvq1cLh>fvt6vId(oR#EO1c%TCBmN@UeK(2b273mC80HW(ghT<JsCrZbZ
z7p(RcfJO@yiXA8_<duR}XF4(dt;K{fYc{EnrbkyfK?m*}Q|JCmWq@4^c-oq5S;BfT
zQ{lW-PAv>BP$UpYL(hBe;<=1fDhk*D!#JGgDEW1PF#{)m(hXS>WMb$OrVTA^z;aV+
z)Zz|88tp|>(Mxp;jgey`&2;a&m&Etq?QMPu_Rm#Z-YTgn`~VD_H+12cH6%aYk$ud}
zo~QxkBup-eMU;&B?LD7R3$utbOq+5ws;!)V*DmLZLI%fEVkBA_$tE5-=EC)%kmrQe
zJ%57T4<kD1NNd)J)d4i{08(lt-Z+<Qru^GhJ5{OdNwPY1TQ~q<;`~|ZhR=ds4G)&)
zn43ib721_cvwaz4@m_2N_q$MBrQ`n~92xivn_Ar=8io7>78rFLHJAIODH@L=?QI{^
zYa<X%Pi>K;LE0HJ{oyUGWDrEH4$QM{D}K22L`^)bq3or8*LwfwTun9SHkiIcmFtSY
zF22f&&(6Uw+kz#L6-t~(I3xp*lnNhJQ|)M?`p~m~F|Mf;xmK^*f8nB@Mn-hqBNa~6
z_}4z)T>qUnPDMfkE7u%@owjK<AvL_Zv;UEnQ{h>ICBp_wqkNZo-*gT-)BI-Ho*07T
zsWlXCg4(ug+WdC0Q`$uKue|FvAy!hNu9Uw3fvjXx)^V%7Gkdy8j-r80UBpm;&(-D0
zP2fzPX>K!V8mNTl*lvyM;?=QK)8$bY!)A{4?o1N9=Zc+uW(C27H%c#BCl*JB?Neh6
zZpMRm^>JyIS5J4=VK?s9;##i;F?}^DH^`pVPUL74G%-ql7TgxY+IqRcNE@{lv)^K@
zt)^i)NwW>|q6`=NH`$xHcsM(EDEfwvI>e4oego`fMtjOhZvOZV?K{MN(tEv<y21c$
zn|Z%iw;bGGR@(&}-UNDr=xdDoKBh@QS-TQvV@fbU|5iIk`O!WkR=@xq0!qzbVa4F7
zOe2s})ljaj)aa>3Lo9JrBa)g}Fw{Q1p$J97JORd{ut9SpX!|I0aohxL5J4DPNCNA{
zVdcmqe2Uic6dF_Go#5?c2HWwdTukpyNDV2lZTFH3(7!gr5w#s>roUL1J=w`we)YoI
zOCnaa65&@VHm5wJTBa1c>=$i?b;%61Cv<{Yvp@0?v!|Mu`285uqTE~g-HFWR!|J|7
z%dNer1BCuKKJ`^v`yFJ&Tu5RS)q{Qqb0QXWZJU3?i&VOouQ}zAKgFBDLv+`865V^~
zs_l&szb3OO0VZX9`PT2~7Y<I|3cRris@-^ZptsTLPzkkAxn|4^{X-#k30hL~gU0CM
zR#vlFvsxn>D$~<m;Ax#M`wf#9#r#LOIlL2}{}p+Xg0+>xW^%6L62W4B+7J;MUQ&t8
z)89VLW-a!MYo#Mo!fyiP$>4T4RAX=o!}3b-T*=f31E(J(mr5m1<f5mr5(`oMlD`@r
z2_!n1Jfkw?Z9g+!muWpOcBbG&bkdiRnw_Td9L-`m)wsrH<*<Qt900c(Y}^1Nr$@!i
zA2sgP#P}AWHgS|P_`xEfm|?Yi!3V7|vuRKIT9)M91EOnJRsZxQDM}UhPv{$89)PoL
zJ!^A&iE&2tmwEzJu7=DM4XrUiD7T9T#dYrXlbNy5dS^=b<CKenyeZKl)nJ(<SI}-@
z8PZ10NCffZ6IIUsX_)*$y%dm-yf%0;T7F7K3F4fk<b@?F{)oY2*xHWl;UVV1wjcTL
z`7CuncZhqbftWtDa{u4~_%9>YVkR9VAXvM$*`jRXK&^=&RJ?~tGe00Tn}C3!(m>WL
zbd_hgx=osTBSVc=wMo(*^~RK$?4l)*M#G0gr9Jr;3s!fmky{$w=HL!$lL+V_>xiAY
z6zWI<!Ii(}C7-&UOqJ7X?p~%JxaMAV9;cQS)3&m-VMELFDzJ&ZSLxwh-|r{(z3cne
z#rMtfXMaTdEJ(*$Eor$We6w+F?lBQKbQB;}YmOL*{0mJuuF|H=1ypQcM?)3QYSFcn
z``-z1g@()Sp_El83y`{C9`||LO`ow-z<u8L8V`-6Iq|tZUwfHT+98QR@xPtbG*+q9
zkViTM|1|EUAUpj3*ji8T-?1D^HkvOv_?V2Rmjs%rY3k1q;O+UM=K{g~<{AiL4s>^t
z=6a$%hgQx;_m+zS;OQiOFHosw4y;56F0zL0Y8Zvu#0QuMx0@T&hxVDq9+!vW@8!73
zhOiSR{stT%{=x0Yd6WD2Be1ivoMWKx?DjEDO3jKtYESJP&~+~BGKVyFOmKhQZD+Q}
zD3y|SLG<O9yD}MsCAH@(1IxMY<Ql%QHz>$eT_(A<sTMfPOaG~vXRUzI$zL<fy-GHv
zERm#RS_#|&Gtq@-`}$1aWSs{5+Ow=TLdZNJq@#dFM95UsMa6y^@Wr&m#rlf{pk0wj
z<N_-$aAjs9@E@V5uJwd`maaj;)RB(U=!cSB45JboDd?zpX3u7yY#_Tv%gv;5=Qcr@
z?LdR&l({pedRYF}@AXiGwHJF{WSY;fJB^6XL>?v8DBpAImuNT9fOHq>#&gRu_M*wy
zRXZpTl<>5HNh2@Awa{R;PBErzMDG<L6jaOWI}*lRKfzP{R((d=2+%pB`*R3}3`2Tv
zY|8sUL*$!G&Y7m>o<N+^9`botS}_KZG(bjy+3?`HGP_kT&f`v6(hwu?(HT$1s;Wq4
z#xOD$?T7)37i~sod6@SZL^yM)x%V4NoV0ut<%yMgp_tRjyf2rQ+SxD)Ykm#o@iDh`
zA3SWUm;K2>)J&%LY@(HWN(S-pD@=QYRVNv#=j}82#}0Lz1C`dss{SY?VvImB1d9z_
zaI$4Tfrz;PKIr1pfyji94FTBSj*U^xTk*vNXT;8Ou#&e3NV;dPXzrQj1_1<Cz<L5=
z5fRpLZ68~&yWc49@#YIC><Dt9V-Ugwls{;9lXb8S>1VEXZmryg*;gcNbJK}quzf`1
zAZb4|R*I4VpTo7*^G`OQLvV`;mHvHP+^=*ynrqVrzoP-b_5|tLPuvuw^i&pebtZCR
zVkw7ozNDTDewO<xzBxZ)I_jgErJ(+f-Gqz#q06{Ze_^ywug5ZiQe~jsW{b_guOZ4H
zjrjoa`-FkO^h-UA*Y8yPgYyFpFH#ElU$c$>6IcA7Y=epM{{nZJ7#RQmz}<fj|2M$h
zS#4=+l1aq>XzAYC7P6+?Nm*boFYW##`+)Gl@Y#5_n%Ob~iwAA{?InK1e6OO?G`0a_
zQBvh2ChmJ9BC_@}3HRsm@%Z@om@dcvee>$@>F4>nVZbdD_ft^gjS6l&bma5#<^1~T
z9zF}l?)km{I+FiKWkk(SqtDmZ{}=XtyL{Y#KW1MUa^=&nFW~?9elHK7ybD^M*VX!^
zgrDWZ<KLbdz|ZH)h5fzw`Z^2W{yPkBxRUPQH&npy`~I%)D6oc|!1z#MAo5=E9dS5-
z0Y@o=)o^QQkX;ha(*WshQJIRSblI(#btOv8_fWn_@vqAp@~<CH<a>>LG8g{8Mv*!3
zxc+KnZL&!JhHmeXd2up%8$M?|ZOzvS_OP-;5ZoC{uc36Gq4oPA_-I=ndW*@GNN9vV
zi(?O8BI-6dVo$iR7ngn~SmuYwEpE`kZcDXr*v-{{z#@>+nUAWcH^W{H$<hCSm6;92
z&&Ykn)qXh#_D?Ys{sDp$#vjC!z0PVM;MlE57e=ZM{LcONezx}(CCc@1Qv>#hQyrvO
zn#Hwo%{DGmH4_?UALXkF9?hN408lQ0CFJEUjup0kI3^*{KZQLRiUjq{{8mU?7z+nU
zC)q7#bL1D|DVvd!=vqSkXBv%ZPa70|H&BWf0-J|E+8e}QDXI|8ILwt?Yy`TzX<>ph
z3MMP$h+_lcylPsFu&TkRM7<ZXs|slY^h>d%IZjMFWHu7x9^u_$j3{I={ll1(6?fPu
zp^--eUM(moG+7k%c;$4HLDU4Z;sv!F-!ubS7N#a}1!&a*v>Mw7U2OCNTNd1XneV$Z
z9VMw5Y%eHy6YQ=jBDX4e_GOy9?ajgp8rF3zPF&q#b(1B{c~dcGc~x`-K>vB10x6&p
zgk<L`BMHe6#*!u#1TiZ?u{FFk4i&_6Z!;p)9OGFxOeG$*LuGfdt;xx9car^i8pK&A
z=N@ddiZigSL3ju)#?c(BZwjy^H=IgFL~=g+EjhJ<PJ>BF%q!IimN;xRiu4bL`kx%m
z3h5a@@7O64AvBmb5ZUJpws0XEkj+XI#b91Y$kg0+yU7t>3a!=$dx?-+ds%7<6_ZTZ
zRyEx)WL&1B^C#i4d`*>%xh7XREgC8ltutiR!Lp|&R*Nf3(Y_ny#^HXYIhHN8scCVO
z$_ec)Z1-H5*tziGidGDC;hvE$Rq%>N9XZ|Lk|SaGwD(sFm5F~#*rme;=rCg2hH-MI
z|CwHXJeUT0G5)3PD+I`2#^>*u2Ene%IA@XOq#UJ}Yx?ZZs8<A9%rs92s@Ub9WR-qJ
zvEQE21wq>G000a`i_^V4zmaj4kCzeE(rMC17>XW(JJB^gvL5@f3rUe*#Ajnrm9-qu
zacEmO2OC1UbyWL4zQE5VERN;|x05Gcof}!&^t_vi!;C0(gk`LpT3F2@987xhDA+W#
zKy6_t9)eIv(xtFdjPJvWG{683Fo0{#!(gCi1j0m<tXyR{@+#YQ;9aT3FE&mSc{<q$
zSxW-u75o_Jmvb)KAI!yDsaL?FFXB2P?W6@ix9Ri#krGuDNlgqNJb~4g;{1)+h0Vk^
zYrHmXHQYv$?v?dDYm8#+?`)U2o(-~#FtNfAq!kf1UUEW2SxX*Mr=mWdT8hHJNQA49
z1~1<1%ujX&i;Pd3Pj-}-Nh}g%VSOsu*9#Qov#@9KD2*WMW0rNLtx!lU$sB`78b~4=
z2NaW!BFB>N6KOGWc+v`JqGQ0`st{@I33B!zbU?vQL{AWON>ZeuUBL%?2wE)5093>b
znPpBXE-oa`OXz-n7KfMFHp-KVyMrW^01NEg^rhTS{{{o?v?EG1q9s;4pO;xoksjkV
z?3D{NC{P+Zh}a_K${Y+px8WNZR<p8@NeBup70i?)MxX_?ofug5UeXYdDq_gh*AIRu
zt=saJiY^qN_C{P^PdsJ$$h$A(qzJmAQ!bgyi2$CcwIO9h&Su(EK!`9^sVD1l#2_0X
ztubJWuKCboxlx@)8RvFY5)(BX5-i{AbOPcOb=Yx>Z{i^O)Lcb`OgU({W1umkj7>|5
z=+sGCGErZgq(PRVL-GkHw^Ohs;MA1BDJ2XV!e{HuWyqyyqajEwWQ<-w5%@rr;sfWC
zD(#dmsrWiM+7%tP3VFQ=qE4c}RU8na5+Z6SSOyLub81QAV1=u;a$eIAfd;DajMZi+
z9L$xNW@Go64e$i2Gk4|l&0B|4$mqpy8+#OtDJs`G#tfubG(_AoWwX2=yr`oQ#W^Xb
z7nA;KIrABt!OTy<X%3bkzHn`mOlei|!uCyd<d_(7WoeTiLDixH^_o~E%C^yo$E0{b
zT-9{<!^RFliRqSX8E@aIM)1}Cw8~Iy*3Ny9ULn-aFF@UZr`3?shzdh^EdlvSr0huk
zaYPE9UWah^0$l7COX_@mLnxXo=6rakF`M~@SO_?wi8(612QlG4KsI}T96sHN2b_7R
zV3cga#B6X>1;MZkenToR5aAlz>iZF0Y?<5#p+$_0-QWqZTCr)30PCSN`w-`3FhEMP
z3mhkc!8eRO36>2O;_w9siQ^0@^Yf^bY8Up$(4txKF{uH-7Y+n=8&4W`h`G-bl{03f
zx+inFIGYg2)kw3{yYs4aGuec(9Mc}5=>!N{Ms}u;nd(6Xu&&%GJen&j0nf{;e~{kI
z^ns25v9IHcVg6>h5<tpv31lgBos8-;;zMk0I%H7P!@XBpGN)@kB+<pNp4*$DDi+~8
zm(^S$J{6>KeQomCJCgc(#E&Gq^(aB@aUap<8nije$sw5yBY4jI^s$aJe1}aP0wgw8
zu|ud%V3<ECsHzgG6l~G*hOHz;OTv)l>Z&!?g8(FwjuSj+y?SA;u3yqGmeSIQU^hg>
zpcQlxvW_#scf{_VhL#JYB6-ew1%v8v`~{2d>M4fSo?^~y`+7@x-LP@@u`J5o#!5?X
zK#(E3GtG|yYwEM8F73MN&I~AUma!X7?(Tzi8!e?0FB9qIS!>@Ta+JBn{zLHahI3$=
zeeY`T*^!JwwtMG|ev&PW-;Uz2xI=W54D*hg58Q7Jk<V)#3ZHVxAkY{O5J#OalsR_e
zS)nzt8y#5JIT0JvAPF<Tnthv6dmFRjJp|2=%UOPqib>`!cah}GNubpPUtKi(K$^{4
zl^b1OOo2S)w7Gj!@i>BeaCyV@xK+4S-Du^2`?upR&c*H*yZ25l_3N~ZtM)e6?J0}0
z?{qU#;Vz2LzZC*$*a6?@3@d5jsvV1WgHw%=OixfJOc1*U1zA<Ro89QJXydc2*D2Dn
zD6Zxui+bIowj<NQqDIF({`7ZEB{b2(WA-PEJvpZEhJB``eCdb@Ki}3{xQz5_43&V1
zUB*ZhP_gZVqpd$;H-$}_oJOPX5YY-xFkluH3c6mRm!RBjiYW3Zl{GR2tWm_E=?`-p
zTsgIn$P_?l!E*zTWEZ7#3~NINQ&z3QicxYaI>{dCpCNt2Q?o&qVsw_w<C5iAcNiQS
zNCDZHi)g&eB>2fI7`{T)SlGv@f8z?d%yvbv8%Z7ECy9rKNHN=CHOB9UV&o@p+3V9!
zFxyhr-)=JNyOkEE3=z`ju;kzm**eYIWRF4VT&J{q2QH!B^9{Y->`=0%4nt_mQFbW5
zc-*A<GR^UG<i=J`@x?c4m0w{V-lDcChSKl0+4fI&Q`5{G9!!gFcnOAUo$V}Gtr@A1
z?>cY|kzX?ReKZhZp!X3!6WtYEV9#OR7>F@N8s4n6xFv$z5T3(&od?y2H@IKzk%w;`
z9g{V2rIGI1X`k4$<K}m`tfMG>#f{xGVewbcGZ}^W_8{q+GT((#H*?@D=XuNyrn3B2
zh#r#%qdGCslTOOA3V`=iz9-6E^6dcUQ3tb}bS9iiuUE`je3zA<*nI@pi=1IDsWryP
zk|5YP8)ap2(M&Kt0pIjiRY(+K=%Rq9)#u1L-VEpQ<~1}o>L-q;Acjqy-LH14w?1JQ
z5SP5nJn#f<{)`5%?j+V>4}88RnPhbW^`dM7B^|Z#x69#qJC<X;^fFGk#Rx_;B=Ly?
z6i?+QYat*%WVHkFS^KY;3IX*#dnBE7<CRJ=-wYQ&C(~DF^!4<TgyR=<V26@?lWge@
zQ+Q#mH@QD}#xkR8NycFDbg%WBl}NYEJJ=0Mb@dZU;rizlP9+^k8Q4eYucfv0z;DwD
z;`3Pho5|LP_126WD&PSJq+IG~eIv2EnJ)hC)oe5J`!AIDb&xy{jl|9*qwq&ZZ0j%Q
z(ttC}<grtEVsOrS!oi1`4yo6t8r$=2)6FbgX5AV5QiUVuY^3TCi=E+cL@DYE@{r&M
zeQ{#;rXgrQ+t78jnMNf51DsVflr=)@(eEBgA2d7$(f5krFgIg|$p~Lye`l<@<(w&c
zROc|<`5EWK-TV9caQJ-ByuKaY*z2<@XZ}n5_5YPr|Ea&2nOXm5{q<iU156D6E6Bi&
z_CM%;Ct}}gJ;l9kq1Tfd842WW>h4C^e`JdWKKFc$@N9TsHoxBD5>mazshrx~ZJVYA
zW!kBfq9H_m9&Fyn>Hd8G>aVwdD(K($Z29yvdVBcajs|FN6m;GzanHtPpBy^;{_d}X
z=;=Rrdi$U7{i@TC2h-bkZP425XS6+lzkEOU_g^mzmL8i<fb{*o-tYHZx*XxD?RUQ&
z7_C*K=g(H?#OjR{t$Oc9dWNf3UsC(ywkHRKr0bCVeV3y))&Dxl_?<jfqn<BckfJlx
z7>|MuqdRJiv_OJsX=s>r_MJ5{)QcSjuNneaI%sJSjL;bC{k=ZFho`rP)$^9y?|z;y
z*n@n(U+sT;n`b1`U?rry(?}bxG0ec&%+We>(BPgTLg%ks^)_sKhvprsbTYJVhVmQ&
zFGK`9fzpB4=Hn24B1EH}Z|c9<uZu5{O9fK`gJS>eajM8WyyglAY8@&N<J0<5{1Lbv
z;EM?29!o|5*`x7yRq7}dFw+^3Cq#ef3IfpXdPw!meGUIs_k(YDPod&D%QKsQYk{hM
z>(Y{aXfSBV+`@m&&ufcCOF`*MaYacX0U;d~*@;uBrb7u_5)rg68lAV&285c=n}5W!
zgCd=Nz&iES9m}OSVMH4sB^K4?5YCK<Rl=j5W+!_1l57%4);mu7R`MCPQ6T#QjZ=(s
zpc|TxbFd7w9NcFc9xjlu2v|f@47GC_`m@r<I#`rp4$#R=BULud&V*LnL|MPrDjH&4
zh{Ek3rlwMjC+qivAXbu#=)r~Joybka>=Z<4mhqBei4)XAyt>ICTb|UEvW(z~GLU;=
z&8O{do2D(s0)_e9nZk@zW{t)*a#a%a30ko$0a4a+Z1ER1vO_kX(tcJ9z&!O@`WMmF
zFs7cZNBXeZTheME2xPc3cJ=MkMWLihO;@QTrByR^+Nh#)NG{%4-)nNo$tnb73p#VH
zMcjk4cv=bbDU$Z2gid<4+vTqAAgfRt&<<7_bHw`r=+Sd!yNGzl9tptl>O8nx+Ry=i
zO9ximnb(nX3PY-unxs4~N5iw*I0V2tYwlc_A!R5N#Bo?wrAte6EXi#y0O-X$DyCJ0
zFbh+^xnoe;XX?h4$Y~7>JtiuVSqV$X+>^pdtwn-BGh_S#YA1GA7!hCQs9ooHK!xI$
z_M&5$C~y(B*#MZSi_*sne#w3R*g3kM6Xb)|7SFPap#>rb!X7ad$`Dn7ZOGKF6gRi}
zUcD9vkb1}$3CzI3P3tDl6Zt)r&VD@jd?HtI;t(rGf5L8rI0WQrgEu<rM_>X^PZ3V3
zA&xF)huGM=EHh=CD`pxe0sTptoV8#`J#gDB`>rupNs78sf7M2>hH+<S#wNv&wLT5g
zHuOMkaEf{Z>mYpqe}Zn)lf&?vzKJzJMxH>1)tF|f<iL_ySme>!Ah9W0t)kQqdj!TK
zz<KA4ix6QFGCvK-P)w_bL8Be6fC%YeswYa=!PugX)mnGJ7y0=*A~@13y}~)t>uf==
zNDdEbG5?I2{fKG>_SklA1;#@71A^_Bq(vcAi9BH@cwy(L+hrzthlS$sCQBAh>q_7+
zC%9gJuT4{_@3=_BY;G@f!m!^tIUChnJ<s5E5IL$H6y-gpNh3ShILf2rUT+-WizVl(
z<+0AH&^5Q=>pNG37yHslnjjE<Bo>+=!@(URB4TZfn{8N7C)!P-t&j&%UiATUHN>%9
z=d%@?=kN|r1d_0KLu{mI*`8)6p`q`wjTEG^0yVgJ=42t9uufi5_pE*bo$%YPad}ED
zq*-p2SmE&WKPct1D)E#mJNuGaA$GcYiMITt^1PsYF`f)##r?x*4&A)~t(2iJ9k;(u
z^iq${kpOKK1^=Kialefue5qOMI_Ph=pQbJKd7C^&&2nyDu^m$wv!7Q{sljs|<@a3~
zs8Q=1)5)rzOx1!j#}6jvTjLLfIg_a8LSgd6Bp{EyPa*8RAWj-_;%s7x9G_CH<!ib;
z>!@of6&MB};6;i+AY4lpLjacP2c=*sEatYucfjSm-(vG|{SO*70iLC*D%-&lXsqTW
ziP0C}%@D<MKkYz@9#9VF2bD&df=Ss8xR9bFJBnfiKGg=RE<4AXNHKPJ)HE+?Ww3KY
zKaDaT*r5*)%xoJr_#sgK4N}5pr7!(U`w7?)goNRaIL-w$Na7g=77J@v!mZsm#N-&j
zg^r5~S-Q^6Mm81Non3krh)$Wp?wySi27OhtF|E_wHj^fy+K84Zs<wB>W?&=s`Q`9~
zSO5SA42HM?1%UT7b0$i#0>+q^I*$;;7}lA($_hI<F#3b(G#v+)5m<Tm#?p-U_sLvA
zVTU((zDw*Y1d%KSAU2K=VizzKq0iB)aH36jFvSw-K1`HL98Lj*<FO%1B{#Qi*NS7d
zrbQAejLw!yD29sqIK@Ic^A6O4!eJOSpuX|=oq7lk5y@uD3c;D$7Vuk=la<bve0cA(
zf_QMUtuj*^TeyZ~yAw&Xckk(*#(R*pAN+d9fulqvj;GafgYkkSyYWa!>qxhtdE2hw
z`8ARQ7#FuVTtPC&<KMz%^(g{i>DC!2VeUoA@~4z3abcX+<zk-Eu8am`spdT4Q@OYJ
z;F(t`S>T=((NMd9^oL&VBh!P|i4fP@373Ghp{%jY@BAXtT^l5+KaM0U;?r{3+Rubc
zEh!pPTJtGY9J|U$Lkh$B`Jq{s-NhA~#QP{#ZQ^kX&Hl%ZD>4VNE!EuM=}_QLa}H!J
zA_^p-l1~Ux8GjM#@Co&$;5e3u^K)>LPIsf<PYgf29dA|=S0E}oZFWuB9i^uBQ{I_R
z<B*%WH(6|cdCms<N1L3vsS;#AMx_KheNYxI=s@#t0nVTfe8ezb7Geo*w-EeBAU<Kq
zhqSsf2MFhD$c0grHuB@R894Q3v~HK?$w8(&YJ-6&qKksnJr1|*%O|DoABircZ1wM4
zEkacRA~I><WEAH@o}8fVF24!WoPyU-*F~Ro9Daa&Jhjh2^*O~oorNcMPI*-{oMaYQ
zshA&M=kiy<z&%n@l+M)`IIQFp)9%W{gc8557E*BqyMhY5xm*FQngA|FKoML+znMtj
z6EH_bp`@U3*6rgl_X%GlvDK4b1-Ahodc*CS0OP;*t{l6KnEV)avOcaA=d%ofIw+Xs
z$~#8ArFLRrMIn01^LRd-CVce$v)Utw-J&mN?QGsL4B|u@A+=mS>=sK?;M$!fRd~>}
z3VB%Sgp8-bj`~X#L(P5|WR+MGy4!)yfb}A8y$<&Ga8Iq1^_wupK97lPm7WLvxB5Ae
zUAkkK_hROvSOO?TIwrRlE5#M<ya+xWIu;3u!(2tZQ*sstI=Y=1cn8ZE6pP^Nmfma_
zre1!<YK(QpKShuF5s|eBi(EKLoDretUpPpvi@%xYlr(Jw$ow*Q*|rQ?>~v<}s%CQC
z4tv6}_5ZDgqiB}>bBZ)F<X09$`5X+#FxSyvl#b2pK$iuIV%qD_VDh(7n@v74X!9gK
zOCV*s%CKW4viJ}if7f?-MYi6-|9Y<dzZ3Fo?Emvz`(I>IObq`knbggHu+N&Pe)al^
z``HPb?)``fASx$8QGXc}7~o^!FJ~qwVm4qZe)pVjy>8JEGk1fbgqJr}6Ww{Q+|w-F
z4#WNXd_2CNmf`>WKFssu?)7!`d>swIU6a6ht&w{+H1o)Y%m2acdw)I{PsjH8Jz&4|
z`MF;`X<rA{PHVT$0QBekJ~_Gh7RAmm=nR;=`-8`~Qx1IAu=DwfKQBgmY4b!hCpHwW
zG@Y0~>&toBy!w_p5I;TiU2y*m)2|(zd{3?c9QJv)d&kbMON)e$ceA;{G7xoAF=wQ8
z9KtW{h?XuYV?O9GX^F_pw@<^9fnNL&xOM=Dw?q$;oz<L?&foKUd-C%0*jhgF>Hhn1
zp&s;oarftkJ1GQS(kLKlD_I0c5=YQL^dHF^o@Rt89REFZ(C=_YZ?}A|J8hb4Ex|NY
z|Al7s@n`)u<ie!;EP&TQ8}b<Ja0mSj=WePK%+0MW^yuHd9u$}Z`)Z2bL)Jgk+S>gS
zlalc;e!sfASXlCJ+O2pKJ5KF@lJB0SXXuDw$d{7j%X%KiFY&Acu?8PMwDD(o$i#3$
zB1P^+tUXY(j3e0qrc-h~5p664x7Oe`$}X(isw>bGneOiH65g5cHHAlqKX-46GC#I(
z>HaFiFlsvKE7H(ufMN7TvX;R{N(tL@KmW5^v!FT@xN<;^T|{%mG*TxqO5p<v1xN}$
zt}YXlc?l21{5Aeo)z+xIlj}X1=E=SF7P~$x&QZO?5T~@bBI4iAU>=|{k?FG~JLgcH
z$ejD>sn{szWm52sD>4?1n)91Vfyk-XCwf<v*XakTNQsq?7B|#^b4HQzv@LK~uwzUl
z!I&<h06v!hAw^kB;<MMPCZwCP<~}>K>cFr|JeYc-mBMo?H#rf+i}0Qk$DvXU<p^lZ
zv_xAhU)Fq(7LWz0Yvir%t3EZeHlS~5=FHCS8}479mf4+po5_IAtd%ogrPHgV<8ExE
zm87si03pdPEuOC1hw;fCDR$(n+ZU+6irQOy$l)^T$$ZvxmiX6ClwC|*!Jf{Y)0wl6
zCO_Z~H4?Gd!}HbbIL{`^-L%a?A`%w&7fDvCvTgB=qc@lvw>bNF<w5k0lBCPYa2_e`
z@WJE@Nez>_WFKaRw)23j4q->L6i?QHdNv`M8XGEFYuk=P1Vt$7!Od!GLryY8F!wWd
zMXCaD+#l?%X_^u=qS;8Lm5Q_JLbId|7%xax0z3FaA_Z8ldx;>K*K=m*+|hI#4ipKI
zr7TEX_7Z6n%~9pg-w(=qz1gq;A)*2cyH3;kOgmnv6Yu#pFqV`Mf=!Jy-8y_b=s<_|
z!nHucBBJ|w`U+$SXN&6l)hCQM)8W9DbSm&ex(gq1asA}ce>a_6W70Mw?S?f8C>OCk
zkyuz7uma)!fc8L2kaNOE1aGHN4+TimE@~LpA)q1AAj$EGYuqq*)B+8I?hT?4moi^s
zOQYFUA9Ek$bR4Z5GolsVU$J<}z<j2)=}4;#pSQIRi&_bWO$%j`86ahVT-?a3(TI`2
zfp`d3Mjv(5fr4-gV*r~5a7Db#I0s=#R6A0`_kqB4%*EI^#5yk>ue9NR_Aq);DbVYO
z6@yQacE}^i(PFsXuL*;Mbd@X4{9~~2j+Tf5WKU<W^g*sSTe(N1QW<Yb6GeaoAt8$A
znMVLq6J^!4VLwqfX7b(waIg@GR~B_D#h7Gl3{S*&1=Z(_VG2^}EI5>}&`vS5;?Xix
zJP9xFz09hM8_a4NoV>)0Y5}U#PumW;ve*b|4_h#l1R5NgrKBjIa2f76IE%Tp%M2>c
zwwj#GWfK<hGM;)9P>4Ce36rx>^Qs&ks4YXzD<j$vP9Ep{<reAv2%BhTN9sEb*glxu
zIjR~k^<8yM6{Ou^1lCq=5#Pp+YI~b>kr$*T7)f`;h^i3XR(duEsI<<-igfoT$0AJN
z9Qo1%Np4l92H~8X5|sMJ!VGwwp_q;8k(zHLLm<?0c_JA=HpHy#S`Wk`voS?~h8hNU
z1ruh0scgroX0M0S;GZ^6BW0V+SfH7SEY*raM|=WO)gZy1?x%PQt)R)mI@OhHRFy&<
z$_KJT@8T>aneWkM`&>qhEw{LN6OR&uVkxjxSRh;1WfQNbQ-Me?y^;c6mqmupscj{J
zd)uk9>98ac3dJ231t|eV;%EkK<jOi<!blaGqcAgN$btI49BDys<Y-VpUv0Ni#z5w_
zdd;#E>C-Lkw*lvrM1a5zlnrvZ3$4JSM#x8nU*DA{o3-`2N@ypQ(E_vkSI$U2jn#BS
z0dtal9){qNBGifnRf#ya=|rnRV#godb*5Zw3`0IeV+|W<1kSZ6w~)Fc^R1qDGFQ*<
zVN03-1~JRTbDK81tQmyc(||+kQ_CcW9sTT>tz#FE=<I|;h*Vw|9SVQcf5^@pBX%5R
zmKPW)iHXDUKnKyRJxzY>Mj(0ETn>XXl+&8?#dEPq`w+HS19#c#DTl@I{vXEPF-DYb
zYu8@Q)wXThwz=B2ZF9A4+qP}nwr%tDv(KCF-O1U>xBpct^`la$WR5ZCJ+4c7AA~~)
zOncIox1F*I`Gsj>L&E{{m1%T5v24t;0uhDX!~MWp<d_+6NB1)ii51i#`W^Io1HK^<
zBQNDw*kwC{4|OKJUQS2VpPr^C1M0_R#8zsJB6#H|icprUYkcCYVF@Z>4XaLrpyCkc
zj)EXKQVdtFzP9NoIbKoH-9R28YHY)XBh#`m6M1qBdvW_JKuJwV&^H6^I;>*zVfV_i
zxc4%PzZ>1!_)CgAP3)NI3MEcv?kVR{Ev44<C4LLik$xvK3SBnm30b0X@~$&_V}?Pt
zb(vj-K%Ul)c+89|9HNaNl^L;R8Z0;oG7N=f9HJw5VpSZ>i-ra&Enp!5W)yd-H`eR%
z?Ksf{?=ppWzlR0}gu&IXDahpVDJcgnDZ76GT`d4#Op=iqdXLXi!|OJcl3kCI`#z~6
z*Yzt^Aj&7VQ<LJdrjMGLmof5mL9C@a$O!pmsDc{ARLE(`o(2qoC(N%&TgHOvi{|~J
zg`bnuFP1K~-EyM75xAr{dUs1Bg%Cg#L$tq5R&;&J=poP+P|0_P!fmb==l+yBOqm%h
z_SDjDI|HYafjVbk(^H|{YEk1KYlS~4J|j2G^?FR$ni}AYJR|4M)&`kfxPzFo!N=zW
zi&@USuVMaGFP_Qi|HH1e*FT&qhYx~NEg)vZg`f{GI=rA52obib!a%K->_+HYEHrO&
ztvFf_<}Z_}Y&61CC(1UUAO?6x`oX0%uQRLgT$#sOz7bG!aZ`6wBf<oW-|+1h>}Szv
zb-z}U)#4PJq`AGctWXuTUb=(H%X#=h5hy@Zg2pu-PlMtXOp*?IstCaWY)#82t)>@M
z`IKIM4U%qN0XJ)Kus2gM-OdLUBBEGW1xTb9$w*o9En_!DX;<F((uj)O>YX_PljEar
z$|*z)4k%t@ghAI&#*-b-%o#11qPD1>rKw!$g%S;n*;5Iq<&sU2{T;4}GHWl`@^u`U
zFA{C)NofMFP{)4|;2~{6B<nR;S|B{GESsT6PS1m5mFP2oTF%@UU8$>RmJ^B!(^JXS
z12NLtgq*_83&821bvLn)!pYGAJuf7F`-J8FqE5}p>-8@_h!%#oc(DUT^_Hf>N^7)+
zRxc}UKk7fE<EaV;-#kTz^zB}Nlwk04#Qe?LWWeNFhNzW)1go-28cbyowxVRw(ke!%
zavmm-P`-fwoL-+_+sZJWR*)103Y>seYe92}+iI@gjYZ+Q5C2f%ny9Pv=l#{JET$>U
z$H0q|5c1p1?6{lN;d6lSFF&`H_T`g}S*Ovc;v`149obz7J<Hfk)N&Df@elmQ;ykY|
zo<0QL%U1fU%`c{Ex&GM}jEe?97t%^$?~@qVn*<oA*!0y>hF260N}?Lww$HXB)6Rv-
z27agQG22wGVal+G8H8r^8DvU7!(z9|49T6uQfB-DGHqSUrGJEW-cL3AITv)`>NNU0
z@u^>xccfG7Tuc5y?jk0SxQ%~2%U?uTR%j}%sFn#k1<?ErM)Qp59`zVz+v7L8lx;ms
zaSMR|<(uQsC@4ro9rv#CIL|uOP%2~9vBD;MLpOTNgm(pYjFe{{eogZwE%o1TO6tGV
zE-Z8iDlAR&-`UI{aq+yXNGt8{{&F#BCULDPGC<)5%Zdwm1|ts7tlDH8m-p^Km1j7+
z0NmT=B+Hy<IRd-u@tKm`i&!ONjc2HQ{gm5ExoNu6k`+R%;)ugA>cHUgPxz~Xoq>np
zJi>HG1~4i_iTkKUnPT?y6dp}=4Fj%`;s=0P^Qd})RKoUL^iUDPU;9`FOLBdt8xaCe
z)pIM8oY3T6r_xZNa^Y+?!E)zS>P8sbp7JO1s#H36v^rH8Vnpo4Cv_Cz>vQRmTiLWu
z<x!LILC_vTO2LmBQGXk0Ur8^V%>n`#LdRZ7qBge^Laoqbz7`~=L{XVz@cwW{wNdWJ
zL9I6;pX4#-;MUD))>z@d@5+8Qy8%e#(C!K*3b^4(d9MVU54}->DIbxne+v~QFj?rU
z2jd!lw^6Uu{@q_nnHph?NWZ<UsM<L~%6Qdh>H%u;Pkcea8S3tvNK!l8PHVP@%AxzJ
zfW5!1m?ZGRy3TXZr0@7ki}vdX^MWyvZ}+_4=hqN`o#}t<`u;!J4<i%n|0;wT=-B^X
z*$)Ff-G3wdx%@YU@Z|p}gq_<=YW`6OpWu1cP>+s)qSFGde{aFRMvRCmJ(?1G!uc&(
zyBt#fOCj7i9?$mqzS}=6%j^BUnf?8?fBG7J-rp@VZsrz8x<47u!CsxUG+%5ZtMmEv
z(BBXF@wI!o{{8WS+4^yqz5Vh0(*zDaJ~z+Xw{mUI{pfz?w{fzzag>4T+3>SJPA}8v
zgH@am_8y)#myZwK-4aaf5SIrvaVFI?X}>y5KkQ%8yxpO*-}I-$p=3*59B}ZdzYcan
zMV(~gQ^I*@r_C@Ndd=o@=+ZT5397NWR8KN)m_A?}TF3K)s}Jg2Ga99S`zXVpLSstl
z#5a0osF&RxW^etRuG~G{7$L3w(EN9C)ztkYB#F$(YoP+1l4QI)IzBTenBcmxLUqLH
z6S~xQ(agb%`zxbu2t%-C2;(j9=l7CqgvdOjBu)*GMd6Ax|D>Es+#?;Z?BCh7X<(sd
z>o=oavsuZ{<(`pbC8}^tPJr;h#iyB<KE92z*drhylU!KmmPb8}Fi+-_aJ2TYm%3`}
zbvdS$7|HEx)7+$Ya<wtlP_RwdN*2K-a9$0DVzzenTI*6(;p>U1M{V~!5f2q(d1fBr
z`&l7LN&3PPaHt8H?7r;n%@`W{Q=1=&T`jESNe6lf!Jhy_X&7fq)t=l}o-k%LV=XBW
zx-!XW9u7qJQej1TA)TvrX%`6gyCKE#$TIO@LWQvO%L^o@0!J{&8sh<E&|-dwDXGi?
zl}T|Ry680K?U^G9^C{|A030zfP8n5}p*+kg^jncc#6_vQ^at+;?&7A}k`E-vU0%rT
z2{}I)gZdTP!~WoC2il{ju9$oPa^j)OW=Ry7Pw7BU*+JD7*8%lGpB-v=gE?flVp^<$
z1Q5Erz!qjg#(weCMRbR9F?X)c8tqW~{z6L=wNVGzYEzMB`Q3j?U*asZp+VEt4fq5C
zBc;HY9Y>AK!-*MldFy<ml#JaU{L2WY%Qshws{pcYz7j9mzeGD$C$>Eq9b^F*<e`n=
zBC4Sf131H}DMu%Gtm!wW2va%8De*AsC9Q|O$Rb-!mmu#TAO9#?Sx%y~Sm<(=-BImF
z3}3!_LTFaoo5&00Eg(Eg&_O?OwPM1>+8NQT7TwH{wx*(!P7`x2jR?2r5$wpHd7+2_
z6v~v%E{&N>mgLqSL|~v;j-F`79o}AYIFPaen8yljO7wi_qvee)8^=9HNJU?*f%}+#
z9f=lYg5rh5^40mE$YH4aPFuBKuwIharKy!1$2kA&a3zURWJ6R-$R61k`7&N&zfAu`
zW{{@3`*qv^knZS^Wu7(Z4y8P0&oF!dF6Z0%OQi;wy(BsaO=wSk4(LG~{1=d3x_n?@
zJ^;+BIm{+sQ;9BQp)3E8+*W3RPjS8PrDBiq;|;n{hhNC;G@fC(-trQjSu?~-`%pRW
zy2{Ja?q4ePuFk%teZe(?G<LS2p<><UCs0vlNP#S5RD4^U56_@g-G~8V-DCB@(B&3Q
zPpLfx0$J=PKoMf@sp>&BZCZO_10=H$f81&7UhE#5zTs`nng(mD5Ps*y*~vnXn>>v`
zC{{6S=cNj8k<dZFjhIqrtvonL*ZSGLfpym0<fB>IU@Y8-+{e@UPxr?I(DzRa15QOf
z^rPDPTYEKtc+&RiD3ZB5!<kh3*#VFYLF$l?taNnn<N2D4;)jT_V%J$zPO2ekY;#{k
z@ovCzNS5Y0GV`7fwG<YKp`0Bok-<37!GQR<3SY1S8#TXcIQMvqO2I)6q?)urpi2x2
zw$Z|col-h~vzOxF`^y)711vI){qWxj6x&^}O#be}P|J^FE%D<tc>^Z$O6pz#*SOCX
z=U8G1KE=#`NqWQ>y6TIdSJY1VybvI@Lmr<7%?cBks%56}#Hu}+rkmwNnWe(%i=Ibp
zM`vafRz*HFv@tx}DW1+$hw5VPUYda&A4%R{0t2(IgF<9BO<lQ30HdkKG2If4$@#Uw
zpfcF=`XX~jXfRoJW+r#$o-F_56<OZx+Clso$DkMz)R+Kg`6{YiP659c)|Ik*QxuCi
zo|rE&eit5WWL8GsjX+i&N5#Y1zaQrd76By7cuF~aZ$0(rWHRs+x!<nQ@waY>;<0=Y
z$kQkR3Rg_<0-0Bl83!Rk)YBD)i-8;+Yu@TewE_nAQua^vfM(?2ZI<8PkfaeiZ{@om
zZCDbaeDP!!k@Q*|>PQ>hs<5q3R}r~wZE<DYWM_q0P`H^V@1u3auXECI;9D|YD~p!M
zC_$T?>S^H5;-UdpK;02EA6N>-^Vc`Gaj#c_A21!@k*z{CR$Q)<9gsyO2Npc%X;zA9
zAsR?SOS-^+v&*c53oK<)%JyY&QxFmvmcYE{K*0XMiUVfn#Ldth8`_|l{*y$y7FexK
zcARF;vb4xtXCa9srJ~MMQ*-exMIASR_$cq^b7JE&EU9ZO+jM4M!!mpF3iF)3yqZST
zf)EOkuuv6FQTqO2mwtNPaMAO0O%5cladl%g0Xvcvuuc~g88C%y?S!LrvTJo+`kU^1
zX&dXYPr!{w5b>Ht4wctc>cdoD2&+OAkFK;73i87G0H~>sDYDLoiev3y<%+C^wjZKh
zcxg`ZQZ-U5L@#!;bvGjrcCo|8hg`v?QBOT;Hpo&}$t@i9aCRWYOcr38&y)jhAxcEh
zbWNFr*WghbsvT=@Oc&OQzJPi)!IfZ4kyOhexIkOZJlY;S{FZ%n#tX|?YjzPTN{|}Z
zssd?{QuA`1@{wm<C=f2NsVRfjK^6TQizc+>!g(`9$wywUc}Y=BJUFr8+{A!1Ls|NK
zm3w~oF$g-}-oJd4kpirdBma#!S1?rF=5v*%q?~Ob;5TiTg1(E+uGU1m4-+tRW#{0z
zOJadB{b?FsBzUCr@&ja=du}Su)G;{8wpw*>Kui^DH}Wea8v(m%=nt?5u;c8UDvdcP
z+9Fj1b0lsLt@H$Tj&Xp}?&xqTgYepbCa5UN+P+ygXQIuegr64fQ&OV>rI0r8c*dBT
znAuJnVd$_UIBeedK!a61@?)omb0y#NSkWbHYXH>MW06+jq3UR1FsqdhI(lFLDC!Ps
z#Xj+^3c?ABP=`|FD_gO|O#@ikdqA-)VZ!0#0HHC3l?7kaS`wvOxpZ5u5apidSD~cH
zlS6Xp?zG76R7O|HNB%H9E!!H%BGz&?HVp@6(%3Ad8xvAj|GntgjJ|fGN}Z%^cQu3-
z35Tlx6)H*Yurf$nPeHh=TqPS&Y<jJifV8SAE^_V8Vgz~!az#D2i7EF0Pd}Y%AjqCj
zd5Q?FyhVt15W&h=w`9HVRgzx*1?PubW8Y|GM|)h{)LcV5?r^P}0}$OQ&hQ&q{DH<T
zgcwTQ<2F!VMogz6N8u503euW-)9f(u`cDGg4cc#g_sDhDR=zUrG4cvIQqt8`7S-ej
ztV(bSv8n|&zQK>}IQ~~rSGHcvZmJX%qqe`Kz(v*y*GT1AxE=^Se!*}$P0jcLrQf74
zVlH&wqzfK+V>ukPKu*7kvC_q=UCJE4?C3lN2kYWGk{x|7YL{e<L-v$uGA&U?hmxeq
z>`1g=#Z_}&V#2xqohVHhv&2qXG;2kBAS0PJMgKfeUp8EM(+S;hn?d>9BCn{60kO65
z*g}vpytO-N+**;UwV=cx7gN+_lTBeF^ZBos1*gAW3g_vsBadkzy5AbLZ!3;w@-241
ze{me_1hoFnrrfvS>L;{t-XZQgwfIe~blAzm|Er*?|6c8|qiZRtu$(21@P@zdMC@Jy
z%KlVF(DlrGtC5GZbUCobcCGoZ`t12o)+X9w;pwV{Pv^RXsj5XVV^ax{&JL;K8gYg-
z8|ucoVL(O&439U9ekK@^DC;~%hXHwUCQOoyPg&dR4?&fk&qBWcmyx$_0_)Xru%5k_
ze{2V&XghAH+ETwfv*B;-E<gknt+>Mk^!*Qq#l)0fS0LTRZSJS;uuZRP4XeWZs)9xN
z0laLX123BZeY6R<*OnRY611BO9ltNBh!U+t;Kcvx*eDSjHZF@B*G)6lZZ%{CT6pgI
z3T@wGWNuNhE9zjbMEwn|yWepvs}z~3m3E=Fv70H-s<}MIw5t|;{0RzI3o32SU(!{~
z;$^WfKMUF3FEN07c6wmHElVwYrjoJy?CP+6-yi1INH{GKhac$Tgp0yh_0|>TDvnT-
zqn?ampt8rw$MqBVa3yPTP<xrkhe|ooRWhl2veq)?RF{kp>Wl(Pkq=0kGvYYU!HcZX
zbET!G6?xPI+7bcr5>hJLi0Km6BBh;=j!1<|FdjS0HY1$RyBcj>aCq}SY&K3O7@s2g
z5KfTJN*^v4>gHj7i}e%eS`r6Q{<w$w{iu;rTnxd~+{=7muxwkdQ>3dD`W%cQ0Cw3)
z*OGG-SH`u>OxS6OL=8T<(Bz6a!r=V}UFh@NK1<0*&dRKaS{st(g4hzq^RW2J%_izg
zQa`{>*T=Jtei1!6i9qF7A829*>`huX(kUY-vr9JJUaN|IxKND@1)o}Mt+2}KTg*<d
zh#QQf8<3X*%JY+1VG1FzGd3*i)bu_q_41I<Lq5%aj|*(*Ylis^j0PKEgqzgw2IvkD
zq?GV!h?@B&k%4!C2hjU}EGDsAr73Lptw-kczVJdP+cuJDhxxa{Y2W<5Mk(Iss5u(y
z)vCAHxy-?RSkcM)`n^H2k^G-p$^Y9O{wo;A%>2KIZ3cP<#{b8@^K+Bwzp(H8doXTt
zhS{AGM4W#aa=j)v5EK^_*SWKOh{ttRuji@TC7>Wdpn9Sr>&e|J>2DsTq`b&aGVX<-
zKu^^BWq3X~S@x%o>}U1)@?`UIa(g@dIYcCbSv$?=QYDR^-<^LB=KXrQc`nBMX(b=u
zeZ0RSb+^A>HoK2r`&E*+bzm<XIdt|FU!G5CWsjFht#peH_fBA{x3PIP4*%ZwpTpvs
zc=N8NYROFNAE^|{PGjKqHs46q#HX)@`{aC>pykOJ8!OX!AEJ_c<d?_9?ds48?MD+#
z+!zG1bC0L8f43XWkFKyse$AibW?5Iu>ZmX{3`^z?5-_#D27a3R`2%W3pukVyD5*FQ
zP$lPtPU%!n#8qE})%kl9tN=IsaZr3ixB%G4#xR#dbAo1BG^2_L1x-S!JdUKOdU+@Q
z2A5@zzV0NtM{a^$N8CnBg1OcT2yH*@_CUAF0C(@rD8TUU+Ie~x4hYz$eOX*rk|_yP
ze8h>|h=SdmVsm0@ysgyH%HUgeSlTBp2gd=j_J?uC#X#sP*GGuu<!Ks7Fa!Ez6161m
z&qAQ2mBE%m!^xaS5%ti{+wBaH&$2z1ryD?}+TY!E+}lCTVZZ1VrsL4Ph)6V2zy3g1
zL^M$a1nweYU7ry#f;IO%b}_d@r*}ptjAm(>0Hy%~3z0EE3ekHIpZGbb^=rOa-MH04
z+3e4`I|Af6{7v5eVWd}(ni#R4EDXgHD9er+ENC}-gSyf)bp%SNSC%mtKzQkhV2Se6
zVrd?{@VGjq1m%G@W0Tld)XP(IV7fv#Z@ogQ@-G~<MWw<K9pk7Md<M4c(YO6X((?BW
z@miP2{>~EyMDMOijK~RvgDs;SR{NY!r|6n^xFb%JWZ~ih$6D(;8Se<TP$>UmaI|*|
z5ri09EQyI!-s=I9NRhmlHnHQqH5){O>-Tl5r2q8_Wmpj-BkEAdeio}H@P;<2m~u2C
z<+KCU++)5!F-gIG+OFgmn%tWtW-|7p&5~X9W$Gnj$sv#;bgnn8voMAw{9VZi*L#bw
z@|(lrNTN9$VSk`23V*G@*DTSEQZB55g01^6%bX}c4u!rnJmFXGp5p4WrE}+E=e~L_
zj#`D$_1=^?x$U(`F7P`^yF_nSYR1s#ZxzX-!c}rHwF`nizKxMFG(c8oJwb0OHHZ_f
zu|=BW{2c%WXsn<pm)<3~pX1a5hO@jYh>5~$bw4|*9mj35uu}U%ikOcitKPIdln{0`
zL&T*7xcp>-zJ{8oH~_Rym^+jM@-GB8CS1V4w1wK|GV0~ys$GKwv@FO0A`i7Bfc9tf
zj<2?C(K0(f!;Z(RrD)o4V#LY{ghE;wsi;wm1p7HDbOj>bTylpPDu*#LTWbjR4Z~an
z-+{oeJ2UXsz-VGCp>XaEX1@N|3#pXif?I=D^U|X@@On^ZVw%D{jX%PL@-CH$zAFoG
z$rGB;hR<@oH($n}sfr@VAL)<<X$0x*h1`am@1dSZyiow-L~&d(1^mKNH<KHYEA#UW
zaO)LM5W~6?2CUZFGv{gHr@7iNjNoqbB>L>Z+(B8U{R|f1iFLlx%u;`e^mY(<Lq~sx
ze>GYwYJ?4Ae&sz%|7Ah8i64I|EU77Yx(Z1KV&U8%-mfF&B#zZYEbZwApm%Xg#}~4r
zxT@0%tB7e<TcU3fC(tswlK?g>w3R9(-~CeIu*fjY02Nu|7)h#M=a@utCL7hZ;zL*<
z92%heEKKHt>%dxJzYclcsgkhdM%LDQK4#~ha8O?-f%CacX2K4_h6ZJ9swGXm-qf8T
z-6nQzsyAYrn|`ngs5zOeM&g8EfZ3d9t}zf^0j|>I2p8BLmhvvdk<=Uj<RXTMv%i{Z
zVM+^Y+yteAdCDsuX+e`x11YN;mZ)o!ZkI~}kK~3R*bp>IHLS?cN}S({#2vXnC~0>e
zX_0qjm|?w=h#P^<w$8)bpln^D7y{<Khzs<!GF0fdlr>M*R!N9g%+PxmRtqSa1i6QC
zNWDxkAdJ@oRJ3S~(6wbsk>LJn+O8sKLotiFrc`Y^C^KJnw;h^KMNt$DhS*1$l7BV0
z_n(Qi{eT;laQ_yNk%y4(3le9|?a!h`Pdk_*?vFDA8Lf_!l-%MXjJw!y90s?*08e6Z
z2n0-x!nI_dBHF39&q!IWa{+eWb_TSc6dhq?&!qHa50YE$mmse@*FDHABiV0YmpF5I
zX(0r!ZOFxN0EIwaVLbW0yUw|d)?0B17dxO1IRPm1FiBZKZ8F2M<=|D96p*cN3cTy=
zNT<@Xg7<wfLY10Xz^q>PVY5PsQGqYQ=%=Bk41{Ls<Kw5-vpE`I#|gc1K55HrUTnvn
zNC_RM*4=r65?m~Uqggjl^5y&o5K$v0prh!?AZP-OAu!t-nePCqfZbW_xOB9ZjlI5d
zHj%|g9we60VD`BcsjsquGT`hoUrq$Gv~@8Eli1pL#krPy`1Pd+{hFyDSK^)o#-~zk
zOTNCPHWK7}FKlpkmv{jmuVC;8|2${LkB=OVRw5P9Pa3wbR-DqOR{R)!dlNtSn?Xt^
zESuX13U^ytPAW%&I3_<Jpr(LnJ5pX_Yxg9sK*mIMkTBCOpR?hY=UPnZw}k~m+Ii&O
z9;7hm-hu~=VxUN!EL6StQy_ocHnY+5#+1=Rry;406ek3<0D<6`(Uy!7c++3=Ieo;Y
zeB${0xS=t7P~kc+zM<h}r30e%`e~BP-N*DPt85E9cEG)ZRi`lD&&{!-wlK4WBrckk
z#uAmr#P7p?VmItY)N!lv-$0bV(~8QFERt5a=?ES?I!|lBA`XA!*EjYiTfl_0$NHey
z&Sq%shW9)M4uD?Nj7HxsxDSAyCMPvltv*4tBMEL1%EPV2P5ap%BUAR3TLPl0bg<B_
zpj)0Gm`R$KTtj$Zftn5uvH=0lZcsD+EWXyrT&=LO+JOp(W9g(2tu!zx8^=WK(s#Fq
z_@yiI1zu`JQ0z3?n0u!Ze_HqtJlqbp{=8rx({^&#(vn8m0E_pg`>%a=b`s>o8dhrC
zxJGNEXG5W7iEV1~s$D06myW$|j*}{sES&ORw9;HPNBxXZ9d5C4PH=suS!*BltI7gC
z7dxKbRAia9Y<4@KV6~XUdw*A1!s0m^s*TF>$f4fom|*a2$YJX<FThobX_Sl<JqgSc
zF2h{FD57oSz_C1jY=Iz4Mft!&>{uwAT)xM`vb?;$uz{KBddYu{ivkclrvJ$)ew_9L
z?AH)KVGt_A&U68SS)MnD0s1svNyA+Xupnn}mZymZ2#}1SOnBV9zk3tUs*eJ0%ijY<
z05j^k0Gz`iLd*UHuS(V)Y{&Z>{qYO%mBy~<HzWxj0@o1KP_g&M;_rcOPa!deZg5!j
z$nS18{y7^`LetCHW1vHy%h4S<CO$%2+rY+{eH`$))PT)#2+Lu5))-&eGU4H85kI@-
zI1BKX$80`8gohz_vYSkXZ4(bTkRfP(8YKt01D{{N>lSPT{i2q>y^Q$^)<&V+-Jw!?
z$094Q@P)xLkJf~m$K(8{or1Q6fHXz3D|b+(9d@(?x<7Ff4n3^&aX)rGM9kPZ7~#KY
zl(Y0cpup<OTQO(Wf66ncXx$2?x$kXm%7}VPvzT9W5fz}4?IJ1B^`HpwH=+c(J7EkJ
z#ApM<&|8d&7(QMvtgtnic>l4C{#RxEPZ`a?%Et1~6aQR8FwiqG|A#V~>7Swh|6hrv
zx@7sf2-4QO3RoNEipv(^U$~VdX^jzrg&5&e0;{+=nmHEWwXgRqMp|q&MwPmAjbUKx
z1GiJoYMZGH`1PB!>c#n|`C}d4j?Y(zMvq3FPqo@GE1^Qn&e%k&gQ6;)&gv~sEiX;%
zobOZ2#U|P6r|l=?^ENG9<DPEW?h5B(rAocJLqL-3EhX9EwmmF$8C-AE$TLL?$L6NW
z*i6&Jv!xDZQPW0@cHpm77cMAyXfAbD`)KZA>q-rSTX+v$Xw6W;?sTFvnWm;8ky%IH
ztS${~net_vhttpP>~4gM;_dBE#MyfScOU_aXl+3EU@d$oP+#G3<~_KGe%jT$EUVhY
zQ<-MVYtV<Q-w`2ReUmXa>(w>S`C5$E?Iaba9)VE#8*kPH4gOpPJ$~hpg&|6V=y;%!
zX+u~Qaq<ve4P~64NtreSuHJE~OPRgRgjE=hQ_cX_v!M<51T8qrQy89>8~N#j{#e#{
z+d+jhLw&%b5CY<hzpwx$T>n%efzTHyV<sZ|o4V_h!HR>?@tK+eiUf2QlPF<}LP9K6
z_NqIP#<4z_a#nq`@iT;zL>@`D)#|F1^?8|yLKq~m)|5mlJom201ywqf_{}vmq?6<W
zYI0RGU0*Q!o0$|fPt|jmXwAu(qLD8&#RV<_($L(195B}p9S8uO9{3(clDB#k@Ed%J
zN$P_+S}3rUkwrvH@pCOgUJGIFDXSGwthVQfAyiKjeC7EDiQb^ZlgKHW-%O$DmD&uC
zpheLbY+{yjo+bT?x{mncZ}6M6p*NQutpgma)Q=kpf&C<4rvY#Wms2}g+Baovi-OIP
zM*(x%t-REZ5uH;wP7=o}B||hja^M_$sgwx)c0$?^mlRrgBNCV}0aXb&yzHKgZJkQk
zt^IG0Qu78CtTmBrG^%w(T|~k%=DjNBzVAz0Bt7BnC+iTv!raf*kY8l2=uTBHZ=3QT
z_CGl&R1;2^NhA?s`Jr%C_4XS^N_Dj{4!5cWa7FbfY58y|EUPM1p^ooTIsMzKVk(0#
zv&ulHn_P3u#yv~K!)OmXb8{vmOS;kNNbG!6dB3z!_|sEXdBH&722|wuWcJz>egQPb
z0NU##k>!ZnVXHR-k-j)Oibk|Lw|8eA>F{vY(eK}g!>lTae;s)3MOcfNEeS~MkXY2B
zOUy{foZcoS=#Je2lODc3CG3a*%AhT}M4{S}yGv+`05^eYGN0v|;_Y^Z0T<0}Wdb4;
z1On3`>+t}E0EAzW_L1v3%ERQJ)TT&!(qy>Oa4U!;{(*4+S^!oEKcH*ehoUb@lNCdB
z>hn0YOo-wR#iN=uIQd)7=OaS{2E<-`b~<`rrV!p1(Q;=0VSxe(-HcaNv<L<KKxkJa
zt7}T(Z=ql2uxnRD9*)Nz@FW<!;`_pZF)rrmLx9OgU04@^=EeY|;d)u7XqQitbC`?9
zw9t_Hf|Kl}PhBW`+P8s!7UmFTs5U=ohw3w{07I+tZIl_t#5!u$Ae7T}bY1ox?6`Eh
zuN7@G@FhtLIK~Pv$CN%S;Q+Q*jz&OwyNT}St3Cq9PJc9?S)WHsJyUEx_)^kmlK*B@
z7TTdHlTg=nIK+kP)eP2aKPh*2)XQS#_tFM8A?EoFhs8$?-5Y@xjplc*dWW>LCwD!q
z)vxDfNAWRXO`RH9*vqfsCOlXMIU89$2AAr06qc;%E$6bC0#V0K&6vK?zZvqT!d8s9
zD}y*iQ>q_e@pw{d?M5zVu#l9xSAFJ~PE#7@s8Ur5Veu7h*uSWnXwuZErp>o|C|@@7
z)Efus_d;PjF7D}KOqhehpdkYV%b0;vQaVMoe{J-N5^<{^{Mu4dEG8N0?Y&@!B-fEQ
z`Fa8s4PL0v?LcRDYww!#dFy6we-A9k4tt_tCdAO;XFb$5J)^1pUQe#vYD(D>p(4h5
zkiiCadbHE+LLjX9!TGvihW|UUyrp9{-s*V#2=C_&V8(vl0EQq3#r}^>gn%<M1wG88
zFus@<y?1v)S;Ik`Ns|DlMoi@Wv_$c-i^z0>HON++lu;Hwp?3J`v#yEo>fAGP10bcQ
zxCasDi39JORIxbv%4(rnZo@!x!`{BY^E>aBw-kMPWe0>FD_$t#RHzXJ=Bj8qPCZI;
z?Sz6r69q+rf`f>~Y1CJ@l`46!j<Ny5AqL_ym-gyrkYBTR5#P|^t-<`bt8xOQxMtXB
z(@Ws}#m^6xHTm;{W&I#Q4p$@4?u%ETT00H<Sf3_Nk2ef-8t_}(7TN3?P6HgfXfyBI
zLv~z&45E(k&{W^?pjWC6XdA^X(rSv%?69E-K4kwMUqqrz{G{D00@a|Mnf?hv09{kX
z`9Oa$iEK(xryH^%y*oY9%7jpI{l``IUkm3yD=R%K`@iKL=vn?#?t%5c$~|aEmJ_xj
zZ*A-7jnL>eZ&C2e>9$+O^-zJ*Oz4jgj7|g?#>N!kk9JS9yO$HG9j?2$Bg{cLn5`?#
zxt+huWD=0NzZ{PT-w(_Byq?1Pyg9abI(WSf|HT>!#V&{?^_~gJF6tk~h28#qyJ=4T
zXRC@;Ka1DX;q%fRZ`@w(6Z>X+n73O~Tc^MelgY^T{v0+K_W6{Loa*^){<;2VDl<`Y
zrGo7PUY~tVZ8JGPqj4Y`?W>h$L5ryBW%jFr=|h38BTE{RvECTcgt47Qb2_328>5Tl
z1%&wvvJ0zGLo7USdV;Fk=W}!X^6^lkc=$Z}`|aW9?BeAa_X`^-Pb&~<g`Xpkjm&Tn
zz62P6ctwg>0{lHKwGY*^h?0FDcHoOoj?><5xlhHOM8#u0F?%!8w(+U_1-Y8Y(+`)4
zS*Snls(4Yy6m?E&H|PexOl533ge_DP;0P&&T|@hOt*hVnS)Ib6POKWy^q1deCEpV*
z*ok5{f^niYdNYB$S!29Q<1*RJpSOMGAKGfFZSzXv&$ov@o-n=~4P4H!OUTYssvZTh
zhHUR_BpdNaz$U$*t3vG8I^@RMOz%jzT(SF`f|OFnLUuLh{1>t<G-F~2NY~;r|96DH
zx!V5vjDrr+6InqA38%6C@Jndc7!dLm^49R$7T=&$ap0W*n2lZyVc70wHu~IkZYFPJ
zbTBzba-Vup0s!imCJ1FoP2Igj5<LUQM)^Q5zpB(n7Zv)LhRLARq%|mjRL81L_Q3Jl
zwP`<A)x`do_>uqi>f&jE9qm|0YY!VqD-lhM8$Y+0K0eyQ85LfTI8}f(Xv{hzqgTkS
zV&&Askf{oSU`>W1WwgGUv@1kHZH5VvYejMqULHl6FD+EybEU}Im;UFeU+8hJ=RV>Y
zhQ-JYm+t31U&>k?We9uOkVLQ7>ZTyC`PzC_373(~`U{QU_MxCQavj{o!3ItHe%-4Y
zDG67hS8Da3*dsty5W&<HB=Nu-Fh#hILo_}*qpCu74blD+-iFPX#ax&I6^&b;<#><A
zep8K(sLGTYI`AGJ_}SP}R8@v-bRN>wk(M@otBU6#RH@Q{RJCf%X#u8wL>S0201v2i
zAe_9d8>#?$<&IBPL|b`!2W3%Y$9a9+ufVHJqtdMkjkhh0{wx_~X-F;g-AkENsE0vw
zgqq2mI7UiAl2JD6+^71k3#W}B2a#YK%s&rl%Nrt&(dGU+ekQ|t>*##)%ElR9YEdXy
zs-wvmeyaR~;@n2e{8nD38kL7?uzf&yX0MO6A+~+9$3hDo<T*2{0;jFJ{@!KceUgxu
zQp`a?n;GLarSDkbVoVro4$`X)*7YNC!4PgOXp&AOKvG?2Y(yf`U<&4Y*fDj`2jK$J
zTXyuO^@iXhObpHHJy_7%aK(T*2E_N2a7Fn>zR!07Z6pn6cS;&zB_5_kwU%2T_;Ydh
z(?+Y5F$Ti1RD{7YAL@S!<}J@|E$Ycab;QuYS^J6YaytVw9-QViuGI4U@<CiUdS4_@
z*~0j64(zY;@TUkU(Sh>|s~<P>@(|VjRPD@1+%fg@Mi2f8Ykqu(KcA>7YgIq+83hd7
zcz*-YtlRkNrx+>>V(i+ju9)8C6SNVu%CS|(^sCB*CY@cM^5}ael&=y<Wg8lcb6fjy
zB)r`wt+bq=x*77WZ~kUhrchpV9WNII3PhLH#w(~#6J6L_$eHJZwT&7=))X@mwekvR
zVUfaXwWYI3m)Gz+Ar^pdy@SSi7lg(SpIY2kI8dV?c~2Awkt?)SEveWy-Z~hX4T9A*
zzyXLT2NG5{m|a!G!WNgAxRQDJ6UfH~!6ijqCalrhV29M*d}v6g+pOUnAC3V~yS8C3
z6kE{mM8)ataaaRj0f=R#!tyy|;}PzS*}AZ~x<|)m^JZa99m{On*0)MDW|f4$_vU)S
zqRI4YwNg}sICx&+u&>##3fk2CxkEr&-l``dBQ^srdd2`)ies19rIPGcehcslfMk&t
zIUoS$;vJyqCRN^3>hI8N9GHYlA~Is2gWG)fGxa@H{ZuX`24^Dk=(wKf*>4vZnvw>l
z^M*53ze`dowdVv#-vc8p=&JN3>vE^-Rnnm<(j4@6q(FouuQM^8`;IOBJQ+e#8~UVO
z?W7DLNawwYG#6u1xl9*+mKwH<on#(V!<{#dU!cN*WWf5E8G8Z(!NnY}x!vs7tsoRD
z9BEHO5`gR>mK&Q=(-%RDe>Ex)b?Y%mzZRxJaN4J{(_cV&x3VT2N^c;Ex3Z3lsxg_J
zO25YvMKr;^1H(356B5r<0q7CNJcKf#j<oDYQn<)1yP33F(s`uI8jZ4f&^;aJH}4?-
zkXgztzDI{4%H^)!CJJ@N3eA2EfMyq+nSJ}PM~?|@jTWRy@QfE?ti!A*nygoQo}nHn
zG|GZL23x2tW`CoK2>;|jH9HV<C0fpsi4_~ZXR;ZUCh0uoM38X~j|E8tSrYYc0rDjR
z%*Trm%&E|nG@W3}&1F%n#1=gO=R!n+3Mde*#LD1U7wPHBFdK04-*pI-8oob5rK#X1
zT*kb2Y3%CLW1c+MWZZFzk4i|x<FiB?X(!*Kvr_gJ7lg#_&9QdoB8x8>ucXy(DgiNk
zhPi_Ia_F%T8YY7=%j5m4y*m2-PMe%T4U53-BDqBTO@x>BH~RG=pRsGCVWbftAh%9`
zwMIpeVQfbGF{6iQ-nl5f%%m(wCMTU6WrD#rrN(Pu*=ux~1s&!DQk8LbVMUXDUmt@|
zb!np&tzZb09=Xe?<I#p@#nHHD{>LJ<zys!luOmgQ6ot~<BE}VHT3TM|88hLSu0*n&
z&AhNSoo^Bt-vx<lV$7I&*2-$Q+rludl0L-6wD*f@9*dU{>PkjmmT%;Y4IKm}yNo>b
z^M!+S@KQ#x$JyDowakH?vf^WASJz_eT2gxri%yhxMQdu}pnvpmMu(l{s8myfV0uw#
zRoQ|fBkjJ5s^eMlQ0~a!z6rk8+PKeY^Nd{4<>_3R5@c3xc!aDZrNT~xJM=kViG24g
zcF@$CRcmOO{_dRDp;#n{6eK(JqXBu=+l)L-*e~q`65PHG1A=GzSGHf!=kE|U5%oyK
zxwc$*b3Uv$lk{g*9H!I|GFA*hIzO%BBGamQW%-b;uA~*Fr%Tpmwm`g-tM*A;*0SX8
zyf|zD1KlRZOCWx4Ixos}^}DMFYVvEbR*IzI*Lfcn$v~*h>*<l~b%xiKtUe8EY?i^b
z>PhI)g{dU*?_Nxi#iyN*jOU|))#MvKB+dJqJ0VshM3XoE8n`I(SjCmwBdn=k%?VRe
zg`zfX1<NsECRD5FnKgqvNxe{%!WeOU#%&T8UM{*65`6c>y%)l@be7jp2=4rus37&v
z!1;-H&D%|fL{KktJgYN#rPn(zMGGc1JZQ;Xte%u|;$q}s#pnmLO?21l{j`~#0PG<R
zKVhvB(_2)>u2M^{DZU$K4;*!(1Rp_KA8OxMp7|j^Xsksq#9-gUJcLC|Op(n7c}1;6
zIf1QSyn(KA{zltt+Xoy)h{Wo3cPX<|0Z;s4ctANE-sqgOd>GYFdB;<4?EXOY?`cf{
z*9*f0>{w|RGF*CnkjKCzU5wEX1YH!>L7o)QcQk3gK*w)03MwlKy{_y+^%hPkHf1l(
z*=~9urO5h!!owIo9xt#N);3W8v4;LvS^PgcRsUW?v(x{FohtVK#<H>aZ`on#nfli$
z2{H)dwjUMf|73?N6Jw#(JE&H^o})%g4$8|!^SRObTbem3ac^Jt!biwzMZMpi`-6+8
zb-ce$X?@=9-M^mhZmJPEYentmWO&Eoo$l<|y}n%EzS8GuVQFvPgSX3_K5s4$VV4ot
zn~p6!0l%JKuVJUFVZ(!hsZnok&ZCQAn-2%rJ@4P<Vaw&x)g!m2oSE$r%jMTotB*jp
z)gyVqKO9zFu?n<VtZ(a8Fa3OUJJguhrO-fNGat?EC;+<K7yE!ck&~sV%5~WQyNq8z
zTy7z;u#AIO4=6UC{?T7_bntkh$~?c_^6Ge#uITW7zHB>6@o*OboSxW9fe$|fE4Bdo
zXND!de}WI~>ewHuJOyksbe_H-dTeQ8jenq?nbot=aas41J!*p9NP7Ei-_T<5RZjE~
z#If^|rbbzO6Mhil*6{?!V8QT3;rG!ilQ%8<L}b%No4eZj(2#tzEuY1>Nw$2m3H(Jk
zW$#n|w3&E2{v_4=<M<`lnA2Ee5knk;|COXHwBL&iV*1#0OFZVQ^{1e@4nYd{VOJPE
z8>KE0jR#|iL6`MV_C=fvoLZ4BE*rW6(l{T(mBQUOGp*xF6Ep2pz3J(|Z{L^Dwf^t~
zT-nSP{AHjBQ5^hgnbIuLJWrW=(v<7MiHj%YyAMap07RE9qm1hZb6va`$@*MCvPZw5
zfK{?jF0nuo*f^9$Ma#>^=vwsaeq?Adl##3SABu*}SSqRo6f5d}#2l+b{e)?apf$3m
z1CUY#F#&P8Nl_F4XFQ4}UW#P{P<!U)SaRgJei@nn4%aTxUf7fCDDI(Ov>%3Di*-#o
zUVVySlCcg@@?o9%%Xzlny=uE%6GoR^R8B=d0w>-jmstHv;CjRmZNpTF*AwKPBM;by
z|GGU5@M-jyPxSgB+VkGi&W;XhGwJUbzew0$by+XTGxtCj`<@_oudXb8l6OO3Of1;f
zcZ+^KP>sF#qNH2`dR<&;pRTzr^uKi6;~_R}>Udx|$mgN+f}R_H%vj^R@$sdx@pkxj
z208Ru#scU4m3Av>YOnLP?`O9YFwU$igt4=h0*u2zLkL>b%7>5MhQnDz@x!p6F^nvl
zwo1-#0nZ!Wk)`FfbVTetNPm+lL=d~9{sz;df+x!01nK#zKWye0vs_2rAP0Ek{pzbi
z!1D_20Wfub+=X|>$8W1`A*s+E<pp#ggO4d^ZZ9EEgBUk1ngMhs(F3T}d>4%9-TLHI
zj@5U3I3Z#CZkl`aUHT=K18tq@A7T%P(Dc{q(mzDoa$k;@NbaR`xsIwMaA2IT#|HV@
zK^rmAFx_=`I{6i9rr?+$`B;Kp(yb<kX;<051lfg7-nv|_i~zeI<Q%3<e`pq~p(z!~
zmQP23xN`Qm-{fFGZ@RajI5(Lqp@K9x)skPj4yoDk)DJg=La05HjtJ+n2QP|h#2H*~
zgDP43G!a7m%J-d6A5V%+W2tfKS>jGalgCua)iNXu^6LzuAi+}rNdXc9alv_qA1vDr
zWuSr5Y1ts`2nvi&@{o>BEGWSmPnaTFNW!l%NLu=IGH#X}F<1Z5i3Pi5l%M3X^MWm0
zDQMQe02mU^-qY4-;$<h~tX&=Uy<fM^RckSXo7rX}a{VwWVm*W=$+)}0s}ByH=z?XK
z7MFG(7CfP<A4BM1mP2660i<pkN$z-vlu8Jo?p$yRui*Kumz~sZ26?WMC5pczv>JKI
za5xAZFBJ2os2IjD2%Zc@F{KcBjQ@?B?Rn#}p^R9G0-c=fZ)#*22D)CUG>m;NTC?I$
z%JG$GlZ+3CdJEYe-ynrblguOyA4<4>48G8qAldjYR#wp=p@!tG3@O0w`jYq-{Iq&J
zP^h~CL<tpeZ8jfB{9xoP6?o*FWX3H;X9sa~+{Bh}tI6-4<(_`Wd@0<^GA|ZqnaQ^_
zh)BKusuZO;SLr`tD-wT0cBb`|Mr082purdKzS?H2!Vj}FPh$bk+2*FkZms7*yXhdh
zeIxLYPX<39UyZz}hScfqOTnPS0=J&XIYm}NW#x)g;eI_RPf)KYO={HF%fmGapg@7c
zY}TP5eD8sw3c!$uA-vhk2&Lg&+eruMT{4VczzpTVb9kV;z%Wt+s+AS&Bft%ic`y5s
zQL32J2RN`uWGO#fNv%$~v*M7q;x(VjkeO(T*>PkI<^45*_3V}Q;-~HqJhrR#j%ip#
zM-+{h5q=wEC!)WCDgo)R92*N$+mak6OvYP+VJoKsjOzd_NeeSuOmy7iB!ZCwANPJS
z&3BKoHH3N|9OzL-oQEXdt=nZ;9Ch~SCyZ<VtC^dj3&s%X*~k!i0;<{0`qw|CDuNQZ
z!;lfEagY6cOjxh^4rQ{esvT)HfD}2jF*Iw2@6?X9+*P^PG3n~HxqThpo-7=k+1o+)
z=sw+12=4Z3<YSBTzTV3~>gZn5VGw)CFPLv3lp$`p>}*A7=Yub?hB6Kw)aAOIzS;g=
z>>`PZwmODnTAs?fH+4iWs#-U|m8pMUL8>%dJAfs6UlE#3%Z&V0qm?GR7VXAjJ>RLU
zt3wu`Qd3;O#D#?evdrBr{~$5eVf1*#@0d$-odayfM%_b>&biIm<gRrqSKwh35O!3u
z%zN5b+coD}nG?|67~y-H_;-j|4Sy9ZmYL?b^FfKT@>Rx4T*|8{O&PGeOF!q{KzaE@
zb7ugV7T9bcM03<BlekDR%K9ciL$Ng$`@1dp`#}-WCWm9rvU5yK#m%|$ad80PJDGbu
zdky2MqAb~u+hnJb#1oNiJei@A=g9)RV97QV-;Y#oS!F|rUs}4lla|ALcZ4#op{5G*
z(94~xPjLCrKkf8M_v8GWlIRgC5#F514Dsyc#RK5b)knb)6LThZkh<eq(LxOb-Ys4&
zrwMj-y<=U(Jjq&atAEQC&l-Z$9C+)BFi?=fIHNk1E6|Sb<UqcR#^$V=TsWDt-QuOA
zQ$%7*INoE;qR0z8FYDnYPD`~WZkFZ9Y5793N$|9-hG9oWuM7P%7Q_DVfb{mle~H$9
zl`}s>nR_f2??}ljJQ9JB-xpD3woN}cs>pGGvBmOT19Z6>yO`22hobXJvwDsrh4@8`
zw&02YRsc>qAWk3^zCmD-LZQ;8m~$S+&<&WcXK*d5Fd+E$s|w;%+OA+@KS?fg%CXhq
zEL?Mx#ov>kAmQDUI3Cx8SgVJd!L>A22M!!384Ox<8h0dvB`)Plo5H$<0ei)(>Cv&S
z&F#l|a(jT+<mv+Ty0W_H8lR%~XIMsX<%CWYWmpRJ4g*R)fDtBhOkU(qIV|#aL$0w3
zY-8?9?%a&_8nqCSF!>*sV>wCY`)-d!X0yv1CHH910={OQ<#eUc@`HXxZU~DG3i`0)
zKP;Dvd=};b*B<q0E^0yVuIjKE#ewpC0xOt9e~H0K+pUiR#Pb&1Evoq1f!r2xMjS*j
zNp3z5%6IrAqSjtsTIgficQbgAG&V`??yvatw!SICQP%w~poiZ@weXB%8v}XH+D(@~
z5M;?7DcjS^D?lo%3j3Wx+$Fia)VUQ(s_OO?%Ny5p6P3lu1G`pN-y!-!-rUNp74#Qc
zDF$Hlw@!Fu<yk~B<DlRC&#O8dgilPnSLB?v*`_;i+sg+EfBnpeeL^D_8n@O7t14PU
z?A5v$S1Sxb8+ig_^u(+w_fZ5si7#$>KoQnw>)b(X&oGvePn3=E8^LQ?75dG2Fq(Zh
z3WKm%aKIJOWPns-*d9rA?-O-FP|5G{+o#XO1jt(TiqIc(7Lx-{(ZaqG$n)QB;*~Ih
z1+|04$4|5Bh;^Jg!O?dc?soBfoX5t;73u}vX4SE<x@O8W*=HQ7gTipEd1~kr7>fL$
z=;=b=tHV2rhDc^#>;lUVHe(>g!sCV|C2163`kl^Ac7LQa$3+4#Z*8hFiq~$e6}=}t
z=!=>XVkhF4&nPZP`9zmXrrKDZTe-Tw6wGrffS3;3DwEv{MnU-F2F}_*T&o|)j>a@-
z+DrY0G>K0pepf;fpQbhqhgIao5iE^*#E~qn${FQaW0BmHaezR*HMaq}-|uCXfh^j;
z=khXrZhL(3y|z~Fdry%#_@o$ypjA=tHg#Hux=TkwAs#ImM@dQ1c+HzQp`za{bE|0`
zo5`wxK+uqnp{d8uDETNX;n(g`@MEvIHi&f}b_o_zST$;;I{~>a*2NT2D->n*4@3nP
z6jpn8aic%JKI~ddwV`EOZB`Xb?L$&brGK!guFKq&{8qL%R2Fc77A4LvwB=}dFXN;Z
z*9BWk>!kAB2#-zaut}4%2viq6REa!9v#;34^sx%kUol8&MWFZoZf1^!%X3k`s5#!D
z_82PS`aIGyfx^*wy$HyodKsl&)FY1VKtN)tbue>ye>fed&F=D?$gtfi>O-e>IeAe(
z9MgHJxH!Rj5qS>i7UV6Kbi8&T>HATX34fi%8Y0v71<2|V4L3_nlhlaIbalRb!xHvy
z)M6RJ)!7x`%4KZm-m30$?N$QeAgX-#VLdynEyQIvm!xa;n_dV=UXR4N(e(`O>RFsL
z@5YA#aiJ>eHKU2^QtSTVlHH&&769~yS$=t~js!Zjwiec}DJRWPeDlmv@chnZD{aiw
z{=F+_x2C(^eLMLb6Jwk0xWn1lB`rlqJ{ZnqzlGh9!c`pVP)0drV66=-qGm-S0%@Eu
zi*i&)@UcTBd1+d6^uU57Y5G{Dk`l0dSbw(i`U<i=ez-yCZ&LWuH+39coZWRR>*ex>
zYhFdt{~ue>e|44rw4jVE^i2O7mSFf#G6aVIN`}z+PYe1#FwV&t?w`!DFu#j2YLgyp
zIObE$OU=_2#(PauFu*_atL{Pa@)RD%9aI{O@riK)xvt*u6i)-R-`+1bAGh<{-e0@4
z*)+7<6|moJKQK-N)XRtX4pq|Zr19Zwn(fc0yYYU?A8e7!nfvF><lFmYpLKIGb(HT9
zjPr5#@RA=B?FU=bYs0I}vylvWOt-l{y{!}3R$4yGYR8PglhDR}SKhjf^Z0*hobLO(
z#MB?pU!RvxU^;dm<^9(>c7IZ*AwIOJSa)x(!*mAS5yzG2Tvz)Hf?!+1VK*jCJ#(Bq
zeGhtsqMytcrL_awKTj`VVXJLmw}ZI5KOeGXyWuaUzh7><&F(#0+<>^|_3jZ^uA8Tt
z(p&E$Eeg_mhX$3zUgou1+w8m&kDkb?Jv&<|5nrO<c4fPQnpf+;7XoYCjcA~>R09I5
z<u|szw!C!eNS8?$=SPU?aM4`5dyjkT#&}A%`uMJO^&<1=wNolv<o*w1?+_#kur6UX
zPusR_+qP}nwr$(CZQFMDY1`JEduQ`v;zi8c)~X`vUsP6BeyP6#`TK_x+v%R+?&2mx
zo(UvE<lKPn9*R$zfbSkKY$6pa&EfC(%FN?R>FXEu;66qO*vreAeRkv$=wc<xs<Zt2
zG@-=7ZK~Z*PxF3ynBrC@QAU_!zmUbcf0*Jy;>RcoE{|9u&mqwF0a6QfJf((r_Bb+W
zW05t6TNz~4A@16+IsszZ7?!gAkq!ZdWZ7m@Fyw@+sA$yY@kFl_;|gKk^gy95CO1{1
zGtBDhwCgp1?6MvgdMv0*qpqg7CF0-(R*L7AT7WTU;-bIAP#P%kh}$su`&i9LgL%U|
zA&j)DYGzNTsFO>3xuBDlvr>4jEh;P8ad1Q{z0<nwLURv0+P7RP5Ht_{B8u+Fh`yW%
zP3*F=L>QyStavfgU+7b<b}TA?w$_|OpD^~QfeU>SWa{4wHj2<gv^5MKB=M&F%Ube3
zvzd_%`UOh~W<p9wE1tPf5xK(-e!|^W%0(Sl>i;UmHV{n;p2SL*p2lJ!U-ep<UgQ2T
zL8buYk{Z#oKqeAgo6GfejWbPp#<@L{fOJjCS^N7LVCc1*#D~qhk<I5fb>L+3<58tm
z?L<0^=kil08uf3|ZffTuD(P+ch2g`{>OE*RE6w2P?>q#q%NVlI$E+t?O5Gk;qcHn5
zg`><$Vx4OWldhC(T20Anj7>6|kjC%zndiv)b)aZWE_Z_tpk@cggabuzR)uLyj)k%9
zu{xxKu;j`s{{~KCjO=K@+pIB+1ala<><vb5ASAQXaz`GZ!Pt>=cu|3Jxh!a&RqR%V
z2$>2S|Ml^#%I=>pB2pBNYRrZ<3J0|jW15&YmdawRD`cf&sE_F38Gxu}tu9x71Nqb}
zoFJ!7(Ff%*HjdAqru`dg;DXTc<(kbl&cQP}6QzuaH{?huFY)GBt@*;qOqcB_@sH@*
zN?FpJc;~UE3DH7XbDNnlV?T}uX3)Oq<E!>A0I}ar+g*uKUBsL8*0r!cT&(J4JyVRH
zWk(U<6y%S)i~a|zmP(Ro0}1j=CamhCHrZjd|96qyiLLGf*3b4o#HpVQ`YH^W*_=wV
zJr0me?}U9g8lh($X6%0dfGP6%P;5`gYlH+ntWEhk6M$b&|1kDAw{iwC>!c7-BL&78
z(r0W_nt_dKuAsS*S<6J`uN??6Jm`D~Fb4w=NAR2I^%~)yUGkUxK$;&T8VF>V!dKMi
zaegw)fdG~S5k4!wu?qu+Ov~P|VrU}ho=l*%_O$c}odr>5*4DIJ(!AeTrQNL9yU=BL
z+W6|AZj@CS2(1IH`faYK@TpA!50HUH{CxMh^pnO-RTTtdh|<y78O?BQ@S$0<3PXYZ
z;;~E2G0$BvZ7Kp3=egwK@3Z(14-eHETy(YvRq16fUJ4a>&5a)AZ#)8|nW!xYJpCd)
z16uczcFJA_<f0koMgkm4<Cr;Y5M7OW$!gZ;D9<a<w}+Llzc{#oMxM+I8wGI>duCx|
zpq)$>-?ON<_uBXFZ%6aT1Jh>Sxfr*p4FPkP2J>Q#yG(*q3uwYB=%$J&*uUx(o8XW0
zs4ScboMYV3e?hNT(HnG$YyCL*aiPp9Ebyg_0J*@jiXK~ZD-T?BqpouLuPF+5ILuY3
z$wH_kEIVEXmT@_V&tpz{u??R_#MiFWk&VpjUd9+lOEPfrB#{)3y>se&0^=$^&x2uM
za=E1)Sx{=7Sk-9MX)gdHCDe6!<H~R?$(rOcE>PWD#AfkJ)*C}~yy#D3>!bkFlWNuL
zzETkMq<9~sbNtZqZbBw^*R{AGg!NF8oQZ@Yo8iU9#*r^&W+Im>c_%9j5-@da;<ip3
zxVV}};xz+#bGTfG65<*4U9WQZc{hpmqVl^-PpHWa^lK}NOO&ZzB;AZ_B<oj}p~B<%
zh94~3{ti`PFCq}aIkY>#E+V{9MpX(k-_qruIZjn3QETe_y#R?%0M5-P2p{OrYBA$s
zQn;(Igcq_VvOxR>%nKlKXwmWxBNeG7MF{9u62+}D(4XE}E0SAB@F6aT3HR`SXgy13
zuM2J+y^&X0Oyw6H6xYz_jwG$)0qED7$)duyd&9(W0c|k&99gD|0tGF#cF-+N-Mx;6
zt%13cT+cmBFZh$|GzgiPo9dqtT@`H*bLojQ+zsk1s3p~t0eM?o(jhRv=2^`1p=2bq
zp~sSViX_6Q&{{ZQbo$ik$Ibjqs)4BfkqvMnI9`k=#u!wnfX?G0gZS@4%9Cki5cp;k
zW3u{1PjZNSLEi6fFBE$c$rZPV+kASE8b@H|uJB@U(;m&kj#e>w586>QoCAW-qF?z#
zF}6L|H`~xR)g8L6_*W<$LU$!yRZvttQ9RW^$$?VNc_>Fhe%_}%VL?2hgpr7gn0?)8
zC(57(zy%VC#|#D>xjD}t=x`EEZ$25mGHI%Qll{?h;IBl%ZGXQ4pvKB!S4ka7I*Wi~
zcbZQk#_<LUeQ~W6@0$BzwT%V&ZSqcue{$f5!<7%TlG|afk2x>%MfgDrcQ(39$6c#K
z#emn4FEI=w(WTd{7IFXs2ntMgacn^&Gs(lVpr*Ftghgd|9T2P7k;pl(JxfBZfCWtn
zTQH^=8$a4MScihB#aRNjiOx$hGMycjVkCQE^=(e&@_ZG^ASAQoyDbG0g>09TKiImr
zT(qg9S?a1$j6s9~*1)pQokJHx_>$TKE+fkNBHKP=G8oB#*!b~U5bk?>pSt5(>nSv)
zt%jqLKYYP8{FckZltmVUYX}mgEDL57?M%Sn_HZz(jxE>h*L@z}SE9zE&E9~op<6;=
z8Tg=XH5wpynDAo!)D9=z8hTfZ#Lp(pq}l$#VeB7;sFCIXb@UkNO9;iH&`)moqUBx9
zp<Kps>|;Q-Iak6Jg0pj=a5o*Mx&)&Ow*z#R@PI#G0Au(H69Id-IFr*qAJRo>(+cs#
zO$r8AQ+i?im7)uFrPxdR^)eM=LaJAX{z*o0L>Rv$=#atEwNg^sAJq;BqM1$2{EI%}
zY3!<VEl|M(mh&Ub!^|4$%%p`@?NV4alBIL#@Q{Q_ge?|!?Ahl<`@2)>>DSLEJTC&j
z+H&+{iPYL)srm#J8WLAXEgbNs8;Y96mP63VkxWB|U%8tt^qZa)M$cRZGSaJ=jyJ@?
zrTl6VOh*L6QeEO32*WJV8KXK}gWm6;HSkQwtb`;}p9ZKwAzHr&^o)=PDN=_*RZ3_4
z7jBFgexwHJgHb@u6&2E^-&(z?zNF2VXbmBXHDbx+PsE2DH+qqvTiT>YEbF<JsU1J<
zD;~-Lf8ZuNF{PmhTrO@pMrjv!Pb{0}uXQF&fPJ1V=b-<L3<!23xuqL?66=t7aOSbT
z29=!O0msgQ;|?_}h~u%rvOAr%7xRyaiL#1M1hPly8-l;l6y_RilS*6i5Rn&xK@I@V
z>K*O~X7HZ?7wr(4nKqk%xt>V~(=lSHIaNg<S;+~=YhM6rWYi2zMFYLail#<E4FJAL
z=M`O|&*-B^U)SQ$oxp%)-V8cHoJ6JV?^1Z%9zGAaAZ~D_&ROJ~l;&E2xmKMW7Jeza
z!9*-<zoxz%UI%R&2(+{Q5H2vN>0EWW8-iJ@oJ)=D8wAJExL((qQI4jakOEG`{E5;K
z1-qG@?5Eg4S%Z{?+^VB-pHnbslmlQ9OI<iz4+<iaR-Jw^|LanVCO{6|1mW|ztY(mC
z?<n@=L5F~BpVSkTZeaC^so2y~c}Lgw=mYP){jXWWV2i-7^uYqUu{b)HalvqSUB`BF
zesy@92%|tDX>H5r)v%+G)?CbTbpQ0*0gANix_2&JM?5BX84wCGeqMjZMM+cvNJ_GP
zV#n*La4jU!sqgW1E6!pwYcc@Tg@ib1RBoW>YD|~ZzTsp(IMT6s*jgzKnP57|YKLbb
zD_y>KU3G6x1(|W`@}j>xn;wNPV%J~(1-Gv5o>AIOtuOK|Wpq0J7+l53`qlBZROzd-
zoGK6bQHpBVy7(glkT@ER3hOZy-}ChPti2!_Yt8a`M+i?QgKEdO)C8OG2TTH%G?Z}|
zW@Tj5$2!TS+#+Y=;aJ&`ln&*WxIjvwb8)2eMOCN*X+@CHE_wae6nx{?Hx!@xp4V?j
zE&|+23z|p`KFj|mM~2FG#WBl!EkdZNY{Lfi7{1D8#Kbh(+39wFYNS{;kIToq>_eFQ
zcT09<GFt}de9}1k^FCowDTB_{4WyfxN*Thq#E*iI2rZ6A?_l_xrPhV4X2_SmTKgK#
z%C%Lp#Vtj4n^FM;5mJkl?H+@D(W_>^odV2H!8~o~LwBw`^i!{gf??}Tjq~F}eB^=S
zBgOEgd;O%RR1iycS67g%q|pIH32+De#sM-ZiHP9c=}E{6abCM|6-R#HvGZG|CbMgm
zIBS4z7EOMpKA7^0Czf&W4Pj4j#q>s0BSy^(lxfl&s_89ND%>Z>L^WiqRW;Tx1B57?
zhha~zrDFmBR7%*yVbtA8?Vqrws%~25`e$nLE!p_A|8J7`|5dsFmBeiSGlt8^^q(rg
z|EzO!(@C4ynmL=}Gcq!<{~z)L{~<aN{p$yOt%HAS#g{qmf)p00A~wLfH7FPe8v)zm
zGFlDA;D-K>D;w@DVro)Z={5SsNc|+K@*aJP1~+4m80N>*<Ms1(yawm@bD1`DJa&AZ
z7j{6OeKa6_QVeUWSayH+{(TU~ht12ov;W<-ck%eX6E}5R8)lG8w?+^A^ZC_QHZ`?m
zuHT4+NZR-1=<bFGC)l5q2FI6Ill#1p`F=L5I`dHd?2T;Z6;?L8PZi;psu3(8I>YMi
z?5S!7gSWB~L%#yU{=|znv$6YCiO4tLhDm8K@9bKi&pu_6dZ+<gUpr*;FFA{ds24HO
z7g#1(KXT0cdw%>X*Ope6_tm4f`};X%cXXE~*Y`z+$nOlHA7DF*#19B~_8~dI3cRh6
z8#0gtJNM>6-xL8y`@_NmNtBcRhphHs%O&@(`tO=VlyHFEdGoPDu#-KaEAIK66YlcY
z!|O@30>GRW+nv{7><cxs&E*LZwmFEWOWgq-g+*y0RB#uy0SAF?BrO4QZ*jtTEGe%(
zTiLl{h>3H19|zSMQD7o@+?C`9{vYDNoU57tz+K$nBUlBJSB|fy7ZJo4%6c4!CRohj
zlDlVas)=>_UCZKHd#YxK&u@9o6=C(-+Hgx1ttko6<<*h^ylUGMJ<vRp--6;$>4sVK
zfIq*-=|kVPxVD*dN=Fauvsj^e6k~y<t8AB+8EJiECDQq};akvb*+M8@@sBxUGa3^I
zrNS<$C1|*5v<3LrM^R4%V0}+RXZ=gDLD!o<q5XPJXuk0EyO}pb1<LK=JuA+=t)ce&
z&a%=KXYUSCV%tsZk?ThsH0?04Sz>H<=SP$U4$SR?A<-y|;cvkT59QL2tKg@sGYhj#
zA9UY26Q**!G7Y#lMmySq=VQ-cqoPK;K&MR2D&|H=ZY0_?5h<z65P1_{81x9BAwqr&
zg>jLjJ1{Frkji9A^JAkZ_+A0k`g0bwJ!CWi@eWZ-s=!$b4)_ppoVm}OeCkL%(@H<>
zuP|et`&h1fIyqb=^Q|I?f9@{F{Di>?wBQA`ycWSOnaLI7k-hl~9kW74`m*+gS=3w+
zeY}MJ5ao{Bz9_P*Kiq${^6*?#L@l1lt8&>@L^0%>{3^KsQhC5g=|bKL{XyGNY7WX`
zUi0BE*A^bmIC29CuDy%jt{5gF9=Q_W4#Cg4?$_a|u0OsE$=y7)N`z8gVQ?g!bfB84
zC=08uq@VVXc&JWV0HAO&JqcrPB)*s8CA(NnpN>ycljToC3klna&=qCGrNF80tHlnb
z;0RpAfQ(T_NujtuC0FIoNzV*#P3<R%Xp-rzdipR1F-eON-BgN7(845jS*~B3oT1Op
zn0(YD<G_}dhzK?uhcNGBr4P=4T*9LUEPG@;S|B!>=wX^mX`y1zrSKGJ0ALem|H%ut
zT3Sr+Ey1{wOd?<moDzx9iNK?fpbv`Z_f4jn=X7&U(4c^}$36-|rQLv(gZ{1>ro<%?
z4KNcgk*^6{=S_rFGBy(MK3D+1Lu!DiaEw;uP9bouvbRpzt=B=sGBZ57UpbFSa70Jq
zZE31(M2l2Jo-82Xh)vE(cU%Pe*8;`zHk>XRDs(+**#5&4GXqW>sc7=T3S&m6tIg;X
zgc?<`+JJKo6P~caU{noQc16raI(%6Z^$x={{m*g&!|tk2qLASA)2i-+o!|yr!}<am
zjieqWSW1CC?u5v!Mjyf4#qT(Z={CAx6qEwPFCKtoH_1ZLltAAy8=3Tx2B|X2o|#d;
zdzUED8qb#q8;e&l3^efRhY7Q6t_7@`r3N+js7Q1tNx+NhLMHEZ2$R8t>IX486viou
zrk$92O59N;c6ulQtq58?qt-nGw~~Y7f7$4A)jsaf&E|hyI~Lr+?o$Tvr+1YVZ=A@g
zh*8KH&iv3ZDjG$-9{4UM8ameB!YZLDyw7^sLi^565=WyIfZ^(YAov)JU#qpYWh-aW
z#&)|1Lo7?-c8!UzAS}i?tpUuNy#SpYQ!^Ey0mR5{R+9c%cHv{h`n*xjf4frBwpR+2
zTVLLuY$HBB0AE|NRBSJyD5i2xBrED$A+_B%beC8>=NNK>JWz2K4jzYZQ@-dcWdjED
zO7f_qM5+%CJ&EPLl%88Q56g!=GLXJxxZ3;!SvPK#G^F9+BUL~SOLc+yu$e@)kelDa
zsyVRN#h`g1g5|^()T0TQ-*l*@-Qqz~BtTqLI|<k_*SBaC2ZD&5{U!<q;-*-;!Z={!
z>KLM+gRue@G7<ad*cc)Z^}D3ja14KjdsmJ<Be1w4{2TgY!|A3luKgb>VCzYA6VdhT
z!3t)fk2Gg@L>c5mHEbQ;frqfuy0CJsOpDv&+>m+&Q6@l{1IQwCing+UuHTYiVOb*2
z0REfN+|WI7&{{(Yd6pi1NQNi01?l$;@B;n41AYQ`R{@habisGYhJs~a9kq?sSo*;`
z&}?E5eZG#cQ#p`o+8WSP)gp@houkU96#z#q4+&UlZOF>Vh~*56_>VLCp(%sD?7le#
zF#TOCXyijpfBxR}wdUEYjX6s#z}QxkXv*{j4<Q+~>dHDt;kO&Qlv2y?X6&5+y!vbn
zWrPSo`yEt*h?xeZLMA|JWjHGtNnBd`s^)QXyN_VNw29~pjAgiIs}jy6JAKZT=hl5#
z3QpjirXDmNww&*qk%zYGa<HfQl2(q@<T3TiH_%0-Zn2iK2wn^CeX3Wy=}sBE6e6ty
zWhp$*G72XtgvM^hA*Ze6W}0nTjSi_DFsK<s<<!@;vd5qG3<@|-oj)#$*|-vZ)jdH!
z&R*KZRHrFCv=gL~E0X|>aVzjQw#+r}p%riVf-Ry?bR01@seCs;i~4xZQLL(fHny@H
zG+=MsK&2pI#9a|oW>YSz-~4dgI`Z-OG!o=#zTrICnr%Ca-~?;5?o{#~IWo@LY>k8w
z$wTEuo#0+m&B73|kBixsQjLWi?8o)a{|aada;h2yE(-@&eM+LpX?L6}l#HY(DXt{o
z!hM(UTdiw|FRZ%lD1tZ?j~OIsn`xuJdZc}@tH?8r4uOrW+Ms!W4&fpLMY2KjIRLri
z>XY7QL-G%w=rQ`OCZz5_F*4>YK44=blK1#LV#hX8nibj3@CF`gJ^BjvEs?82E53nb
zP*2mDVoJElEQ_To1I$RdW)P+6eP(AAB$=uQ9UVA@d~k|LH3o+v>#uV@C}pf)cHRGK
zwp3d9)fMy>gi>bei06(f|GbknBo-|#QbmSgYfFWdi<i9I>&m@R7GJC=F9~`DR{K)L
zBU+Yp48vIClJhSoa$Z$V`?Ya04^CQtUw^>2z_!Q^N9$5;?ZWKUA9gqd`U<QX2C4mm
zuz2St61FdT^NEM{wX%dcm#5`B7YZHfdQ~}>&OFv|2c5Bbj58dE?^SYJa%06<P`blu
z)-n)sTCv0#V3tQ|Qia*kpr5xP0?(e@hPyX2<rt^sK6OzOx9q4f8kj}W)+yi1G(71(
z_XA|obkSr(0-v1-KuXUsL76CNXvpg4j7pq&I+E5)w(?%h{`gSXc&uF<eUnR2BGa%o
zeQQO4-6vq{bO6Q0c`mR7;n)jAWdC7!u~Bhh%q{s)SAN(RLobyOH!-;iy!izxG9I+0
ztb{nM`-74L;f&2zUfx2ZR$h*7g}!qEkZQU|&9@nm3+d`K2cc=|r77^Qj4T=ljizF!
ze{eAzMcWADI6ch*g>n_Z7dpnfI;TF;2(QFGayF~d?C!1If?jabhbM>-68|PjKr9|I
zb^Q?Yg`WfRqeqcLIO)Y}$t)(XyEwdV<12HT^inaxc3(hdg+;c5M6vQi1x&t^$y=Bu
zW=QXOh*6*;$FqttW|>x?Ht<Qz2Eoo!87B9|CC7pjf;dSCpapk`)`Zdl3+sssNuX;j
zCt?q{nGMAJ+ZBaDmLcS=hQ4%Q=?(A7umv)(t%y>P^&$x7R-rNrJ^63LC^bl4SCsxY
zA+Gx7b*|d&4L6X5vX`2KjP8#|aaeuI(CP5Et0<1mx8{_hSd6aBemT{k0xHKlGnP|;
z0;ANPx#KPiM%h>oqX3;_l#u$*B$Z^f#b1M$hjnsNUVECY_ATXWy&pR^sJM_FO-5Gl
zaQef_l|aA<VXV^00xrwRwg>I()zRSJTA9dTv4aFtdFUjk_c3DHt|=GLL=(fb(2(V{
zWrME0;3?l4jWYwC)Gyn?*UY=mGC4h7-;W1gg-$&+cwnpcY<b%enQc!PLnQs%mFT<%
zi52*{YYklrh`3+2_2hl6e30iE@woPTHydC0-Kk&1<v&?Kdb!_g`pjq735<_}zfcf?
zACG_05ZBs6=NzB}{RWlRuqN9j->_Q=RU5*rx%Ly#frb&5ZAnbHgY=$dgU+4U|24_m
z9Siwt4O29eT1Q$vT#nmA`_9{oaBiTu=*FW3RP6H3r^MVsG+FJ|{SL$?9?&Wy3h(DM
zsJFE!_kgBRjE4-;02J?D%fR|8+D%saD(#vtWwKUR)V0I@AYuQ5D;ZoH#$Z>sjt*#^
zW!#S({VDtAtv6%4!UCL0DGLP<K91h}*tGZwm+=+UFBAm_HH<p=IeiU-<D0L}gZ%|%
zAG-Xn#p&eiXkuXVKg`bmin#wOK4w;q|FO>czkrt*S^rPqC2ftWqfr#!zP>^NyMQev
zFA03i8x^;t;I{#L0yrVu#C2HNegaec|Ag6E&X-FUZRmy#=$p-mRnDvTHYA5;zn<#K
z;OO@JK3=l;zK@sApQE17^T=Ec%^Vh+c&Czbjy*ViexJ|b`gna_or6B{e2Y?#htMwV
z>d0I>x^;&j-)=wqczb$zEP$b?(dyr>tCqq(o&RFDdVQW88ZL{_i0Ta+5`U4qc$`Fa
z=;b~evg{(hHR-bR5|@coMLENji_Ew`yB;_;)K60*y2S(e4hQ?SEs0D=`Hxs5K;yQ)
z`Fmmf3kvLH4$(L)_-g%bV*TLT81{bMU%Sb*wUyEF)Y<9%elFF4d_MB^e#jYTx@EB9
zQ(b4I_BR`85THPlqe88Xlf%=~VbhL>=xspl>fij)qGSEJ2mK}AK19rYm{RjoviA+5
zDR$5j4`qDR3LCM->HBN-1=^-9{?-R$_aZ0R<&f1hbb8LM<hvZfv~R}H)S*FAg8Tt%
z=<}&%)gn)=ms3no78PME%g^Qov%H&wt$Uzqj2|H?#;VIhbdv~=Py02MZJc@Yw@Ed<
z-z-e1!o8N^z(P35(upL6V~bUdT3k=;UUT3L1-X@i*1>=$F4j}tMj7Mmj#EC(i}F5%
z686*Uz~e=4ur8*qf2w|`hYWniJ&3|vNDF#*k!;zX7IYwd<AI8Pzx-tLGQ)Dr!SwyA
z<+S5fI=sG^MsC@$<2yLMpL*Myly%-fm0rdIEy0zP4$*wy+7#((L5n6wht1us`DI5!
z9LiiAmDFu<Uv^U)6!Qw_$C(LIXL>ys!7=A{*|`P=u$xDI2-5VxCh<*TX$Ce5F9h$J
zr|G<xHd*0Jj>cwtA=Wl_wxer%vlUyJK9?XqiZ>q1fwd&E4u21!5<TcoV-0R#<Z;g$
zOG3OkYdj+DJo$byKRv~@VVii8{Zr)b`OnQydMZb`<QdXhzm&`i=ELy3Dt3&<a1$@O
z<zR_klOontrb)j%!RJ|D8@9rDA4<NJth$Iud;nT_k6Dy;Aat4PA-KqjHc;Syei`3F
z9{#K9s|Em*+ylf;U+70`1BZ7L*Vx2*lsMvwqrM;kfx{wB`4SUn){+%j3t{8<3u>O{
zkF_y}and2@B7fSwVL4aak91|KxLnT)JCuZ&I0pet^ktfwD4k||MZK5t!h>HKDW~CE
zvU@Vr7S1X(4D03GV9z=A=a&fB(SZaF9ldP>F@6y=$NpybL<kWxXFvp0ntBVM)8xA`
zE^9h_WiI)dD#qDpwGZ9bqt(~RUD8ls|2Dq(*8>w7M7tys0NhJYBEJ)HA*m+6=c&@z
zTz^x0I9~GJnxrD9X*tEzckmt5QadzwQVhVM!5s%Et%@a4OCNB6Jk(AUfp(f1IO?qf
z6*jr7XwGx&0sQC>ECI>0gphOcVgyc4?`T4HJZhjcvQT+Kt9cRA7|j7+J5k5FlX%Gh
ziq$m?wxZTIFnv6fz^gkluum}=$?1HN%bsrv=VRV-(Kjn94;*v(d`5^~*X@D))esQH
zd`t<9Eq979%?@YIDvrJB5?bgy$~JD@?UZ0Stsw;=G?aQRY54}Y#E^E96~x)L;omX}
z{UmJiG@{W@730Vm5DYvTIJgzE_+=RwK)f0`5U@E5$xr(b!_U(3tD$EJO|NQBi|z}t
zYMIvkWepGu^T`FnKS?4vqJ9Lee2wOlkNRCMYnwb}HKO6ZIoX{FR6LhPknl}`;f~tC
z@u)><cq#*(5CvKrJzd0=7vq0jwnF-SRM|EsU7B)NJ6SryGrBu{fh2<2ZLFQWG%Q=!
z+i8ng!Z#q53nlLjog$z1Rz+uT-(^wZZ8lIK#TF(^q$4paugQcduo^!n;8Bd}ewHKV
zZ9~X1c(f=h!XB_JOnRYMPSuS<=o?Ddy+o{*C+UYWI>jrcFMNKcF=G8qP6k<Y_qT6P
z*w%b270TGvM~1P%Qt>LRS_Q!1L5vL?oSJJhJ{6VLyFc?JL%=1#lnPLh`qq`nR~_RM
zrll;az1o{ST$c4~%U3IFY4?P{NJxk|TE605R#I{Yt~EFHgE&$cF$XC$G+0-;KGc@B
zb-_rx&?t+;SLC(r>+R+;Cf9x)KVJl?mRCn7KOYPMIm&IN{@UwKe+HS2IOu+xTS}|q
zNyTQ>eP-kS)<3=RXx>3Qa4p|)h=|_S9I;3yV$^*-2N1u%Ne4h>^}RI2W^(l`694>K
z)!KW5n;CujP0j4`0PcS?(JwaQz3<OmGlqoK(t4pfQ02+AWqxDpy<vC0h0Q)anGGmD
ze)NmgA1q3C6Ux6-6v_51atM17LZP)o#@sv80<jDlwQ-m8VD;8Q5IDvY0Pp(4176>X
zY^0-h5!Z9TQOA<Ih{A*CsmBP5|78TsAVjF~LJtdwjwmL&Vj3ycWjN2ZwG7i?ey$z2
z%a^@IU@RD61wYS&%!JmLii+kJ;EJ%5T0|7u_h`VcmM6wV);tgRW){d$LSh5(q9~)x
z>}({IOx(gg%w#>Y**3V8CLXY`3Z71OjFOcg=Y<ksL}t|*ReTel))sbh$ob`eDSto(
z`l4(l_hq0?s&*uzMTH|lMnOv^A>AVLil7=Yl&=WP0WRG0``p<>0y0rj!L5-p+$&if
z8?<w*vgs^e&6biZPu21YRSafrW|kGX{8#t%I)EDJ$a*R_d5?NcKuBdPZm+Ere3|>6
zLD0@T%usJ;Ko5Jo`<_^sZ!eRctaoa*u(%MXdIv`3jOtC-a?7QWTI%33XSCjcm1^iN
zt)%cWdd@hc*h2z8|2gotijQWP)xZUpDz<=$y*PJKCeF2JO}B9u2@RftBB4SnKbjR0
z@{KCDJwcSxfvKmTD0tkB0)B77pv{v<?u<#O=+IL$jf(;l?SPV=BI115{;!d!|5~+J
zOO)L8M=2*F{}oRvjh5ZSuclvgn>pS})|ibK{w`0pWmY3Ddw05v$sSEw^w2;uz$4;;
zGbM~U_oK+n(dIn_Eugq98V||W>tJML;oy#Sz!O3j?QH)Dgb<h_5q*faj75Qp3(_h4
z^{kDB%FZY}WmGq-8{ILcqv$>Z>%g!ST>&EFUPvez-CYp-3f>Wvm1TCLtsCAIF8K;)
z;q%6(^h=@4;qo_$`M!gYr_>adQ!hM?l_VsdhH)z5DdaGRQ#(bMe?uNZr#!hC-9wLL
zJzpW}<X5_w7yunJFzEhM@PQ$AM)&AM7@kG2BK*y~qWmGKTl6sFcId1aJqq+88k@)f
z3>-@IcR(Wia{;%hJu{GM;)PoaPI1iYqC*vi6K><Vd;37Wz!q_lxiI1zL5lvL^>8By
zpjryzr+Lf7{Kw4oxB?nz=0n~cr}*^wao%&T^`ZI{In-7@^^F0Xf->(g)39FhR0}2t
z!6W?h{AmXy5d3bOaGQ@NpCSTa@VeR)xfGQ;Sx^8b84jnR>V5<VJypk6blgqBT@m*Y
zW7~ZT$ikrPvVi22RvfhRd@qh$f&H8HG@Q(|OyNDI%(EPvk}U~E&92x)<l4%j0^ZVf
z+w+URAvIwkN9XGyGNh~_O9cfQJ*BKBF3FYCfQCTzEhTLuCUKAB5z1<^OKQQBykqIX
zQoMvtS!pFk<~MRR@7A~u=uu_-6PtsU<wxcuXHi@Y6CMCh*>eE7M?4-=SiZNKR0XOf
z&pJ%hs@8m<$?v)x@tuP%MQMU66;stL9WKR+8jkzWwQ5JDhXaHB`en9_v$P=>egNk%
ztGDD)ObbdaI%S0z>z}f7F!L=W?|_*4N7bc!BWC$TH|F9Uq?;0lvvKg+1V?Q3F_8@n
z1)N7a&s$X?b-g*Qi*BJsyX{GNCXkoQ!$^O^Af2+juZyW5xEl{qGbZZBj?klD-qb1|
zGJ#cAIWI$DnUgeMiHsUn*e?l`HZ0v1%VJ3Ru1d+L&ygrbykje>GFN1*Xu6s>WY*dQ
z@9njx>60Y1qPz5Ns-8}$Tq1LxIhu%7Lws&S`s(RhRe&F=caq@8&36*ujH`Lx%^8_W
zk<<(27GE~9dU?lsU5k)7nhVliH4!OzJI^Zc2dFY|JA!g6kwR*E{UqysSfsVy)qW^X
zf6khopUr=vA=Rog*_L+Ye;<8+9cFjSzQKBt_TH=a_7|iCcRzVA-SpgA(uoY76Osrk
zzf@PK>iB=DCDCvea*V19N9@MSp^p^ZMp^>BA-DQkKQ%~@S>I)AGCkkyVEHZc&q;;)
z6{Vepb3JEPnCaPQfi&hkIoxlG1BiM6{ybDqV7*t>KSS&bdAinq@UmUwsq9<V(!4vN
z-Pxnn|EL)`zIWn=Akp#7%udH#8Ago?oVE_Oqu`;ru(%afvsNwm^ZoPJy8I;$H%ytd
zQ2D}I8~r+w%fLt&@b0f#o@&I;dw+-PM!t0Axg`L}p}ozp{X9PC+<+{T{#SqPzXIyN
zYKw`9?SH5(_W#XaWB)(-YyYGFeMX)qQ7{e}8A6B7dI%R4)0>`meOJc_&-%ZqN7x=A
zNfDFh>1w$tK|2|f3zW!zu}858HIKK~sj@aazmKhd;E*Y~ut&DEG(VhSf$qwn`x6w{
z*`Z6vxBJhb+kfD(u_>55zmFK+99|!%_v>f;)o1S+qPsr4-w#J$KMiPDSH*+<*IU@U
zn<)XwuaoaEzU*q<=ZVbcGg(wsmqkyW$)ujcw%K4Y%CC-U#%_?Qi8GaoJMF=Ve$U{f
zC8{5VDh>@i-L4w3uQU5}&A}uSmA}RIfBY1I^z7kLFGX?E=%r5;e7_GrZ*^^N>Gn#8
zdi;L#@_b8%^M2oV{H7>Kyd<Lr8P1da%c9MYQQ=6lyD3TT+%Je-*4vp4%Kp-L6G>||
z=c!P>UYs>k%6I{_^#1yA0xehN*b&!~2Wf{${lcepcXI?p<4wSZXnjLaZ&d5*c$40z
zkZcFYJ4{+-mi40W>iw-g_jZ`!w!kgG=b=Li_B*;iWfuClz~#$*1hR;fS|9DvT1YWF
zRzHs7JSsnuDELbaR}3TCeG$>D;A+8vXBI}^6^@5?zCMvHV)T~|=q=&jo{fun#Sv(C
z0(GjL%f&BZI(%u;e64j*QmOMDuOBe!D8}{bTDP^n1S6<>s4Dw&V=cMQ1|?=#3PLvA
zN=$?QzSIrPZs?%jKfeIbvvF$s&^{Y~MY%r@l_q82KVbVbg%nYEW<G0H;GYyes|1{9
z@v7T+5^Y%XVSwSS{;_C{L6KS1#DaNywT)K&D2(aAvfre*yoO1z_mwqK;oHk!T0jh;
zqo21IGz+;Dpu-dhN^^=2yx3(I1@Gs;sXS`IZ37hZyl7g~Z45uV3wJZ4+<8(F>1>vI
zqEcdZLQ&_96`eSecL<aEiyieBCkm#VHynGR`kKRC60-lje685)+#iwCn@kZ=3O>TJ
z@+9j<0==0js-T^D&5IfGS0og~MOY!Aa38|ETnqnmVTNLUBj?HBy->Bi?<=!%btz{b
z(<g(Nm+stuQq3F1gq;y!>&ELc{simatCPb0ohi31FVV)?>P<!Ku^Tm<(t?%^vk_cr
z^WNa{@FVF^kMO5FJWI80Ub^OXMU|jY06CDDmS^6WI+`ro26ac3YzTyKuM0UpEhAU&
z(=ir_zy=oTicq%%Ci8uQ{#}7(a%iS#Vy2bcQ4x)CgGh^#Gp@0bExyqcJAaPLW<BXs
zOqtUAY9r`jjHFIKokm%l9?Qs#YesdLk}%5Gz)R%|GJ-Y)#O6-yv~kofc~d0Xy{xC4
zx(%HM95Lj-P?b0r)P5s_o;Eui@!2DHAaLBi<Fb)UOe8DdwfEW7lfDz<PBKx&5C<O>
zZq$6Qt_2dO?1-8RFbm+bpaA}SFEnH<=*Cm7nFKDc|M8#87k*&;ixlh*DSdL*2jsZu
z5hl(*wgp94amaBTNYtDFbM2J7s7<kGO|N;|C7~g)zMg5CL&~gdRL?P5Q<Gze=h*O5
zFFcyprUqbeX{<nJ<zNC53$mzI_`)g=M&d+Qe=HicY<&e;YL&pNty1$qkK`^|FRXzl
z{E>qCcuh){#g^ll=T-v)WQhBR0YIxBmZOJ}Hv#1lt}L4cq5Lc6!9A?rI6W8QS=#N^
zrCD9Y&P#}zlg7uu5|r=B)p`=EPE89qZ*00-fLa(Jy_lQ%3EMPODQxJgWBOf}7vJE`
zZWtTpl$*%LsW<z{O_!uRM4R#P-ydlenrIi;gVxyq1f9{wAx)kQvb-V+_IpIelSkyh
z-A!1Z(RE&+uCEoJIim0(@`nOBwWic%-X_Ew0K}t9Ns$z1-61|S+{ps+AQOA4wKiAo
z2v<9a8G2PWSAyMI^h(AzR@0?J=;3s+WG6^<RdkWSpy%#7S#<bHjSe^RCdM>>-X^W7
zrNd&TlXS33D42DY&0wC*v#W}`kEJP;J2|FQo2P>=FqC9N?a^z67IU&oJ9UuILze*Z
zr*S~1@H^AK-ztDj!w;c>O}n*G)@$F>;X=aqh47_b+OY@&-O9I@lp<P2e;7o?&x@cs
znmxl|p*f)oB0z6uU4x#^kXyaBonRQ}vj<qTyY_2@J8QM2kLAp(Se9_=0uZwkJ^Zq_
z?q=xH<Q3RLcEep}?X?lxy_30B6H1Z}TZd_?{jDSqMg|`Rx)bs@kQ`R-g0L_S;-jlI
zT!T<esQ<8+H@ST|H+>kWBBRb}W3<%%Wz#&d+IQrj6wIkAWo%>CeNlMwjOSJ`V@)zH
z72H-*B#8XQg(UflI(O6o>N9>Ff8d>%H{?BL*sHs&idLJzc7-orZI^iP$w5ib4w`|j
z!dzq}Ba9q>jxFl^RhXg4CzU65-BDmF*nuckuE7A8J6}mt26-DZ05Ac;tGEr_3@R=5
zdS^~PaYNuhZcIsLvAJNuQ&1e<VUJ4fnRAVDQ_c%CsGcoFg5m@h(AT882^AR1>J|)d
z0Fx`%2|(mFH8M^KgqY!>mbI&yNH1RP=t!&-B7lbAcxOejxj$=R{|c20rtS$i`P>A}
zB}c&}Si{khSypIX%T&T=bW-ubUdVt4jV_2UL__1@A@WojSHe#6fV%Vf^5rFIEO_8-
z|G=@u#U_;2?O<HpI(0NL^@#8<RY69bMfIhhnP_9I9+=be?$!j4=*(Bh5rOEPz^UBT
zsNpsu9}!3eIFf3;i>?j<<Fk~Ryo=9CL_nyZR!tJ*y|igXl3)Z{Dfb@D(v{wlZlWeJ
zJN?48w9<u(XHv^T)B4oi2(Bi6{Y%rj{3kB5!6aQL)Sr<%lFne+quG1CVzm6Rz24w7
zNr&IN35j~D)RG0rapX2RU_u04a#K8qPw%qC!ebCHPf7*RToW+Oalu%`-CL%?Cf0>P
zzC@j@C^z0;&=az`#+0R*$ho70M^e(t;60lGMQ!D$Mr|i}%Hc&rZ83fT>wKyBf~_i&
zM8VNN)?42-hRYvU({~x|O~JyLZ|d}8VZh<Shbhfl3F|Dg^i$LIW^mNH@v*(hxWFB{
z){c($^r(q~V4_XYzi~@7lJ0haXo+{Dh;0WP1}XO{R~)2lAuDn20vI9|AhKV8Gz;y_
zL!<EGgQ2N=iaP#U!h^*<P&i_uOre<7enXgwL<sMX#iqq_Q^FVqfc-biGPHl|XkY^R
zr&JZ5^HxCGw8)S5j%&m8PXpAF>XQ-cJ?n>nj|K~L0yd27=OB=6k`(E<JpMLqYgi6q
zYYr}PR{C-Qm0Esr@s*OA#_9|@a|C1^%bJ)YJ(?#RvY>{vOOa;^ZZHG-E$jI5E>y^~
zM5T_eqq+3JFGuQL3`>XVBYNh1JHWzIR@T@$vE1}?qz#-JVpXkkMM50}-;F2pn=aCF
zZ3yKQ?K)-&F!$W@C56kM9lEz-PN)tV4n7jN9xUDXE<U&AaBXM;01~?N&zAd}g~Yk!
zlV=6Dj-gXv$%(d}a+BmiI+Whp!8WJ0tih?_C%+$|N~itLLOB&bj~&H_76TJY(HkcT
zGDLABHH?Xp<nvQpblAURPf7{vMes(v#o6Nc*)em2#^)hrL;}4(l>n^tcL_kn=veom
zyT`mno6WsX(ebgzlX<k)x)~cUolbbjlrfibGQOSmZERr;aE!Cxc?|v!(NDbc_0i~x
zInp;8E<GF##ZQ7mE10Qh=dL)BO&FcC=9>Oi<R`ewFe+zTd$@jM=lg|o%*oKLJ~6F1
zOtOfhy1mYlax0?zG|!cBTu{B*agg^?LgQ+Hs=eH#IbVyh@ZJ;D;7||(M74y0lz6;>
zkP2Mw**;svhhLV~Z-W;aTHxGaZQejyg<I$}_@J-Ben`?=r1^q~R`&Hxj>{!3C~i4}
zMrWM_h9wh`q_yaR+LQNBWVAY1k%W(f9WH?~K=!TPxJM$zt$WS{g7e%dkEH9zs4Bj#
z#ripbAP?W$iDQd=;@7Qq>F7&AL@#z!F$k1@G*zv0VU|D*U$2t;LC-Ni5b)?CrFb>)
zDk-qcbBc?Fh%3cv;f1A+T8SCk-#N6<z8W&Ne$Z5EpwgVvrJJ`*_#}h0uYtq|P=L@~
zT)O8jk0qk!_t5P5syuH_C5ofdlMrl%tR2a}H)Gt5<hHol>=C=QZD!4k*5~s&RRVB0
z2~xI~$ujaF+`vETk=VUXOr0HwC6=H){4sMccC<^MVsGB7P)-B}lu_kQBG4_Hzhivp
zeA0TFx!>9`M;YBG2x=qvbkY{wCgVlnwA6t3clv?0imOqzPMbYseP#&c#+5X#p(jW2
z1=h&XvZ;uVjM|Tc5fEx899KaTs`gkugv=>XW52Ht{Cs=vto~PN^k22}Uune1@;}me
zObq|wC;orF9x^ffhZ6Juhb|6LmWkS;hwu4^F80(4Cz=t*#0ti5K-wI{MTPbP=V|^_
z*c6fy%D?WrjV2y@AuRwAHlE3PJ(&^jWc~LpvWqRZr_0Bev;5Lq<x5fH3^UnMD=I>>
z8pGLJKF0N2w0Zyj(F0@Pv*&Y`66>&q2J#!LS9LAVF$cidzki@n^BTh#x&%`fwr|rs
z&;>p~M7KJc0^y6NMjM|*6kifW3f3`$E(@OnvI!tF+#SN|i^;3nRp2?^8Jfmd=9b_0
z<^972$;<}oSvzGCFb<T&Eo{2Vsz@)(d@iFcFmL-;gOspx%Y$${B5;)5yYG*=e@y%6
zG`1~q$-C*4W8)uM^{ifTAP$ftA5K;s$niWGye))WSwJb|x^$%i2@A!Ff2x=fh~gun
zORBy*3tSx-ba`nl^i#22teA?ci+bQ{Nsn^S8-%I~eEf~4jFwu%DK9a5qt-abaH2U=
z@tvt2nPq7+CFmw~3Jq3{eh1QtOF}{xxptyN1207TNuP+NkcQzmN2{Hu?dXV+<}_8&
zHU4}@^0_`;mtxpS%f#0axG{tyQZb@xS-T6sVSzcdi^3;s8i2gC-&m3rtx4|jCwV~I
z-Pcyh!b&Y#8uFMjlL@vSewwr*LUfe1)_t98{t@7117(VCy4U++ms`8{Wka_}vt#;f
zVXu95zq}M<kZhP>efPG9<do}{-|G^`0oC^sx=*{8L}s-OyOF5-xmlgeZc2+GY~OqM
zi?mctp3!g?6cfR9dWo9KSN<2kXjwA+f1A_)cl7=<k1TBe!!Kp}-$J8I|EJLCh?Z6q
z)fj^Bo*uz?mVwL1?h-w?Difk?I36^VFStkjA<uxsItdw+#E(zq?MfSlg-<xc>O$;?
z=CjL+nhMX6INZO?=+o2jciJ4^&+)hYkFCes=|A#k!awq-*gx_oUfEDu+7R3xwk{s+
zKd;<wgWK=J_Wj!vzii0^hG)Nz&d-OPk53wr(~7WQ>v1kjZta}^VC$4`Mv}bZEuv8)
z5vio9@P&(8p^0+~t^$O}QbmnK)^SylMl$#3>nkj5>T&4R_vSS1xBE9XA#d0B$4(mr
zhgNW)>?vv=Omc^ioogW@JA$33F=KqGDEl19?>s~Inuv8{5AAb>4}ZHYM75WNd7o(k
zc{4o&!SHH{8JC$J`KMk6ohu`wo;l3sKKP_(u$q2;Qayd})vGa1hwjs8K`0l5`^hg@
zq}JBJ(R9)^lmNN8UMeUAvafK5hruW-a=w2~R%E;K620|2t$`8IRDV8b>vjgVogW80
z8cxe$=`H785ZG2PL{T4Zl($W9&f*RvRB<aYDYo%ie9rH(<@IcyT9CPbh;r@Pwj%iw
z`QH(wq6jI5?9j7F1h%pS(Rk#5fM_!bqHa5Can-i`E<jia5IQz_0&;dR{cS$Q8^F`W
zz{n7IlA96K&!MDss@b1iIJj#HQvZTSf84?%2SutMK_5g#Q7DJd%7>Vw(mtM{b5(hU
zJzU)1V{fz{Vv3)2fyM(&tsNP{^-pF=BJoEImtlXFy^(TwN`kB><`0ChVwOaaMa{Vy
z)L5qc;RxT(eZvR;^bdW(s8wh-mK>wQp>FQ(rmwb6lmU*QntvuIyaWm&C5&_k)FRvv
zMh2tFY9{H!>b44f0vEiWTCq^oz^oybP5lfSVcnp<{y<@Up$f#6DS7Kr(#~8L{KRW%
zh@*jp6mcoB3DL|cf=samr#%3V*w?R>5L)=xbb8{cBTKy%Tg<1<teV^y<J<^>_rxXj
zPzF!|F0jxro%EU{H(*<e5N~IKoqE|va2Xaaw{{g^yhHo%raxwCa=~vhS5Ci#j#7L1
zNdJ^MYUe!})|wLVTwRZb$sx4p#nJt!pZ`5S0o7_h-nT1$Ut!TfT5eeu5J;9jx=fFt
zy0Aa+3)`sVu^~kOeT3i=D%a@nMxXZyj*JsReeh&-NCq`_?LiRe#%(oFUb1Ae*0;#S
zwrYRy%t7v7%$o0pj6;1L5La1LNs*A}AUN&xi4Cigk}%jKX%0fs&!2*Y-9ZU+rD=*<
zQ8Xc8DmXh4M~Xt5Ld!lAO6&MMt~^-F=rHF>)B&sRh9f$jcv+JYh^3~sv6d)<^0ETB
zEmfzXbhQs7%&5C?X7r+|h`{FWjyWKP4j4cn7{rT?H>i`WFdbs^(-b~W`Hx@kT?t0v
zz}r#8cQKv}YPaM7*B#8Ji*Z1%Fi;$$4{P|O;zZ!i%UQV3MgLeG0ZB-ba;#yr@2?*?
z^Lj+X`66=4>p~~tZoC;%BP!+0P(i6JD5%#OigTHpVR@Gh!|O$BFnmBV6K3w6*y%)?
z;ot{P*c|pJUK5%netjUG8JRG^RvH}gXc&_Y>07se!!DsH;IX@`R8m2?WtEAdU|}$G
zT=y=ndxC{M`U0~s7gpy(_;oDr=N?Gf&BM#b&%@_e&A7{Z+_eOifff-=vKn3hZ1@Mx
zGIkKV!F&NLO%eD-<U(<IHTu~_C<A6j@v|AakW3aC=NS?5b<){#5|cr~`QChol$HZE
zO_>2sAtGuQpSFd7mLm3pH{cjIWqiGLJTpVG;2jvD{ll~E>Pg*|UrU{ci>gN}pVekO
zRx8ah?aDDu($!nbbw=9DU+QLyII4yyD?C&wWz}1PXqVK1DV05Z%$dX&O4EW35L;N5
z?5$hss6&jzv4Q5nv=r;$BVEK!h==%q_-9;S>RyY}H}B6GyA%yXjBuI!fXz#a>k_gq
z=wLc$QA-ifa*^V|xQ!=DGm{Svlhl~4g!GsCCoo-W)<1+u+OY7Y^h56Yzuj0{YFW=n
z8#SZ=eIC-)`N?^ma}rfvuNz8QI=D_eWK2a=W-MS)Qu){wv!qAI#>2N@#<I753*M97
z-(!)kVAifOz;!la5}*7<DcxC!kG6Q_d3QkO*pCl#IHCdq+&0{7mM#kYix6u7w6X`D
zm^)u4``(p2o}j_TP=r*-5D@e+Cb|l*w&-9#z7t^8-zanyLOdg3Wl0f&$vi2Hl2MOu
z2Ms+Cc@>fdDw=0uf<T6Mm4ul!ATSk6(0&prWZm5kc~Q?*WLj@U>nc>onjnvMVjl__
zGMzP&MLpSCtg&kJDr<oiMB9_C?UkN|OvyPeGD&PKA4a9!_`(KzP2b0$F|~bW3OA_D
z_6~zawu%Z!GMJTZNnO&pN`4#sA)KLa@F}|qdn#w9(m;71XO&leu}|{jkmT#v17Fnx
zq(cXPE4DPmL>dnGH*^`%hfgaYgnqVTA08IknUa{s%dE>;seu-=rczz)1Z+~t5s(Ci
z!J-p>Ylt{0W~nyv<&s=V`E>1~dK@Mr$-J_mrCd@0A)Y~NTcR{Zx;$Q0z$2{2bHhYv
zVEV3+k9DADdAf~zq1cxEl6V#-rhx+#_42Xe?~(TakvC@s1#rK7+8qk6RRW&gj@oO{
z30r)>!`(QGRijCZ97YElp~EY=rk{v7qP@L#&Q3^vRHi7l=F$x!p##FZ{xB79yM1z%
z$2CeW=rrYQ%IGC7&gyCh*TUP#zUm`rf^x96WZXcXzFdpXF%ibYK}%d}&Cf55!-V*&
z)$L)HiT3I_N+aQerqdA>E5i&;b*up<AnG>DTvD1p3L4EyWqM+!4M3_w$XLIBjMY4P
zJ;|X2C@F&*j$O*nUZ)XagPQVr62j;jz^L*diYh}Sup1RDM5mCVinKRwiFn%WwwPdm
z!vR`U6;vmwA7}s;2VY_T^@`_)gOB$7rY8hJF#x?dh3cDaFsdjdhcvpRPOK6jAsC?q
z)jA>bD-z^0)5W$A9_H~*dB2<0k6K2QI}0rxG0xW_RMfu*5X^!QXJu`EipZS492v<Y
z7tkw%2h6*QZ<jfSfJOdOEt8u9aKix3mDs3MU3oL;BlpvJwWA^3H&zSovbXY{Y82bF
z<qzAs#5cXDFXaSO5exw30Vp^1DJWEOf6B`fFVl3U5R;dIq_LUhG;b<X<&(=b&L$}d
zmrg=8@4VvC5$6?=Dco*zr<|a@_`yhs|A(=6U=jstwk!*`Y}>YN+qP}H>XvQWwr$(C
zZF}x}6BDna=Zon66DQ8j+__flgvSXK__?GW4t8u;X^TjGQwH2T4=FnCA=Mm@4;&E&
z*<Jd)P5YHAW>kk?8t7}v-K7Qn3lhQf>b*3GRP^W?&YJ*82ho--!eCk<J3Ws`q$S}|
zD2Uz!AVHZ}ib$JZ8|f_xW4=X$2#C~^S_KHB;`4G%wH4BV5y`i$x;FbXCxn`gby7Is
zsTC6X>$6Ei0G&Z1s$rz#?^+WGgX3q%V7FO?*7m(+s?wD3R>jK}(JCCH4mkzM1Y!%F
zCURDh(P0&BKlX!gi3md1d(E7FwIGx6u}t}NTUE8P*lRZ6cA-RA6$@QC^m1Y%T$L8)
zV@k}p`qs=iSgVeW2{I$>OK?t-eH}-5ngcu=3HI8XEeKKbeedW@f>zgTT$L8prgSV^
zXH34Elb$Eja$F_M*^4=Aq1F;n0lh<y6-z0IfneU50S}>+n}<600gtz#m0ND2L@RGA
zq_POQreoPjcSW>fyhT#WU|QM!HB4O*(NjsvMg5kf7W>vjd}E^MmehNRs>_60rr558
zotp4W>1qD;SyrU;Ovkbg-JfAY8$%$1wLc|ZezQ3aY08^SGhsf_a_y~eWnTKb2ah5Y
zrkev-`dIoT8T~VT;QXg3J>ij);*!6wg>`BYhix?!=xjH5mPTMrEyC{x&6%k*WEX}E
zY1SOW7&x2q8?KKy`sf!Mh`XwtEFEwctO%coTN9fU7;2SSp5I4PVtJpa*4oD<0dVbx
zPQy$bh)<eo@e?sOW}mv|NDKJvYRA{CE{*<@VG&9TJkbJPWP4Vt_uV}67`GH}a42=W
zFST}dx3zY+bP{rh%v>bQdWQ|ctLeIHVSfRP_HE!sIRVcF<^YV<wqT<YKX^*0u9i+|
z?xbXc-d0<^&#AT3;rRXia`(zv1aIWj;!Bu|w33jBWbC%))|+AA(0U<vapb;_5DEeW
zh3F#7>K=;K!(NE$>dHyH2NT~y%t0KW-ptrc)x)fg5?EcC5_ysx7?guj5)+H<evdFe
zf&p+LHHMOx4~luuG0a-PsKpte7_L&eq!s|mee^nnV^iXZJ@CcB`P!HWXD}7bBCno3
z3TrL~z)!CRmfu9VGnFxwf*FP{qOO-A_#u8<nAy4TSzaRkn*M+lhNJr8O80C;G}Wl`
zYzj<3@eH>p`K>X;2~5OX=%=@_uXViq3nHg>+O@ZEzrbZpv9bR-VEuo)P$niumjBt2
zGO_)KMk*8A|6L>XAC_knp=Y+%{BC-#G5J=K9MiPItM0$au=?I{Rmt%tsxO}X|6HKL
zyhM5`+dQ2E`cm{6=QUGN5nqJ=;IQH{u~&Dqp>A?`{|Kvtt^WiI?mw13Z=VL7(y?E8
zRi4OTM#G2RZ*M<$)3tDTxU_fQovW|^WjNsde){>|O*!6HyR@4PJ$Lrx4b8v19p&TW
z?&T$iA%Z!KeYyMi-rtU7r+0P#-iM3aBWsbKP2|RTXDm<DEJ5)zc^Fz60LhgV>#Tbp
z+P88K>sK=?kri{lE5|8B<4bI7BU?I;t?l({`v-!>8Tx+d?Ck;bSk2}0_Wa#n<SUr6
zCU0!{Q1DEj?&pkW37bMQl8d4dwKS0*v&5-Qx%K_|*>!-}(F$O=FVly4FN5l)9>~)D
zJs_(RLti6f6vSN%B8mc1pc9SI=tdtW`(e)LuX7CPLSwp+1DW=JG26moa`+;)(8+<e
z{2(7FysIB7{c80knt84X0(=A1dYcTNb|7$SfLit7<n2ErQy-+81o=8|NvbyB0VGdz
zK+Jcz|EKI*q`)^tzTgP^IpFn!rRu0<|EasN%hY8TKTmxOG)@UZiUZY=-)e9gphUtq
zNfXUM)(Yx^h%tl~V;Ve3w%0}o!$bl6Z8rx_%c>P9+Tt&o*S}>WV2lk5gLX#_AR-hi
zOr{Zon`b{qGT$J^=Cl{FPN=@MmRU0l-D1M0<eeAG19QghjczBGW{!w*wnwDz8@Q44
z{fk5bc_l2f=-5d7C@J29z+xGNDgPj?(1@NNZ0flT8Hea*`Ukli5Se8cH1W+FkNDHJ
zQuEe{tGeji(SeqF&q?gff6v?0*%~p+vv5Vhgzs1<Y0CGa%)Cg-mr?`x6yOY~n<g(i
z6h^3<KqG*+wM&BazIZzu16Yj_K;!&|miB|vX9e4ku6JZ{8VevKo26BNJyx6@05vbT
zOTK)BKSzXP@-)cNu99J?-yAAF*<I<>KwTJV3N)e#5RqEcP_XPE#c|%AHOsKr{K!n*
z5g?YhHB_GfAd1!b9y#h2=HP0}-BaMS(cr2t=eUahGrK!9zp&fQeE&Iz<T5@Om@aJy
zG9g;J0HhK}Ymk{OE&c$xnvW9pc~3|IHWHYJT~MwBM`>#wI*LNrNsJNBz}RW2nceiY
z={yrVMH+@AERh$gFV7+sQf`K$8U%v41R;9RfWg!2%>t70;)S9?){ey_M*$0qT^t9P
zv%U&@AB+<zK}dGF%%|TT8)6F}M9}Jwt={%(ypcO3cUH+543}|OFo9fworPwq5`7gJ
zqTk<!Kq@J$Kq0UU`NW&9sWr%K407>t_3xLM*+eyHJ2CBS8C*)n55fnICP%TOFEa0f
zJYq^GtxOy%@I(PC2*EP%yJQIchzofSZLyTFUar$vX@z88uUJxKfiH?v>VH@NG#fMu
zCQ&921xeb+oIv=E$88Hcfrb!Ru`zY7S0b9J9O@Gflwr}>??pNuf@~V|%ec~xz&So&
zqRMsi$d0~E)yP36a7`4=G+?SbiArId{2kdinu|*;u{>Ttf`prOrYV#_p-0^HL1zxx
zmEc|;K50gWobd}4^I}?Ln22*z^p>UYM<Lh=_D29>m|bd;p3^Mlnxn=%URn@hXv0ri
z9=a3z?M|!tE6J?9rZN4q>|_Bd^bcvNp`38DTZYtLHDw6*j@y({*(EDie#W5C{=%-c
ztfFJ_+U16W=)pnybHII~1vrwDi^7aH2TU@Kk%j-}n<SeeuUDe?X<5b;<0UD{Au)E&
z)Pc$=85R5`q=C>ie`5)D774r54B@FjVDclko2I`3cv?hPK|4u9B=>U+K!O!roRRN*
z5*=*=ZYDerL|x>NKbR06R*O4Rgd6V2UGRtr^hSR?M#LBUOySH3RqPmNDj?5meDB|n
z@LAiqOD9ES@wc1}F^@&*173%PmjPWcX~>rgZ)n-mHKaA8P=o5qJE0PgIX@<oVBcd&
z=#^IB8xW)n+tiGr>lCKN&K$LmM@A_37v2l<B|}t5#i6gnNy42I;2YjI9=Fhd(k}Ep
zsKh33kzvhcPb6{fvfPw7E)$s#5{2ot@Gmp&F=>kQk4gBVOL|B{IxfW%kf^t{!hVb{
zM?2&y3wSQUJSV8KUk3U`^|Q*ouGJ=_8dfuAWRJ`&2d-xeY;k3w%@`oxg-(M}ZaxQS
z2jiJkPsYY{`WUGu5H#B5nzRGc(!F!oNN@$%4^U~0tHQKS*-y0J&U6EMv=%1^wLNwF
z?sf)jPNs1lYEurbo!Sfa#}B-PfarOhhxyyx<hl6+`ai%i{A@@~WjJb1vSoby=W1&h
zStp29w!1kcFKqO5=61IQ)oStzr8aL##c<L%M)lLCjmMMoP13D`YP&K?AS5Iqbu0qa
zl_Nkw6>cUxn7RMS^>{YX%bp_g<oTU37nm$cX<uBio0>YF2~s|ck}EBHN;rb`8&r$G
z{=g~aPNWGQHr<_t@~O;Es`!@=?<lME6F~~-S$ogr-<{?-I2cX7S1^Xc9{)0N0Dy<F
z5a0mtf4)xH36Hm{p`l%8a=bo%;_-bYeaX&;_bVEx02*0|XtURCZX+qK@YJJ;x}8$9
zYq$>{vW)Dg_L9^}Gr)lA2rF4zbzp!AH3Up`6~^Fb0qia5kUYUl06q~}vqTqV?%ke*
z#t)Yyl4*EN8{h6g@Tj=Xr(B^thYd#k70AQCO;3w?v@m5wTH$<xio*#m9W*M49oLsL
zpa8#J!D*+$V;!K@kD;sM{4v^h!y?8|aVFE($qY~yV`V_@DuPGv@tts>dE1=>ATZJ>
zVV>L_Gv?nmMUJHyOC5aggH9m8SJ?jRQ|jcdQIysP|6H&hF82oL{Sn2t^?G;IL>|6U
zs7J3qF=?R-ebd658-qBhWLs0H0S$Lrv*l+=Jq1vK<V#Cr4+vYd((z>M`o|42@EPQk
zp^S)csFdN};v}Td{f&B1PmL{@lGMaEC&n9lIIy?9J3uG8Q=kZ5$W<jV;3}hXaDRe_
z%-28>;G+Jxpg=OBemsbZvh(EKciobbN^yp!L`CtrGlo`6LtSA&7H~kZ)uQr47mK}h
z20|SS)N3ZYu|%TMiCtU+Mj}495ff@dTCOQWiSey4v2f%gyBKe!e@4KmF}lJ=$7EZU
z?Ds)wG52M6zMa!H2cgk6!|cXV#{}z}$uNcOWi}4M?WLy0>ZkUp#xyrw&Uu1&jLjsv
zm=4MJt1ejdh1Ks&5J+1(k<uo_KTQBu+T9rW5EnCFd2s8-ChvHgXzH#&a?29UV+aSQ
z>Du%6Hm|!qFeO$>Q7{et>&7Dg80-31u<YW?2aVEWDBGv$I-}Q|?D_`E`eorIs8r-L
zniT`-LXFL!mwF?elc9SBsO90!_M&6EKkU_!b8g+KFN;l#xwT#Yl?V^kEi#gKXb3wG
zf2m;Jx**UozG;jl9@DDKa>4j;TIJ?c*HkJJR7BM(W29boatv455XZ{<A_=KZd6nW4
zDbTSg(|qi$co=EJ_10~EphUM)r;1qt#$F)r@KQ_d38{z)8nrTmIGD&fN4sa76E66C
zYut%e*&|xUbmzMHT(YrYO2&Kn>ZIZ`*~<&h^*&C&X%$m0ZZmsx)5=z6b4Ib*<pfm2
z@sFe|(-^F_+dtC&1A}rfe6YW<ry}|_jfkDCMtSfUoKYSewZqcVBzxOI4x*PMu16`#
zM|e_jA()FoL6sWr<;>v#)sUfoodZ%0U4->@T6?;5v|YUby5DCpY>$H<3>@~GOj1OY
z`(Sm9>o%QB<>3tJJC>c#Rec59mO_E3uTf7$=?61{Z<dfYjwpX%pOr)XDN3^~wC5(P
zk(RX+4Apaf?fVVNdk1ZC^wv_42^ZmtPBm)Q>{&G@UF)i4KM5!*qhl|d_=V#ii)Q!0
z&2#r4hiNQ1Ez7|#Xf?C3CZB)Q1H{OeLMK&P(1!Rlhgp=2wc;`5^-6WTT2xc@h6?fW
zi<Ny2GdbcYEXVe$$!_9y-u_C_sS2UmN8TY;M}Kb`YPtED@XNxUqnRwuPxo&Spm3YS
zZk?{41a)(lLOuc4m34|ur~Hk?ZhIG!T{>~IA*<L4)3_v<KITyc3Ys;``|Cb3VqKe9
z&ty_XR88%qazJHNM-$1B0jBy}ot69h#|gcxttiFV8j&z2FVwaEZK=W-+LiPEC6m!m
z${qSHv$+*`W610L{wdrs_s`y!Jh6A>8Y|6sv#SyOL|qTAaG4hDR}xz?m`u|wkCSGx
zBiAiWdKl*R$!5mWvpGu3ZY;E|8MbZ3<HJJ6xO@lppN>ok<JS0k@f0!4oVpW{lHJ<}
z=hZ<^pm3+o`ZAD|&5wX~W-_Lvyr6>v45E_WR{$pWvP^EFQuFzc)tPkt^}pf3kyos3
z6i@2Sxs;%x6QZ6sFBc=Aa8|#50wkDGF&$<-wy^6@XRcIgYr*MaXZivUReDW-pd5!?
zX?!Nri8|mPtJCrMwXECM!58S8ZGr$hD&q@+PjGGmy6>C-=TW~7ifDG;E(iSp$nVcS
z{$q;!?_l=d>s;plHN`PA{#U8>e_Q7=Gya!2@Bg&UtyZ6mIATTKUR6VHz$&xsHt}ar
z9#<ju*MLTzA~cRS#wCu#SYRf8|J<rft);G{BFOJ=vf;To%ql!IB;);ZaOdRf{rWgB
z)zb}`)be}t(Ff)V7vS<q2y}U1hMmO=eYFdr3#IDv`$&;nT-5sAW~}q*p|$}1;_>6v
zz6n(rG#=cRfO&-*T#SYb$i1@veHtu!qb4hy7@jt4usnI&MYyqhyNf{M#Tz!}=0$-P
z4OUCpU*sm>9#UZMpLierd=0()zM}>8`2A<<V+;8HdLGo{(A<eu)q;@-F+c9}2vdPv
z3(-kSi}f@#+X_E#|Ej#3uxre2gC#m(pF~5wY0uTcL@~RAr&eo}FlsNVJ>PKU?Ff%$
zN;Lq<+5M;sIK@SkzwW^eFreKEQ5)FPb%<qW;WdTF7;;Eb!ulI5@kV%(XMjcSFL`^}
zWGHCp&ro+1AB*1b_Y`qZ&PZ7k#<T-jIBmqZ3rYPCm&Ct~L86wTr$c)1&83Ai>-HET
ziK#lv_~?>o0<@lL+micSLiQFczWwp1ofi{fKva-bbe?h^vh)PmD=H+478&po5-}=)
z6ovCSn(*a|82_$Bu*9(bEM_`;d`w52XZH@Kh$hmDHV_qXo8jM9j0`*`A>ua38f5b~
z^&BHbW<eQTm3>$KvpU@FI4DTM1dHGWY%mBeZ5CUXO7sHq;u$P!Rt8rCV(2ry$Otj|
zg{vYq`UsD{83N-0JM*CQHo)|W)WbFkpZScXCr$OC2>9d){<`MP6%{DDJd`qGh62F}
z5Yo1a+B<O;>nZCnHiiOm7(AkpDt{u1FtNU9nil~oq;_*(<;a;oV&uDPr|i@)btDv!
z39z`~GxBpL^UYMDuOMjS*{nhh#cZdm`onJW58$c`0cF?aNIX_~83mcHri-4gLkl0x
z7>q8m1LzVLe=o9CW41NT`Gn&4#8-p6^9Q)d1Un=+W!t^Np%4khG8CuR#>7ke5~%Jd
zi*zmbprNXg79=TavqpYvBwZkBr`2oaDR(x&x;aK7#Yc%H*tU8PkdphA;aY7)*5g+C
zVob9A&I*Nh#r!XsHme>T>Jj!y)IkSsSGz`2On-ylhMB72Afpt`LBjLtk;8|Kj#I9v
z5_ef7f-M^$qc18*eyE2<^s!@gfTA?z1CTVM&0s2Uw4A37q;w$Fl%NVB>6)GMPPK}S
zXgY5z*T6rP1CHY(7#1tghka5q(<VfnByw%oG1xGcP5+Fv<&9AdV7lGSVi0vkDIBiR
zlV+VHcegk7m;rxXhsz4;kt7Wi@#oKUGA=7`A>|PLcr&)dxJUk_7XSykg|N4RX%!h_
zo!TW)YL~#{mvLpGx)@CAFxibOZlGeJ1CP}PT4%>H3>yR)OXx-ZW%H<rc6t>O>El>D
zI0Xz(viY+i3PosKJo3z;!iZ|sJ-I4zA#Pca7ph#DCvl7mamqWlw9;E$rtTWU3-y<n
zr6gnxEqDg$^3h!9Cw>Y6n^Y*Bv`l(x$*)YQK_rIJ@b|KV_T=Mx)jKa~e8Dw;U~VaC
zCUW83N*tdS+a3QSVH&_p>rUV7wZ0^nd))O4*cvmdN#OJ%2vXCN5ip~>T5k2sp?VLR
zkju1?47IpmeNj`YxHw*tc3T*P-LV_1{ZI2*d&LV_YX_q0>F$iSx>P2{nFX^h%^1um
zUKfDUNP1>FBx!M*V4e}3)_$FjhYFHvHZmLJPnL=U#$Yts)E4!moPMIN*Zk3nLcnQi
zP1Gp!E{q>=RjRSre|nhz-?#R^9$<!l^R@pOuQ4<I2SqqD)BlYkd|Uf}3JhBMuTL(X
zph5hY77~JA`s{IFiC|p3urY%U2iW2dw@N;>6*oEYD-896fH>8vi;FtX%WA6{_k?i2
z-kxqh`-`o+-tVPyp_68pi@R_K__|B|v@arfTLpS2gK&7Tes9nFhl?=2zc*|b?%uEK
zADfo~S+c2C9Y8<dcc-P3pJZJ9AhPQ2|IWkrw=ccp?rt*aVnlPV<~2&?X776a@k&<D
zIcfGsABnU5UlV`tN`jE?{4<EX`v>T#zXm9N3*`K~e>+PzKTBs1ZFl_MR!j9L?w4Qn
ze!1+VU|U(HUxr6)&I6MSv^2Ai6tsglcq$9)>S)?W@Qy0|R8|u?C>=a?V;p%Ue3Cf7
zF?E}JfnMm)>Q|(Kcxgu8{1;3N-ZJFtQo2g)f)l9_Y)@kjw0lcS>Y4&KX`guSB~x7s
zlX@E=r9zhvrk&fgHQUmEi<vD>-Kh*lY3X3Sk|VsOHac`a7TU$hZ)-cbNcJ*m>Gmr2
z4n&)wCxc!eARq3bO7I3_>ah<L&y`83&0hiYMgY>V`Mux(&fNtx&d$z-0SPsBLFqAe
zCW>P7p9V}Md;t8(>6MPsp43dTQu;n6cf(tiYRQg)L??Ozx)x9F5q&+XK48NJKHD<i
zrky;e7r>H6A}bx(Lu#4}I{MrnN?Fi#s1oFOs$IbiOSY0V(HKc1{Qq4N-gj1cM<>%I
zK16H&ozlF<OIEl%|JG}{H}-UA6m?Gh!$18)y}^_<R-w?*uYt_Zl4KciUUVD<Jto*I
z-QC!i@lMQhrnP9V$FB=0J)#OU>k|8fm`Q@eqCVL%R3*B<HyzwBFyZ`azuE?D>f=%z
z)ckfabhU1z&xzO-la)BHe3`V~knn_rR;pwe<2i%QGDceC_<X9O;(RxstO4JZ0i}&(
z5I>y+@gtxFBWjm{6Od2+V??Yhx;zXUjecnL&}X~X5K2d+hZ<7bHZFw-f6yYCJM?M&
zXr`Y_i2sw^A&3a6AS5a*AmPB4Diaoi5t)^@Z=UKK{nBZO^f(v3JGv(d%c8T$$wTRB
zBie8~H;v`(>oW6pmRu5kYv3Ih#I@F*&J3^K`N)$7m`Jw61V-@%f;1GG$jW9$ps5T`
zN7*QdTu$Jry=;>KHYrhg=9!GD0WWVzMQ`XoGs&Dj{Aai0StyyV_u~@mj^^?ekI(1r
z?Hq5tcg>-TPy|(ux0+!D(?+#X{rAQcy6z|kEYs61Zo)%M(QaN}tlpiv(GjG2DoN^4
zJ23!wU^ph@A)VeX3aAF;R%A@APJAHAj2^KnBnD$Nw!vQ#>zhJ^3jRERsKQ;LWO4%F
zWUN{0A5ALgW=F$6l7P7d^f%Z$;cx*{1FSFMYy>AIFT;YzKQ;^1EDPd>(MNv}4sxOR
z92B%3;LUDuI2(r?ci3>rAxc#fx@x|Lne_mivvX?CXsx?&OnWBVc-r3HHj%}yA8Mz|
z)tLKT(VZt@s~P@=#r>s{51g<Ku`GZyOEY;8ZB!qhb63jYJ_t__DyI*_iB6s;lv-ln
zWG@Z0##s1mCg`YZj1CA`AD#j5S1Tl-hwv}!nc(t=NOM2NI_jqW=#!|!3OvujuyadY
zWX}3wYA_~AbA_j_Ly1PS`e1PiM*&ahErpJE`U!m4)UrhL2DKydt)wh9Gz{t}MfVy!
zAQG%|f7w8~<?}7$FMP|NOh6i%qa3QQLJ57+)`UgtdMErl$Q)gCS!-$}r>%QY_6?<X
zT5;^rXDy6>|MAgh5+TVbI)xnUr&IdBuGCr>*VX+DovQl7H?)ze_(Y2wuW?IOoDcZV
zi229l40Ba&*~)oGQHs|P{l}IdqGYM9DJZ0TA-rP7Omy(_4(C?|=7?G5w`yTos2zVw
z)(i!)khx}{KF_J;uzq95;u0argcSdjU9p^?$Y-~vh;np>(ccU^n68s*%ps4Xuf(Cc
zPTIs<mV!lO+hT8M9mkH1@q1>MOpyeZS>N@1I4Z%VNYxlqCg;^Vg5*yic8Ax}-e<OH
z4#xcRdNZl!ptLFKIkJG>XcFDG%oV-aRZwmju)3jynh*1>&CUT&#8A39P?n;W^4V1U
z$uNF*2p<&Vl>^IFYvr7A43(XoM=9HsQkOaq!ydduhMCQSQo!JL(l6CP_7}-gW<$r9
ziFSbORF2?RRe6{&5U=*1)pWQj5J^KDpGS<$H#+oe8SC&?^<}e|Hd<hGvcTEdE<{>{
zXjPGCN8<Z?nN6Ua`9X(Ng#|BJh3r8+c3nfhOk}(uf<_ZGL<?aXMLo<%V4pX^59@k&
z?tJ)8uE_<CnSuhX4uyC>_+q-Xr3a{z-(l&}0kS5i6-(_)iiJo~O;{XYngr`B9|mxM
z9&=UTj<Ish9|RM&d~Ga+|2G4?nXHX)ZjUgN1UJ1&fdL+!byw2}j`O@(mGvLbtak|E
zfi~1}!aXOfN2gW6m;|GXOC?hdsaniXmqY<5T-<(WZd?Mb>4RQ2xq|gZq1kWH<}+x}
zHLgx+k5!Zf<XoIcT!}ok<ObTcXGy=LOqZn|-mZH<4Au;iVX8JofpAD0NVg4XY?>_C
z+75?-tUMczTYuB1eF;AE74}_61CLXo9c;yF)>syb#yJmBJt%KNL8p|~bsJy1TR)ny
zgGE&xe-mMOrXdovh-HHwZ!{J+Y+BNbUs-CAz9#$4R-n*gL~8zWWR~~TGL^5Qk^8oV
z(b%oaEPk7$H*8&*0DNPHe+HdQKZ#siT0av~y`qwN$kemCK4b}dwpem)Yef_IeONFG
z<Wp#of;emMT_*SOgGjd6$A9xXm{Um?i+er;<L}+~x9Yx?r?^h+I!F+{lG-{j4;7VU
zrG+_>6WW6pE0DkI;*;pRpQ>z-OgaF%wIS^31@(Hk-|p2m77>5G_+|Jf0H%r4fI|A$
z7;H7FC%zH1%dj+t6Wb%>*&SSq`LTP6G@TQzj1syQl(PW~_E!vS_0nMy`1XG4dcpM2
z-|VO0k%yXM4pp)Nr6@)V76!Z;Y2X${7&oY7h&6`2y?>?*t6>`=@BFlYBmncf&g5(^
zd!=g5*9Iq;b5u5eT^uR~Ik8vwEJ`t3P%ztJiTxy3cqU$^$pa8CVYF`wOkbj<$Ze_4
zcGrkjiR>4JO=s6QUqTMv6Nf&!u^QAWInJ1ocQt^WG|!5Tkn@0$<xQ_E!@={CZhFvw
zSvYmayRbO6Ha(9N(M%8VKFf^rWtBe82-MWnh^X4K(q<L#K8u1LM#qj+h7k#hZXSI%
zK!VObV;Okywhv0nXh;;WTZ06Rp0t=g*LlY9k>ssvBa81VK+OXJoJo@cHMpp-PuLOW
zZ2gqDSR$eEVxi2;^SH6)C-|amI|UmN3;P+iN&Z=26leg$cGItt&lUg<PwC0>T+Dp0
zsLB~oHw6>-`p68y>OP0Y0SvWje(pINwlGH?m-+}0aQ=x*6hO_pnz85hB<=1X`;%ss
zL~#%8a!~YypvDMEo8Pz(p3FZtW?n@S{IVGJQDxocm@%cH%VkC6Hd<!$Cf!^a&fO8(
zu<6j%_$6`Wn@H5jq#4o+8#~1d{GZn$C~bn0fua~2Gww73_7)rKO>U~M6<}1a1F^d5
z1wy%bYWW$aX<rVFSzpYqmEAgn$`#j<I(Jc<m~bo7dE2{_@!O+BhL*(Ai+^E-yvA0z
zEW|vc%9f7QVY2unnaLS>Pe+ci#HKefBD57_h&S_o1W~WDtmqB=LkrB|{}PHV`G9~E
ztW0qpE`}9>g_DU|Qn2w{(N_Tm$8|tB-ek5oR1|(^TSjOaZ#LAt>jMVnvj#u>QG_TY
zQZF?4m7WWuIp{M#gGovCa_(=a=cf(gzi-h>s7N01L>?`W&3aylOI@}L!DwB$8UvSV
z8(2lfSHo66bs)sF5r)4!DQ`Mpb?Q)aoQ>Aj;GbC*G=vkfwfKmlICpSk5q_X>yseD!
zbk+u_$m3xBrU}1|hdp%dUhPmKX7G$M1#wm)d1;KW$8SrdR<LFHa-9R#_&Ph!KZsTk
zii!?{MRLd$dTM%d^3xxN#6xZ6+66vhHbFH$mcPbxd4Xf=Tu-kCQ(2N;eb417BOH~h
zAZIdbuZtSnSjPm{S0#$>EJf_NuY>HEq-#Xnz(aG2$Gg$@0M+MqN#9uk13*YLt~)eq
z(<t7rU%%0<dDiBnX#!@wvaxxhN{y*_4bUmxEdA8L4K7`D@-|yA2Zv%xVNMV@bmgpC
zTp{GFA9Ruxo}D<6ZXEn*2KMng+RpxtIw8k%pW6;jb1<~M?nMsyP19AOy-vZ`O`Nj(
zG<erO^BX?Sae~yk`w2t2Zo5QYGI=c8_v`IeuvBo*$PwqS*ub(C&8@{ENKlG{YpK|I
z6fbxrc1K~U4n%>wbvK~|&oX;zzbXW?5rO`LEkPi?Z&fFJo8D~wh)rcUg7JV=-3_8`
zWp6rwUl~P8W~X0}eSqodnhT1GAS?ybf?hKN0Z|h*dBn4z%B|b1hnP=O)33KXH%!fX
zx?^_S-q7C%YmV<>!L`j^(c|P8AxdgNT57bs*%EEA;u1ABE1z~x#{9`{C3KyAAxpb@
z3)AoWx<9xJ>El+aU)Yq5>*|f*>>DElups09X&2?u|LGPyXMDrwap=c=L{WXs)>+lE
z@}@!XyX)Im+2JQfF~WR?+dK8QHN!HTXhhe*a1+xLL@Bx%>h!wLe}e+tf_Oee$9}bI
z1ti38xm?b8-V8QSPj0Gu<269fLYXz?q0HT0XJ_sJ>0sZ3g$u@xhD@(k2+E~8CWZ3F
zA^<M)disJ$a6m;Z?(76<HF}s$X^Qwv@4h(j?i#}e2SxOY#{5s8Y!9Q^65Px42=QOM
z8oTE@C_ox^r6BjvzE;o9uw4RFVqJ$RJEEVImQJE9kkk-wI^~kXO)tRy8R*wM!(^1P
zUsSku09~BxKRoI()`W`q5<V=o1RXtNTIk|od@&6BxdAEB+zkJ&BrSdu@LV)(C(;t`
zEmW_c&e~yE-u?GIhmmXP`H_Cw)qYPux|raYybV2F2>lM8%%es)!wBASd)PP5i)2cu
zj>jj?+maA9D>HMRq_>|>Lw^A<60LXtW5E9J%>3VzPj)8O|0Q7mr~V4_|5blwSzF`3
z7}~zKdIWcyf>sYRl<+|1lF>F@a8NM5>R)x2*$h^h7~HmX-?um(Vn+%j&l~8CbDN54
zx(IsS4#rD$M0{U|=Yz+Wo3pvTZ-<-vAJ-30t-xG$h3sb<c*p%S59~NSzT96wnS-aL
zSYO|RwZrF6`<usXm;Twat1SPlQawNC=N});7U<ULAqKU4IJ{lbV6eSDA3sIQ8s&-0
zW(2Y)t|wo{Cyfrh7m4)&8YjN{r)EA41NM!WHp%m5w0n)or+i&MFXt~GPdaPE|3Jt+
z-;#BBz5h^eO*p(;G5)!n)?&Equbc4)Q*u`mOYa(4X|9tGAiV2Hehzx!&sDMk*}3n|
z2Z@`^si&v!$e{Lb6x;OZERDl{$Ds@uyb$STD`cc!PgdSTIj8J^QOyn&!_`-<2w=K%
zBLlBUSKvcOXfjOwG5T&>a>r^0PFaIFMfX-g{dZzD2NGM5+RB@9oA!Pbu@DXAZ*wHM
z(r+XW1Ybcv9{q2Sqtawx4tt5(vl4OlmmK0dvjL~nUg20$jKTxW4*VKhl`MzBK!Q^1
z{ef8DAE!Hyfc&b&+-3kCO~&13ZN@%hkQ6s*KXeLKk^1Ut6Tgu5YADQf&mM^#&<F%m
zAvr<Q1P*JG4CbuF^dBnf`r(Q1y%S~V^0;AHX4h!!M?yq>lueZ^S$hFF6eDx!F}u}5
zkSP65DgBtS7-U)Fnov<wiZFb^SLr-i1H^eBLWkETK`{GAaq|a8aPlJ#)*$2+5m0#r
zqq4~ys8Hc0s`|jlTnqJa>L>cSx-(1()s%w%`}iF9j-ZrRY1;JSe3Vo0GzIC3T<m`m
z8tP_&uq+T15Xfu1NR#K(t*ytKfaN8@<dftWw(DT^EdFGA0@kMe(T&)evUC)j^)iK%
zhY`MFV;VqG+Dp=MzuK2r9~txyLkM-0a6a-?m6TC69e)qJqyDjvE>#_(cA14K^4A5|
zctd3X##}IZ*n4cid8J6O?rk&F0v8mXM$!K!Ge+udS(-@sQBu2lg=)7J#5O>+9+E#C
zMQxH$7{FBlBk+n#xL|MPrPEZkp+W=l`e((B=d>3nSPRH5iuk07WM2^1<)s#yDI{ls
zgpB;0pszciOc<h=iG=_KLZQ_7*`9~<PJ3J|q2Fy3T~hPL+>nacQ5G~{xA1YMCdPCt
zI8Ehr+>0~@cdUcpF~#?3!nwZf7YSP_q~Y}j6+%QkFFzAQc8iCRXL(6|C(<&Dz?u^`
z#C(1GG0;YNf+1L^fvskY#q<5T6cgu3q08On_4WPqlH?m=|JG+5SHxj=YEYK6AlV07
z)ZFglPB0c5kG`6oY3@&CYnK`HybXH}Uo0ReHnPuIjO7G%M_R#^krM@N;QPBjZ8-)4
zVjL*AHO1VQr~I&nCW>?f5(Q#PDJmd1A<aNh;Tj6qDiol7u!F(qV7I59l#^mjGq0-5
zGD!fcVWB-W3K*2eWr&VdI~bS4arE(R&TNZ`=)Bg?5@f~nJbJU*>|Q#8#kQ{&MmXjX
zfrf3iLC$;j$1|dha3#z+M!*@+c}2762q#aH3y^_OV}0;S80xJneZ2yK(d>MZqB>0B
zDiSD)lCCC^P*Sw_^Zii|QG{F?fxD&#`LfCfQM;xytI#W}kogvu^v!o1lDH(#Wa@qu
zL5BYg2dK~`%!*eaVwq!twL!qF1l8-FIkP!hmp8!Yv(P0XLO%eE$ZGG710o91wL<nd
z+DuhK+fJehp|l)mShkt?*N65*z-h={(td*JwTES%AgxDDThKa&&#|m>%+zt+Xgm|o
zV*@pz<Px-+PW^%d1m7tD6i>iN5rBxf;I9!)1`Z=&E{gDyx%+N494gwv+<X$eX01<u
zy_T#^P@jXTdsnKqnu82V=SLeP3iq8N{2wF9+hq{$VbdK_K)?~b0*wSWJ5&&IeoZDp
z1Rub98jg`Tkw5MusxMg7h<OFllSHYAi3d@vkxI)9<~G#iwGu8^#^(kXq{8c_<oqBL
z#{DZD!3*)BN<g_!1j>^V&&5ICHpFyQi$MI;-K_MVAZ?FD>S$o2>vE^)op*8BZAfZc
z?^%cB^DD2Fj;1DuDIFz-REG;@e}QO52u1PR?ZUYkHQg-MZ0G3J%4h89U{Vo8+~d6Y
zh8$m2a=d82?-_saCuR|*ya!mr9%ETm^U6gMgPaMEi|t3G5XIWp`$z189~_voJ*1<V
z%JNl4XkRew>iy)bg=lNR$+R~fM3n5##T8aXm)l~iz=w*+lPoEJ+cljDxNhWS=Kx0k
zS$f>kEAUk~fJ=oLHk}Lh8RTzx(AZ?L-T4KTIIIeI7+xX<P_nf|Zpw9Kve7|x&i?pc
z%I;rBOgSo}#WCp|)Z<$n6vDU$Qukv}HcA@mOF?U0M#Pf`2Th4^tQLV7GqguQSFa)%
z7nZkFaUzLSSd*&NE9;8fE?Y{Fvi58n0)(qZboSNR;P1UER6y)C(AQ*IWhL~sw!*|&
zWq@@pGry=xZh|F(G9U0r0Av2d6y<lmy#)XxV9XHUzl-go>_>tqEO^~mWC(*CZ)9K9
zRzx0tzdm9k9v)kMH>iM8swrqm_+O8?q8(SjXnVef$<U^Jcfud9cj*3|(HUqe&Z)2k
zHcv!Mb`CfQ2c>!E6=BRhNTkG-aG0YU^B=WJ4Ju2w_K{nz_IrAoW2N6Zs?fz{{Pq}p
z3I;8GjXO_8xMloi{NgFu)#|#PFizBWx%@bqXc!t3G;o!l$0(1spHY~`%n%xy9-gHQ
zOIh&X&b=AwK|os=Ek)&6?21F4oK?9-Q>zun=1pBdbfj(HA^79kzima@?ScXa$Z$L6
zlZyIRHp82Af*qY3_7tMeVNty_KlB8FqAHM{&(#y*=W=4TASd2Y0Q0@ETf8u!QN?eR
zHSyEiQM>wN`$pjSk}2YpeMtaMc*aifdZp5%6&Rk>X=R5T<lltY=v8qRC50r-`8u4d
zTSOrE=H}0?fu1EtDR~{`j<PyJ@h|12A2K%<+I*o5uj-^hNX!mQ4uc8w#Sb&G%>@3A
zj~3o|$=%^Ljeob-`@GLDJDFp?9aZ4<Cn$u4n9=94C!f<<8T$Rs6uJt7AOiA2YzyIB
zu);Es&<BU|yk+~zW)J^cF6rwGO7euzo8-ZOy{+)`RYq-{j@!_Pk7eaD4su$#5~2s4
z8Q&_}SSO3)?jgpv%u+8oEM1uL$;l!!<*u-1f_1cnD5MK<XfbhNbBd%CQ7BuXD)#4q
z;A)tJA3ON8TQtXdUj2AP;0AhnL4;g~b=6|n4^5ZeKYTT+)aF?MLd|d+&nB#W(>b#8
zhUp}BJ;X*k^8+Y7O2$Y1nbPD>i@YGhXKT<!C)m{=CJ1GL^MH0!k*wZg4D8>1?ZSxf
z1es<Ya8v_pqMHk^B&!)tqFkh$N$D&Rg^k{jwDcGrgIoO(w;ttbtX}GOS84gq;AV-1
z0C0<UEBUGQtMTFKhN8Xf8g_Fz+uF7GBU`K2LUO3Lsm!58i~bW;hg5FmWu9S$QUfnK
zh2nMXKdIgK34)cYIM{ERI<4WO1==-eMlXlHn&mjAe#Q_RFG?imF1u)8S%o@$s0EG^
zVs?m&0XW#_imoCx$ni(y0<N6!<3S599AmNu#Z3}6%33WSJUp9h(LERvSp5|j;znQ$
z-j-eooFuu5zL7C*^1c|%q7SyW1-DU2Q7$fY{EwhNi<(>WSmVp|Qc{n<e66Caf|giB
z%Z9p9%v;o2GzqG>UWEO@!N013#t^eg#o*0b5bI9?Z%_8>sSep!&m1lJw4|GYK7|@g
zKshj6?94U6pfi)SE``hY@#OxD(C6w~4rOj6huNLS3Zb$O=SP~e`@<xd?F2S!qe$nn
z^Po5ALMY0`-v6pU=<5ncF$dM08(fHvmplX#gBvMM$`DxE!rXJWx?_f?$)VSbnynIx
z9%5jgx`gBM;(>8{t|xhIT$ZO@o7Q9?m*CGehMK)rLlhF9+X@9epk0fRAV=-@ok=zX
z{GL9p3#?0GirBQ>zXMJG^3&B5bX2(4%LCmg=4Yz`UnkECNFr=n9;pneo~FVkYd5aM
z?ys-N!YJoS!n_xy|7wV+ZETm*6%J9Td^_s{_E~9X8B20|V|&bNE<MvxE2-8nZ2maQ
zB+0hWIYfJ2eP>=G5^!&r@jd<79swtC^=HhtCo~B6{<KJ*z?PGe#XpsEbo+|GD;yVi
z+?S4<m3PkFT8CA==QR2@PBPo?gHu=vr2?`XL#mr0l>_o<h2^YXH~+<|TtDUNG9OEv
zVu&nhf-BaJa1otw)L)B2EGRUe*X{~&!Q?cd_i&#ZZfTEg9<9nqoNgh=MR?=5=_`LR
zuh~wX(Lm>u<H^+4S-l-z)7NDiqI(Nyw1O*7+ndU>u=QpZ79wxchpd`d@6)t!?2+%2
zcM11<r<>#1g0KC=huM#tygAmRN(0_I@M8Mhv4}jJL{eatJ|P28y_P+L2zj<hEbzoS
zsLr_JLsUA40s6NKv0xP!?to9LsP|!+D#ehRwq+hl7$#qyF|a+O4kXrk_8X`}ciKeQ
zRM$&3KnFy*-a!w?O`Q!dPNTGcXe!}#%QPlPx~RB&B;3<nL{sS=$r*li@oKpFxB&6#
z7k>ZL*9X=gPre%%s80R-+JtCay4MmjsQvtH5CA7#aLy|f_}Rfq0@52T(J(@BvGUn_
z{*)Uu9&%ILFR<T4CW=9`P*`YVHzRd?_+Lh|<IrECB}IqqW?HVD`d?c*i8{X#C@7N8
zT~s}u1Fuz}vpOtkmaSd;^cGr1m@)EEDekc7(4-+`ARlQAk_Po>Cd{aQzEp>XW{iip
z=mNPnssSB({cfl+&j`d=DxyQE96~-c3b5?q*P8UE);mSW=Bc&>@uW6WC-t#)`lULV
ze7GBg;I_a<1pW;_*6@OX5h@{El&WYii1jzM`07%8s_kA|W79`NTOfE^+l4WUEM@wz
zsD&z002v3gh4xjrLFOLNp{Yodb1d~DIAOPK{YssjqU0=7$D=flucI!OR7Cly_Rn*}
z*;+iff0E|H9<DDe3JHk7|Cpx#r$@xj@V^lASQr@p|2-lWhW|Pd`9JlDmbL!3G%X1q
zaFY;Zvlbd0;`1*}k5<()G`e%^f9`TU#Ecb6W-w3>29&5(OhiN-MuyQfti|K~d_UbB
zAC~rhe;m%{!q)EA$o+EH0dqwJx_*$ut&AT!{?{eQH(My2oZ8#>Hr~H9eY5#2mkP|4
zt4DVZ`*wS%m#e#*)8vmuy?FQjGP%EP!(sn+xr!&7p<$5Ku1S)%e`2|(R~glU$h*Cs
zwMPY|*B@(7z=l>hJNse0tdYAX=hQIZH}<Hv^Yi8G<Mlxs@%Zw?m-~aiCfED@uuF}W
zJ7I$Av!p=lvBy0|GMt{fMx}IW=3t1KGqU=|_jSTIeEi>udOMuXj8;y&BzIrwgNtAC
zW=+%1;NeR49*SUcz#aps4z;(aGV52e?vCBdknXIb84{_s`RpAw<sL2gbFh2CUBTUV
zgh}m3li;g%mb*5|B+9XNKh-mR?DaKs5ue4}Tm+3^{$Mrr4Q0JXzm6hPO?%SP7ckRU
z5)LvIeE%7>wr3A)m@hmUGnmK*?KclLFAF5}hNrLg_2qRQXWpc0tVUa#^p+~kUvIBm
zSWaUi9DfD}MpqSw{n2p^5r0IQ_&{;dD^gs5g0KzHJ?WJ`@~i(cQ;)x0k)&AG_z(*C
zISMy!aL9|^by**LlLIAHOID@GlLA!6uY!^-2K|7uc3A2JD_$C)4W`K&z%fc$trF1S
zPhYHjWjh8$SYt$`25CmBZT@96GhTAwKtg_W5j}*#-xoMF9j#1Z{m=VSzb-IiEx*sZ
z^Y2i(--$EQld}?)m+LOA;v`i?CYmHAHJCW97d9a|4$WMsOPpF>{av~MxFB%}U4T61
zzOXPKpiDMSK+wF@GNwpuaoq?yG!#920b;45&#p-#qM$nQy$i$;R>M&A7Oj|Kd@fjJ
zAF(&d;j`|gaByy<GOBqc1T2fFpfyM>)hY=5e+w>)<N*E1+@b5KRPWmZKLOcmN@Be}
z%%2g%V8ckMF_F}CAQmGbwTwf1N8aJs8U?M$w&4N}m2!-qy{+IpvyxPpB7~{;waNt+
zaUwvSn*2Ep>OV%*?ny5o@NH1Yf=p%z(;d-`#G6SpT*MyCvh~Xm1xQ`vDBOZ4q9S7T
z+z+F1JRL!y_PiAL#T7107<4PA>9$UtvH+3@G(Z~QpW6IK7Y0XP9iq{elhpw1*nhPT
z6l*I*9x~o;(B&ij#2s=$Zy%WwE)J(%uS{hyXMMF7-928Q^OI_~;!DbeEYB4t)EhBj
z{OC?huZ2$~#XA&R5{wtQL|HeQDcSBgAaOw!EW{T-8z4*0C71csr{UMg8{K0Z*pMWg
z;KQ(*$zm3rQLwwY<~B~m=o&!qu$o}nYi48<;bC2%NbdJ(1;bh*)xly`&>|Z%1Z1ob
zVO$cwc(`gb*5*~IRZ#29<((-^6}~OOTn4BlR?PW&trkP#ZNm2uS+RmWi*XVD@+>2a
zd(_drWUI*nWeXMLkW+I_|6Y`V`qnRoo{PNZA4LaSVPR9dOZjkR^Vq7%v<o!Xb3|wA
zNz4er0My7g($_=h2PA1ep>Xjw)w2(J^1O^+4&V%h6zV8u_TiTzk&R<egKIY|QTv~P
zBrqwqkwf;5AQGZyeVRp_6RHXfGB;pKCMZzxE+*^ClcTa%1S*WJgiSR=P@Grp4$Phi
z>lc){RnlXGcb{grfV4-yJ@_IEZ&RY_S`t~;KjOPDHYZb945bXT-2Tqf5cq^?;;MDG
zwG^N=0A6X+sCBB}fv@u26vs1V6ds2LFr%03BjtocF5+8)+_j}pYYIoh(e644t8&MR
z#(_^dKnL^aW80vXb&0YrS5pFgGXKHP9YJk6$kA?&HOMv4K^(4vQYhaAVN{?cRj{98
zMhbviM^6TBKC$zN0#T_gx|;FN=+3FlOWh1(?NsJ9E4QS+SBm(^+NOR!M?7OC?}><d
zZHV+3c@z<!&kgl>F&|yI_%M1BDGs=^wbvaB{v#@qQ#F@R8B~#7kOhR`CGh$s|NadF
zPWomC@!K<V;Vu4g<hwD&N<v2%&4tK*KSF17K<h)VNp3~v9#;*2zQNpycncGMELj*8
z5ulLFt?C`lB6`;#cu;gi6OOgql>z6zsX<Y5TFlPOYT1Zf>zPX=c(2(+Bi*DtUC@oX
zl@x_2jr<~^5|`pi@QtB)lebkXxoskT{Aq&SUH5TTH-c;M&R+V;E4^U!QNv23bo2m+
z8Mfir+nAEA<>?2k>4ww}Cu~z-Qj(Z4JZMffkIO00xScN*aRslQb~zBtV(Vy`LKgh2
zn{s@4V=PjcA7sOnrM3AfMrk@`!h#q}R1IO65&s}wYXfLTfOKMI9;wIe5bxYQLf8NI
zWC`#W7dVvVac^%}I)0h!ivG<~x6A0x@H7zZ>2Iymouix4&eI^#Lc8-_vGtJXtjt68
zo7aVl_<&fobLygeFD~T@B3AwN3@kG+-DJOkSKzfnp5^?uIRZ+6L}!JA!A7t(IioCQ
zy~qtIeyJI%<90h3dNDwl$(3eCym{A^j85S@#$%T6sz?yA%07g|?W)6F+s=58JbLXF
z>^kowH!J;R4UsxT_81!HK;E-$NQApEbG9{&at@HKTJ>_p3dSqVurVIi88?q{KzI05
z<wTCPisT`3+uL7KfO?Yj(MTk0Ek%hlO%x5td8rB`vK*#(HHg@a83euVt$6*?v;!rp
z+BqFH#;Q!_Qr|*BjOT(7b?iFzpp_`2+L#8xGYf|%Wjttm;qa0zOrr^;TpCJrT6+d1
z7zwOUb=<O*cd)<fI3f~Y4P&kfTXJtD5d=(Bg84L{tn1B$&eM~1O}!Mm;plqe0&)dU
z(_7S!ASwGl(%E?2vx3S}9ga-eBilO>)?v-W68Cpw`M6<hc5!Q+tH^TUuM^F|Wp2b9
zh~XT2gsYN;O<i1Wdo?9I$x5_#A?sPMi&q*#TqK`Sv754!ov5iDnT}2m-UDHxCk^Qr
zk)Ag*W;&9hdzR*)Kicl=mBet)eS$PkJ6?$VPmLu?UZmFQ29Y{6f5aJ-E<n7|1rH7l
zHN;B0vj8>>%rz+k5jXz?Zj6CDpeZM(Fd57S9ZtdF(}Q|V49}4|Y+X99rUtcrPOU_Z
z)w<xv*i1pS10@D$ZBM0>J70$t*qR?7^lvk}jwux8XA>W8ZHSiw?AAhCIOe{9vN$AJ
z*N>megll*>17}`qrnmp3%^AI?Z6t5@`B6qpn;R<IOsJ0?)lY66lcjp3QsLZ&1}}70
z*u)+w`wb`G#pPUwyjWepfM->198og++-e8r2-EN=D=8;U1q4nGhb~D-f>bL4wZIia
zG`}6rEU}ABJ1d4LxZ9H(#?7&vfKT?>dfiZ7FXSF~CWR-Fi(#KBOrwg_#VA>x&DhQ>
zod)9H=2Zm!2!$%Ta@9m@JI&S;TX5I@MSk7;GeQ)EL+ShHwmob2z$y1}zIEK%P_VF_
zBKpM4-Uu`L(^hFasVh+QaBx*IVHabCXi9CkFdB^1swN|7dOg9ID{9}SHpPrAa8Su3
zgwZRp*w18`NvJuG>{?OpiKW}vPZ%_{^$mFx^za}6uUU0xm}t3KAn=<dqqPhL!#X(*
zj)wTPP}1I}u1lVYb`XzWFv+ijQUXy4;(RUh2N(KqBye)cW%(n?-fT&X00=bnbpfef
zuDBa6gt{61*0a^YR;aHdH9G5(y4}j7ywkv^2v&88A{YSUC|6x1#wi&W8`46)i40qz
zlAG7(KEcx%OH4kdg&INsE&IIjHmX7m(wiNDWZV+Qqg+Q$$sn$AFDP4PU$4$Mw=@Y|
zj}6Xt+@Ha18ZOzDOP8?Jdu8KwAJfs%)$2o5Wo-Ld<8eN%4U^-#f=0(=Xgx@Xp5exB
znmHGC%JIaL-s|ywGC3hVg-V<|c>zeVEy(Xie0T6QGog84e!iC7hbWVnC_kpiao~O8
zsqH39_Z3x%5Lq&(sA%9vpeu(`=v#WiEWQZ~r!q~X2vOdOFq5Ybzg)f)_WGKFTky#G
z2>3Tfp?3_I9DMW>{?o5H<Lw#i3T{z&)1l(pfx#O;6Bb+44ji8BC(G&eSXxB}_gH)R
zC6j5pJbYpJ^baCZ(jkGlW0$FZCQ+{$rB~r~#(IY>f3nmzrUWr%;fm0UNO|l3!`M4U
zSNd$*!?A7KNykn)?%1}`v2EM7JGO1xww-kBcmK{g@3{9r#`$nR>@jNWs^{5jmsZW1
zRdY>sl6y)cHjcY5Tg!4c(e<m2EcJ}Y0k5Z|D!lXsuei~1u92+?Fi_0mQ*7sR7SWk#
z6EFm^;7!Kj|K)H==}u}!ny-T6&uZk7I@-B~#MiiW_o-*5Cr?Y-r-2XRT|0FR{RS3C
zeLnqfXz1Sn=U?0+Gb_{oaEolL{|ybX{$J2gvDQWeSsSwVO$`-*TU<F!Q6wh=SJ7Ci
zjD7}0=tT@9?CfAMwNC334!r7d4XQ?NH&%_sE-jmurY@ch4?`8Bu}=#1<@av&@_hfi
z-|_M0(e~BM{c=Wvv{w!_&xv{4HTCAj@Al^YI0_v|E#cYxzAe;FLFBLU?Zh8^_39eJ
zxV_of$*r!DD}lz*;v$^ddu$m9#dMeddx}t#%TF(wle@G(sBr-4)s*<%IRI{XYsAMt
z(1oh2vR_#nJZx*{-27UhG0-rp{7QiC6FhDGa&G!@&NF&5=Qi<UIp@kyuRquB!1NBD
z5yVS!#O(X+t)%4rVqwOhyC(PR{t1%Y=k;yFcVY0zZa*=zSJ!9%ji@-cS=Fp9tb%d1
z%a2+vQhSe~WfYTtVPowjeQbe5&a4;%nlwFiRsbi9nKkqFk48`;?Y4^0<O}7QiXU5%
zg!iN!A;Uf>vu>2mwz1on(0Vl|!8d(b9jV(E*yqSfjXBk9ILQ6lFD*ChZVEnR4<CPB
zp^H`bm+Ql+8KP&S)DMJC-y!Te;$vu;IZ6ApZ7>)}46Trh@qMD+F#Tpm>lbC55g1kY
zW!n3wLKsBu-vg#);d_P)ZCFISAuP6`Qka*D`h)h&{<fzG^0z8A-=|GbqxCp^w8mUL
zx_iO0(CVw`KaeI}l(-A5>6N4>(3Xc;CyIi<k1=U^FZ7>UeUQ0Vm(X(ix<54`E_Pu*
zl^PS>V3BUVo!qx9oI=UrIK7BPo%hheD(qkC%>HKVBC}v;^UX~DGF-64w)g3cW%LBe
zEf`VtO1AR;G5r=aW3F_JKxnA&%vfq+d=mjgN_D1$iR~$$F=$_&M`o7}587s=d&*=-
zP0yqm*y^(9a%xx2s5FvsIO$mz@@AsVO#r@6hIa#9=jtEnZu0j{z^>OBo|L-v;i^d#
ztKn$;e*EGnFy&!k*KRoOFmSGTH6Oa=u5IyY8E&gk)Uzkfk$|d|^kP|#yxofl8XNK9
zQja6nKFII4L0u^6Rg7bB;pxz6Bbj*hSZ<%mhnvx1MkoH~%UgU)V;0u6wgeVX%}HC3
zQx3`}ZbXgblvna`60H=w+WGm4V{+8zGwT9P^L#CqE}LMvDtR)yI+O(Jrc@bCU~A6J
zkwzOFIgY_VZU1{>GF<Es-}K?6dhfo=Y+{#~#*U|kQQ3qfJd>$EM04EQKw1WbIRh5h
ztgss0n@qUU9&Ir*IoDerk+^&-C^;GiUy>`Y$Akib>HrC!<Na|xlJdA1>*_C=@mbar
z;624-Xg*n0?TPU|ccA?>%Atr$o%G{hW@Q?E<n4YxnCw&U%b8Blo8dv9M}HI*t->mq
zfB4<9_b4v@1-{7o3E8VaqWvrS0tm7XLh@Yz`@0qleH%5AKVD>yW<`1cI<}g8Rw-d_
zm`aia_GHx00ZylDNDtKJ_jU1C`%_+kM2x)7a@67dZzcZYrh4jh+?Sjq4eLqSB;bgR
z0;7?GDJwrhM^18(90wE7RsQd<qg?2+3=);$>S9j87xQ=BMY0=rPSV><f){e6SKU-X
zDHm+Y)GSv;{W<e1<z#+lY<3w1VW|oPE38I*;&!ghBAPrHjvx~Q$x(%(nCvY1zEQ=p
z3L2+hvs39t+YV;csmsOHmh=dN-Kl6GmOQ*7C_*pwp_{0c=8$weqd&(At=*jQ#&RqX
zVf|6u4oSP)H7K3~&NTgyhj+QqR1?|oCl)_bEQ&22)cD`f&{>$KHX|)iDg#o;cCXP0
zJRzcEtDV-)z}m@$48tF+Jqj;TYNxL(Zu$nUO~-&6pbjqVjrWnLS%>8rV6Hj_O9NLb
zan00Foa*z8&+CukgDlz{7AO{P?3Q2xXpN1xZL^6a70?3m^GIX%M_2b{5PnEJyfdGs
zVQ}=W4$K*6MkUTmN34&sr|lkFUiE{F%;z}#TDLSQw06G9#u1|I^%UN&msDQ(Rarbv
zh7}($0m}SdC~NM8<Dg!soN#a`m_ek5D{e}qFfnBQ(fGAcR;nyjLw_-Z&1l-HuXh{J
zRYH|Rzv|WZDyXGhJ?q?U)fx0dVIidEcl*b+j)TnzDk?Yi9XMT!`ik{EgxD|IR7FYq
z90Pp^WC9V0%W%_50tw{Ws&Z(2;{Dy`L#3g6P3MA~>IgOC1YgoUhEKt+zPeH;;@rp9
zzzGr5VO8!OAqH4_Ok1}6pTankre4@NqbgNSmt*3=JT_tB^?|9`zl+TLH+b;$EwR<;
zm+OyEqsNfbN2!(jN-X2fNXll{`?DMae@bcylmFn?u*I38F)o+fBuS^aXHC#jg`qou
z{X`urjpp4P0PJQzw4mqH&PYk9i;_1DYY<qlrtAopvS`URaY;lGf$hfQi(Cqh68|la
zU_i&`NNHZtjEJnGEcinoBR)yP>qe8QO2686FoLGS8aliy%wi7X;k42p*`xt1Et@5H
zW$Ew~Q`*b4EqUrNus+OMht8AEo-gc2ukaHQK;O^FvUsugqmc_BtBCkXjI$|GtLq~a
znW#sH(~CdJo0J$F!=@B?tsQ&>O(ei5_iL3d5{}SKH10rBj7zvHLj|I`&ajzi03WD0
zkTR(2MCum9|2)Opoc$HGIxD6fOZVHPE8Yazk}l)sp5$iy3Wlu2CRY=`<cs?OX;ueR
zi9wLgqBBEt#J5nP_tA6_=iNW<s@p7?Ds=|NVN4<o)ZveT$|7S+!R3~wA!2``g)FLk
z-%JIgOlwTLV!6QIZi*kEQwa>*ii59KTGRza0krR+Q`a5=B(rg}<V1)=aRw0U^J(W;
zD$vzdvAL#EDIP^(jS2q0q~%$IX6c-8mCIVYaKYS%Gn$R5>;sN$1#3fbNY|a(kN35Y
z(Eq5KA9nj3D+aruT+2~Yvq{O7pB>W~&S6Y@`Bq3>G%tI^tq>f4;*VWYoLAL9QNdH|
z^N=JHJFZ7i-5@KDpxaUE&kRH;&~kD2E6ZlMafs<{Wl^Y@a_%eL8hTnuBQoUwu<<Jq
zPb#0_lL*ICdm@>{Fgt!%j;2rmp8<;zY~tQ-Ah{M&!5IN#Qr$VEX<j!r6xk<6kA&@5
znyb4s)_QNL2aV~{Cp$L%c9CQIqhe$mSpy-vDX_E6Gg|%B%1V%M;BkC%qB!=T+hi%`
zx4DD5%57EOL5}l0IU<Hnps)sr*c|K$h|+nJCp^{66|PLfUw@YIjAyA(f{>*p=GTsW
zly2QztbK(a^ryfTAe?)*rhX(FEtc2F!jJTh^5$CJZBgP|=_|A66j4}4ccdXBh_&QA
z*R6wE;>D}W&wOmaXsU>bn6VMcKh~#I%-pXb<zQ+&4PjSESrJU#K<Bs{sshu~KHuAM
zq>jQ{G&GrGBv__k`|C{r1@rH6$|nl^1dWa^^n0mPtc<;`DGE@)Ui@idpvI*9sg}kB
ziC5%pkJB;pMg??bkd+u-+wc?VN8A9O;LNy+biSHnd<;y&g@Q<FiJJ`BfL1qF`KoJB
z%-xxTiFU`mlDWi;0z*LwQ<?fU=4`9}Hq0~K&#es9*?Re}l+mZOF&^W055#(@%}mr0
z4IUYHmm+ZHDosq1l6vwrC)N5M<amjk5;2{NuDWdNi-->jM<-N)Fc#s05XuRy(#v0P
z*6U$&Tj^U10^3cao&8`O^!+Jiuk<~$o_l!#d8~EOOW|W1zaC^?;lr_cG=2?$CW>(Q
z)*;I(p#vB+p0CI-$&wvOPQ*aVxIs4`In$j|7$-;`Pkp8Aj9ml&fXXvhx{Yt&Vbe(1
zZm-X`C%_@O61=IA6N=)vUkF*aWyvjRcVeV6k+Eqmx#Si(^1UI-_=gLA(r5QpcIyK1
z#^bB(>?$R<ZZ?(u)vQ=VY|qWpQ!<wX9Z)j6imgraTHW3@ppEoTApUWU@UY2xOc|jO
zEVW-Sl`Y>2k{%4$ZV}Wj#Ey$J-IBrS6is-cS!TbL5HY#8uFUz~-3zD)Pq2f)@Y@}~
z82m~n5h20(aW)BQo!uMp#IIuia(Zkg#n6HgNn;EtT#zf4+$PKB_Sv{JGdxuXEuUBa
z5OCccvv7!GSFB<0gH=yPb*Xo?yu6f+vnxhv2>w<()d=R;>jMw&85q#p-b?b%beoYQ
zoDtlOL;KoC@U;nDX~fUPP;=8xoIx%qUiP94z@~12d>0R+g)vM>YR!)Bv3z+tyM2Y+
zIX@Zr2I|HaX!x&?<zFb|Uyy}~jq!g$7PkL#5uA<f|8fz0N?WT2w*}c}r3PuX1&Ht1
zxeXQy#8{#PlNB)raTc-=QR1M{+!|5_zVY*!+$@A6{P6mP%v^uhO)Se+d^#a_lvr$E
z@cO&U)BWvk;d#gVGga<gO)tmwdo!}jP2RI(6|&1U(kJbizkB2REb?<?YbmwoBbyIT
z*T?<q(}W>rL=98u#h3rf`T5-3j1tk#(A^FotNhGBc%+;0x!`Jxn8=keU>wVEXfVH5
z!zA|oa?0<_j#hSi0(X>GEb?+862Rr0w9hEB2kKW=$S0k80Lw6O;FMN9f|(JeMv-Sa
zE1zf2*Zy0P@cZK-bnDUl8OKxYb^np?VG8Sr2ld0?$%5w7|MTm-rQ;B2$MeFI;bRAp
zhjwT{Wd7Ydp`WGfb)@G?*SoI4hJT8}?@4nC5mw^n+191_!@%}%Kl*T9@e4?0w171&
z8)FBBc|Uh&1m+L6*3mp^BblX7*f219u0m5YaBpQ4ekxehOsQt3gf~b3JNqMkQNfL}
z<f^jfc-c)EYg+O+;+`=^Q9m63&I7(1v!Z!4t$MDJHdPomHKNWKD=x;HI-b{GmR&3L
zrI!|h#?DKiBR5h;k)}QoGiQcSG>DNL6QTKWWXziE(O?SQz@71nIy1WXH$`fS18b&K
zpax}Re5|5DisYE|Kc(1{`@vX5L-Ud0{n18j(iWw%!WF1Y1qKz_f}&B%S5hK0koq`}
zNI4}-bu;_Z<>SSW_LXHnfMVknn8Tp_z_MJc-H5D!d);ATSxx47>1x4&O0c0>@#pa>
zX2GE-kzwp>OR$yqSi=55K{J+`yC|=MAW;DSoVSy4%<IJf!rNyR|4sGhPA8uw41y7w
zb$0%=>J}U-^rRZcM6kh)%xkQ>I}#kfKhsT#`5s0g=G8`8%livEaV!mWSg9i?_b63U
z@cl4&-_rC5)?o6&$m81aDvfnyljBcqhWYkv>hHFcQN1g1@+Rd5p?sfjZ{DRDbRM!L
zu*f36@h0V3k^HQ@cs%*G6hIiqMN-aqu+kO9DV$&r5K<kYMz88s(lQElGI-_c;(%W;
zM^G|{{&ad0Y?)~1(0CGHeND=BlKDBk@zUitsq1Kd2LA64j~q8UpQ7RSh=lxI?=NS1
z_Dl@+OtDhi+YouW=W;OJ9;P)AQr;b@C@F9I`)W`9H3Lh6<F{(&Js_B|`<MKwCAT9C
zlRwJBl-yLOYi5=zF`Qv6on}$klf>~Qb%W&;(5)lHu-TD>+-a|g;Jnxe^!$eYa@E{k
z9MkT3O+-FfTKV?!e|D{+K4|~Zd?$2@P};WqS;zr&kv#=6S?uA`4z^Qz=;0Ke6(eP5
zaI5<yHA1c^+ebby45w3|ML)M5#5HkRusodz3TxmesOhuDhsC2icVEB$m9Hi}K`XkZ
zqPIhG+#Y)Y^@D)B@MxO$WEZ{XGY4@#RU^aSp3GU>$n>3eW%Ud1Z{(j~wop#LHf1?o
zg{RX`<lm$YaBtA=R9@8|CsMn_xRgtzFe`puU=$Y!WahsbjBLvwu6p;qlD=vJxb4Tg
z3(72c7bGY#_YQ;qJpT&W4bL$TaJ3MP#W~m-ygS7Q(!?1Kaqs}i;WHBUE=g^l5|s0g
zfr`i9*;Th7(b~w|m9mYK230labTUk?eotPM+6i7iuZ=ifJaJC{(J0jr3>xGMxT?wY
zP=#xUT8KX=<Gq99oKn*58jW7@+4>7?evg>$-W!Xj=FQ-At4+>!+aQJwo9mx{^KdM2
z9t=xoaw>Hza#1m9^pIRD<p0x$#j!Ab5IcNx@@LCht9sjBbFGu0>E@uV&m)NjeHZA5
z?~66|E$%@TYEP3M(6nI7xNX*3+>Ux!@mjx%4=%~@d&V&}I5J)#v51}biKM&A1=vU#
zGIUIE?IflU*fZSoINv~cE$ET77=k|il5YSwo(=w4VeRz#u-h{4WM>F%m_7IQ`V&EI
zeA&mmJd#dVZMgT;XMer^j^9kA6qqe3^V%i~Y9dpXh_p+nc;Z#%Bu%3IxiEzhaf&Id
zTDnyj7EeoC8wG_CYfxI{g*JatQ9_0Ea2axX)W0l{eu8^ucRl0O`TSb0{X+}Mn0n43
zeS8=sB0A_)pmE8pRP2YTpc1&A)AT1(Ym3^YazPMU4h@3F>DG(ljnh`MS%W`Wy|3Q0
zw<ZxTvksn2cp6BM`LYMpJ$dDB*x7u4r8FXxagQ-9*sj6{tD^-QU4Z+L73|DzcRNv6
z^un}AST$N8lsCu(0jFr-q_qVbs~6gGlE`>FqZY4MyWET$?CGtTb0)*If_B-GMYnC~
z=Mj~cMMI4zw8An{$n_=4_si#qZ&8apIFd1Mo1buhh}x1wHhcH>agLJ40_#T#`|iez
zw$yg}H^Hrj*R|fL(>FXCIvvYHFPZ1krYXuAO9+3wx9jPv%pcsF{nV#fby80ZkkOp~
znA<i*R&T}{G}?WkYa*QIkbKF-MzYp`l*08p>@s(6`%B@^5yX<ZpB=p}5c8I2b<P2I
z6=!(>>K0a0R@|kna*-Zh1+5nhrB@=u<zHU6j0JtW@Yyeh5pq{Qy`umXcv)L6SrP<G
zNVU7Hqxxn~vn9w5R{}%xX1iqa(6Bm3$k5)b5Troo?2BiR)HxeJtSBW?W-QpgY_&oC
z89Uo=qP5A&EplP+>G7xIABRWf9*g@Wy15xhH72ZRo4a(jOFoE1%P6t=ON}4!bIQ<z
zU_l{fD=~(Z`H{`)`E%zm64%;jq|ar8IwU?;e1XFdBSRbBA!IHUGh8&Li{N0xb9y+|
zTBJ4cU#t0nEc;i{0{iD&te5pG=8+1xaTsDd^}4_)%O@R;zKm9_dyE)>?yD9nbNe(y
zt_>r!+)mE1cq`p>SRv$KK|hDmNH*-VsBr%Vp2HI3+H*tzG@$SrUCqsn>V9cP%q~!T
ze`V*<n!O8gGK5!xJk(TJ7A?vq5u-#nj|W@Fs?{p#EIjxEaj@H&wt!U7QSG>wWWrWC
zT8>N|`>$Ty*wWW^^L0Pw`J74E{b~Ex$`KLqH9*w*XKk~cgiqe~#J&>5a#7q6<yL*l
zfSK{Agg7-XQL)sLE;F@jSWw!8sfcVn)XcB;z|nBXIx;EhP>CWDmY+PW$I*64hRgA(
zjJ{xm5ts2{LJP>rMYyoPmKDJac}N%~I7AJ7o500>6=L9{zvD?kr%Ot4J@KYOG-#rw
zlTx9ZmL*LV%`3{9Dw#9VE(*(<3YIZS6&q6|r#LWYN_J@+jYr`p)vu{Xm^zqKi#4>N
ziKa567Ky|W$L+(yk$S`oFv1K8gsGQ@)G7!)t}8NOkzk2=fr&vcSt|WnR?6Zbf|5j>
zKx9pa@e|iDG+%A|i(H2t7eWKYYBR52ISW3DF%?lr0^bCq=VwP3FL1*PU-VD1XqL8!
zBO^p2c!mfEvg6ztLjF$tg;`Fa)ZtB`WM@&kmYHkB(TZ1Pn6#UqIsIB$0;X&V9llC_
z*zGu$^45)Dd4c@cAbAHezUXWt&#OAbMbX;++=(<<xD#-InX?{QQ))?`VG)%x#!k70
z+;ioS^_aGR^ii`s#3!Gi&wP;7URm)cILsqh3~7&H_WGiSVWMho`kL|J;AWUTkYm|b
zq=~GcsaOO>iDs!Nql_<QRFma8LJm_h3~ex3!Mh0Q=8d&<w*$ng<zd~Or8Pvw-q6{v
zza%<zfcfGZZcXiAILdoIis@iDZb57ls~#!NXUS<&F3IN+uZ7iUptbnG38lq}4(w3R
z+Hr#AZ%xiYrfDr&2{MQN<Uek7S{|wmI^I9bwjHnjR5V$o*`MPC!7zV7z)<?-!tl50
zUqZJV{^NU5_ipI@Aia1EDv-uA2oWfuS_htM;6-?6i8U}uTWGr1uVA1JuZQdcdZXvm
zeLUo>yr9LuB-%t&wu0qY2Q&&=!iw$KBoxO6aIl6sPg=ooi>EO^LyFWN1;rym)iZu*
z!%9RW8=bHR4h`x>g&_F?<^XIlIixh4pknD!QL`lr^aTTAx*;P}qpkBu!j4vK#i6mu
zXqpB<{pl{~Ya6W@_N|-%?sat3v`y2gtn^mnoXQzhTcqkq&)?Dhz<wQO8D@uA3~~Ln
zPk@AoTT*z_l9&_AE9{x0O5aG8C4NY8B&ACX-m*N?>C@L4<EF&0v$`>CZ)!Ibc|RR~
z(0(JSo2+xhDeFCIPd7MkwMR1o53m-2-pw9I2yeyNM%-GxXLqO^x&In4wRa=Ib?}dL
zeZuN$)-%Uroja;_o3Lx1VnBv-LDJ&$^=TMrCK8`vY0@uzHA+T~K2zQbFkkyKT{X6x
zIWXe3Ji~Y$KUY--#d!*7mzX*vW6JeOrT>J%zd6aZDXQwLs=nHym`}L6w2{-OcvX*T
zkE_LcgS|jU(SUy#LBQWUT;GNwDbEp>Bd#z?{?oh?LN+wpQmG~Y_P9oWwX>}lxmzq*
z52&^r2@7b;7%_Fop4xPKu&bQQfK(QyVf5c(!Y`140<BH~VpVZh`a%a{J`*YQ_2o3m
zi{EQVA7^tNK1*6#^a_WTH?22A!&VwY)ExII-OoU(LZ6~SxSKcoonA$aF<SA95V*u-
zY^vS@mc0Me7*5ka?Tc{jVUH8=u<Tl0|ChBLJPK^29GNO66tFZ1V134We!B6dwwVnB
zPm_A&u8<5j>Y5DT<U_`Su(U@8NA~G_STdqPpWoAf53C-TIClC(5a2z)<f(mc;5t<M
zCW74VtP__Ej~JJFq+FJBP3zO4iy;h)TDKRlcyNnuV!f+S?h^`P!6oRgdNcUA*ALuK
z2Y4HN=dFuuPu&@Jv!yVnK_T_yJYsH5*PBm<PD<Pt&nqSA-o$rutXbJi*<#7y_!MMR
zqHTgGr~dFU*_AQr$joF$#c-3q-?^0EI|}82N{K;0O-e62Am7wLZ!<|S{5SM_W_!Zw
z+ZTEiXFtx(Z!Lr_Z<--(5nZ?~UXI*~_fiiAV!Pg5cxBakF6Yn7DSxgcems8pQVo?+
z{8yO#FXa0#n9RY!`9Cn3o#X#k!{+5>kT$U~bNWrh%+B$Di444@Efu@jiroENgA}&`
z!h%6qK$b_W|EGge-0vqRfj*)rLgrv5q!pw++~G}VB~1c(cv1T@G|FZ17WuLonN(%$
zkVVY9*wW|4!|~a~O3&BB0b!5J%#NPy_vu@;@8T9CV(cGWvwKcwJw7LXuN7~;Ew6XY
zcWcatsk|;#fz|1#u906Ngq6-c?`+<$e@_;S2~TVmhh0C<SktH_2s^0G#7@W+MfMm<
zPHtqCYWbfE3AZSB%w8~yW4Ag`Q~8~jV}P?Y+diPV>nqXWIy8R9_(=bTDvs4j39wLH
zw3pU?M|DQ6)0pRx0y;iFh0E*(B$d{1r~OF_?L%Xtw!^A|WUHXq`ud<@Py!Wc1(j%1
z3rQVmajvuV;KvxnCmEX(@)yUCj5(VE_6)K<48uYc#zTx~amK5(V?qGs2;N4BaUsI7
z|EMx2X|`p-m8h~_rq+yw2pWczCBqe~(o+tUp~G#g)l&&j<Hl6|rfPBE!kMo6y=sCO
zdNWx%u^s(GL-H8!zJiTZ%aDpGa8XiJkv27PZ80L`ohwM16%K_(y2_ZU$$<-7wn~3h
zI^qXYQvKd)M2G{x(7jC<5mSf*LQxk%Y6qdb87^jBG^`F0I%nZks{FTg6r)rqQHSW=
zf6{36uqEbbVf5IrV*W3g!12Eo!lH)NU5v;<Nihoqf`-y;jDmsjaV^Nmh8=Nf;lh+f
zL68v+>Y~vhM9PJTQD6?rqLbmsXh{5_0`F#rVL(Zi;sk<v-An;b#Y@VE0nfM@1Kt%*
zBW`D|_(7|oPn2qkIgnD<Hx2@7(3&V9IA-W=6bQ_eMLkY+s!nHHX-pJ+VUF$$r44Ny
zJY=NaY_(9_^kS0@i)S@<rPI>o-2B}0M6tXbzP=&ht@az$E3<e*x#L(WXS8mRqRU@J
zs7cBb5P)>8aUszqW=<Auy~EpcqWY%$N~W<3wYjC?vHCt{UOA`FjHCq4=f~Zae?=<u
zwmT_6fv7sC_u&hwGv$T8ZwWO`m!YhNT=qr#XTZUR*ke;8i8mm>krR;5dFS{D_NPhs
z+%i0oUoCdGwNc*tM-@8|AfJB5{xRDYM1!sGw?@KWO^3|3;cWfv-1xtm`<cN16fL6O
z(2%Hr_phL2yaKsUHn)c9wWIO*yaNE~56S1$9^bFGz55m4oEh8ho{!`8$BDmQ(I<!N
zZ8+<<ZXX{W8J;_=G)rAyWuEtj?YCDYj{I~rzC2sHa<(n!!-&7~u7#czyagVgPrlkq
z9c@z}y;W%d5MkBvdtUFu@ez&h?Z|*A`O6%8+C!UQQbW#TS#D2jRx#hG<_}!s&rmse
z(ZbJ(zl^!bHxvAG69Z17?|D_5%nNF)^F36!qHI5Ud_S$t>DNPCS2H~Cx2U{0z;AfI
z6ClFBfBD@)U=j6zf>$r>ias<1WA1mV;kil<5st49)Up07kRo834m&p6+}(+QV{+dr
zkh<1OLC;lpe&Eg|U?PuI@4+57{S67Jl?uir%<LX3N8d-8iX_X|i1$YRBQHV^!kIPa
zkDk>}mthSo9uy$DDmZaj1>sv@w_{CsM7E$V_m!>p*&RD}(mIvf%;!IUzp^p#3uigq
z4mU;|YX%AyM0KdC7{2n`OJUh}^>;1#%PZ2u7HAHHTDVRiDeX59Zut^!5=)M;Aucr@
zQ6MkAn+$&IGGehBEVn-=w)SS7uv(;HJIn;1c^pHdVuKEEkc0Ep9cN&dUy`T;57IZK
zmfEbJOKq)~;zZtxhB}Ux8bhH9sRePu1pYD72`mCDBuXf6Q`K9qZaPp7;^59onpJRN
z9zwDq-pt3%n8v@5=Ahy?kQkK&iX%4`Fyw~kQrP}xG>8ZffDuvNf=ixBlQF=G=i&u#
zpTx46WA`$BPx0;vv4U5K33L1vHCh-?;7`3cWYq0X;(h%y;sb!gW2u;((4C2Ru7z((
zagq6^noc^}oXQ=_^rMkeQ&K_g&W;f1lbyn}X@r1MBap=Wmz^%P5nb^^NHly<fPy?B
z4hN6HQMRwzB)EE-lPt-)$Dd*)*&))3&p&6$8#aNz-UZozjQd5@$JM@qqW%>A(|4`c
zyUrru2Fgc-fqKYLUIUTcJAvlJBLde>N$7H5Fe|}5n1@PCbSe^7c(nawbw?$O9i@+z
z)VJt$agSMH6N(*GBs{4v0yPTwxSobIyGD+9ggwbeqo8Mq`1P8@5$!hGZP!m&3AF{H
zhrZFQaY;2bbwENc<Tla;Zh-pK8LL%#fz>CvVUO9wiW`?ym6U+iqdG$wQwn44%|jcn
zEZcfEtMdrfC&Gb_RiA79Ow-sP{Z9eFWB;_n`t}c1Y{vCsatvgkQF_q7?o;}@fMW-t
z_lQ2lB)ZWvPK;#dgr=P8{4is1u6`uBM+My(({CnsxlBGIKMw9lbq@*Ys+ML%I~Mfb
z(J?RZ1!O=%k=c?fe&??v$MA<PlAR%yNdy5|pb*EXT5mKA8A2)~>SKw>u<g8=u$-2t
zrbrDEpP_^c2c<;@S`nFgzwoVp{UF$2a+*5iC(ow^2I4XiAfaRd!)aG&mnSd$3#6t(
zT8Vm=bI#Ysj>m$v73wu}!jp~@M{x{JXo*_-E4FNYx<b?yJq%(dqu$B|@<rneZ+dMZ
z!@nNm4i5pKxz$nb@;M@TUanpZM1w|$SkV6$_G!Uq9`h%jVt$cukq|OSseBM;MEsLn
z{?GuQLO#IQV78qQ=i{ylgfjVga>aZoCQL|o@!*}^owu5sz(z1~5Fm6@0luVZsn)!_
z<o2a-dCWIW%o+D^Jc9S&B+0Ig@)xW%3Q@k=;1CvrJg~qK;g8Qd0*J<j--v7FBW0(S
z=gW=+AFX3pT9#J(V5Vo9P`A7Fd#|2r(rPz^;@gaM8m~VEkxSE;``S~SIN*go>o_}w
zo2^LJeXKVP<KTi?D~~mD8Tp%J@16FOoWdw&kwI1!gX}_WetWj~VD`T)k+s7TgMd*O
z`FRN*it<CmTx1fDJECbb34s^n+&b=S)(rb3Cdxv4?V4&Bc0hh8T3WSxkP7Xa9CrK+
zAZ$ix;7|zd6=N0|-8K#@)c@_-Y)>x43}@U~ZtH!`&Kg_S>sEl^e`g%l>&6_!<0QP%
z@yLU$s_Bmc?03hkKj5~fDAI{EdK14NE$Q*K*^Nt#gCM<1vsN7R({Ev8SFFrfq=ieU
zpOmD{DJLn1*7?!Le^78x`Us~mH*VhO;)K(XLLzijngon75z4;t_eRc-oYnAjumK{|
z^4H}WB9rPL+mzdJPT`%zLX$&+1lhDbeLa8NY)0glWL^A)!GLVW{j|S(<_zS5lO{pX
znH>Hy@iqHEG2Ry@z=QoMk7B&r1oly#SJ@@W37mRuPb;CK`wsRr{&)cprRj#?z?_o1
z^!ugwBtvtCc-rH??~`g5+AzCSSS<Ho*zfIHgEqc?<P3+Gfq@eLDR<}89^>pzB0fiQ
zq(TO1mH$s0xKV`evelEs2>i5DR@B>}8saApTcMlRduxm^NYoqHm{xN=^Tx=bF(lo5
z%HxT-idY$lgEr`_xi;CgbtaeH07lt)^j~#g+Wtex@%wjwX2u_N0w`AJ??~Z<@|X3{
z8RDN;ePR+xBK$@2D4$Om)}9S+#-fVtzEI*4=)UK~WO8CbWT$Ya;su1G;srMd6gyA9
z?@FT-j!f5rp^=F`9)^KlIV9R&(C2~0Y3VS^s4PJ=|K5z)yuvK8`8t{F)nkR;8j=}7
z)b!>SNp;qPete&(4x#eJrS$5EXz_sY6ymA<5y2;M4o4Dgh4Aanc(b0tkXshf4=_Lq
zUh=BQoqTM?U^quImkt6VLH%dSdHRN4TOURX@F;4CIyb!?+r_Y+wt>neO$rokpz?NU
z@U-XH!Y#D*abEeJUk$xYs^qS>SUPP0=4j1qupyw_(kgymd-Y}5t{=|P9<6M=ammWB
ztppafM&Q%SGg!PnPwD`~54lzTc2NrLvDBEEE73N+Dr(v40VXxNU;J+v;@_~~Ul@Xs
z<$uK{<@j&PBOL!H<&poFYCCar*SZD?0Mba+o#iFt6CjM@Ba2@6(}d5;Hv6=bnuYBU
zs!8uUBDvn*dl$pG6PK0!I#|(e*7SXHy>wP0$M5w$mCJXf=j*=x>AiE+Vb<kZ=*jNM
zpK)UFz0mPV*uCnzsU!Sav6D8ix0HIaqx-aV_wptbc6(F8f1}%TsZ9vfjhp-Vb=2`$
zk-1LW;rse^mER)fdAfBcf$xF(&5i!;fyo~-l6Pl}&>k4uQF-;K;2hc=OSsveOOz?>
z%f)B1$%f%CBN7MAh^egnQc*bWu6TF+GLpJ;Rn5>*Q>zt>+Pyv^t5G4$P(XUA`@D&~
zx>w`dHSrU1%O!t92N3S(MEQ9$@xdpz_(j@c?~b8kMej0e=Q%JsuWN4LUVQ%jGZR0R
z|FQ}vFup8lf-nzeNV0Iv2kr+k>E5e%c^+Y{3Ln3a6vY(c7-!x*OL+=A5GS?K2s-cr
zAZ_ZfV~y#R`Hp~c!IO-_p6bB${4-UwK{9l8%2d$spZ&K(MS8P_Hr6!fz8;#)U*>>)
zx4B7W0D^I$i8j^Y$A+JoBuk0|rb#cdijpj#z7kF{H6mhiRF<T0piXU=)5e)xXZqvF
z961l*(hAZ6_KjUC<4k!Bkr0xb{=>4-A33mRN)h)}vN5qH5XUKA4i^z9QBe4s2=oI;
zHW`%i)D(3LGR8k%Ae7KcQc7vi;O-*C#SX`iZqiZA{$W7ky`A@${<Uy^0FEt*nF|p+
z1(<P4JkM#AOEnK0DiJCe?UE}H<^!w%jTkr}qrR}0SwI@ZqsVTGs~7MPv8<p_e%e8Y
zfE*EwJ_^;W!vlsJME~t3x&j8<8tER_dk8%<cM!*22n&E;YksYk(VF;Jph#q=Y*gx)
zl=~_k{+-*|+ij}ajkMmm{pZA_+B(rR^L-snm3a#H4duuv{Hy}MtSCuRRsa0{=Ahe)
zewDbwRGkD|nVx(YMVd<(l`GGI8r`Z7u-lgiR+_3fh9mtmFrFT1JQwz9v>ZD{95h)f
zybel9c2=5T^lz|oJ+#uyt_TSfeQ|(Fng;|WGj+F~q!LgF@bv`8PPgwf?N+w$$IIE)
zh}^e$p<8gF8{S{~=#L2|pPIc2GbjtjVGhsYeys1=wu1>hdueY-yS{2DMmy)wb6do%
zqf!JNth0+i#k-nrg51q~p3qp8*y56x@TZY4{m!$=JUM%uJlQ(BX|^PPjp2(I4l17d
z#jT`h8k{Ltj4y=S6+!YMMrqX0`YFw_WIpzt!0M?#vkSVRYQ%SqV2pN;V+%A-8fTZb
zPGRS<r0#L<CVj+`kA2uz!>l@n7W7QRq9jO8b6A8}VnMY6QfxhF$fst&t-BFOA+c@!
z%i0D_T1_6YSmQBOq|(owNF)u$yrB;;)owTlG)Y{N?Pz?k)pdbd-nlX>tw)2<12qas
zoG87$OATs`JP^Jjf5bZjd;+ZeXPjTW$j<wu+w<+BM{#FUH72Q7RCu0JEEoys5bWm)
z7vw3A&n(B)a067`*<5sWs7e@U{uW?URbT=LHci}3vb$3_pdau$%Ig^frLR%&@Yw_t
z?12QQPWGP^tenZ~BD2>v*k;t?ZxG2)y4(t51@BD@7Hh%7>6`?qi<nNqKb(x3g5gEn
z8Z5x)9;$5Z67v8A+eCNMdgesEYt@D7yM1g}5vefe-g~W$`lIkd#{hE|c&NJqvm_9x
z+ROun`1zPvN<EX_5BL@sg2I|0bQtY@4j$zUiLCgssp+<<V&rlBmZ3Ws<^u{JSYZru
zhcmd_p1qd3KHGp6*$-7;;5tM~YqeJyMZ&+CP)w>?t>d;bBAy}2Tc<<;sH{OyHfwF;
z+7IT*yJT!6ec?#5FG69v1a>u=rmghTCgf*Sz;N21W>~#@R`Glh2bI=QCztm`maQR6
ziVV0L)4;gtG;r`d1r?O3Yb(=`DN){}J~-MWZn*Jf=e%iY(z|4a_1GljncQcNo|WvX
zcNM&(LaU>xBtd$Q!W&&nTx|B~dBlSz6W3i3?6_)e(u$-G=}>z?g2LKQex4QgPSUH4
z15E`%$v_a*J|iZ&kK!gGGL+*+{PrrkM<n&-aT~&g?fJ|2>}FSp?Xb$gJWtu7CoIUL
z?hCzB!A|H^@l(LxxlZajTLRokU{LdWe|hB9Sel0k#6t^k{1HsT#6y|?V~I0xk+6ht
z975_=h0aFTfAXOy;Q$ny*rt{aPH#|?YO^;H2%NTefv|qfH^vE<mbG)Ahx713;uh*g
zw74~bbF6)~3Z#W*8s*nlXsqvqZN9pYym<!*J07hrykqCW@QPNpvxQkj$j&^P7j7;t
zIqvHWaPH8_Uhu=cZC=rCP$Z&I{mN1}MSK_0NBAYCupDH7(uFZY8S<EJ5KuiP@kcq~
z`gN5oYxpHNJaN6=^rZsNmD-rDB56X`zv|5R+s`xAl`-2%Lk0}1^-bi-o<s66om*w}
zLQDFi7kqsA&rQQ8o%(L)T#V}GgyNmDMN22w0^;0RLUW)iH|m#UCkv?8_Ua?v3YDlE
z9?QUy$|!8LL6*oxTzj1vtv#HAy0<fW$xU+;wg4JM88S6sfdYg2Z>y{?L8Wkn(3($m
zua+cq)TjXsshIXJqtE~infjb?MU<fnvluF|wgvvms=LIo@VN=9jGJl&4iC=ZMv2=z
z13akWAEiR@Jq)e_E=-$8wAuaCIEmA7x{4GXq9$%_rWzGha&OfkMYu7870Koj)$$H!
zeyN)qJ)r8U1m@hQ8zJIb*=QY2r1fSU%HAB_!T}O)IhKEJJp8C4CTK07iQ-M^0WPkd
zdozF3Wk9Qghzbl*-QDgO0O?0>j}~0%EN4@SoMw?F3p=!@xvq5`fAc~nV{fRf>%v;^
z<9||_if^9|N`&W}c6MF}P_6JmHUw4P-d`^Nn6`nGGn!D}XDw)bbFe5@P)SH!3}vMh
zidw>`R@6bA<7-=8WlmuYI<=W=Gr;OJD5nN6aB@L*{g^`kX5b#F-JUlHd){52tejC0
zTM(+Y+s&?a2fc;8&m{Aj87YEk{l{Z1F+r*T0!e?piQ@i3UlFZ&A%_P!F-^NHL`T0&
zUduWy{0LEImUtCXPPMH{?;A+B4=PNmW(0?3DBK0@h)9tC&7EKGWah8qFDYOp24Z?P
zEq-2Ozgud&m|v)vt3*xgNS&%QQ!@V>0Pt~OBq#qlYNI`VWW^3x7i9b7*bL_lPAXET
zj}>cAn>v~^R{ZSw3jE*R9cHfB8u6KS6iNIHd^n6i5sShfT<CwCIU^aP=zpB~C5*~A
zJ`#7kCHqf#W+s8unyjPR`w!$gRH9HCC^QZ(ELc`huH{NJbgo4hUQmO7QE-ro{$@l`
zXdb~2qK;{3FVG_PwY0isV0B{s_foOh$7f>MK1vRKk`B#|mDw~`VGIK<1w2y{#4T-k
z`RL=n&3t(LH{8|#NVP8x^&p~1EVKao(hKoaEOR#XB)WyM9Kp%NN6#wK2xXU<*+tkX
zGmvvwI>fvNoQiiPMa-I=LuZi^gcrt*qv@YxXOZ;iXU{Lb{h%)7zt2dz^4JrR1_2B;
z1}~X&loNxqSz&gWrNLl(aLbAE5l_XCKYnJNtmwf2a(msSqSSo_AWbUPv}5X=jI*7J
zoowYV_0KqEuv;tNN^6!Ymzv-tOnN{*2_ymAY%b?Mj^9v?eJN;1h+5!~n6Z1K5bAZV
zaMt5>+d4<yQN|QyaxID+AOSeM5?E-CVctQO$VR3N$>gD<0DbzK@N87`KE2!&gST73
z+pnwAkWM>*z#W8YEn80g#7Wn_eSi!k!G1#EDf0+k96K<>>zg0DR!Y1O;(-GWYYw-L
z4NO8pOz1;YyA$7E#o9b4&AI*3Dp>hH?L^W+q)>1qS#O?OZj@5WgmeO9NB{?C2`g_c
zveC9wY+%SJC>+*@kzFCH*|Zr6D_?+P04x~-=<flr^0BQg?QRj_bO31=!0^*e(8p0X
z=*~c=h_bZ3&zP_*dV>KKB;pUmRKjc<GR<aeRSdTT(Xuk)H!=|;I`(U<S|t?j>4MQl
zd*P~We5(6pe`8=V@03Hk-SXoRyW#*i%!$gDJF6vn$LfGJ^)MT?=SMfKvo+x+xDQ}V
zeo*{tO#anEopZ4{pi3<x9<+^|hQD;t?Qx<hM}C$0*O>hHXS$kkz$R~ZA(JPhIPx?t
zG@##L&Z5^ovZh!?FUsOXJyXY_Tc~Vo1!l@l>a7wRsjjC-DFFyzY<Pn6!78cDZN+jC
zMJrM|z!%D*hG;kQPHeVXwZ}K(P_{O^W{OKK)i~G|R9-m~8$dsZ&C!z8Tb#DwuX8pu
zbs>u=OCdxL)ZWv`Sl7TyNao#$)c8T2H|Vr`$pSk1rEU>m;r19_G|YM2+Q<1aCKI(V
zH#rvV_JV@hL~@0te%I$rh{xSmI5+ANH~XTHR$WZ0dt{4Rc4Sog5?S2flZ?9cs~}Cb
z^`H_Hx4{Ih<dX>ZZ5p^>;~p2f%05Br@89@&jLr7=MUh9~s(&}?;<9LC_6Fw?xjEGQ
zM!jQ`+R7tn8NhY!8$(fg5sN#<wz|FsrKZqhg#*?q3=HyT*Xjs>D|{HpSOn=Kg39{6
zPMwzFWlo*%^cGl7_`1zS7c4+`(pZ<hmkimVBd=CmMFrppe9ilqd?qIc)(4BpgNP!c
zk8A=&g)ZGlD&iI*<w(T)uWs1=HE;Q!TKdtBY6$?k?MJ&>ZcA1yCV*`t6XG<OMZ&M@
zaQ%wBU4!`Q_RPIrFZ;xT$0F>mx=6ObC$$!O@N@I59e3@%(DA*p=6@4(RXwx09QZ!r
z`*2l$+hzOc=lOu({ov^L#qrx?sXDmn50!hvr5lI*l&T5%wZNe(^MN1rPSE+Y_3QU8
z<w=u&ZdPm$GU2-YMUBC#$-~lvDOKV}#iuV&l6-^3e?!av2EhMj+&KSNoLNq;|8kd(
zlk5L-mu^c(E0PXyFm*?dDXyirS}Rr6b%3#!hb0sCu<y>FH;tFGE*q8)!5)F^^;toO
z46w&`PMs+L74ow%zPyND#k-tFB{me(@$F>6tcKs~ZK6f*^KRkniesguCpTo_)==(%
zxx00tu{HJeVSuA#=kw#?bK&RHN+CagpBu+ICk)lcn2d0d6dI@<&*u~7$6hG^&#5mH
zE}7+_GJd{jo9U_>*)kJ7A*(w9i;vf{s}nhv+uRW9>T9Dc)UV=Y*Aj*t<M)HHcj!{b
z8Y|zy@Xpg;!v;(YO4_JQ1%TZ7fPD8n8Owx1{=cl@&5f5Ks3;SAWN^9RQWG}n=;lFw
z0n(G8(99B~kIc^3<cg3W(?zQ&MVk{vZEDSlL{bb)1VW1;lURUQv(L<ho3tD0_Se6L
z4_L)a#G}eouu60dl|4*&nCQC(-SBjW`~RPE<iiTyItEcc`qDhp6|R%7COMx;jC$M*
zz!zzvlo*(3y6UsBQgsdSB7*iB^l>7bl;q4!Tm(m#IwVT5n!tpwO(+01uxxBfMTLS(
zQ!ovu=udV{Qaz8mm}Ys#*JVb_Gg+Vym!)DQ>#oU0Nil$=<LZ1c=fgIkPyl(+L*FS1
z=SdYDnWwQg{dSv@$de+Wu#*`q`!!&x8bpusr>xJ8TAq^)s|TDI_y-$G0d$g%J#`Q?
zY+0Wld7RDAFC>V%MKE!Y6IE?6VnJ*UEIY86s#YkW02&K20c6gmeMKnjh}J$oV!Pjf
zvM7sofxv>hlM#_bWK{X0%x?aqwDiGo`2o1Z{7E09cwh>na;cN5d4fZNNbzlsfzgVq
zZxNwHWR9k^Mun)&oq)HkY3I^ZkoK4NX$SobSdS1+b-s&S$K>QpcrUT}KE2HK{S>bB
zMR|-({8Y+Ey!B4H7PgK~osUP2k=gbi&tGr-S?_(g_OO-M9XscW_EzHkJ-W^B{T}-J
zo9vR%?6K?~yrXPBkU?OYz-ud^BoJ@=uUo201vl~Gt@Pyk$e^=S4vK>t#qrhAp0gB4
zH(pNI!u7&!yNW*`8Lq*V)@mcMn>xV4bb)|aqlNNubSsjj92v4wbq*9az+z7|qwbv&
zDuA6arvAg-ZVRTuOomeMD)(-;og5LAix-(P+0?egLIpAa@UmC5Qk~)qbQB}ykG%?h
zuji?mOS{jF=iKhsuLb_;lNle!&!sC?ZF<`lG|HQyrB$)LyN%EilQ5k`rV>QGTs}`%
z%9n>LcPs|NuQ#Xf+lN<=)<`J@I7CKo9KQKmhM9pY!|A{d-i-#P)HAD_)RQ}2?SmGI
z!ReD%-cH@&hHUzo>q`ob*4O&1D_YhmTBKM3gH7_RD_k$!kpWByH-wvG44$Z9|ItNa
zgFN4Gc7(sP{CYm$dn;8<S|H!k4KC09v%0KB`1^mNaNH}P1oi{+MmO{P3ZxTGA!Bio
z<RgTrc>XeO6IK_~B5x#w!OA{*(MQcCIH5V>ZJ<dMhuqz0BD#|8P1&`ERFi2-q3{uS
zv{T+2^^!^o*X1p|gwa)FA{K--i!VQTAV)NirqAJ3mC$1L*s?4XG-AU8mn##G3New6
z0+BaVzzs*)LD>FzM>)nNbt8AGr;<TE;?c9J=fk|MSmn=#gk3kwZmVO`JxD#as9qF|
z?28>Rwn0XQo^V<IWe7`5FH71C-<JvpzpPHkgoS~Z|B!)!`~6tkxM~Ml4WEOP!^*dm
zpcW<f%gr&_^16JW6&5RE%A|L7gYe=YFx{J}-Q6O=l|s9hdR~FERuX+EKExFqm;0qq
z9sFP>=QpV#XD_^`bBj0d`x^Doks0rSGTIN=tEkxS59DJfaNaA>wciDktQcj)0)1!!
zaK_7KYNu@P!ml5Ym~=i(kalx-&e0}h`e9I*FhoI-kGCzi&-?d3NT33L>1$Wo#p*NX
z6BY!wiDu;b`OO9ADF59?`k(@96!yv@fQhK1D}eq@qDKIvRLpdGfq*KGI6@I|+Vyrn
z;KqHkUnVqyCAV?z=f=IhBFwuaE$&ucAi%4lfQPNARy)z%rllSs`pF9R`#L!9<;P7P
z2A~gtOHb!*Ao^&BwVQyr*>~`L-5NSs_Lf8;*vtPs3fb+kHNGF>#53f5Gh#y6zkxCz
z9p8@M$h<Wy4eZuOQ+i=EU1j4APFg!<M|&-5T7is`Wg*7SjsS_4{bgTt?LEd$YV~A@
zHlfd8s@Hrtl-7Zd*o8IKct7qzcyGvhFc$d=jbbBu`TH(TUGXSN8H@;9Ft3*ls*J>k
zbJW;w9ui^70P{BBgmrBoa$qF4YC3WQ<zoj#m!%EZuOyxscsqpz`{-xHl?RwxIW+RE
z6Pj!pH;~)s9pHBtNWt7POptc3#+SQ?zq#ul7dFXmfKwGDVRoGq6oZ7B9*Q?6+2fil
z8>nbNz&eEF4cW!If36k;V}<cK<k%q2&@n1b#maF4gjJ_dZJ;vTQWhR&O!+pRr9Py%
zF(9ju<wD${eW^T~2??!9dcQC@?g^k|VEma_n@~-FWUfuyAqIQ%(;eo{lC+MGQFxA7
zu>5-Hf9W+(B|!!zni7M_dd@ddjI+NPddo?h0mI?bL=?A;<}jEdK6f(gnBK|`UmU-v
z8Fk`-1eFNI?TtkPiMYC8x$Kp8_0qVCtda28J(U=TCn6d_-o6x!DE0dL8Me)?ECaW$
zQkN{4T%YE%&SBXroy^!k`Dhp5<#K^!4jf{T;{W*0HqkojjHwrm4K!de_t!6#M}!!7
zf&c_6O81=6#)e~4qUVM;WmJ}D#B!m2<H(-M%k7hIKmr-iIorOf=y(M2g%F-f0t@+<
zxx$Pe(0{jjv<aKasL+7}42Y@x&m8>g1Kqf{p7UqfkINHJnN?)fnUj)kxOw=<Z)n!|
z_Jh46-H_`Z*6kB;4DTb)!88zOR$W0G`;SBh2i~RpSC$o1gBacd6aeBjuVQtR*C`mk
zT~g~RyTt4tjrjLPvX`YfV#n{49Nj~itWygZR%G)7Oo^k6JQJen?@?Af(CjTJio%qB
z`HPnoK!qBfO1buI_K8_5Ci9d+0S$o(mI1fj2k$Cl`lf}+ss9uK#d6t|tRrX%^>Uo$
zLm4Nc<8E=0y8X^DYUoHt#-T>twx*77-J9Ag4zLg!B*h1J3+0X=H9D1QR>H~GfFRzk
zwz_Kam68lA$v{Gu69Wz_Dg4im()U}k$kTv`bPCl9@lr)G+DY`bm1nio@4vVBcn4W<
zz4UIM!k{*Tp==MgN*02)s{n=TF^wMmR>W0V-@*Zn_QOhF=Mt^W!BQe1O*9n}qCf{H
zNsQPRH-AsC9=?c@jxb?lz8b?Qcr5(|sg@mSBiRp+J~Xd=s384{dU%n+#FJhQ-%f&n
z4s57IO!exk5e2uMQr1ho{<7EsWj7Hy_XCV@iL>~ijrc`DRt+?=2(dXSp$<wR=_62+
z8JmwUN})Rar$CfqSR|8$FmW}o2NS$elBrNX6*{<K62J`if6Um6QUI7CdNsBz8~4op
zki&|a@LW_NfTpbQ@8K0SJZF_n?_G$6aGDgl@>ukcBS2FNB=u(nlAF4g%W&S~Z@E0*
z+YT2ZyFoUj8YjVF8x#nEq%)V-f+}ehykJ1<%jy?h{SDuaDUzW%EUOL+DbVP{OAIpo
z6%<#_)q;IfhavMI*_4|A+0;vS{ZsK;R04D~fgXs#Tnw)f8pqS2gm_UJoV_>;fxI{i
zA0DrlUcuC9S|tr#I}S8D@MaTqfCKbclkUUQ&i}{QI|f(wZtdP3+qP{x>Daby+qP{x
z9ox3kv2CuXW1Rl)=dJhIRcBY7{cWyM^V6z%SB-1j*SLQD>K5yYLcCG$hpRtDhiX19
zHtMP}#MUrpvJ|ObggV5iae}^m-7B${NGzy^N9tP&6TtMx`b#qt3ZzB%Q@8_em+^Mf
zZCEnQekjuh6WPeOK4E`n!wbr=5DjER0SC&6BEgRYEPR$u-P?ryX3=V8qjI;A8!dMD
z;1d$^fS}3rVa;X~iZXSw?s_@V&p$Z%+_(Qrc<UQmiy^ZtGSr5=xD`Ea^WhQ$%!4`*
zjK@~wK(Vh{yyY}xa%Nr;{hfdbHdRlOR)Ev=$+5s42r0^iZ~X$u?rci#(C@C*6p*A_
zY#r&?>x>hM9kZpedQgF86ZdiefN+TI^`V5Z2WI_rHx2bjPFwY`U@h8MF%!I@3hpP)
zzzcLBZs8}kGtRACD((3r!@HT=jT)lQLOT(tXzjKVrts+VWU;Ocxf0qTN(YMu+G}4t
z?>*=4!(@-KfmQ6l>0r}`Bdwfor<&PH(ZQsgiiqz9BVoG5$ma^wH~4tGIE#59XZNM5
zR<rc>6_P=SD0q-y0DB}8+bZz<x{Huw-hj{}OsBOp@T&u8z<0B6--JFx@0DFnHr%}{
z-RJAUN!gM53Nd|P5rxq#kNum}CsjG09>oAVS9^G{EwejA$!@*Q1}$_|Et8uS)=gsB
zf~p$y4DA|yoeKY2s;U(t!wZv1V2VSw;-b*br3!ApGkPa6uys`J%Ol{c>de8)_W91?
zbWE&eChqERA?-uV7z9LOo5K~+NcoN_nfax&Qx<r9$6kfA-4|W@iGrnHcq7~2eHQ)+
z-OeE&M<-*Oj&`0dyZEr}uyzfNgW}^#+_C+07V@B;V5LLUSzvG<Zsw_-_7_lGPo4KN
zsWE*Ok-K|ox?*ab=;g!ITUqUd<}XYBi4&c-M&|4W)y<b27W{x{i!TeL45gphqX47!
zn@><b@epO8Y&0~3BccA}+NyfQaLAg(KVd?vJFm7_8k4vUJ1}3}dWNSzEf<>P)Y9A^
z*69OFK*n#S#o<&rnWcGbXPk;`w>sI|;~itos&_^G^m9EcIF+UTk_<{y;Mt=ia_5XB
zZeX#6EzB=}BZkdHA3G+)!x{<)hwYIE^3+SCxnL^48@+s(pv;5T(ir4pGac|e3F=kR
zOHZ*`R>QM-^d&NQZ7)faB9Idx9-T023TI<S_Knh~PRx*)Z;$Sqn)+*~Rgsz9$qr9Q
zpiDkBS|ciJlflCd(rzNZx^RzuwxyQ}k?bp@_6I*m<3D=3|Ao-Yj2vr;!}4r4)?Xdh
zwuepSyZ*FLuLKc+(~-RMG=Y#p6-TITslC2YNmQ7O9VVZ(8Hs3ENP@*jsY2h>z_;%1
zf3C?-&H>wq>iHzt<LGVe@@)TZ+BJ!y=B)ZmG+CeX@I6@k!tk`Yb4Um3h0TU}6ud`m
zz8$?|*yN2%x#s5lDTOlHqVfCT6531{Mb~``ADVVAW#n+753O4QXFF+Zh&wNbgJC(B
zxI)X4h9f|zy}R-vWp}v>?n@`SXHlzb@d-#N1Zm-i4oqCQdj<s=Wk`9~1ZYH5n=5+1
z9v7Bo4`?e)#x2b?+zcmk#=NaGzFMQdj`^lNOwnxTpLKqG%W57sM+kP-z_NuJ-_xJM
zUIx~P+UM-??daYZiZf3t7NaGpwF1iQm7pTo&Tc1Giq<c_xd$bP`WSdndBGp<16}TH
zYmjb>iXN##I(U59f7E+bQiRx}TuB|O77VJ~UEJopcI-a(r@);Ku~e_xOE~O|svh{x
zzw)wvy_GV(;=1043T<p2RybK)&w*(UXA&;LD)#^%B_4QJcF$ZaydBrmK3IFBa1>5)
zdsTIt=KJ~9tT0<jkfy;+Q&_4}aoJrFr{fsIHf?_i9}Vgw=n|z1$zg7r+IWv{8J+<<
zsbD>szShxwsb5RN9Cp<PS51Cej*N`7IDili4(fMNqv5v*1qgONq-$RAJ!*@e=J?w!
z8`q_eHmjcWs0F<NMdLT;bsx(H(5a4+l7#ER1zAVc@Y~SywSK3kzF`|-FPe@8U9gU_
z{2qW4|KKrPzdWL!XB|Y|8QO-QUFSK9b3;)i2|10lHmKz%o@WhV+6qRPVjZKLAC{mP
z_ODB9D$N8onXt)m)4FA?ml*N|`tCIrk14Vn2;pH5g2BT8(tEASNAeSMs|<O3Jr@|3
z7f1R}v!4GM-~2P{VP)m~-xOIEM#g{mrvKFc*IoU$_>blK|CJ&et0o=2%!s=4tPZ*b
z)y4r}RRCUm)Kka^Rd8TxS1=cIDddE$_})oAB9+yT+Y<Fo&RKo-JuPWAJyLh>_4N9B
zd%1gH!LsvxNLCQimP=8sAsmfrC6Pxs`n109>FEFR^m_UHh+32vxcPqkd|m0of^xOP
zoJaMO*UvJv;s(=$J***H<m1u@GmMdmcjxQsL;?KTPl=W3NWM6i)lr1kv(?#?JD|=9
zP{-2elO6N@py&q+$6JKKPJbv9WH|GIENl-jhuu5X&~=zORLmD5CD>#4FsvuN{TYLT
z>oosRWvmNto^#z12XP2|i903sOUcDpgcr=R+(>NL(19Ym#>Z7}sRGuLW<`6!1lZ^h
z_-!~gKy$(`OkQI6eCV;YLuRH+SZp1?I1I_wv`XFQ{s&Myy_~yCy|ugJf{`!FGTWKW
zQK1MZ{N1QONjW4gf)*q|qfCTZMG+hK#8lb5gG^5r=o&lZkb@KW33;1zP7}(?j0>m8
z>spDt>*JSdwUi@aV!u{Ypdg3W)@XeT4mdS>i$>C#EZC2gdV2hM%~Q>#_5o8tgGr55
zQ2a9?#mz}PL(uTWHe)i^D*_ZSoZY%Jd8qfyC$fuT9-t^!?eFw%LWAWOL~eI%=1XC3
zblk}VC2cd9a;Mz_3x=;i^-)KY6vu-H$l!Vk8=8TH$s)Yuh@?v$bd%WwGi0QUrb^d(
z?BNl9xTX}d8vKlxj!>nd@C5_HD7r-kNn!2wMz_)il~&CPF4xie0(X#6p({x6CPL({
zGm=|t_>CVDiPM%^yKb6=6I>OMQ$Cq0#bo+F&sP+hsKaPkyIU!nTxZM1$xtxu22@8S
zR(Q9FE$5@>#G2w(S6v0o^Gx598evYV8e5w@<~3mKA)FE!g^%Fh874%}XL40~K`QOz
zc^N;fEPJ^LwPO*}Myulpbh<X@YCC{feOxn>@JZNHNMg?5p$~Xr7uSWvqj?l^fUtg+
zV$ij);WbkoE?Iea!687r0<SSrU<Ri@*53^j6IBboTVET9LbQxN6r1fSTDVF?GXL(n
zgud}A%}wB28`uV`6=ntU)cF&tO!OjZLFovz$a9bJB`J&eA5Q51cj*2(iJZ*;Yh7Yt
z{0}kDe~bUkF!owYGMcvIpY;dI+ZlyVR4ru%R2NfKCiZE=0z>#w2yb*_0-Fzye`216
z3dvG3D@#xJJ3PY9CnlGWlX_o_lD$H=`}FvGe828j^Z&x$)3?tzUyt*7T9oU&PK&(R
zx)5hBo8LbcZ{BxrzP_9W0QtRvLw^Cr4}e)7SKhqY4v4S!R|bai=ky6fbA-F)n;rix
z-_Aj~A?vlC?~m}{&_g|fAa3lp;P{==J`A6Iy3fclKELd<8Z~j>dhFc;l-}50el1~J
zWg3J>53ZY`fpB&c#xa53zadKZU-x)0pI?i8eIH^~0^f&Y->Bz?lsz!;7`Y`JJOQL#
z^WvNp$qQpWJQW;SA{`|BvyYHSMUCg@uq+%w3D|pcKUTYoe0lp_K%FaMw~cu1qEPPI
z&28I%<s=b!COt5v@w2xTtln5yBHl^87c=D2@|7vxf3Q|VHMcowe2pe)y+N9z(%`C;
zAec#AC;vXDX{Fu0A8tz6Vt)mhRO-4XZEk3#bL#7`&k6@>aFlhxa}1!B$l{=DXD>$D
zbx<5Fn{ha?QNaVEf2jd36AxL0{$l_Kb@BSuR)ZfyWPfWPPvlAld*_!$y9frx)nsBR
zpvnKScKD2=ZBR8<&xTDVt1QP!CMz#x?l2~yO-luHJ`rm6)3!lU6PQYR!-ViN_=E4W
zwRtnVz%klMUun>wiChi>Wa&?kZ0s1t#zMdDpO9D?T9VB+l0AvIdVskP(gnp*^-`0|
zDbt}Z7`rwPQltm&nUFw34mzwHOn*1`x^d~foAN`mq*RjsOEpg`<)O|*01{@sZRlt3
zEqF12HWMgjiBoln<UCg;eh?;8!i!I)PJ%lNEaYbIJ@Z6rMl)}V3ew4m#FTNR&#Obz
z5Mxmf$qAF&WqO5&pj&t^W)uotc5bCiS_zT^G?QHDLn$Gc<0~q8Q2;5QgkK-AZd2U;
zPe_{O!x<O{tL70n3e;U~S?pqG@ovQR?ndOfkCBMtn%yufVuYpIK}=>?gEi8Fw6iFL
zzUXi!i%H95<82Y^l(MAPPkx+E^YBh{ia#Yck@&*fI5t?Ai}FxB3a}E=Dq&M1X)G3y
zSD`OakY{^ykw|PDx5M@?n@Dhu5TwHku@-a4#tqg?h{D$K7F$~3^*vfdcsfn<Em)`)
zhqFRs-opO+W2Yw0H1DKSx&k%xQyaO30}^yMqvN(elr2mw$Jgzl!Y^KRSXOKq6!wRH
zE2LxS%`{kz>g2A^V^T*FgKOFU(IvYJ?EZb@pm0x${?2}_5Ve`;o4F#!)}qO2N8$rc
zXt}wSS@s(w3(*uLkb-!OF7P2S=Z<$GkA?_Dgu7fDqT!yT>T(%YM=%~YZwz+W5>022
zZ+cdXEfkNx?t00Qfvpqn445kQ1#J@cDsFZVkFTXA!k6JJr;0sgF)^%xrJ5J=?KiNW
zEZ>W|1|7ZZBPT{D6UN3b50iK&!^?TOPnkFyJ^M(Aq~=0rk7UnZX;n9}w3~pE<vE*X
zH7O`WaIKb*nW<AbPBADLElSe4B{P9;x66-Y(X~d>s<7GL!Zg_$K?QWTVvMHFyclbH
z2qM}#<9ez;d}}lQ0`HNTsSo&n=^kG<UNp9kDISbb3UZM0hbOHZ2BSB@G1h17A;|5|
z76T27w}w)@38N<mxi)7!Mf8^TC7p(!pxI7_d6GGEyMVMbL_F0j^M)+J#jtz*go{@l
z;t49Kjg2M0u}G%sGUK!2y-)iNn`K{1hODO8c<FHE;2Sy9=&5dw0ar)N(oSWsk{-V`
zqo{37DT#Kh11y&m`Izv+*<3y8E<*W@NYbKYjaM?roDNzdp)TcwqVu3>ufT>&;yZCQ
z#*LGk`JF4|gh&tFEfN<u08AXMHydZ8b1=pd^;Gw%^<7|ez}>X@Rl0!?3SNAODY5lA
zl-`a|Cfgj65j%%`QbaI@k+)J`K;ix{z7<sOzEuN?gt1&4(a-i$i;66JSdWQ`E2VUF
zGG@1D;BB_?SC;UVeLS2WybAE7P8)4Ya*)dg4?*$6K<$1TF3KadpUqPuU{4VKQoY+w
zN(-v@=JOk?ed0FuywNS_fPob@*YTDwipH^W_?t&iy)k;;&M(A1Jw?~J-j#R8DeE{j
z-kP(<Ivt5+E>&=AeLTEHOi}ipKKq;fu$qd+&a>n(8TJ>MuvTc1<O3<QWf{R-<_J>+
z9MA(5VjDh(lUZtDibO1mhKR^yN4aNUe&S*Qr7SUd+tt9{gob%+7q@NQ?D}81s1*z-
z%DwB0h6_F}SU(rP+D?!&6nmvCX4LXlp^OLCy=%iKFGDY;1Ldw!v0~9wI5(pAhIu&j
zfyh3_8--Q~c|%pxivLF0VW8l}#Hf2zfkDs@y(9N^7&rcvsWvQV(81K!wE!85kHW<C
z{;MV`;8-(ZFhQc6w~ZsmTiYp5u7m3x<`R^VKGVWJ{MQ)W+~oE|{y2AlgS$uo6jCIk
zc@SAxx?+=+;?O5^mIIHv&<>3NfAV>N<AmtuX^gn-cf*fXHv$SDy1<yCMbxykh-MR~
z8o<G-O(=<AQh#(55JHLXFUoekiJ<|S_W~_ai_URll2@haGf00eF~*#Ov!K-2$;%>H
zHZ<5Q(4pUqG}=3L+L5>>%0yuo%;$WxeR7z3w9hYk3Pm%WWy(IWwPB0)CR4OZEgD^_
zPRckPAr#i+jPzL+9`v#roBj&kQqO;B)iPJf0!-%<WT_su#4h+$4g`nxCjqQ@w_bu5
zXLhtA+2?3>w4}$?3g9~9vE3;Z?=K4hH2kiTPS(JpP2Fr;AhN$}TCf1ec6BSQ?(tmd
ziW78idxe6e!tmz~1u8v4QdeXfU5(2G;|3IKyk!u|lfu_!(qdDJ0IN2oOH$82k?B6I
zsv<P>>JQPTbQitk@ycI}zbKMBio|te$-*VLftg>&WJp&!q|D4Jr+yKhYk$}At<Q2<
zvcppFl2sAo7SC{d)7eE0XAf&k(H<Bur8-Kn)xqi@S2FjmvHO-TwRFF`pfh5nk+F3G
zUlw;mnBL<2$ukrL?4Oy(m>~(<sF5aV!;<?fS5J%?L+%}o&cH_TDUX6C{gEVb<`i_Y
zqmX_q4jke<hCs}lPK&^Av%}0SnajU?SMnZtjlaM_FoQrBZNLQzK6IjLlX}3^Fg3Ma
znhlg#>1b)LeknYR2v}-43U7z(OD5P<x48@$wj6iOvcs<i=XS@?$F3q`Pia5Opb5~W
zGIabjvVfpadUVTRn@6$VVlC2!StJKd)9a^`w&W0Nmu8$qm#R$i67aq)w!x(GU#%NR
zl|o`mN;vBAEmiL4W}!J09ERGCRU*@{xdg9d(4j~E(wBCp)>UJgEo$~PmV9QIjMAvs
z(e7y~5q-7ZR?Vi<#i<yrFVeqoZ=((~LxDwhi{xK*ANNj1w(6e60H45j$lD}ck*lRl
z5WH3QpP$6^Wx_||xc{DC62e=4Xu*a7S`~Ny>i)wdGafKbI)C^bn~(UA?n3A2ayMG~
z9?(-Vj!Et&{b~2CkN?4!`5)WZf3>Fnw6V<WZ2#WJ{{QQ}|1LDy8UG8Rd95uSO*)3u
zJ6C6MJM+6I6(B_k?N!;;5bKHv`%?d6pq-Qm$E=5L^X)Bu#L~#zRAr@x%pDQB^Q+cp
z^dDYHQ#cII=jrj#pT$!^-}}@qf4*Lymfn{yw%kx?eu^rFBeR;$=wi9Oy#L$vd3ZWc
z_xJ77wZFi37=r)jD#v$r8G=4tUteyRr(aKK?JZz&S6^>ePYkRWbCluf@oDCKNH_<R
zr^ol%(a4Iw%F+Yx$me9S;6$MBbN~43>Hd$^5BB=#5|VKg9D|SvNRpN%wcXewcfMKs
zZ;Pk&)~kFq#&)#&&H8EcQ4021T=au<=g>OLRt1#R2Td87gHwZ(rjaz6kelGVS5n%K
z<eS8+VhW0tq+~-1I3+c|*p)g*Yz=dDx#|+(4b;9lC+uqNXgHc6S!jOHz{5iWgH^?w
zm(onzHFHEM1$ZCX&4%!I9%!K9k*od*o!XjPVC8m1j|mgh3>T*-m_|z1IHP4{wVxIv
zhrlKl!7yE6uAIe=xm@zmLv&#fyQk=CS7WRVRN4;Ly~1l=8x18Z737||Ge_=Yc7MEb
zwlnG-UpH9vC&r@fETB(4$~GK-#M4~i+2~pl0mRO;PqeV;F+P6_vGnjZeJ7?K)?Dpg
zugeJHNfX`Md=WxuQhScC9Chs!G<iQpK|8q$K@TZPYc*PSJnb}hb9rP&S2Qpp))H1O
z%bzb}(s>S}y|t|xK$64bh;u@0j>QdvHZh~L<ka^X<m)J4Q0l(N?|$FToh|0Pu|{{M
zWA`_qe-6jiOX~7vAkt+dOtOZ5a7H4Dv=M}uAcU|EULzq+;@xY#OuGqo6>Vp7JjNTG
z|JJ2hi${OZl)Hz=v_|#w1S!d2eFp5O3I=4727}*dlXNC$A`$;|ZW*f1t8q&CeLSXl
zYKxw1b`#yeL7*;=zVX<x^RxJcDc#ml%oi|2j%o&7W9l6bj607aQmE}DDam)A<;yVi
z&i%23m`~b3dM0GD4uGgUg-9Z}4_e~|WObB=z3da)2&ocC8Q&HpCO{~Pj>93juOqKR
z2az~+5((vypn$%Rz6R!>u*D65jhqMza*S*tE(L3GW54FcME#}{rG(=w#}Z?t*uFdZ
z27i@eiboOQ!&K#Y?&}hOyTY_xB}DC~Ao!g@=VxFB8ZRaToy5Kxqs{6VYTIGWCiAvG
z3KffGgaz+BCg6zgaq<NhKGEWjPV5Jz0E%y%Q{GwlxkVVm6nk1^{&73BX)Dc!C#{+m
zc!*c8y0Fg|A=}x9q7;&wlEXFBM+a>&Y^M8y_XA$rn*3a{A8j%2ao*+E7$fpp^xu3B
zNvr;}PY>p&W)ltCpKexE?jC<L(4L<``h>Jy@nSCbx&pf_&F61)?cr7eE?e2}7AxSw
z8Uxs*@vF!2|1Q<)2mq<bz@dDl%0t0LQvF6nX&lZmA-|Htx<Yr8MxOK3Go_WD`8|VF
zf(Ey4w}dLSE{#@NE0SX8Mt!9!n^J0Ja9STro2Fe!Z#=6Hdn6Pe4-$ny)!OWOoG<Yx
z&%IIz&LB+H-$*4rQeZ9s8tFQ+^zOUy<fFBg5e9fX-`Zd0-Ou#|wqB5-S5yf8JT8H<
zN+mBb_sqp|uBSm1HKa8@<Pnfc#Jkm<0J2V!lA~ULPu;8ofg&>L4ilyImrRC^=kbzN
z=ss~wV*?a1vltYyp~MA-h2ay5M$6>wFiuY6hpYg>Mj`GRU_CV%5WfPlOe=HP;j+9i
zV$@@B`S#px%xV_+AH8uH%Z#9nA*YzvAdOu!%2Lz5kBm&UNqa@i$Vhb7N$*8Kxgdkn
zyGY?3p{&tR`yi1s(Ms3r@q)w74rB8)t#{*Iv>-ZcMrPNNO!R2prWch$Pn1(wFeQEk
zZ#f}dQc<@e%f{J+_>d~rG`p|K%*BWSfvaebq+wZNDZ@KA@|U}Ca}*~=SZSSi9a5Rv
zo6*o`#Wk6csDG_Gy4!n)UcoBL)hh%kubPz4YrM{whWNn)N`Q}{y7uEUL7;c>+<T(u
zPjg`frCehcDDZZY|0Lh&|9qApI5uDpzCp~$XO!XCCCG~2ol|2niR<+NfsK-eECnZF
z9n}oJ+f8Nc=4nwih|66jD5^CGCU0C=B80hxt^gd2L0>u?{dSWqM<5~%g9Hg!3=U(S
zk48#GYEPu&y^;`xqm0+0#!(GJ?Vfdvtx92LzJVmq%R^}0CEZsCuUH!Sz3vb16a*9I
zu(EN#L)|vMMRFUdIthd*57Qz>oEn6g&Xi0n*aNR4R{}~t(uw{jv0k(HZaF=X0LhrK
z&bHqM-;U6L+41Tn(1mjL=OGcn+x|?xgxlpXW|S>I2Az@bZ&msTXb9Ty%aIe@ZRqY>
zRX^&tnyPQ1Xc{WmT)~8;cHLQ3!?~o7&iVr4dFoD#X0Kp|j*j6!YGmA8%m}Z0tVbE5
zafcx8`D^`@3RJEzE@7j0W-Jd%%D^Y9*eLc2p`{>SF2Gdkr*rsO6(n?_$*Ea!W74M-
zuR5EITUNFr(HWLWe~_I?LsY7B@>XvfQljbibD#U^!gipFFcI<yli&dpo)XXOM=Y^e
zfdg;(9SnPi%Sf5EfjML_2>|6VVtx%+1OsGks^Nm{_qEiYsO5Uv%dTD$q%sN?0<0o1
z5)>~HT=TfC$dP-ZPO7~&AeULRr2Q8*J=tz&($Z--kc5wr`+c4x<0*qW%Sb8aDX#}o
z6VR*$!#`Bk7EWtUGwNvA(p)Vn9Mp8k<t>RqlT3&=t2G{Q7tw5mGNu?JFj#2xVn)o#
z6o@&g@$&`g$?tl+M|ow7NG5Od4xJry(kz;`V>BQ7k?x}L4qTKU+zm0_8%@xv*sdpW
z)2sQFSP;t`ky#5f<xLdf3J&d{$os>walHHlgIJ`Ge{V}EFzP}AUmn1)Zdo^=`Gmh*
zb`9u>>`Z3bUyI%r*5nwwQ--8qG>FUAnu)!7>pG5w4YM>_*=Jh~&bU95m)c(0sE^Et
z>RNgVKWi88RJ^IM8<W9t&A4!Y!nAD>JN%(sl|XG;*@viWnvR*l3XX0*w;UChG!Pz^
z9wd^yAwCvsoM3B_vh1`rQ|0@57_-Tg?&rNc8Vwbo%3-t_8T}P?Ig;Czn(;{*|A)JP
zlaMS9=Lag0jsZhN6sIhQ!J(wREi_K+Q0_ntG>2a9N-9KTRZ#d6hbgl*(uCE>Z~i%X
zr~TDNY!&a|x3Ku^Y&MM9l1lYQWa_lp5l8Vtdg02-J?!^RzNEZDZCWjvux`HU_>>`0
zwv?vQ8AnR{Dk-W|)C(d4u|r+enm<JZqmOpKsD;Hfn+8XISv&_3fbd+=i-1{qIaBFq
zamz*4aoN+#%UZK592XOKJ*%?4^aO1P4i!O9u}T*Y7dP=--ggI|*2A!_&xU(FN4Mh>
z5(y+ACBkp#oZ-sh%6|7Z(AG{#6Z(~R&=M07YyRaAqp2mXV>}B<TuFFnSTbN(AFrE4
z7F;*yjSgOu<c!Xoi@=(wmANvSRrRc<sT~L&xp`F>+@gEetkJ0?T#|;~_j3&<Ojf!Y
zz+#~fccZ?}BK`fm%#TRMUH7A=gx!B?0v6ES)1Tur{BCZiA5kjHN#@8a0fE`zzA4B7
z!!NwzIeKY`v{U&>i;LkcyDmwsvSi1Q>N(yoTf^w=^-;l8(<?q=pTa>GA0+oi+aciV
zV_K=&qq8c$hI2<yP_+sq@&eswq`0M0%$;=F)W2%&wttd_vd<DF%4|g7<yRgA1k7Zq
zlCFYCO{OHQnhrKDs<!6#drC*eGKH7%l!6Q!Y}KS4g|e~sni3mmUVELhjpW@QK<bi4
zBF1^&GkbVl(Lt{FaLmjdL&&zWIHNV4nB+0R<Nw&&iREUGGHx@G41d05DDh5ZfG%bY
z&$$EQ_Z%Y7boDnN%bHq)+k?A#_IV6qo)IM8_oP&w=<BOuPNfD5wHaB#u$#RTnz^7%
zCTD=@p%tb+6k9@o$l~Q1MQO&zfnIYEtwyh$s((~Fre4SX_-xRXK)pc&%cWrT!){K_
zAwd;oq>a~j_Q0^;Ne}@jU9I{4Z5CGFE5mQ9Rs_oEB|VFcod&i<sUcGk|8Rp*SqvoL
zbL;dZ1q_%$s@GOy8G_V9Rqgv1ivO(cVrO{(CG~z<<or-9tVw%B^7JD*gku=9z%H!u
zJL3Um9smeMH*7txmVbj(dxb#$N4fGZ1@ezvVPRrr|L2W=p8x*%Ph)qc|7z@htRq=P
zD~YzVtFO2xSMhEX2P=Vmu@V5?W6}OQdNg!ny9j1v4CK$Qw_FTG*<|JB2Az~}Pp2l<
zB33VpSd+Tn%llOM;wgjw+rGR1i<8Iu#m9Xc2v5Db<8QgX$za#}zlN2suiF_01b@$t
zK|sD=>B^r)^;3O)c$>`~dPmTY=ht`!djLap*gzT#=Ev9e{^DP@BE0;L|BIWd6VLrJ
zZMGKNZk!w2>UD*>@m=63gqocZnoV#UuHVb<K0vg3!)CCLe9dZPRMms4+kFUYVag{J
zxV)px-f5uYlfh{Hh}u)*xV;)$uhFoZjWc&Ne#$N6Rb(x#|9B6;$|6IyPctU}akJ{Q
zX}|0L;N<K7%8hvb`R?!Y8fwt@ed+!!vvfdW#r0eXKMM8oxa9Pcu3&lc<>~8`QJ*is
z`L*&K5=+b{8fTxz+t`XHD)qdv&<vRBlI%5*MIca7Lh5>so+G#!2wF2%o*~bfxZ8kN
zl(UyG!HxF|Z}-42jKvP59VGwBq-+yuA)q8?7DW7~AGU@Zqu)M9PL#C)G|CH1(+BcS
zpz!<h8Wp~7osJmyi~Kin_v!9|xnErTT=s*`l4FBi7AG-$+tx_nE!CZPG!C@4VzyzG
ziX$`P+;DuoW@C%#q2F!dP;&F!BTqNZtOjOeyj?wN(>_u{i1=X01c)W(q%}7~KC%wT
z_jSNt`+{y_6MRB}VImmtpjZNCO2AhJ#u6h&eD(_x6-S}l%Nu${rbPBm3tJ*?!l4R2
zxRAsNGtxmn86t~A;b+S&vApBHi}M{8E{iW3vs}zk93U@C`2oxvUGrnGkgD#(QHLuZ
z@hH*2P$#WS*9OVihUrSvhKhtgg3dH3-Z(l<f@KOx=R+G`m3Vf~T8s2H5Fvr3stmDs
zH2fYGW&sC?yov=Z1E|+SQ8?3r=|n=1ysv*QGr4OIQAG5(rhoQ>BqOgo)j%F?8;WMV
zotH}*S&>l{oAgqKRH@}si?fMdyG66@v%@Tccq^c{%cF>PPhkcr2&;hi=Rt9FvqE+X
zSml%--yw63^1&KY2Dz0vCBqsP0*;2#%o(M&9T+C?kCqk6jTqLKgMHY6ULl-xLC~#4
zV$svFRK3|$J=%#+FO~DDh-tWEr1Khd0I8Sg+o?qXMl-9anYRNFZ2vFdZM~nSTvkmT
z*kJj}U?+P~acvSIJa);9zMyNV(D_;qfSF)2;h>SWkv)o8H+rEeg#t^8$(7q1rKeOC
zOwo)A9cCeT)&W)OD_f(q7oYYMSdlkF6y|OUP}9}BT4ok-K|%RTUDuON_0t0CGg1*m
z5|tvvP(9)R#(>wxx}B7Tyx}}0!F))v(m#M$s-2{#tMnw#yh-tlMc)Ck#=$`(EuP3`
z@xlY}eB*$^R0z&*JqLq9v1X}c?=sg~QK!(uukPQTOl0(;j;fJ?^=Ko+qhJuxvTX3M
zBLT%-%>CS-%>(XMm_DTN+>ReA*3IZa+g~Qi0R}Fw@dq)8=*Ed(sKy@&9?fI>TC)3E
z4EM{tV5=q~>tu7Il<PSroylK_9gXW$sx6|#cca=#RP$m~BNV`6sTY&eG(}|$RF5Gp
zWPJtYuV6Kz&|-dRA3@WvV6CCSDz9MqE{Ly%%$^|pzYy=C)J}Z|L3*^(Awr-uWY{9w
zcR;wnS;{lE9?o&-CzQ!3Bx!{L(vFK-Xe2*)A#;C4lhJ3-6>h;n^{|=_6DR6EjezBA
zKFrQnRmZ}Ne(JCfQ<ql{&w%-DoVlT9pfK#tL02Cv{W&|BALXgGM8!p96^+GPK<zke
z6$Sq^p)Mop1Glv#Gl)A8Gynx`(LIg>4bb2c{3hkCgk{^GB>UPQ;KO3~Z$6`7&2ut_
zEdPta%eLXh3|uDZWu4W5<uIobyci2dclt#^88yi6Yi?S|DB9W82$Ygh-Cf}oWOuA)
zN6rIOxV{UK?yxW+SF&>GE2EpEJhUxd@(4NF?v^Wi?GX5fc%hK~whMMN%=8?}Uhh~`
z5A>p-Q?4}slF0M<D4#A@IJ@WJFS}di%Tf+jx9nozmUoAUmS7=y#uy?4?U<NJUI<3i
z2zMt6IFe6@`N7bBSdK2#$+uFZ5GX2K0^VXr&i4&_*NMN-N%Xv3I)ZGmUe|)0ew@#4
z{IWPjqs%X}@q?<4wojm?flNO5b&7O)_{sz)CX${(>@HfpBuQH(wX-xulo&+dG{FH{
zE5mmJM^2#-h!mHT8>N65{kT}bbYhA(Eou(f#V(cNY>L#~Ip&F(!jQ2*h*>R2!?a!w
z$x{WD4>3U-s2C9vna7nvUfmmqHSp4CxJQOB>6b2hfD9eqa}jOnJ8uMn9ND%?xjY#Z
zQ%XNF(qcsN{F2lF$H5`og5X$YBF7~o+9*svU!1;OZHvM9wzHSE*aziIkEoBzuTB&^
z-PN)p@WhYaL8D<|x2#|t%UOdph6sc-*>D^dp0n@#`xBp9xJaf%4h(pIin(oN2X)=h
z^TjmH6sb`v)o`2K+BXhqy|F#VJg1TaV*-BLeMf>XN4(P^@Zf@@Y2K<MQ<1=#%Q9y|
zXDZCr=9Ctu=k!GiSp{r(eJa+Oso9jI2X$eNGNF#Y%tTAFKeD3Rt<&W-<ZA01UTK~E
zf7+EG`cltuasW9lwKVbx3I<xk(19Ei-){6etjf9?lGHRJn>2=2RxYZw^)sU=Sa};p
z{3Qo@Uee`^@2rY|ly4u>uAf$?>ow8%1(iCsS!uNkd-y*p*>>JKU+bBOg%#Y`Xb>y!
z0jhz4HYv4T7{DV-hGtZBa}fB?Pzk=MD$NqYPRjCxv)z*7TB%BL2*mJMj&n5<{wZ4)
zcod0Z@nPgmD&xdIBPK4O)M9>^3rZTI{)j?WXPE*qP>#d7`R3}V4A@I*pSe7VXsWxP
zO~wXZ>?&S-=>{hxQ+}Q$j;$KwF#nZ{E*XWW`C{#dC{FastQtH<NWpD^`s)ooDO;KG
z8Y(gO*-xS-|LT*Fgn#8-klZ2$>!T<n4f-q7*0A9ZEQ#DJDx#~E4-I0?K%V7^BvSCa
zX*NOFnBi^)v4{IEE;>Qb#!AKXa~HQ5Rh*$-_r)@1hm9qQIk&Ie%Jd8|2%zP3qE=I-
zXt7Q4)9H%UpjgUrnkpivi`KZ(Q50v~^vOKi=%C|_X@0y-DWM{ywEZy34blZ|;;QQR
zKyGdd#zq(Op4_rV`=PYD;OB5=1w?;&&32WcvGAg{<RTtZNESPs0deu^Yi){z4f~mM
z^*T&pq85rZdnu&NX#$4pgWU-ZdDwoJ=jh|yrX{I471{@7TpE(-2LRRm!Y^F0jmXw`
z+O+-P<>}K>{*U+y95N_FRLpIWC@C+m(#+8Cr-oV8#=Y-Ys?>JzOAhj4lmtS$X}(DJ
zCZm}?{fVph{!6m0n#u6D!*<>r%=4f@`RHGs$xbZvb0g}F{2FJ_XE`#?2G<aA&r2ek
z7eB)S%m~j~h9?>pqH1+20ymO1C0#|6x;E9Wt>st@$a;kY(-ktIX|5b1jf67ld{VKx
zX4$Rt@{No7c(J$O2D^LBSpRFM$5s`MD-*eNYR3j2P+o$L@yRG}VFaEU-=aHpvQTqm
z-j)SM#`2y%-ZZI-KQK^u%V0pjG~arMh?o!UAR)>}#EsLglQi}eoKcW!0MPj)boc0r
z_p{pX!FajFaCZSk?N`OI4JZ9E&m&}6^@IB;PjbY<mC0`l03#_38%ZYcl|DG><^ys^
z6N(>>35Ua+z6f?b&n_lpIvDS_X-ZOY8ymT<N)}6&;TJ!kP_nix2X!W~v$czryx-#9
z37m@+Ltc4KwF`9TE3sLb-;jGI%+>a0f<GZg7h!VIEzjzjzkOrI!-}=+g^~myBZX@Q
zq~!&e94{(UO=Aa$&=qPd<8W2F%TndPwT5P8r)TorVR$vVpV&Y0hITyEg4!)5mm)A9
z7-vY6zq~TJyJV4PGYKGM*hX*ya!<?qQGYpno(n$3K=jz1yu&jWZBcbkFUfL;wAs;g
zL6<+k?bccyPcLKJu(Qlk`m%6T>uVaetKJ^50~i8(R9IF`&h2$qj`N_EqrGNH2X+Ix
z-D7ZYf!l2N2sy0FUrkl#SgdgRRz<a%u6I(yI_G!0wvWeZQ6E6prn9NqQRjkWvF-%x
zsZe|nZAyl$(Feo*5&Nj(=_A<j?HIdZSu~l=pt+EFZ{{<<SnTj6<4jmo?H>8?hNo}M
z@Azlrg)C6caP95Ny7r9*+VSdk9%3o_VW+0;>7C=Vw*T_2Z=^~LbR(a7#XoLcXQ;QA
z#Mff2S6aeDK_BfdQ!t?O$!Lglv?YlR{KEmg`vJd&O)S&0L!2E>)_`e3cEEU(^z+jp
zh+=yj@@=}nAz;8E<o}#FhJ)qaa;yxIWVmkRRei7(BgOM$Pa+&V8Q)L(Y~=wi<iTcW
zeA`NOv&U^P;NGkeuqupgyE>7{s_oT|E5|Or{HGPofve@B5WNN%(a0BDDE5~X>~Nh8
zEnLBpm2^rIr%<oar^m`QWi6mp`~L>x2ep;w=z=QmZE=HqOEm>#_F==gDalC`gFPv(
z^5`BDN23iC`}w|L#1pUlYlqd@#mUsr_TQD<KVGSSDLhs-mVc|W{|DzI6Z?PTd_4Z=
zLTUo;e~eYX+3w<CDUmxb18vuagog0Z32Xqh4G8S`;D0Zqr0-O^nVY<y7!AO!Dw$b`
z(V)*4DMGVyU(a{t^Y!@sUpN2iys7lXOZU}s|J=36+!0A0-!zKLBTp{hufIF4_VV8z
zokO4U_5$ChQ}&?m4+8#gfaCk~u1kPDMQd$c8z<_Q@7Lwx<>q3MA^H?ojQ{)j<N3Z^
zPX3Nx2V+C;=jZv?)1xm-KbMao7U56;0fSE6#h_lMR{lun`5#UFL3g_j<FsA1bowoi
z_8RqAhQT@pM^v9s@yy`-dt!VV{e$J(pP2e$V|6Rv2|2tV`OMpp07Nr3#rni*%2F*`
zY|q#vy~AsDQ~@2C^jb}`gf)3G6QAKZf*tC6ZLLt3jhDksf}lxr?eTJLiyY3XXB#4{
z`i@Wz1ugXD(PKUZdC7}vE%j#LD9ARj*%u)+)AOJ0rc<?*(JJDqL}HcoA12i{OZ^m9
zkY3X9=428LPL(0Fl6+Y#y5J8e=6>~xjB6IZ!xAr>IxF6(>D3NLHs4_LiMPVF)%L*X
z1cB0qR6Q=%bz#FB_SHOOU@``H9Webg*ia-KoLhtcB;X;##$3;1R<sT8p|u?`&~FF$
zmfWPYA^JJBcUB9L3OG3S<y(tC^5nF!d4Iy4!YFm4S|7rju{)AR!~kRf9FmZ#T!rrI
znZigOnHI8GJoUi1U8byIx!P>vmc=I-VC|6iQaA|~zzm9Pn-Ww6dOYs!L>L0+Yw~{O
zN#5g$-WDJgwjn&1gdf0zLrw}lWUI$U=s9RIh_p91eOhaT&BFDHk@-P|MBE?kLv$~e
z$D-M)FJmFXi_0(7xAIJ^S~(Q_(+tcq&SP~i_>m{q07#DxD2z}0TUZUsS+54zu;Ak%
z-)|gW$wG!-9{PI#MuAxhtX@!luwH}{=XZ~y6X-)&Tx(e5A|`|QC(q;|xC>M6F+@fK
z<cHc}h$5^euv7l4Zq@$DyM<Iv(sgUhwP7_MQ%7#VrcS!VNvz}1GS-5z52+!%i2|40
zo`HvcJQ|@jaGvS$88KwQ2ermy5s=@NU2$Fr*!9b+ZeSqni-ZN?P#-gA08dfFu8{;I
z#`QB%49xQl5#u=TI<1I=8~add&(N&iAwDupgdnk@n)NACJyQ1qzmup=#fg9So>%*%
z>x0N`%xV;D?~^0-*6rNJ(O+_*h4Bu$C*EcRMmd|8ecqW;6PQBb>apC}Z?{0YGYj=g
zLB%W@xF(_#eB%{>Gd7De_BA7K_mJge00NgRR&CH?z#OJ+iQ|b`dxsQ#sLn7R@UjN9
z-L(c}>qSjE!-3DyAF;~VbeNXE?zlR8N3WA|wVZ1p#}ZVW1Bs5Du?>TfJsU|YEr_TX
zvEhtDh~M!cj#LvF;;~mz`{~ue!z~lI0eG27`KG(2Ktv6_zetF&F4H?sBPOTu?xX@~
zQKlTFP(q$FEQ^bN2(es%^{$9Z>6x~v7kRt7SP{#MoeuIq@J!M!JC2kY?x0rl$(4Ov
zlj%?I_Z2@NZjTx03B9vz2(=Q<R*_vyyC%g>uPB&){6v$`CFEHPD?J++1!zX4n6GM0
zreb%rgL&Zy!BnTWSt=`$$@{?2i>HQ5-xhCvVx9zrCE3H-Fw*=k`-#EEJ3jYudN*!h
zo)}n_B7z$OYx)yL*lYPaT>k+d5m2ax%bu>1yK$s$tQDNrWN?4f2m(abuJj?g@h5`Z
z&DvgxwEp&|p%2z0<btA>ij2J3n;;~i;UA#_<E4V*OfxV0$86288^+IzYx6m4EP1^y
zEWYCyNejKXg$&#KcCK>9v0=y@Bl55W7ADB@TL<ICvM@fYM8}MZ<0M@%awV0*wdH-;
ztxcoU?mT8tU?c3{YGq|BIsDiFjZ~jHQn|Ey75pY`1kJMZ9$?OQvr3|}UtvcV5%*|6
zbEsAX@vG_r_FR&YBgWAXeZ~TjBeDZ}fYtW^K;Fy+OJj^;Vw>HjsGyWY+R)xRiqq2s
zq*XN(4)ScQ>61G+Ls5E0J&7RjcTwk~T|uOp7N#kUD{eUEAd{qCdJtwb(B}~Py`Dj8
z$1O)SDRZKkVx=p*j9x%#T}lC#adcKSRmeIv^e}gp9X~Z;Di-Ze;P0tB9t-*JCfh5=
zm4*hH1#K|IFp1fq(t*XJ%z8CUVLWDlge8P(kpI9|v}cx)z6#zv+e{ngjf96gpLuWf
zEIv;L#Fy-uyr?hLaQ0Jh%}Ib!_Y)oZ++B=JC+mknC>NU|UN{_)76%0H%1H$*>SE8E
z)K410b1{zwQIfsrc9a?)99FDsDt0KW7t1$cGWB<MXFo*fw2__0HREr;eLoU{CKo4e
zJm=(Q-e5AJjALC|L}}}+aBC$^cME;gM>or;+pe|yAi<41tu-nV(=-Pn$m{UgC#aS4
z-fJ7c+x6p48bY^UA#(<YMvN8H?)AQ{k|X)JG19cijZuyz#K68lCME6@h%+A}P7F5T
zckrfQHBCmC?7RPH`Qd=mAJ%fPU#Vdob}eD=fCDqA`~zw#2#k-R7%j7r5VfUx2ZYrp
zy9c|Gfgi<7*)06#uF5_LgR6S=1O(Cl35jFi#ap=nb;!oanvZU6mK+&+e7>%i;*D(U
zumfg~N!&)AflMj@zWZ3s%EzTAGzAAOVE;}YK6kZMOEYwATDU_hltuhO92IsPjcn;X
zTsQ=DshqC_I#JH&>Q<yOher*{as^o|7sAtXMWyVC&D$d_7!=fGDpgBsgJ@k$F0;G`
z206m5E1w5QTZ$ca?GwG?>y`>74`>Yk_%Dnj%ZX=Ys?a8PZWANqU2OxyCq$*VzRG#+
zn5OOQje7i`Z#`+`x$tRylq)`D!*C8bM9WaOh<r?l4(m2iK|0JIY;qTI7$i?VI&kaY
zCVrSNZVOl_U^C^F(`lCyDI@P>f+c^#C#2jD)z>&XR9q*@d&zUcQ7V8O=l+O(;@Bx;
z?<j7-5>60g>oIy)kjl_V28B!F6}cpJkipFmo_;z;!~i_AykgmRSg3u_ZzB?xH=)H;
z96VY!O&IIRSp!?Ra<S((8w6~g&oGvL2zpej25(zAOtXk0np&sK;)?c67b!QkEO&`^
zcE1z?5(f-tL0`@@y9iNpik4PrEy&wm?60ru<D5ovKE^mc=cP*POvzLMr;BuW^#~cq
z^%Pv2l*<phQx>g3Y74LK#fq)8iwQp|xHSrBTvY9GS71Ff=nh!c(kegpnni6-kKH}l
z_cBNEz^y-cT<5%nRR?BX98`dthF)Ra!Z-wX-#Hmnz(Q0^$F-!roq7#+@l)_u^^ok3
zi=L{XSlAbZ-wZ?Lf&yWqh&;YzzX3gul3BwSsrSbbITyF6mcq~G7FIBSGgWO*3%B!L
z9Sp~;!wX4D?<yl3Y+Eha3Vok?(a%Q7SfuG!%$;rXv-uSY;W?WXEUx91o!*)hS%&L(
zs=Vi9HRMCZbW4sk-q4L?7IT!^V$}%iaST~&l;90w^R865;%#ql9kj<1tq$vv=F0iD
z=+7DKdPAGV>wH()CB5~!mEW6B^Rk+e($Z^dE8<VMo8(Yy(_L8oV4ubVlz;@O`if@1
z;rTf%FD7&XQXW5lsLo#0`wl%@n7k=`{z|FG_#*{>Fve$UJEyliF0wI3-Cglv2Dq}J
zaHG7r?zjr#<Jv_hni<-v0i7lQ;OEgy?mvkxPdfd8>5PcT;G(|&k#%SDC!02S^(p{c
zz3j578k$J3o2us3A(0C2`=|-Y%T1PY?iK(d#BT{L`U@o5ig~CuIc7N9po4wBBZmR`
zYofkKkdEK^DSw!Py2^R0g$pb(=p$ECXY_p|_q84iv_T}}20+->Py(BwL`e`A;Z#1)
zwX}*)mT9g#M?MlU3Bof>JaJeoo*yOgzSEE(mE|#6ETpa};p)p@Alw7e_Dsx4vZAg2
zo#)J<q?|BLCPq|wn<MFPKgWpH9za^irp+L@ViNNxuZ0M*-mPba__LF5^TDQ;drpo!
zIN~Ih`yAHK`NNp3uBo7=qzU*ZJx(i@1_%Y0t}U#t+iIbwU_kX{1?>TgGC>`z;P0ow
ziL9mJ(>DRt+KCvp(#MkqeR`*-u}UFhIaM)C0pJRRF+26*nQh9$E8sBD(IeOoh8ZJH
zoi-YTa8U`dqa|uqw~l7w&xj8R@QVXwM1gQe%wo`FrLEFL>7E;a{5MF_l=j;{GUfjg
zGXK&h|8rHv!Ti5MhMD;v6Wu@ce{<F`Gc)}c&bq(hw*MB_b7Q%!&B%H+JDn8rGEkoo
zo)Avj8jRu)!Spw*hbq;MtfjKce3pr6)Y;5j>q6<*MOB^DGD}ayVqZRg&)3Uej^yWS
zoj~qRZzu2PC2MXOh9~n*cSZ8Ug(?5%%k?=zAOGjAOE5sd*XKPy-;b=k@8co+J8v$(
zxAWu4D=Y2zIxB4OFH`dR{Q7SK4~DOkQ2$H3y<Gmzr)0$9nER<DErGv(r!TMXHXNc*
z4<@(J2$DbV)MnA#0e9x{dJaWTd(-c!CaJn)>F+GC-qd~UZuGB6kR5~ZrkLGm=?~%V
zaCOhn$m3?-_ofUCAePEUw%Lkh;yKG(YdkjHpFtB8h6mI8pI{6fgLF5&$v#7MQ>czY
zI?>4cc1QdR2N9Aw82M)9tHIoZ7>avT)_Y1ANTt$k@<OD(BgbIA8`V0E;O)_~1Uf0B
znTn@oNN?3g#Dlp-h;>u>{C*r8rp2%tt6u3twAyZl19>9m7?kG7l$B;uVS(5ZNn&^r
z>MxYgHMRSFRF|-_m#Gzs<+8KI!E(h5cL-aPFKpd2QW6*n+A3x1in<)llzJTwEuCuX
zJ}>fmODbmIhS6(|XwIFYI(KMvbnl=oBW}v`I^)ox(*FC<r^Nbq*tpj`JPxOgLxvkh
zPS|S1vq~wc{kKNIkhp#GSPa9E3?~K{E3*OI?NcmQ%s$9ZSRaTdt%4#jlg{SeFz)sA
zJ_dsj^d8jh7&^y8Q*;+*fB)?@(F0Q_ZXPUJG={j<o^Y)Dk%MZ7ENwpsayaKh4kta8
zwT=_v8bx}PvLUWJyfsi6>S7z_tq0BWb5l%#(7Rh``=RFrcQ5Q8)h0kI7g%}#APwds
zPNk>q80HuNbm@k6RC0y`a21A%h(-r+`BK5+>y^yQW0X|V9dPv9kL64QRXcbBnXS(w
z6a6g(g9E2CpaFVs#2B}2VSPpi)!%{r`l7ed?T9aHV4VklH|@8eV<%Oog;F1WgqsvH
z1CC?YrP-|Y*yhLu4?|zhXfy$#Vd7(>QV6><Xb+MpH6EBi!efck_pBL}c#vJuuZT1{
zeY_AxNbNL&>4Ld|98^2mAv3qmOW79@5Iw)-Zn1V;A`8ae=20I75MBFq+PO+Tk{Wx%
zF)$bvLkgotet=;XaIHTx6?B@50aN{otg}>D3Kzy)8wr?((++DLkoM9))L1~J_3ydR
zjn7<~G~O#qM<Z8+$0@xVh|E=)z;u9uBaqlqrBDl+KHgEJ<5P!Y2ee1KNFZJSyE7@x
zq9}|eN<jxRr!=rBs7*Y~lSK*jl1i#iiuST4c0SFzK~Bt`oEbPkv=?)ETA1`mdt-H5
zmlpByu=oW>Q!rmcnV0xQ!ehqD2VM3u=n<Ntz9D*9qxZz3{BV9Q;J~`W^h$=p7ZKT?
z18*-BmOwQ>9khK&&!K^Ya4{tPm>Z71*SBz7uioJiLNfP2cV1KWu$7!|N*Itdkq`|U
z3P2;J{V``%C!<FMnKmjdiM~P9U3-q~lY){>NmW~ksf}9gVL2N>ObymKMAVq_gWNh7
z;1zZEiH~&lCo+)e=R%FeS+-qcO-aKGy*g^i6*csX4ct7;TSw(zV(BjnHOgh`Or3|H
z*<}K=9k76w$=%Bq*WqA2ZHnLX)<mg`Vl*$`;DB!QEEsAdw`*9wJ9do;AUgMxYv~V(
zH66Sl#?Uyc(}UPcTvvteUlY<#l37t>>JC8k-jbtX1GQ~Z{bcOo63bvlVfedkJ6mF%
zz!(_F#6cp6z)FNO3-uoo@NkB!IHkVlpGbQP<k*O9C0hbDZPZkW_><~cF6T<T6-`1e
z(YyZNLjsKg8W#w}Q)g%rZE1J3E!`=uj`SyD^xzF{oTfv8ko+!&gfs;rNUJHqM)*+Y
zBiMNg1ig)xN}VO0;K5J|q$X_O`pE$6*ITWGPH4qmQlcUQlJ(_oDOFtA_?{V+1>~wm
z$t|)CXL~$0&_*U>?2WD3ROp^rx6TWvOZUQpE1cp~R~pmOhS0VJga5<WI|PXqY}=w`
z+qP}nwyj;ZZQHhO+qSvOwq5o2dAIRj#5;}K%f{+tM6QTAFvn<D{8kRB{}*$EOHAyh
zB7##cumA?Z3zLW_NSE9UA?n@KUTr1J=NMt~dckE6rkN9<u?GOLgiEIaJ{(5m82=p)
zb(I^Xv;b8K*hlTF$j(;d8NbvVvcJlWj6D6bahKrL&2Dp({O%P&Lee~6Tvt(Bbm%E0
z?{$&j7!tY&ljNn9|GRCRH|R;{GF}YzJoDz8{WVSVzR(22dc!>q|L?)Q6CyVsjbQ+T
zNN8%Hi~ERh|D2Zc?XkQ>iD>gjwnACaTpnj1S9RWqX*2RXsSLuM4%=JZ^2C19h_O3g
z(JcV{Ix3B+02K7fhKFtlh77UIl=n}F3$wH2^_Z7mXIioE>Ait#Z`-#2;aqeqM&T&`
z=9vbQ5Dd*%s+>hx*9N^@7`T=Z5vtm&ELH;;BgnjXz_KATUe6Yjuf)}TvNoDv%e}U+
z^qmouNbCN<VBvD3M@%@>d$;fL1h8eclEWI-h3>JEGo1;suyxGFiywrj#j~nvZSrp~
zyL<>jIY{NL8+Md(L=JTgYjw;%$|5U70u1eS*sgAdq|;_~P1B^5NfG}znXzO~jojaN
zfGM3E`1y+}a|ywg9^3K4(5GvtkhdEMTil-ZxMgHD7Qq7eDi)bLUY7OR%HAAt%B8Y|
zVgL}u;SvKxTM(#yWTY~`O3`O2ff}*zPNruJ?^$dtI?n2<*+*{eUSv-|TC8^IvnvW)
z@v0a!u86$Q>N%&#e7KpleQXXiormb4ad|x3Q<&5H2ZBz+3A4WdrI;vi!Zo(?Is*PK
zs^2@ahu3}^f`#P@xhno!C<m=JXFot#KAv};Q!Y|>wAySdR)4DA@gTjkGxF1}n>Gx&
z;rXhol?DvvM*sw+&SXm4*c_qcB(5`{j&S(6_+CP`tSUg^feWSp9Pa8Y5>W{u-H5Ko
z;o@?3ClK1irhmZ7&xQ(wAo{!-Pm{Od8cb*Z4XtX2K-Sj)z>BQt%RdNSfivgp`BWke
z5ruE*Z}W^upYaGS=%w}G;^_R3i7Uz!80Z!7!1u<sGP`ZC2@n>V<~L)@eoy~7k7Ah2
za@O*@W!ptQeP9a$G<VP6TV3c3@aE2)EJwQ6*2>4|xLR>?A2$ZkUMsl`uM8qg#WeCr
z<imnZsuV&{7Nx)_S0{roj?0M1PL}jkK~+_}<rlYN?FHm*B`yoC5UU(%S4K&7?=B_b
zX_v@<h8J#uFkX#ypvvT#8Hm1MG=;Sm|H)d=r_|XSL%B~0=yKk5AgZ_CFa_t%x{2Iq
z_v&y7vbShChV9_jhn}ICA>Vp;K%J_qjWf~6ZM*_Q_&p@AR`gcxLGyT<=Hb*{ls3Zc
zK$QMClm&J<!*crG6AJarHfY?Fv)gL@Vf01EJ=lRg!(hazY_WVK)-9&;hAm5T@|KlC
zAmm;B-~|)b8C#YN=bIP(n(fe#AtM2IPAzvve2w>P^x8X*SOy|2j6O$B7oabFY&cB-
zTs9Q~f2lHGLf)rN1KnL=esuuUiD#F<2@VT$BwXN9Zm9IsH3R|>^%u=&QHB_#s<$$|
zB-r`GDoJ;m4EE-e#o-mQAt?<fGsQpsVe}z1$uA?h4lFx)xXNBNCWKC@iH|XGn@Rlk
z#Wk9hDzdAr1VL3&C~-;w&b4hxVQKBZo_En1RCF8Y=Tnd+vvW6hPtHjVV*(32R?RE2
z`l#yoW<WbfhGPlgC(Qc=#hElo^o}!)R{O?{Db$-mpm`Paik0e+l4LU$p1{QS4ZI7R
zZs&$k(%VWEuGAfF^?S|_qUJnj8GNWrh&FDzJI^M$(-`ptastdEO6?`pfKdf)Lt6WB
zX@6pjz%vSPhIu__lU`<yv_S5fmiv;bxJ!n3Sh4wRTg8FRfjzxP9;VP5BZQ-*<wm+<
z;eiM`Wk+j+l<hYy*fqGCfclzeTv@t~;*3^syiHryyqaOGIlMN4nxm(vuD0cNbF=Dl
z3b1bmC6^?)aL+<vt%n;$8TWyCasPU2wc1jb*{3sf(<W`MXKtXVSpv(pm`f_o=RA#u
zw1SFl%F<47#t(Q6mt>@m%E-ja$do(7LO@%LxKR2vg`!VUz?W-v;EIwL<iK0N+IrS=
z=U3pkAYf<pR*2EQy77(&4w{68!yQy=u{zrSkU6=VToT@!LhJeH@GuCWTO-sHPmY<2
ziA@y92o^J128Z>mm=EL4wtJ+!iJc>&77-I}-eJ=?zhMG1Eh#D^W8q%mA^t<ZA~8lK
zK-ptvJAV(5?XHM%8+*<TVUV1<rm1Z9OwLmF;J3|>0|c1ccEFIWVfSvRnQZgT#1s}(
z;bTXPIHz1Uhdk4DyAoS?a)q)XLpp?sC`mnpH){_l#x#*Uroj^g!dTF+pg96gNF7cX
zi4_sw#RK0&XUhQ*q0;9%EAsE87L?r;ei2K|5q*_{6G+u6Y1F8dVyL)gy(%T%Q0NvO
zrJnX}|FBnkDT|F^xz$h>_$i*o9^3+SAu2=Le-cnFE39-8SlaL%V@LW?FA#KEnpkmD
zp_1_=N|o|OSF#;#b2Etwp=^l%NtPVrZZ?OqARu06OB{&hkZZJ#mt-n#VcI0pBE>Kf
zNfq8qlDiYKojju<H~!>kF{NycG<gODt(b7oR_DyiS}3oLK;5K8D%Uljc(oG5Bq69K
zSV3<x$TFJl)m?Q6*|Q^tJ*Lp1|7jK_03?`dlCDQ}Sk2$KTSgJ8@{wS$5vkgc9heS2
z2Y<k9zJg8Yw!F4OZxK4)jTXBqNL92t@Pu|~NYMiwEfMjtMjHyDfJDo?*4+JjQtujK
zJnRL}=uF%Z6aAII{c#5|ewHhiS`?k`FJ5khuMf-OaALA9f`^$adLZhqe^Id=&@F~F
zWaXy}M?I=!@R4}#Kl6km2?HOxc!{uwzm9aCpd3vKdE-o9rkuK)ZiBLzxRpUMq4ORA
zI{`r-v=V0%+1QKP8<~$DGfTO|sT0W8jFJ=y65_cWL)-_QT&*qY)2K0Fdq}2WId^U=
zY#(A;s!_G*ZuvQ`cd^m-!jTN_h$fhXmH;CQihFN_Ng6uZo6;7C-U$6S-s#g9@G%e;
zNy=KV80K5d#C>J^ehF}Hbs&TWH9W}0o+)s3AV;oD`JSYV+Tl{?%I^*R1CPe#Ri1WK
z4R_PxdlXj&R%-ITs1!05qUCq`rAd-M8r_ewjuRkCSEyJomzxrGH_||-D?~iTL95Kp
zr-5tWutmI}KlK3mJU9F}FI<X+l9r;1%JQBPpjudQBNp5U21VaQQN~pkO=yrZ?0eA>
z8nf%_!%S>S$36HI>ggQ<hmB{)^d7Tq-r4_)<xaqE_gYp?Y9gyKvW(~Lk>5itswua{
zevf2zJ!@sP3-b%sdsh2RePaXaZCewV-N;`tH1tkwu_-gfG8g^p<B7jC&7beT(F*^=
z6#R!iU}50+ziEa4rjPzB-u&Ov3X+JvdHM@`Sqx4OxheB3&g!rE2YfXDS=h_JsjVK2
zoC^H7jp-IYDyg(W&>ZGFbyojN)EoXr#ALaF&HsIQJoQ|b=lAv_@Av-h{Aua)ej1Up
zp2cBNwtF<e_1>E8`*HIWrl05Q?a_a$&)56;I@gDEHTV1W!hiahR=2wQSN_VeV`oX>
zZCBpUr^BaP!?!Ve=q%1oUjOe-#N*P~tJx?$zMq$ecenQrPp`QK3T(VX|39l3-Pg3O
zjIQ2D#`zRJzb`x1T*m0oN(6IXu96fr<gZ`<ZuY?iqh_8JyAGb(vY9JvR2Z$jkK)fE
zYA@PP(ryThyrh>$%8&Hh_v|3Dw`|bg@3QtG`9NL0oeX+(x;dTFycGP2AxRtW)SCUJ
z0f>r0BleEq_n}bR^H;0HNIIty%tx^0k>I*^2`eUQ5l>Uux#6L84(9BLs&0OCH?^_h
z5}l1!PH5!3J(C1hTcR9No|<(Tx5;~U*7#n18(`W|P5}F&+F~Sx=oxTj)m-m?tcc0}
z<z10`-yNvytqT$>vV1#;tmu8I#etbvAgMmM0uP{)*<QZ+F073DadV_W4vvnwm|4C6
z=u9=L!q2TDDNsRMI0-LGFW?mxkW=LiLq+`ed*HwO!Sny{egeh%0LpizO7(UO)Xp7H
z-5wV+zY>Yvh+48{BjJd#A_rU76<Z0mztpp8dLS0FZIF&b$>HDuJzmb>0P|%XW*#Ap
zmGgjfMBdpT<gqZji>T0_$hLLLvcaNZzqX)Z(}(HslB|SW7M9iXfN|q2Al8VlliiPV
zqsk*52=ELjh<I&N6cFh|r9pj4S4~Re(H2KT?*mhL_cl&NUwZdj`%iF(*6e=k{JBJ?
zls@i;RAporqgX-u>6VpI;F2CQMvk^uTwxT?Gpu-*ZO9NBhlPabh6>k~xUDq(S^DUC
z;@*7BQ*+&?tAGKmDSX30iLaHwFqD1@C>-EcE36d!2Y>v5)vPEqkiq&xXg6euIacq|
zqnp8<*Yjt9r$_QYTVr_hV}6lb+7SOaKN>h#m9%(>xd`>RYmuG9j>#>;H6Y<kv5r^0
z+A8yh0)#Z>%s4_9EsEKOG+*OQIlS2<q|cy83d3|!)CGGF2j&AZoEOXx7>|PEv0UQg
z3jy;8i_P7oC7yx)ZOcg1UPUKj@ox9ilPp##7NdK5U|)Z9NYsgYB9FqBktFmI50lQq
zNI0AX2EZzjqm?8{9wD*|xp!6=Qu+c#GTVY2ByjYea55jicsZSKWN^|=WnoHsjp2;=
z^U;M5ln(7+J)NC^Cu8qp;OhQc@sJ_hNHGI2&`{)*tO$Zu1f-oe5p@OJmxv7+hj`)K
z;hV2mbRv3p&s59Dfdb7X!={L)2zAbu5}h1`6)5uEBdi5NgOpYN*$}bJ?l5ewz>H<l
z?$*9FXb2<b+Y<=x6rE}iF-qo;QKk|iceIW%PmCc*pe;dRhbUa5Z*&upVq6iwi;sV1
z!ue!YM|8lLg=GS56o|of>9pcalbG9Xz++C3<S!usMvO6XlF*P?qU?z4GjdZQ4oWAU
zymh_N%YL{iS$e>u(U9jNYM2qHd_t?T1$`{|h?e6Zq3v9N!wEs}OPuMOn9x=|8m4_m
zQ#?4%*FY48o~3;P9T&&`ta_D9B0tdZb_>JzJ_ulzg{l_MO}I9c0}N+fnUY<(o*TQ!
zr?XE)Qe%)AWVIY!8wpd=iqzMw@(^9Nd&B4LpMjfizO*1k8em}&IFg94j)Bcow^5#b
z#7;Snz+6DKF<9EHXUBAF?3eqhHK3Q$OKsBpstyIVV~D#`hu&f!(DrIw^czfl+u-=U
z59e-vs17g>9t-By1~dyW6LpWwnej>|=Y_$JTjHVHhsoFJ(|8l@KN!W<|7h#f?^h3=
z(Man9Q2-Y>g2y&>`efOXGjCPvm2mMlEdo?c-~muFp!b(X=R86!%pdJFIC4&6C+a07
z(pgO|x`Woi!(F!q(=3F!g;WR;<4QhH^f`)zY26@)j!2}}Fy|pd_vf&W+CCidhzH2`
z{_tK!8a7lF(0QB4TR05!Vwg?!2U(0|Ri?xR8UK`7Z+&n|o-NDITTaVKs-cno<FVJz
z4_Ua>e%y5Gd+Bu}vd*_A<pEmb7bkt){*c4aaH*79AstciLO)P)c7<6ltvFJm1AN3|
zJ7mw#|4hxG=t^@y*>`Xv)F7>YOY4zxQH1esRD(s+3FJmm2dP96%Xkw!3{$D$af`&4
z;3v~zBP$Co0(eTEzFLYxIUCtv9&jHT6=Pyfm`ofo4tr_l&qs2j)5kDrPTayW%M;C7
zm64H*6gjJaI!c$-LVtek+S#mhvSUfynyQDAQ=py6QOrrbAUr;^BQadQVDpC)GG?f^
zBSZCSTL}D+DU7iHd<n=GRlR^2$8y7%lIE7ukGDqCK(DqQl@f|c>p+wTXNUMCx?;Ae
zuWc}nJXBdEDMrI|3B@MBP(?So0B=Iw@Sey}d_rz07NqzIYkMdP%?C4gIr}b!W)>av
z6kg;gfw&Pns9FK{Q{JItA|Y!<x-wZQi`p-|MJMCswV$;`NWH9mSU!rZi($eO-i;`)
zFRYZVJ=9*d5r+;D#-0kFSsWmy{)dXb`k2c<#RQ&QK>HjXf6oA(BQmD)BGvM|XF?)M
zsx;eK3Fnge9>LwZCb)#3yx0uk?7iNJ1W)cx#*YfK>$57*5D~p=*t4?i>@(mDlQ#?3
zKON<>5a~g6u194l0bkle)|+XQ^wQCLQL^y<8jGq1NI3v-eKvlidV~iF--o9Li%;?f
z1$m>7H*LEBFuf_`pmB_*6ixWzSd7A&ZByWH!Jmt|ye?o2qEb2JJi`<nG|#ei&HJc-
zd?Y2JwqzxL(OU%H0oYW*x}NRgC4A2q4e3j4x@#A2^nFDcRB`RnnVcyp`kI*<)w|@1
z2I);z|2KO|T}PA1N~;#Pjhw7D%S8@cuVcjat}^`X*53uk<tUkmwQf9n0{r#-OYrRT
zdU-IKRi}61V+@vjuvB}-00AW_pVtiRnr2(7Eu}abb3dvrG7qF)Y4c1fthMb6Q^$-o
zF;4HYdbU(14HRT}oyyJy*^N<mO4$^yb{Nqqtw-*9sG%9^T)if*)GBb+gcxq>aiQSN
zdR-AZIK+^RnBL?mLF+X@RxA&X&Ea$Jv52U>Y9TqPXK^Fmot+D|gUo$a3v7R1bva&d
zdhjn=HZTqsb)6a|q44Y$0J=lvdbP}J-cFFZ7_rF0d2t2#Ny_fPVP~YvTL|_vzrWG1
z8h&=mvd5-Vy%KMazF<w^lXx7rwQ?`!2g`%rD-Gx~xgn6>rrKs*$Bvty*eXP_a|LBV
z5M}et?$5mDmYBT_ma0v_kVRpq8zE%vq)ZRW^E%OCrfoc_zsr5)8GeRj`d2*X`WOBd
zV+y2!9B>6!G$CL(1PBYVU@8)#Htz$^lY~(gi9XAuF?KXJ&AdgKPSVuk37E!hu9@tA
z0^7B&X|jcdvFzj}DrH&k3|l&|0r1@8!Zb}$1uM>IWZ88NR+c7XAM!84Zqr-s8(C|c
ztt|e|3=QsH8?B7?4v3ud*r4lMg6Hc&@1#1@B_w&GQ=y~8(Il)DQHni`iH6iY$Z#QA
zzWZ|&)-o2onuodH)Jwxyt7^DRt1bA?IlmU{$K0|=Ss{KMe}07^7lmP)BPI9tT<EE2
z%RW}Lwtf7F*NX{J3fBn~Ey_0G<o(7gN>w&BNZMK(dN@K`f?6eoX1PoW(=5%XFmF|U
zWe(i&{u*$=SPA`3hdY#RzX+;t+3-BIev6^&oL~P=_=ee_;6Y0rd7dP_XoK_MT8YaN
zjN=4?2AhSZ94$VTcqfS_^@3tcwPB2yIso|MVqDQg9yH(nZFzM}hG_-;G?Od;ny~`|
zwa!Q#bJ?OIm2B_-V=|1j2f4`+up4F-u<erT^rQ{8yS(WQw@B?bw;6m{U2{ZfMJbkW
zIB~-p+DgGq)Ar|9)|TEJSR{a=Lw8htzEq;FiUTD6Sy&AA51TG<HD}cM5<#*w%wHR<
z=hPPz<envAeSfKRgjSo1tykox7ovd;LH>cyD5U%L@~=jH{Z1)x=i|`x*g8y_R<J18
z7`9{fmTg7T&ZVNaY0*`^gAaZhaX2bH`Q3_n8<6O?pG_mftR9{oFt_NOp?XcLhi#|7
zMiqR0RFQwdb|lB*k{b5EhX4;T*x&*j?lx=hvK{UOvqbQPASA4dQ9GQKJUiyKJ;%H{
zOnsS{(NV-`wETyU&Fpq#by0mP8=~g2(%T#R;!PLkH%QH93bi~b!+hy3>$<$b3nG4B
zd_wB;$G`RJ&#ZEPn{@S!d@-j-m^y`UT7CA(D6Pw^u6>C9Hre!liLkHbFHEa3yr}pu
zGfb)4`v@|Lod<N4bt5<-U%B&as6K^yjw?-0eIve$YOtOeH1KWNNiR;;rtQ5$n=^L#
zpG@OE*;o7RoX2NUYo9d3lU2nkG&l}35_YX72%U7|#O}Yvz)o2Ci7KhV2QeHT<ph;<
zN-Vl&E1@jY2EL&3Fv$XErJl8PlhUF1KnESs&d6>ykJl@9MNR|^ZC(ILQ!?4wL$LY_
zs$<^#N>ePuYbG&6_&WLmb&S9JRSdk!uOX5}1MtH?Eie_$4E;x{W`sD1XTB?AiQ4b2
zVPZMIL@*pknv*NxWwva4ih&1X>il#5?U+8qp>K~OBXu7yMz{Rc%lD0LMnSgrUs2`%
zFIKa%{a-OK%#8oVb<527zd@D9I@(plV~D=|eM0}bWfop~$^>B~h$Bdb;X{Ev7(Bv_
zxj6vCXrLv3d_L4xR@h@qBp8OFH&a-amUP$ZdZ{vS-}m$E@@Dh;zTSrNe!h<F-z~j9
z#{zKI6>*xE#69Ze@Y04(Z{hvkp7+bzvVMR5VZ`5$2kL>|?@za1z8pTEmhTr&gG<kj
z6YcN3IX{ms?`{XWxDSI4j?SSmw=j7(kG-$E`yqC6x;3}n>|vkhI+?nU;o8eC9)~8!
zhl4(kHSz{X+T`EYf4K71_0#>+vlE(cGsH>Ug@MkR)ON5$HXB2q|0i=5+a_yUv9*V>
zWfQrt?)HGBwu%c94Sq09HQb%b?IG>Wt^?{cVKGn0a$r4`pXJ?)RNcWSRTFQH!fu~c
z@&Kn-UL7)^>K*$KYx<b_o7$~vO8x<Q;w!~(PV}#mMsyIt#Nl@d6@5Bed|uNC?NJ=f
zMx24pLzN#??d+c}VpuQ9xbfF_+EVI=%5(Q4M)bbu5cYEy$Sz{XY3k9eT7sr0wu`_G
z3QBEVJb2{XsL@a`6>1%64;J8%FmfK2gb<Ila#@iMb5zOR`}N4WP(;x)DQh7n?PQAZ
zY`TH;#_T0>MHzJtHSerHc_x+>Pjs3PYg)^q@$ZJ}H{G^T0t-qW>pJyz;H}B%Fz8Mx
zb$avvevI~zCx4q7A0leeGFjVp$p^v(wgs~%Vg}l+EgR!~<VWlq_>o7Ec*I8n<90tE
z%JF1wU*GrwOX16MHN#f~8C_S)JI|Cq!42f;#L&__%NP`92Qq_nd~WeU6~JbKC{mO)
z#l4>zzH3@LUt3)!N}s>$A`*+?p0p@Ps%^4aU|uhHDZMha#ziDT(}f-<R5I<XyGmbj
z<5ZL}HCt5xAS!rVuyi`O*LyHs1ERFL_Jk)hg1S^WW#!SK;C_>LwC<5LD4QTN&a_&R
zJf59$Z+@PHIZ->sO?E4fLKst4<_C6ZMASKdM2#k=Gb8-a)^Nli2&+&USQ7x<Vjzd!
zhjJJrkHX@&Arruvv)OS8D-uLH?0Sf&i9)l*VfOW6Fpgs-hue!ml2ed}sd1!~!}H++
z5Cc2?zRG*3qNu*N0#Ol2b*YXK-zBG)(wsY<3(MA0!$nuS5vn4k6v{xjjv_i4S!=mM
zwud|TqGVpQgW~vdT2onP$r$TiGeCrfS-|cB4qS-=*!dh;9OxnEjb<xFgdd$5&QNA_
zLXvT~s6jJTzyOE?Tch|&W~7AY1r74535Fr8+i4!iyvXgCL}#V#q8rn%Py`dna|qd3
zffAq@@daXNjDu>#uv??*P@GEYK>jVqBCiubL0aD_DS%OdEk#qmq&uK<O->gEKeuSw
z5q7bSB-g!V-Z2Im#k>&C6>O+5rgm1NR}OH{&1rJgOd|7<)w0q-L;2HwDpoT$vuR!L
z9cE*8gnFwMo_1qYDp<hf425fpY9m?F8o_@c5QZ5*2Q5tlB-g3E3FLTz<?jGE2xVJA
zbC)Bung$WHLv-JWwiMAM9Ef2PW)jt=nxPm7xcI1z>M*p!<}<0t>byAm5Dle_L&OT?
za)h_Si=Ya{dP5PFQ;N*1b%P+>eL(W0L$Iqr^pl_<iv1Kyv7ng5RmK|45bwHwGy3vs
z<xLCx$*M4xsanO#JkLkDUeb7^(PB@_*8}1w=eCqev{p|e_*F^^ysD)sdk$mlTe+<r
zx&$;xMiI!WhEpeZmDWs;l?vEK6#_6{`=x|zhPpflk}Tq@Sr{bmMzP+nAs7dB7Ip&3
z&L`r;x{a<P3~A*(4D-ARi|jcGv-e5(aOp2K(GRCYf+X@MFCOoQXQTy^z{oe_c$85Q
zeb`ImZEhVN`1V9&){Nby)gc!6=l^^@pej9yY<%AF78zu2=_WFD2I4^&+a$9`CMX<4
z&hWDvssaz9s_U^rG&Mntg8ORU!{v*UEDvjR5sYL!==BRHXN@dyAA)IC{kx+m8eEW#
zCUDlqb}W6-QSYX`h8UrUCH=|{6>M21qzcEmG6KEghorfJ;3h|wp1v;_L3RRSJOs|=
zZ2+8i^F5`1JUB%QIOl>$evOJpk9=h^GO60hq3Z@u-9N%(Lew`++xRjdQ#dkgH{AFk
zGBOkf#IHh_mti0GEY9Y^spv|oror)-M6;d0cb%2&Q1?^&r0{~N#}5LYs=DE>=|-6W
z%^@3dl*rix(qz1$Wo`~WGq{xu%h0z(;VV*t_~>5q0zapwW7E*+#Z>`R5CFQeYQA$a
zy>YCI#Y=0)VNA+UfHyDg1I<coB_TnfnH@&^Wu4LpA|_^4?j)QrV+Dety?d?ME+Z&0
znk?jRuHJX;0Nka!p<5!ls<6&0TQm_czQa;=jo$QT<<#c2CR78C(>oZ7kW((q8AMDb
zi2?C*G+_ro%HL@*K+Y37@*UxBN$L%@y(pwL%3n<lrxd8JKrn6I<G@<tJqkFql8$~g
z*<-;sIPGcwRE^hBABTNSQtRwFjB*Zhb_@%&A>c3M(}+pdr6TT;YTN`_lEJ%Kerv-D
zsWYL$oJ`OQcSizS5+4Y>@r<m0(#uc|jxC%DgIBipg)$@ww%tBJ#NL6TtkLH4en7bU
z)6;9TwspyVu-D}i@V9Ay*RYqw;6;0X?MUnqQ8GJbniRy2?A@rXf;Vt(s^#11JrRDa
zP_e-<jf@ZvcI+fBsL|i~4lX66rppwQ-bMD9bEnKJa6)o&8IzZQ`9Pr5Oc(WB0;6PJ
z<F+-?<b(~9F>!hYG3<)u4sDy@jcJ-R$*Bv}%)bTj#!Y70*w!7}lDI@C4_AmU0m2gG
zWO3q366&ckK=iPC2?1<DS4vbtXc_R*hm!Xk<QOd)-Sn^E>xbAT*;rVN)0{P+qxl4Q
zB+wBFPoR+{@m2Gb+WR&Yx^oc6O4i^)xhgfR$;2s2hCNoZt#eusYa$RCz%Dj6f7I7g
zYEiJ~aanJb6d4y`xN_-1s^6EBn?FYUMQ_T1R~2N7HXT5M@tQ<nC2m)uOM!Y~MEISl
zYPJqNra@J-K9-$Dk+8$^<Jbt}3HCh}EIFd|GP1-})$viGAZQXxlSNBN<gn<wQZJF7
z6R`J+cUdMA0%hW4i-PX-{#tplb76Q~y;%qWa2imJXAhX~RY;T*ExS))3%)cadmruC
zXXnb`oGHD>>&{4&Vsgq#>uG<elk5tWNzYyq!hmY;SXUcgwm?#u4Fg-)wW0RVPPh((
z%x%R^hJo@a9Mo>IK8Bblg%+U`fk>Ys7{pGrfYK@yg1hR5QFg61Q(+w~AOdrHr}`FT
z44o1iDLouoed9QeHIwBKdQo1AKY$eW-cwNBsr~Fx)vJ>|SV<ey5jl+lXB`7a_Vs69
zA=N(MOL#2)9J=GP2M9AKJU^h-sAt_gUV4&Zw$UY&MJ;bu8!33Zvx!`TZARTPxGX=}
z<k~<#O`Drj$x24mCdi2AhI_cEPjgFnMJhQ~u<FiDSIBbW{<tVx8c|OU%{0`+<Bsah
z{PbtW6E?d^Uw?4ue*{>FFCB@!!-<-#6jtz933)dc-ue3!I<&e@?*6_l?apIY-BZJz
zj3x8y_njtjOi|}LUF;9}*8E#WF&+LYJr%=XC23hjMiM|T=~mWgh}>}iP{fG?z#4PR
z>a|Yqp(1E~Q{<gdmM;;g;z6gZWf0=VC>^nOhdl>{%5-D6P-n_SkODQ`4}f5SqNgE{
zgDuN<UTi;Rqy=d)5$^i?46+(z0D(x$+ROfL5!8?D?N&~=-m7e(78{Z@r$<v^b-xYE
z<X6Mhstd!mHZ>$s+tK0C!&u4v(KO}&G$psYCN;haPh^{`^kpW7`r*N%)lh;OXa|Ie
zpglp%W^&fJg$pY@SM*^d1~i?xLq+=Qlc|WL1b4SjSPE+G&=Ox%7S;k^_Ubef0+Qq^
zOFzjIN~Vf6z!kmdxfsV|{oFglFpK>>BxRo08%ZyL8&C14;&X(`s+bK$l+c6ocs)V9
zzh!pPX2CF5ChOBhSUEkE_c<v%Nk>KXup)Y51gO6KTIU~DO1x@h%FT5fW;YQsWC#fT
z?i4HnTAF0(-U|454eVmz9j$CsRIg@xJckTmGiI^x|1g8}IoBVPT~VX<xd@p|luJW-
z;!%1eT^mPjQd)OY(M%Z_b48Y4iuS62WTA6m%Gh&K)o(U7zrfD)y<vszV_tNaG$v0T
zfyC!!Ks1eW&417(Rs^Q$R`iKjWpb2BUs}`&b3kr%Tq={K-sB{miFp=%Gq)-h2j&T<
z!ou=A16JS^N0(Y|95`}SrTXQOu&QWg;ZxQ-elio(ku`~~IGT`Q!nu*m5aCF#_F+r<
zH;d{O$f2d9UqC^-R2ehk<r)-@j5+FN+*P1D=$+uzLC_SMQnwY5v0LCeLDKJsz6I<2
z(o?Iv+AnksR+&o02m==l{nAr;Xwe}>>(6+(;r3I-mDrFbHk<6*-n0)VbF#9<58CGM
znVzbTJ_Fb=-3>r^>#M~Ix?B&KL0oo|DNbZmk#^qyO)HHMt*<kUFE({Q?66@4I}`Jk
zdJWp&pHsq<xwsijf(#F2%f!MBT$K83FyjD5H->k68Ce&;p)f`96YCp@m-`^yg9tm!
z05nR;-U*t*Y9(zMj59Zf1a%htfm9NfAKonzYsSeEPE@U|W?-t^tBCk4Gm={o9RWmR
zGJ?DtWouytg3Bh&hs<8SrM2H`3*ArGZv?Y4oPN@@qHs$#n4YMY|IP}%7y0|st;V1E
z5uWC5xyP|3k2QlF_+*z^#<BWspE9kSQke_GbN4qGv7PPDW%ro+Xril`&bvJot*LbF
zG`-0<t6ayO>A33fLK@SNXKcLCSZaT(<1YaCr^H$#(^e-B=PFgGF_R>hky`vO|4d7(
z!+gRWPcFd~4W1h#MnVfPC2u)%7l_265cB#x*UY0+wh>=s{{|55uvw8oM^G%$SqNE#
zZz0Vey2*W=A8itAvk+sJloN8cH=pC8--V&GvE3tE9v9SKH);pfxbD@7`pa}6PPI8I
z_^elmY&?WJqkM_T$|Bn5-`_&6VhvcAlqgq(!arAbA8QD-9^t7x!O~9b>;uIp?E1lU
zkA-0#-Jn&O?H7^`mn)Xd9hiTzb-hO)G^a3s-LgfW^R$buquJqs)mt|z;>sHNF4n?+
z0UFb<H~$+X{~wh7fBfSd9RF9;5i=X-|LY%TX8+$Lv({*9{wJCB{|LS8!mlSe|AgKr
z6&FM7OF@SGuo3uHQp^p4!#@KreQqMT3F`Q%8q3T}DdHld=xb@Dt_NX$eLkJO?;lHX
zem|FML!a!ITYYd>{c;ESIeZiUl8%~jdcW-7ZrZ}~c5Uyzmd4<J-#@Siejes-f4%tp
zK1{#AT@BKvKGDhs`{@0=ynfxaS*ndXI68*LUc=<Oc<g=O{#A@*)T9-0Jf_si=qzVk
zPATT?tA90n8>@RyKY{+}?0L8&iT8xvrsxlhro2SS&V7@sqa%+6kAN80ULEx%QpLXF
z>*SQQ+iUzDBvMF5w{yZEev0<X(MdIb0_uTi;Fa~4#dAc{J6P<KKO7H|%76^SA|;~)
zN}Y<EeyhAsit;Mr8V;)H1V*(RE&D|kmJ>N}Y|uv4O)jokS{I3Xnp=I7T6ZdpyvZ`Z
z(OsJsnZ8NbyFZo1@ptd={q413D9GT>0Hm-#8QT?S28zTWY7|r4PB<IJ#gZ45*ejd8
zn;_Sd8BPZWOb2J1dzdAd6-Q|MGC%`^I}mk}ME8|PXCk~rY7mD#i?J(8?YS4N$H3RX
zpFt#dm#%q|7zPt3N@q9I2%U;%N+%+fAY$d1*6M`;PVVmiKr5afarsNVO;S(7Je<-N
zJ#hxpZgUDlV2;s>&>Tzn6`h98o<A5OOdCL)Pf`^`&J$3p1u{JJ*AqV9YI;$aJrktb
zM9F>2F<to-u9774t)S^HEof7iBMLKn<$)-BD%i{36dNlG+g*WAs9hrjjVjYwIv)-K
z-oEZC?QnBgW?PafiOW7z3gb_6f>h?tHqDnUde!g@4f0Cxg78crCf6E7Y-@lM4X89?
z5`Z&)8qS0x=&hThj-Sz3IIu&BcxY6SNOras2g_{LHc;*5Z?bEoLy<fxn26d}C;_yR
z&|5AyB!2dmX5$2B73fsdKs2}<DeSl=rUqq6%5s<E9rDk)u2x0KpxrbqtZjRO+6>HW
zrVDgBIzIZ!G3Qt!^Vq?OiN0es6X6t+kbNXBrY{K++eUsBy|t@2^8lK|n2uhxYJ}3D
zm)4Ro_rAx$xp?5#5ia3oif*`Z$%;|n#QUdj<OI2*6iK2!ow&LOgEi%AK2UX<bh^@3
z5BY9jgV3r4)i|FUX<PPFe|TK{j7nHPj)k?=bM|2#Yc0F~Q`BA7_7Rzy!u@-50omDV
zlqc+tiO{O@_MM0mDefUfOcSADCEFL${8p>2`nv|%ohp&pcD5#Oq`4vf-sPmkbcd?L
zF3cKDIdW=cA$MWCnC0fL2(JV#N~pyA<mzR-<1H)xJtd^ijGFX{9N$=r3OOqS{z!}X
z9KPSjJ3b^^XW)!v5J;&|5UOlv=o8FudUvGmm6{gVxmU=q>zi7C86(yrd+DR>6=4Uq
z8QWc33z{*25i<~@$yWk_QEEr<v9q@%`s$$)%e84GLLje1%AV2h5nxNJd%rIRF3WK~
z`Ofm}whFX)pPs`KQ-Py$8rQPQFnDtZNEw2!s&ebgHN+Mp=P)xt{F4m?fT|<XDmg2+
ztkPI}Ku&dDS)|)8c*z9D&qRat-<NUfXi`75`_^k&vRvW<WQ8XYr}Kk+xdh9wM$iQB
zkOR?jA2mkMU+i^KDB*~J91*FkCj1F<LR5cSz~Ti3q1jJ2&h2kOwWY`vDyy1cHOsI(
zTc!kPIWsoPkMy-f6y4@2z!gsrRn8y=5LG>JaJCX8^cZNbz)HL6)%2X;O64c(Boeg=
z&<Is3zGPZ<f{4}Bd#VtWBo^r41nT0@BeLQ~<VNaa2#0=woF?bR29&YITtzzk!^F^~
zP=6OTZxA%Yf(1Oq(B7W7F%gR}7;PXsi0xXgX^Br-gB=_R`~~0I<Pe1Y&AZV*DHT>k
z!64$ONlwvcf{mB$Bd2ghdbViH9`|~OWx#$+^d;huM;1n!;)XC5UG_8zgqvxWgMU)3
z(`9LPlO{@KFvzeW#n-zuDgq^Q?>+JjfiL6x*f95O-|#WpRg9#mm?#ygE-oxpQZ}zN
z1_nzYD=4aC;joiN7z>YtI<l23X>4Tqtyv<}q7C~z^(0jVD@tc6bafjacv2W7h<ax5
zMZk~iNHfpwa-+GZK1o?kOlGBe<;@z{;LtQNRpp46VdGPQB7_(cnXMnJMx;KKm?ADR
zs-e&V_?29sr34hs>i$`i;h+IY5$$bWJR9}0@^=t(145hTvsenQ(v38yd|2<T;ozC;
zpNZ{hf*Q+XrbtxqkO^hr(~nkD%;gzL-DBf1=<?!HY*DCNIBCHtz7uP?UXf(32-?M7
zU`5#oXu{HO3cxLb^S+fQ7^H=(OiGK(Mf8ca=PfHq1}gWSc_r7$Q7Cm@5)Kh#pT91M
zMB{3~pJ}PC-Gq(C+M@}%!!l-mAupYD8PBh6B+kZ}e3}rW)IAbh2Lvzt-LmMU9ed%E
z1KNPblAuLFsm+jvJKQo1Xa`%E$8mN6NiyB4Cz9Hzj0R#S(G|S*gQPTWrAd*XJzcR7
zLLg<3tQGzxlv`E}3r^dy=qCS5i(Q1v%g$t&Ayn}EIHLy$a`LS7Y=szxVC9=2!HdYp
zT@w)=zXS6Zf!;jp1uyh<b&^qXmom+8c<N<{VC++V4|H^g#5W**C|LoTJn&H=NJ?wE
zR|(!%xX8--T?sq_ORhJgzF!){JiI$ZyMe3WvC`M?XV{-r^S?sNu)rCa9aXNhU>MWG
zOY7LL>n#B&4kh=WC>kh2<Dl@ZsO7*RIdBk<GK2Ih60!Hb3z>2Z>44#Pe}m0yC$Du1
zd+pe7))+fKa^4i-as-y#2}3zmbpiz#|D$F^CFPN6Ynmkd&)nE#AgzUh1wj>jGTJCP
zFF0ShDZvCPU^;eEGF3SLmyDiZxtf-`+u}7<F!Xu-k!nBOIJvjwCcwI-p_?}=?fr^R
zg^r%d)KMkSezWu?4feH)iSDyAK_?0yJo`m@{DBe%DKwaXs*+{3O(CcaoTo-4^>JA@
z*1q*6+A>T|E)H25%V6%*u4MPlY7Cvr#PsqT6%6sy;TAB$&7d57q@<Y^btPQ?HLYfw
zctElRK+A4Nn|kF^L45M54eYmMd#&6nA5QGGb1o9X^EI2Ba;4q0Z@F$uEuIB7?xsGY
zM;CuU0RF5(U!+~b*C)b$zlqzFQr|>pJotPHyD2r$f-48y==E`fq8f!IJ2)Y|I%RMW
zz`}j}@J{5d`z8*g3I@X;ZS-RxdnNMUV^<;UJ?mHW#T@?yE0f**uvb`yUGY#+W&(A(
zu?Xz)I!9TZ(M-wz=aoQ_RiKV`-pAmXxIAvVASzN@eRDZY1D*eoTRtD!*5Rhqv^mii
z<USK%UDjiR8=X)rJ6%y8%zaWA(8oe5Tf28R+^~Ba-w>T+gEgl0C~Jwl{$VSqd<wd1
zwT#^g+|$#WSPO_Wz4)|qM=LEly{7VPF#7pGhoKOTr<Sqq`$I=RX{F6Nu&$(dE*5D2
zp~_dSPx&Xv@q-VPuZXy+)53EqrnwkT;}=oKUH>a4mQGJ1l<P%Ln&RL)+bvi|T2Z{-
z<$Ot~q6}A((YJ=`?837m`zZL#+eW?4BIQ>(P~{ZN8f1n(a-jzylW;yahg{s;VgF6~
z7HCc{2vM#yjW<ua-(>JN$$#SMgqNcfG`Kq}x94`W1;<toHMZE;+>U%{#es8W(G%=7
zF4$=$yp`UKZ5vy3KIyf~XS<|CMSamV*!{+y^pQhCT~@XDK7<0bt?JlhCvGFtMqPGB
zPgD#EzqBJNPi)l_A$oZ5!yx$zk%nf8m!aq4To0^#xHx7ECId|0lX#2VTC3aC@ds3g
z*#};E*~!X;FFfp#sq<G~$8vEjvzd^e<9G6csEo<;rhb~icl5OBKq3Om##Ri|3>|_A
z!8|)4Z*lLkjGe|xcxTGzn1#80l&J*uoVn4KsooZ;f}syA`_$GpP?FMiQQ(il`S<m{
zU)&cb!GDDW|7Xho4<umX<Yf5I7ymg!F|#nR{J)TZg@N^d;r$%Z*|H>=K=fHtXL*~+
z&y60}CS`$Da)Yijj7dX%8+bFkTA^cew~1nWIpwxf#Z<-AT+z%NfoU$)R#MF#pGGF9
zBXtNK^26if?eTlRjLZ9dIKKP3KHk>{cR&#5F)xdIFv#J73wv!F!vB~0^S*!5_j}H6
z&*k&+@-XvEFnfAx^#l8R`&|}xx)vt*sn50-dvW*iuayiM2O;+5?&A<&elq9Y#P(GD
zw{rHy<ViF4%Km5R(hlFY4t}@f((myR-tPAsHS%`%=l%WrG0m?#t}W=~x_RMnrvFVl
zr<k+vC#K`XgsZi#gi%)-Pe7z;q3{9SyO})R41ql0RNMmyS1)Atw)VZ}AzopW9zkz-
z=^c^aOXsIe;PZ2izsF<9_w}~#_uWQ_it|#y>UL~`$H^X%QX&8yWl?Itxb~}jbKT*t
ziubWN5LW);Wkn!PJ<FStZh*1TeI$^0HgZ=sHrn=ixA&!E_O2GVFD-(%=&@L3!9%MO
zHoX;Ax%|*^>dK!oWL~LgJg=O2!wB~c9IcNP(2vo1xQ@j1%M-ZI>OdWC=-u>Ae~*cq
znmY|eBlrIAGm5ZnuZ}XM>{sOj;KI8T@iCa1IdcqFzY`g>8Xu^;FW^vN9t3Xxh#$cq
zS0(dX8(Z%)Hjz8gPru8Y6!4Ux!N~UX0&RMlR;znqzu7tY0Q-$O$J<~6YHxHmyV5Z$
z(dc-tVV*L2337t(&7ad!@YF?tuys)xx?2BkV*4pn8&~Db)7Gk8NFyEl)1vHpkZ+J>
zapa43zIL7o%47I<6E#k_54p%7wlT^-v7VS{c6^zKD}8Uk&kz?RwWr}n=U1buIJ}8p
z4w#Vj*${Zo=2&v24b3My05mHLw6e^n5-bi@7RNKn<P1_?+TT-$^Ott1UxP0~o}UYc
zsjrV9V48f=1`4sA7C^`|V)0P6Zzw6@ZhJ}2iv`z10W@_UW9}eFv)CMwp_Wk;p#32~
z1O+OQ(Ij;7>E&O&_2k|W;-W#)yODhlObZ|-sXyj{-R+Hnga}RI<klmi)>V|G!F{Gf
zkQgR~eX|OK!x*4Q-Cc8FjX0=nNjRZYEac*)O^Ev4h;-YSo)!?;EF@pN6FJa`tm~}=
zhL9A54XsF;8*Zyj6T{W#NA!}Z3;1l`Cir`y?NElH80&!Pq^Th5XH<)x69Ph3p0dst
zbCKknDEnsyJX}<PahFz$m{{=of2}2hyJdDSrxn~~PYyQGmn4UGIK&%kI*Qe@PcrWm
zBHnRYfp}F+jvqtYKMf>PcNZ@xst*eELqHY(aKD6lOfaV;{;UrB!<JInYm`daA1(Hw
z$VA^0tA_ZX$!SZPelRqcfO<ltlc-4fLL*BHLMl@VPP+t%JC;Z_)emyrKe%g50v(@y
zbKf<)#G<q=a%zfq9glWpfqKP15RK=zMXtNrZL3@#AaV_j%(Oeo2tlqfHeiSz4_~t&
zHx*6a-HdB_AMrX0=>BY^)hWj)&{Pp>$eV+l6t`<37S--Ix1fKxgG3R{s^u1KQsQGN
zHq@=zDHBXGmM_tJ4}xtj0dyErDqGu@xfX_6mUn2aN?OLkvA7X{^pex6!UmY|G9pxo
zC2O-vuguOVsG+8BZDa>SX2hvuT2ac23RTJqg?AFE5{Z-|quS-llb2of7?M%7c?5t6
z2e=bQx=yK#AfXQe&57t#NHnWH>lDz(vntN14T&o&Aw^E|M?F9*Gn@-oVRPbz@~YEh
z&D#>|8e#>YDwZw79cf%MiaNxeIjS1;fb<7hQ4}gbl8mBkVmO`)*QSj_ue-9LH`}Bv
zF8c6QIq=NBbn3tOWc9e!S?TG)&em}Q)~{c7$WT41CruS=zxSD*({fIAc9Q-0IjfC0
zbmmwFHp~>iN4A?^BUsd%2|r@~xq3q29=Djm-i$4|`f{miE!%qbnh%A(v%2D?Ga7Fh
z<$4uTJKpx^u+3oiE{`<EdN<oX1D$W2YuG+&5gx-ENZn(&_GU#fs#^9@yT72lPj@AQ
zYD}Cwocv>0_3gJL&h$#JtJx@5$Bva$na&uIF~d}Daa!cBAlV9JMarIY-9u-><B&NI
zPr8~cV@sWwj_Qa~iv&^PO}vy5h{M*^1|@BcG?Xx(YN5wy3oFj~Q1k46)U4a-Gnts>
zjFDN|YN^25#R!TmZG@TS>SmiEcI8jrzAvU97-FGGl}LBQG)zS##b%(Ds>LLuY7vhY
z4`IIroN$bP4jMv-<^o`1K?0myI?K>WprztP&}f}Zh?d1A&={R4XtdL0i938MVc#*<
z4UQo#;;4X!)NuHtY`%suYKC#`E}||!T8fi)b5(*pwKT&pya3-J1D7dKr4@B-0Z!07
zlU*K3t9=LxERS*Sxw>jpjZ##rNZH~!E^}Tu6$C8L<6EU+sd2x@p#kXTnhu^Tj^tQ$
z$s{ZClU?NLP0SwUi+@vp-)qPz9S}nd)`<p@t~^__xYds={}7?4Wat=3ZQ+c>SBnfY
zCu^Diic<iS)sq!amJT9lIC8o}Km~`T#vvi;fZj2=lx+R4ccs2-v=&Q?yq<=!{Aq|y
z(kRB+=-M)XL2Vf$Z+7vF5|=o{xr-api6$YW^;N)zCco`%;2tDd09t!RKNZ_z6;n1D
z!3k#$t&j!m)M5~h&K{N%gzuWz6s^Xdo}Wt(L-cDgqZ7C{H18aw#S5!1y-LGXxtuZ=
zH}(LMhLdWPy4TkUv+3`)6nPQ(WA1&rZ%tVuDm`Z|Br*NOVj3mvM7(LhM9RK)`O>E~
zvat#DAiX!SjN0>iHn})@j&k(6H5aN1PY0<ASf$YzjH;*V6R|%)4Lq`Z7@hM#1mvqR
z&_Go^h*T7-gh#T>N#d&X7Y&_Oc7$@f@vuz&a#?WU35t8n18~5YlS&}@Wh@3D1Yk^i
zsHSR!K_Xk63))(bErGj~(|$A(w`cr)ASK~r-3r6rRWz&vyBu&7hO~rl$Cr_joh4{s
zS;0W4uMcC1nR+cE#PUoVW_z-707Ml^<n?<`!uqZ_(1Jk%!<I13xn?^n7Gh)Mjgxiy
zD90frcAO!7F<68@xG>C_2AwYpub_~++t>*U(ZiLsKhh*xj{O_sbNwev&-)2fLdR>$
z7Yz6UR8_}^-GPM`6r4`6zSXz(=m2#I5sOSxg`#N1<goE!#oB2MlOmRm{WHYgNyVP{
zG_#P+rCgwtQYehZT&SU|TWkP6bsAnuNh*r9E%KIBW@x1?_n(k=ndVE!#WHl{IZnK#
z>A*sPwz+XBqZ8(AG1wuwca4M`=k$)>0u0|sozYINh9EvL`{%ls*;5~Xe6%@^2Fp)+
z1tSS+$vnx~)kU<99)-iDYAx2m_XhF{e|$A{jHeZlFohDgRo82<H^YZ35`VGdqV|bV
z!{I3NR+XvY8|(BMWUruRFu&r6l;em&n{DcMb<4rp1HHn`8KyYg-xbbk+zN`j#|uFt
zZObQb4j?vg6MuZ|x!LgJ(@};2Yf1W7bPB7&WAY{Bh0w6y%E5`0TqZilyO__*u~EVR
ze0Oz+o49q4-*t|=ptFs4F?K03{LG{BojLeAvsWukemqV1(-`H-D5zuUiVIC9=B6;v
zHwRbJK@=*+#0=IAsK>8-&(OL%^lZ8eZW~J^g*sWdOFSG9Un9K=1zUpl7k6vXrx0-M
ztV3e`1>?24g0Oc$Z_=SNB*4Mxed|thQEpGfQQkWHv5zuOH+S2coA-4v`&5TVi$KwT
z!P`qj_3EZL-g2}2E{nilRn{dxF@tlTr%fvMsBx@d4Htc?jJh;%YwPFqg6(JcxJ^n$
zLscV9=&`H914#}iBin<I^X`vsgnq$Bn389zvb~j#C#EW$jW$2FZ%$CIhKgrpGw1tV
zL%#qIv3&ov*WiDK_5Yddng6fUOIDWuLiV$={%^?s8QrZ&k`6?l+kbV!Sp{Awou&B{
z={Faltkw68z`hz^3@@|)ne5@MuIAcoGa{)%idEFq4sp|aRa9eVC*~s*B*@cv2ln~l
z@%enepX>O2ex~ZePVMyZeq0Q|Uxwi)E6E)g)OcjW>h$6KzOMJv!qi_s!t8wC@2C9y
zhA{c@_`N?LX5Rbd%1)g=@;@J+Ps2{-;lbd*zRdW)-QVuW;QHb6d_VRf=w)*8W)T0%
z9gP2#`xw7EU+}S7kNSiyUm|YLOa2^v)31zzzk7_p=M0+g0}1vT@qwggX8q;-K3}@U
z)8ps$Mi>7Ko8$L$2>Sl+`~5kk*FQxBW;J3M1)dFB1-~5iM$uvT8O)d$%H{ip)$K9}
zTuV3DX7r>+UhS#(CJ1or17r)=i$6;l8Om;WWt@UCwb@9rFgn?%3-!Vz_?N_rsP``2
zkGr8@e{yxCP`Gtdw|^f8sQzSwE)Nyw8d?i-DX_+RHrg4{0`B~BZxVMu7S8T_hjYV)
zUbgRLCjr&$xVKPl231^7`0%MB!%Efcv4~y12T<o00Vs{k@QyKVtcwq<pv+(M(%<6+
z08rzz8TQL`bpHv@dcLH@Wyy|U*xoG-06^=<2=rh8PLyBiAIQIfn}3TB+>9`aF&^|6
z0aR7=|6}YOgEWh}ZOyc8JG0WZDs9`gZQC|0ZQHhO8*j4G>iW*P-F+kOiRk`2*8H_&
z$BKAjjy1;d9htVub=rnyAnNsn5fTgQi$0=~>PCjGItQHuWv%`ptSCAX>W2;toH$pF
zbHT76X&=2~%6tz>S*iP^+|8!CPtM1y@n>m*9J-tbroVJzuAX%Mefq%`Xvoq#hvTm=
zD51D7dSbQ{<z#x;Kj<O*0Tye}!tItDup@{#7hW4jY#YjAsUtV^?Z!@cLb{6F49^xh
zpyk#uWzCeZxxNbFE{q|aN+;mUp8ruv%F!5TcF@ah(OR|DnRC>*O7iH#(lA*{K~+>%
zWE&e}E<ktqTw%3(i=Q4+$08oI=Uo?cM<Xj^?hC^#=|nC<y^Vc&LV7!0bj31*waQ{v
zd(KpeL6tG+uIkrFjG<_2beY;8=baqn`TnQ^j4CNrbdUK#&^zg0lHO156Wu*uDV8ov
zgi0q#XE-{&gRL*gYiOm?47a<?EEP5L-k-Q|=qjhZcQUj7NUGoKq}P2I63#6*HqeV2
z;|u7avReKrmv<B4&#5sr6~sw6Yd|2XgU(WEEtgm$`GscdVkE6KFLWa$d{sMR&_P6H
zA=PD&=tK>h?64K1jT3tP;dXe<O{^XWkp^*~mR8scBRn+qf-W?e6jU}`;&msf8+{i_
zU$p?{4}3yz>Wt$T*$0t$nUonOG1&dSIS5)~x%iT`!1-u<hQA%P+#HdODXOIr#e#Pl
z7d-Ln(&0*1@Pq|ZN{zSYjCWn96g-9|y*%A;hDf&Nc$P@=Es97mrR7{(i@7U9ZeqQ(
zizB`GRH?BwtflY-rZ|7Z(*)bn6vO}LBtO5;@B4}HZLrt|e0Z=?6XF19Q(r?3W>bc!
zg8klU6b-wdj{J2YvX-B3vIsYd;e7BVatw(`5%XGgCH-_|!!%sN;nYhQD=`aV)Et!c
zX1o33L10qhn0OgomS8X*8TJfXPbO$`$A+v}sx&j?z0nMbyTbfW=~TgKP#aIU#7X3Q
zD(!<XWM^jCl#}_tEQuLPOiYTNp}O})X`{^Wq6?*D<}+=Nfbe`*<&u)!?V1(KwZ^it
zER|Y`<YQ5SjzVacSxTxdFpTb6&cAtWfDYkgYAAYZDBjjgP>CsBhq|{qUSGf&nrx-k
zv49H*`DOpxaJmo)44B<PZ@~x>ITi;Qf$SxPMW(pljJ!UZi!k2+#zomwM7CguSf1<f
z3?WNZg-!8+FS=SX%v2^ORtVi(m1Ukf-z<*QluW~5DJLjFlv3~%I>!jebqRA9R2FN6
zTWN%v(GiU+n5i$yqAU5S8m2A=33iui(uW@J2j=>Pqtq77cP#x=PKQ&U>u>pAwc>5V
zmbt2aRbcS+!2rw1iYuyolZHzIaNIp8uRN0*J?9tj#kgecmrg`DC4s5x#2dLHVnhXn
zbY(k{1sCiR1HYdw$tzNS-QA;7M8;Ey_5%a3nnE)t;`p!}s&hIySzW=7Fuk3YxS+c%
zIC#mI%~#tpYuTE6C`dam-Jf<NYw8=f?JiUJak9i4zMGSX-#!*dTyzeboXZx~pzF9G
zze@GsS4QZ+Ffq^L6M}f3wS=)~d8ZxwAty2{fSY^gMS}I^N0*TV?7UoG+?WNrMDx>u
zdqTmrK<QqH6UF)Zg@i!`U8Tzbv^KIK%Bmpb1ouFo@X#i0r=I{u%avr}y`}@3-z%zf
zkaJcU)9ulDX9&(!9S%cUhLvb;y<GufJiU4um+z3MSF61URZz6;(lC(Ju2c-!R|?v^
zwhS(|rm+C;W{d4BSY7RO{`pqj*VhT&xszA-X{QRr76E_FEHAg4O?vBJ%Z)Q*rmfff
zT3QId0GSgKPT6%F@;15%zBN15Q5#jtt(3ry@e4mEYV9N{U=>{#Wr!Vpe(G5kGtJ**
zR6(hhK?Jg{Ghh|CqA7BYButJ#4b(OvaYR&s(-U{l+FJU*@`aGWmTwVpnn;3hq-e-|
z*L`-YyX;QrV>{QAqP+1eri?EPcYB!(Xl!Nsg5yVHS<Ou6CfQljVc)^t$q7#nRq!)p
zf5Btd6zpThTi{Lk`CiUHxiJMMDp~0u0jsdLO{#r`35)hyT)_Gw{<U{c4}yZJ@ZEkt
z5gQ>#{g_?xo5LbfD%J_;fFk>%PaPKykVusZfNFy6k~mAqE(#WqutWyQlX#rOAu28v
zAxa4b2hE(TMld2e5rFDDC)1&{W=!BtU_??wqgcT2f9xyg4-Z(7gCh2=%ezaf&R}m=
zCk8HxAy-y9Pd`U*-v+@46}AdUIG|7EPegZ*e8wkZEKw)3D=Q`+*k7kv+9CX;r6sTy
z+s(L6=>f&}61iXj3?N2h0;n7;DBDJ}{#ea;Og03@je@bdB||LngAC9CI?i7(1Njf<
z${e!2{a_1$+E>9aujgbOdvc&RyOW`tEd?y}Nsww|I>0XTlYrhi{YeVW=Fbxi=&wf6
zK%6bHFsoZQe^Xoz!ufS|M1XCY5qUB)D22uCUJ(Dm2TtT(oMyuM?fAos$GSK*In`jS
z$kxOnUVJBcN@F{?)euIi^-dz5(r27NI$<8SIG0{S<br0eUnn7)TKms8fE}_X!x%xS
zrAn%pLVPS%xP81dgV)5MU+f`$R|0QHsyU?oAFJm?hFuBgq<ME*vOP2YqNn{=VJ<pz
zwIG!IBn*rtjYwg_LrIJx)<tCD$YVv^3q0>;DzRrqdC7n&yfxiQnGAilhPS(Dkt`l_
zih2k`*qRJzM0wiZ^t=pQORuvDiL2kQW-158nnSA6UsRYgxf?Km0~aFO&Tj$7Nnd@d
z3zdS*s(GljSsW+riXexZ&)<nt`N5Ff4UzAFk0iM+ontb}A*4F&66TX;Y;q;J%&;4o
zH}3|CU$_PM!69!J@bR%G!q^Gy_ZlTL<nl*|OFetXWw{)Af{Vk=VFO|qg)uTi(VycB
zt_4us=2zp_p7xdJXu}<_EQ3$YVU=Pig*o!x3aWId2PeKP+yL;T#WB2t8ZBXSQb58@
zCH{rZkXH9H!t#O}3H0|m?7`CEj&r|&b|8vt3X63DcgezTwdbBdk*{P@ll0mKly(i7
z;(G@@K?91GjGryB-TBkfC@C@R$#zs})Xgb5fImvtY_Tu2ht)#fOnWYe9XWD-kC<1h
zvJX<AD*}Z8!W6l4PYuo%HcFf6Jf8q~X`S&=jb-p}zHD*<VV>F13ULYJ(CPCek<=!D
zbg&aRmWq(<f^Qz!LR((Qvh-mXeyFzuH;-O4+wG8^?mhgGxT#iT{w9YKSt#3$PcBkq
zdq<)x=MiJ9#oP&wm5yYSkWf^3T5)q{uYisdx|urHn?_))=;4sRhk8?;v>Fqib$43e
zmKJ|LENeI*1#s9l(m&NW)WZPUtfYAZh8gP~5-5gzI%m&H6Nv$O_Q5FNZHWR}cz0D}
z5Wv1f2Eo}prH~b<Vpw7tt0@QHOV_1xF~j35tS<Mbd(fPWbi3IkF_pgOX?q!A5+Dsl
zm$~|aJAWq*Whp_?1}J-qUAp)41>Y=3Z3D*8A?0NYNtG`lwC7VcyB8`VZEL{WOi!GQ
z!vh=BGTglSEdy!+DSt@DdEj<Nc1^CU!83%4B+3uyr7>@w6NlML5rcx{EQ;liWYK;9
zeBP&Jdz$xpp|_IV3jFjd>7N%Hw<>2-pZCl-pEVIoXqaz7d9kRR*CVM|CtpW?*V?3)
z_CA2}y;1k^B$=OeRH=yaO%fg=ATA`|_1SEsr;J3hX)TKQaNV`wNCFFVjA2|#a-fV2
z&(4h0+j>peY!`|f8&udkMQ~X#BcJ$sLj|)BVBD-pfikw5dI%z;Wt(7N+2LCyY_^_Q
zTgL;%DJU=4G~hs!nld)cnsZ)HPn9aL4ZgDPRw?9@icF5Q*K}XbV?o1V`bZL7Tbw2o
z5eg<OC?X!;)#@m4s$K*(^Q?twwbbQ9^41@;NX6)7iQF%MtaF35K4+!m>HXBm<HMQ6
zNpDBn%LJF}$`SG4hr)UE!r%nhOVN%mB6nnkMh{^RaA$s&uxA0koRk!{kA8@l8V2YL
zNlQBpCFk3njm%}=ji-2~)A854yyVPSUZsXW3u6<Pk@s{P1>qrNt^RZx?44JzvJ06V
zhH^N;3(_$`F!jp(fzEP*W#Wg%vH!Z2MWO58=0HF$Mo!WKnTB#d;gg68J!F|GU9K9l
zyp<vW$VHz$ARS*SmrVVLZ#pIJx3f*HauiF;oX3o?E%-f|*RoIfb4pd|x9|f0wmSJ?
zR}ORQNnpoR4{!lLp-lc>sug1V1an{&(*7#d?<vaY3o8rJpMTmp@UJrI_#YQn|4pp_
z<z?ew{NKE69PIyh*~9;qh04MHpKX>BgP5g_i>VWXn2n)}sfekuy@@G5Kg|D1S@p=7
z$<>V}9YYVhJyVBr!pzusueC!8!k>ZT+(#M;V348D@vudSAdVJ(cvRNk(WUDt>#SU<
zVS?S%j9vcg>2g`)TzR?D_{;D0cBpJl-~VH5?)Uds+t6d%S-3ypdLUn9@Xb>)@46np
z>woxm@8|yRYN+bttIXc->tgEXn+WS4-}-ugpPu}OZ`1#Zy_{V!AkN()=DMxbZ}<Hh
z94h1R+`qp2enb@aGrRn25&sDwi!b~gN!oN{l=M_4?itf(Z2!yoc(NxzbNB76gqN?9
zbnW}>6&Bgg2RX^o@UsNVA9^i@A*#>a-rvyc)%pGEBcDKTkFYm7@bhF$zqg(9`!nDF
z3ox}tj1?DzEX4cd$$C29We}$%?d|nr?lwci85A}Y;=K)mU|u$MGp;AMjT(6mJF71r
zpM&2vLdryN)NgXXe56Q5u+;Rc3!1={zk<myj3xxrCQ8hhbuqSqHqDDQOw8EZeL;*h
zE*Q$Puv8+JP-Qx-3=amGfD|}i%KnHm+Fq)ng^nGzLGq|U)=_S~6Wj(rc4qxo6EM4-
zoSlv%ZW!jR@c765g`?IJeG2U#FaDe~>!R%YSKxFP@rZH`V9_)a)L1AR(AZIunNK2I
zV+$f7>t@AE$vU$^{;r5{MK=U&l%SdLbbsz1=Pl0|1*?-sv#82ICBe#)d;<I8zZjGy
zntWe1V}k8Wc-1S@{1v<z5S-u*7~8r}6r4VI#)e?AIKGHV8hN_p#gF4S66k+3pROuJ
zMJB^%P*K!LDHI>-cGD2k%;|k7Wbc<Bk(+t1dY#eVVtsPfJrm=S(-RH|U*<^z*|NR)
zCPA_Vo}~X+tgPm0s&kupk?9Rq-#Qi(wv7ayWO@Q7?D~Kq>E<>sU1LYt;#jk0G4Ejq
z+_1ER%F8!+OCkPs$XSzaSqo2(j~@PNCh*|2RfU8W${EVY0<i)TiEdgg>^W-(TQ2b<
zoqc_qW-D1Z9TcW)c1%hJS4EV>K+|f-o*HRiObn2~v`rJToSkd&-nz-t`BLz-fv<)k
zp|hjImM%8yZq*}A60zljtpZjO?Cj`i@#r2!JHF^1J4C{;nbpNk5nU80C0du++jbUV
z{zflg0&SdWQzMNe*Vg!bD^JWuR7kG<bouP17(No`voL*=$fZ#%%#{+V7%#d&Qp4R)
zIU|tzXpN<{HFpgI!*u&qDev|Jig<Kd3{KFDL^HKDCH&GqL`EPrz^5c6n0WFv^3O!|
z$5id2x5qF5s?@wS&jpRRwik8orY{hZu2#y`8Y4sb@6hCM>w)mWu`iT==T6ui>>$-l
zR_I~$UAT&a{U$GFMAoW&^Ty2D&^&kt+6+2?9A-diqz~W++W>PNy>efQi-d;84A+>7
zq;vOWS~T>*=-qzyl{U2{S<gp-96Pm~L9Q$T9{~e1>EX>qQDzFxFJ%$+MgT2R%>c%)
z%nR>hA)3l(&2S9sqeEk>l-`7zGdO6EF%1^ZFi`NMwprUlLeuZ4TlSQSbM?73YkYB8
z+d)TaWIxNWXUep~!rTleZM+rj8Gg9IvT4}1wGY$ssH^8z2j8&tPSc{NoL6#EiVqn{
zY^8ECnRs1_OEeEdld7d$8g2ekZP38Ych<FRmw>ke{}yH+KB6t0Qq@~DC1fd}jHFJb
zW_vwlY5bg1iqkd3Yg3;R2DrRl#Z^EnUY^mjjtdh(QzTPv9sc?Qd$Jw_y>RytETReb
zBx57Ut=U)VGnHvlB~(FHfPi8PK8_;YKx|nWKp|iRjZ{-tsL%AlzVC?If+cd=y(CsW
zGE!?qpE~-AW3eDa%iUC(BHe8R!?Go`6%66nKTu`w_5;sr@r15cL-l1^+Pm}Ma<aQ)
z+ec$Nv1HC1UloW-H#0b{imt=^#=Vt8h`_E>^V=>kMBy|V=`zu!nHhFw4egsbnZP3<
zacYA&^TatuyTUD8RhydQu+ac_A6-Seferiso!73thkK;`ZB$(RI`b_yo;E2mMu$XM
z!D6B20uv?ktXb8pG^33ixFz#N(7BYyo=9=t%<f<ODrw}h&@H1v#EDMdK;n)IXh_f<
zH$ZEFz@#fU6R^+QYn{GLgyFWq8{<XGN7q{`s|!p{S2GO#zQP~`4v4MWecoqj=(Wy`
zihJ1=2vSqpjbwu#>>q@-@FP32Q%lWDS*Ay<07j;(sAbYqJ)T)SA%IBDEBE<=9-@ta
zj?xMes-ju@%91kxj>?a3ddHNSQDfdleX6tXZ#w_?Ihm(Zbycqwn@g8^f|;k9*WJ~F
zG#XTiI7M~j6Pkid!bgt@pjzCNC?3qgwyfzQSgQXf9-ukF4h5~lwp4P;zzu1Q&c`@;
z8hUPoA`m~)B9?^83Z8W6tSG_RbS^I<GMHcNe|cik55qLM$C(B;Cs0Z79aUM4i=6sB
ztBPH3Ii^!-BB7%9NPtUq9{bou<{Bp^!1VPCVXM1KVp1+kLEk#{x;?7}49InYg)zVE
zLX?`BZ4DbhqHAIUMltT*R{MjZ@C*~x_P90NA6}enDwG=^(>krg?cvcVN1$O$ALxYd
zQ8_T*Qd00+Uj%OzoSm=Bl$8uo?cuR0M<U@)j_8sVxp{k{Vd1up(OwEb)9v5`f-X_`
zcS465HRY}y4U&x+a!`6vdm2x0EHP|5z<tSMJGeqL;zI~ajOIM2sm8DC)wHYs^+E8&
z0a~P<4{0-&qxm?;dRx)h7&pW2+9%Qsjn?g8kS)(-<FzRnJa+~@3_0ZV07J(+!1_aw
z)+PVa3Ge#Fr7&J4s0R1k9Q)FZhqMpDc-vUywuiZU^Gh}FaXi7R^g$Wv&3TYJ7Mf$R
zRuus5Isr?q+VtiPJ9Nk(dRwqUf(#`Qqt_m<J4{X<DG`$B)IL0%l151~5u-D^o=Wf^
zxm8IpRn@}Fq)j!ty!B%Z2XrJtZd+<1u$C%D&Fr!DP`LKHApF|Is#p%_7a_j(k?1Gw
z@J_rwG}1}h+4g>A%9^rFM%h`cyO@E~O~gW|1kigC8MUz|>aVpZIF=uue}W^04-XYY
zc1P;j2&vg~CTjEdmQ!AbX_G@ES6ITJyX%kMI%wm!gaRHY;Ip&s!;w6)7)KtkMkyLn
z(o?Kk*cq0}EWRqryR|e@TNQdu2>C^iMRYguPS-zEh040io8TP{lxGp9XK6d<4z%rS
zQ>@mF^b=PUDp3&k*>xu^uivD&d{5YWxQZIYX-xl?z`9J-jW!6<_@<=5Hh(HU%zdin
zXcrAC8GmWf-Z`L%`aBn;gg|(5o?Iw0+D9eWsD;+zIIXji2kT1dZ_%MYJ>hBcYS;?#
z&O1m#Nf_g4aL4F-0ez2Wan`#Ga|Q@MJRby!dt=e}FOFmO5yl!XDd8~}S2UQ7znUSx
zL;^^{b)_0#egy@@CVn0_*278(;$T;$fcPq|+>P$wE#PgXq&#SW#>9Gcko5DHh(t89
zt06~)`hA}SVSWfU4f<-!wEt$^hW9fFs2)(E%#naSmXfI@VYB!F^-mo!i~e38Ip!8K
zNmiL^Vr6F{H(96D1f|`|pz|@`)-VG+=Q^&>7dP*jbvLS9p0MFun@hD*Dx0PX`QI(z
z#sTD|wmePXi;zF^QD`Q0HwG`YD%>`I4b)PWd@1_uS5+G-Be^VUZVaBrMFyMdyfqE<
zt7{fWu4AR{E6h$Z=d?p^VPGm2ynCT|5~p7(Upq!UQT-LN+vG6tR=UOw=xQk39sMpw
zLww+{TjVgnRQ#t2Hc-S3zGF2~?rw7!7|Z`t66*`?`*-tL4Jc_29s)KRt^2?6`}WHc
zOzR7+`yuksSWR)N6(Zv=u<Px|>=~#`2&*%U>K%XG7r=#}`|#Hr_sbEKd<AkF5LX9;
z)bJvs7?S9Oo(Fe=U++53th5Bz8|jU%=7L2(AkiQFi(G?QpD#+uCkY&>FVyaj%L9vH
z##TFj5PyMLzbk6a7+YaRfHjiagu9a5sZs8yCo1`5V%cY_CRR>xT(s4YKaG<N9?|v+
z=5;_(J4bE>A!kiVcL0ucwYQ0e?ea3p5AX?)exhuB8umha2jT#r)`S0ghVGwISJXE~
zl#7Dwcw@gnt+%H5r^TtGiW}yGVL#a2pw_37|5Lcf(&zFG8Km(TLp*EE+F$FMI%&U;
zU!R_01&vb;9yW>F@ap?#lhGJY615RLhejm~sw8Y;0?uqZm{8WKlY&Zh?9uZd!&${Z
zvPF%I!LIG6SStJ75{JW?`&IAW+W*a;{b&BF212QTh}74<ipW>SnykKNxJ|78xK$@6
zBB>(8rGpOiBbQY?h&lVU6Nqy&Et^!4IXfY(6~^{^|5O4=E_ogg*k5}@gO*EHB3PTR
z!kbMzs6IR76zX-$YCNSlhq-+vxx;u7$q#i84>)-%l|c6=JpD-Y(0?Xl5{iKSF8Bw<
zg*aa9L!3sgR<6k|BckYHCfoDrY;~lHwRRQD{u{;7Pc^x=((BPmrMr=QuSyt~sgKnE
z)0<$?J^Tl>LFc{Ze=-{WH-h~audy=zZ|g`dPUip9XvoF+ABg+^;<XXo+vwwV<S%}I
zQQ=;2H#PE!G<ew|xfeK{eIW#ho1sL+^zGe50fa^!iSN(zblZ-v$;Rym0@x-#K7ied
z@<m0Z${bzZ#oxWM`260_=lFd8&ky^ubo)B_AO6T>kF>H<`@EHjzn2|6zHdJ7-|=Po
z`Feo8-+qr*^7%h6kW}YB->-nD>@7(hdWJTSg0Gj8^s@AqveK3{Y$x@;AD8#nQaLiY
z+uuJ9X<wpw73hEy&<mCc*vO`KU5VV(W_joj4$mfrhPsdWTv1_rOjnGsS|NRYtQQf6
z+Gnc88_%EernQZ+8)z$f!m#lBr=h+n{k@;Rf8W3V>M|ZN{QiE}(7HeS`Mk2v?}IBv
zVh-)xC1%=K%=5CI)WjyIzx|Qfbq0<-E<j!k`XplA)%bAa_>sEsYl`2YDS40wucw7`
zZoV17(N_RV3o>}Jwb}woRm<&`D!?gWPO!viY{i@l3zx~~<6O3~{Am*NX_W9#p$z~=
z?9>!d0i(v!H*o}|TV13tGI0o=nVjA1tf8~7x&UO)+CEA5BW%+}>_d{sP*D9o3tmgt
zGX0~vTpEmJWA#Z(J$rw0mxu2qZ)|8a<Lqs}<|8)PjIKFfB!4yIobR{GO4l)fYQoC#
zZpQT7FNgZw*dy_y3}1_>M^dKhzIEgkQX$zoH&G8G6Eb})v;5wn$*tEJHM+svMG?(t
zA2C{+f4l^16PR*fqqx}Fzn#Vi?l?%n-^{xa&(b_aJq@2ki%M~nQC*m$nt+$1`powf
zrMik{9C-t*J`_SU@_0Q2OA%oTy1;N4%!%j+Q%s4+MG<uB`K-7FNzX-M@je>{=3Yf+
zQ_Zf_FeH~#F%A-$-Vw`}^;Z~HW*@_AsU>=cHLD)hdxF;bjBUakJtjwcHP#ZNAldbu
zDhB%6`t!&lN&kYF6~?EVlrzO6k|sCKA__iJz`QYDdtbH+!}}O*TBbo}zn&TOZV@4w
z)z@Z#%u%|_@|Yw*Pz;Von#V55&~Gqg!8JZH0bHWfg9v-ojTBuPREw5<YC*!e74J63
zCcKJD0@OF(&uHLP6CoiQun_O3BP)4+NI|x!MQZv`MIP0YT{@Ukpwr71SJN+-#xzdb
zDq}62^h%a@;XcRA!pM}c^^_c+=R|x|biS(BmPbg*FIX?EJ<P6+8nQ}}qSZZIl1kgN
zvz0d3UD)|10SPAY@0qWI;(Q3uF=l+g&65-2ZVt(WdO8jD?|ari`%0Gnws6_c@1PWa
zR*@B$FDDvY>3^L{({?6DBUPe>UP&~uDb91ISbn%ngJa#bpxIhrBcT~N@IZjdI3NUD
zPNPC_@z47>ig0`}=WOXQ-aRF^f7YQAi^<i&KvPH`k!%k~MAAB=6?i5scX}5`H9|z~
zD98FXz&>t9NVHq%g;vGj7i&`K=q0Rc1?<4|RJv(aP>sySY&@wn#vUlB>M$O-<vvzS
z!~tMyG>LVfCrQ~98nPQ7{Clf3W<lzJo2imL;W{9an#uS!Gy^taL_gr3DeZAEjE6x;
z)Ie#+Pwn2GDgwa+YVJDz?A-5=1|*hoz6{57SH9tz_**)&WM=6A5zl>BVn&zyLx%YN
zd1#Y<I{!1E*t7?eJYZk;7*^(N+6j3$Opc}0-hUy?F+AT=V2IVzrjwV!ESSt^b%3qA
z(eL9=5?IjjhRWTyYP9f)!-OqIji{kRN8#L6Z6<~hFpAn~l{I!W!)3Abd^SFYtxrgN
zI-PWiflf5c(!ThfSUrqyBSvciM_niWuX7wV{-pwV>#be)z?hscf^rS$-u(EW-dID=
z?L{gZsFGw<<e+vwd0iu51IAX`izv8Ybu8hiV;&gRs$@Aa#+L`fEVNAYM*{B643&*=
zH({#-M{|P)j@}(h9ZW`ypLpRkVShsX8PVp%KF)MVn5B7kd%NIiAHAR|<h+Gh0Pe-A
z%Rnr+m8I?=Q{4?f8o0+Nz|W*D{cuY%q-8y2VD{__9~qe}exhX!H#f6*F1{E`ZbIe*
zmcsZrSXOy3e8)5c$kL&SMx7gLR7D()(i*LIV0~LjRI<=}_}BtIXH5K?%eJ*};SrVw
z50GO{^3|FA@U5=MpLU1S?;>JsFy_&Br}3#7xlwQ!CNI?_c0w2{+PyrOU+%dppA;W+
zXp<g8IfBWt2<<U#<7sM#oVtBWtTvZ5gA579FTIk}DwMOK?zaf7ow!DTJ;PdPzSR2p
z6{F@FK3IaN-yj=917scAB-+Gt+wNSRv8F$y+6&!AO`TB{yLbPKhC;<D+>CE-h5fEF
zN>Zk?)}07$?AkT(lF9Q!u5O_oB*Wv<?aJMLu>nj9p{MYrM^Ze&EnaeKZ62iw#^6vg
zJ7yjK_wLZ&!%wOJ*JYtA>{>Tlok%M1`8yq1**+fJj$jIvaR>_?+k3Z)+_7gkmaak<
zBPn23UY2C`__1gz){W7UEP)z4Zi+BjffFf0GPQNBmaa#HYmuN7L?UMq6&gh10hKb{
zKr*H}usZb3v`!@?$+J=Qg+)6iXDI%R+OO064CSCXn149{WTeCwFwe%Ym%s)FL3TY&
zGRAv(xrrKv7J~6$5x_Bq#_>B<vyq=lPPuNbS=SN<R(875)<#1>QFvX~A>AAK9Z@*Y
z<I9cCz5^1I9Lsyi63#vr!@pYDe3W4KDh}Bbl3N_AAfaB_+u>J1L}dcP><K9jSInPW
z2l|tU-6v}kMC@U)5*$FWBy!up;n>hl0ELd8<y?ad^`{a~HOUdgCwc@h<2A@Ia@}o+
zQ3d2f`Q&R55D(Q9m{6c^`AQV9aK{@^a7sV6kY;-Bb+KS%>MP!42~mvk!!WrZ<Oc|N
zajx*wC9Jr9z<3%m=m-6k{~8dAHCT&OU?uBWrvP*zuF;+%tLJDIn9@kttQHjug2(4x
zu!t6BB(y-$-$7^zo<6Ib80AD9H$B9b&wYsS4qU$~gAhx#Jk4dH`K?u8i&MMq6L*%O
zebKlR{EoyznzKD!)Xp(4IbI4`Sd};LJSh>vtKYq#;0?9Xa$Skak!C<bPi&DXi&5x+
zqi7gC9{<(dNl`bepc*^oT*u;5EryBt%Vy81H+GTDtrZZ{O_%tNX!|wC9O9$&JTr05
z$Jt2$8l327vFGFMa#)@Yn;9Wnexa<MRn(p>m+4|aY|G&p0KqKV@|>&x;i<lMUN8%1
ztMsIFz!V7pIai7PgVk;e!yM;;D6vl5AJn<VOOZfBN&ySFQq%Lk_s2$?gcmkf-2sOM
zV(aLHK$<iQ9N6rJf<v0Jb50viU#ou!wYW@hA+QF<&$ps&pLw9dxD*xOtN^G9gu$D5
zegt-w3wW&*W^XA3O~UjvK5UVw82uc$R>yG@pBm<Ng|q}|agPN~Zu7$~zyKOIx4n>J
z$BMjYdG;Qi(YG1dtbeTsTJ7@M(JW72dP+M)hjT3Lkd1bF`?d`_3DV_cp~Lt#-7$7{
z10nu;+JTX${@|`9jH<_DL^}#xbcdy;p`EevZ7MG}*^;s&k9dANc-WLMJXOP2dpf=0
zmWY|8-ygp4;y7%+X8l_QhyaDF1}qJ#0s^buVHvG$Vnchhcg)X~$y-)ew81fCMvo_6
z^;)VP#j!Q4F$E7?y0i^FBW(=;CNIDhplUA_y~3UUKyi@r0)#Aw*`1WE^1hh)W|@j9
zepzSDxIS*~eNx9l2V@=wwW)I}7U*p?Ma0GtpMe(wPo~$8OAy_TAP4>3)V1By!6=i7
zHY?5UfReBAVGW}U3FF=JB1KN1AiHk>mZ`H72)As3E<iS_j?{&u`fTa=rV+xmT{CL*
zpLGPjY}gkoYki4lhli7ZaK<E*m>)->=yD1b7NjLD$Asfo(y!{}XalFhouU5b2Ao70
zP-=hSmIrNh<DNel5YV1o@QgKzyuVJqbPX!6>^*p(zFSpZ?C#rI00B!cb`TFQhyJt_
zE(d9&lY2Qq!C3hE{gF%G7<SqE@~ILUqU96!zmdS~*TL&k7=VT)f;jNr#-lM<<~rsa
zs)&P9gW09puEEgyHF@hp7!C(4133PkLi-E1zu6uhol*cw<fMN84M<yJO@pqSjXeKT
z>3&s%0v-LA1TUwT197asdue0t&@2<O9Y%S|O*~X#DVy(P^r1Tfq3m*|s3`j)<pYT*
zBUs3t65^!GlS8vWQ?0*iKsHVHK^*VPAUFSVrvNblVCNXarUpK!dzXqD$7r;bY8+-5
z9_e)Z3Qu5HM3L)LG(op(!$CEA)1}X&_GY<2Y)fCUiV8E*HE-9B%BQv!8U|auDvLue
z_O8;@Wl{2l*`#X@b9;{3GiiOE#~=)fYIBQ_P=JumMJIbbHjHx(DYZ@g+*NN9|0EMH
zIs|R~xN3X|w+d=$i+>fn>|H%(gIz5Svf2HVLD%yn4Q-nVXy`Diw2zc1Ups!DHhngB
zyVj}kDTuax+>T(g3&hnly>3@`S?ZXa?!-@%td3RwMpzP<o*a&w;NYotz(H%G*t^*`
zcXG?pFoU6>lwT3>nUqsDnuZZ1eygyzx^yi4r<>uPSd|ITN^Q)dMTY7x9C3D7tR7MC
z-RKxGW$tM1pwYMFzok+%w9;(OME>TeWp&4l*_iQk+9Ocqi%HecI;|WD8P3-R(k`Nq
z`|5zNFEHtc>~am(iWD`gRRJo=xAns|1gMKZTKql}tPvL<^H^Cs7fO$Wks7<;d83$<
z>`S-jB&>Z=bw;6?)3Hw$^qTKpS2U8;5Q#tyiTh4|hPd9GtM{8`I=em^qk3t0*9{(i
z@WvhEfZ1c>BuG^D$>!(k?&R3ct<3Hcej=RhwAa`6CHAz#eOYoz_H<8P$k^af@PW+6
zq6XBq+L;`Op4+Hwwb=uzrudJm+|RI0_Hw@wozJ?9{wI$8Z#4Zcj%DZke>s+wneqSZ
zVEiZk|LI^H$<>Y~oj?xV`%s7aG|R|~=~fFwvXS1Y4`b7_xEneQZ*g~P7=R^MUH`r3
zNuydxO+q7_OU}Xwr_`o$RyCcRn66BkcW{?qHn->V1^CCCuWfq>412lx->yiI_q2#+
ztaF$9Vo$ty|E`eFx0mpL82j~+-}m)Y#_;o%i}v90`MLA9H6@rM$B_OR{XMs)pQpE*
zKg#sU9<t~6b8+`3i!Xq;>;HWKb@>;1Sg|*^m@|mWS4q4;{=3fp^U49u?A`f&>Vq&(
zZ!f=BUjL(v(EshQ?<xMDb5_64C$|@;z7B#sf9#<PVE9+xS4C`M>En0QoQ`B-Ga4~p
zN@$96x0A=C|HPCeK}i5H)FjSQmtsyL2@G7FuaitFjOxW-fT=8X2?{PXTg77B;Rc<m
znB?GqW|Xo5+o|{Hs-Xft&ZjSRZ~K>>rdBwv?~>j**4YQKZ95hHZpo_<h9|;L_bV<=
za|!Mk^0`8w8voTp6h)xi27DkW-F&Bc7ZO(Xx(6CF`+)SN8TBr6S`_lF%H>9iK2HS@
zo75ijxf$fzY!uFjfe&b_85PAdoj<11nO9^k%}!p^;vxAHL-LI=nvZSTb~Z$NB-T}`
zUY)gFij_3^C9!15YMx=!tP80Am-L@TPqKmUE&BVjCf~_zK?a$F_BvVy*R<NU;-b+c
zeg>}xzQwukvG>VQTZ{Sv?V0q6gxGh5B)Wl@FK-k5&Z*HEs);;?WMW*`GBWL$E64ma
zy6cPNylD>VM;v0r>id)Jjt>w)U%7YbwvqrhqNHaI76bwo%yAF=WTzMXECHN8{y3pS
z46L!^!$oXL3slzLks7HO9z_q9XL|}j#q6YUK4DB}D|)0>Nk}LW1komSEQ?2pCit<_
z30G;ltKz_4d;0QVDMKOW%sRhP!&ZxV1gmN-bZ){wiCQu!c~(U+rX1Oc<+oDcz3S+P
zSoIcrY+|)jyNLZszkUsVnBDkF3+-&8-Ha}J35Hg?$y6SWYB^lie=rF)S318=?8X%<
zOr`bOES2y>)J2&}i(R;toFI=|=Jg2&D|$R-jnZ~dAF`jQ!(ro<MF<0@nEKpu>mj?@
z_(Ch|@C1vF#Pv-0H!}^FB>ko7RnIa1@{}x~!QJ*Xq)lZUpWm$#_Z5#+Pf#qx$~EBP
zeJT-3>s7e4I4iVlS_wX$246(8fTJtMDt6XQ7rA9bUljqyTjhlTh9hduwt~!gw*wb3
z!#XqdTnh#@tTas0(BTLMwXNEW$%zz56~2SNrCu|wGt%AAj>#Ll>TPy7O5MbC4eiXt
zXxQagDvVXX3RK=CU-IDD&<T0H9~<9&xJM6F+}5KP_8ZYnJ&^%5d$ZKSvgWw0IAlYL
zT+Pl>(kE)K5u$v81qKMnjHr>jlOqo~atZ3(#Wj9~_TDhAV|6Qq)?fRp4j3poswrGQ
zt&pd#$jN;_ed}4@v4LZc<!C|&%Zylq*Qe_vGY@skVWyu>+SWcIu=NhWV+^9`5=RC`
zuxp(7Mt7-9iKRsKrh9HBh^z+_=zU}{@}gUrd)Y-30Ols)uc_^2Zw;?J!yGO{Q`}h7
z+^kIT&5Z>903YmO)vC_c#@RxTAuI(8!3QG%HYTy$(9ff-GrMFKGtZPr>;Z$#1KC=0
zTTl5H?#$h@(@-3U(PyEfnH%*ZF>cN!Y~BzJCJ^ki^p6;?Sm3BGUL76elP3yLXh~QR
z)ONLGb$W2oDkpG*@(i_Q;6XO$y9N=LTs8t2>T`b-9nI%5*gV@8$CGXM1`Jw+)p!0}
zty(~pAw+Bc=g+D=TsAshiEqmwl5c;=aBVVcSdxn&U8NHWR4F%{FUZx3s|NlKiwzOI
zrM`Y+`s3gor>&-L2q)9bH8t>XIZj>fWXj4ATJV@?mlM%)tiXaXiB)V7pC<Q6K`yOC
zbhH~pBhPJ{hj%UpQ&)Rb>0Mw$!Dg3O_@%8iLPMNBnv%9X)b*{OA2utTIV2ww8!c@w
z&NNRz2Y*L_!x_~moQnxmoO5R4D+n)Qh>rk;F^Kht+N}n>PGVTF<K%vPzMvCR7}RjC
zfn`Pr%YYgJVC}RTW2^{wLe)D}qR8bT3%kVAj5nAL`Fj{M2rGcP7w$%Qg`_iDHH*nj
zprz|K;_$3K-h^2woDsVJv+J;LQ>>T~{I(YnsTH6;R7b)_oPCiW;pj^g1zZLbmQr^h
zrrrLd63UDij<(r)i0C&n_=Lfydj+R_b~kRhRXHS{(TVW(q~U%+4{pw@z{EKun{l*4
z*j7=+ep&R`$O?<aycoQh34`WG7IsvYX7^~^GA3|CBl2bTVbU)!Hx^FD#aY<R200wz
ztg`&0-ZlCc!n)A#{eqE^)@VpYCPh<Cb2-K*4)bL<oM=HL2%OTrP$-1dsBoznZbLXx
zeD@7eKI~?PlM$z7by^g(tJk}lcYJx;Afh#lKiyUcVNo0~2D!Ms0}k+4fCVflcQ{u|
z#|1o?az5&SEi^I$Z5gyv(s@*vc!OycTn<O<A!$Ea-Q0`oL2x#?nvgy}vZ;-J@VRVL
zdTqy9wsgybeXCqeMzqW>K3s%6<t1(qtuX;@paOy{paMw+ej*OpbYo+oI~U^M_bRo5
zXOW;1wE+t3WqlTGT5T`&rA&ml4}=``GlMoNxcvr>njxZ)5M^zmf}3n&;<sgZ3F_|V
zF($tLB73cn6C1LHO_Cm?4w1B$MQ(z5VFzdM7P)rz^08n$O}<pensWy6L+OfT{mD2c
zihg5zEjky6@nyW!sQyKh<}7*C+#Z>>xg792kL)mq5cJ65)_`(sO7y55u*B^J|2f=M
z`p$%YU8StMm>^fF)=-fd@`@ZA+(;uu{x!li7<WY0_UOuWiB(TcX};b90cA%;W~ME0
z*#>CV_^vJuIJ<6&m^O*VR$!bw>#6y28vsQ!b9d{l9Pj=F8yzMHrv!Dabg3mxsKi0%
z5c<eFWSOwXTe-t+ILm&X4F<9yLTS{mWTq`TnX269<q9_qH89?@Qd5oJ0!htuBGkJw
zW|kbd2)>Mp7?7xSWoXa*nNS`Oa=7S)g;y4~ux(k6$_H8yZ9hW?BK<6mT3gz(EG09L
z1N#N-GSKnMcFbNA-qUUv+ieZ|lAQ1yTm}dsSscm(n-FlGi`$yKijauA+6iQ~(Vtmo
zN}8K=Z;sw|oMis8xYte!=yw^}X$@hTWft1yDn9Ac3u@&uSCkwVwKroqK#1Lz*m4y_
z4I3Cp=%nPqO<P3$VdKL?i)aCmdqM698a}PS|9bAH49bB3>=}PIsh?WMJc7n{n_WCo
zR_%V<L(BJ?QmAA++fnqwcN~tvlH}%(iY|AMm@KRjZ(_)y&ygE9yE{_HBM<UsPxJgT
zMNV#Ab}NqXZjMD;)7-|0Vv8?bZ2zM2G6ZV$F@4|0Pvg8B)+udAxNB9Y#^xnB*fD!8
z524;?;;I>Sb!ZC&&r6)5EkCydja^l-LL~8Em7_t`8s~1_5-K^pRIzc-o;-r^=Y7Lq
zx5LL+Y{{OB0pfj6OGsea39FPC&bmX+bnkDn(+ZUZC-dF{DLEW7d4Kk!q#N>Y(}JEG
zv_!QcCyUz>sygg4AxbZ0ixmo8!YJ!YKI{cRy6a)L(k4RLfg<z1q(v$aZ%=kMWG(`K
zy;$F?WQWy%1({fC539?h$t<a54LzY*BHemT{Zb<y6l5a%WzCWA1>~VaH&vF@sOk4M
zJk01N6Au)Ag#j#&XBDFdM&R9Yzp*%st;yw2Z5MZc5oqzMiY~vCr6wC?H?thFnI4sl
z$y(I;WZ>N2WT1(drbL&w;P(?;e~*{m2%1W<qeD3wtW$A-?728<hDiXjd-1mCK`jkm
z3)jO;02CMA*l0nGzqz@!Yow{pk6rj6Q)CCqnm4!TMO^VENE-mz%uGg&<@LMxDMb?C
zyb6VAWr@mOF|TpXULkcL4k3I?c5({2E;EHL1W2y}<}F6Y@Q*k?XRrBpXeRFdN0s;T
zjEU?%$T2h1*53?v|DZ-D2_}74HYum>Ce00$cLiNe1f^if)`ab>%&5$rbg37s$BFya
z+|r|;#sTO4`hvYI>rMG$NlY#^95hsQbW7I53bFTx0w)i4$*etf``ZA#KiCkP1YM#B
z_0W~=PcQZ!I2sdK$k4V0lq;@^sRWTxc})g^3qLAiswMVpclATrmN^PJ0o9a9Ihd8T
z;Vc)J^55SI-ULC39w2mdOvF?x0AWTH`9G!+DsoSH5izJtx)zDqPM~Q<JG=9#9!7La
zg-+GHS|4~Yi5@nxQ}br?oLB78QO?PMt7;hWT(HFVSlU`o;?A{ODpu^W;JTSAivtmN
zH)=f_xR{Oz8eouPAobbpRu}Bdz*ECd<(f^!jkXVJG9Rs3)uvnH5ww_dpzZ|Z=uWuz
z*VpWSvWS%rG%5a!ef`LYbkg0l6;y1Fqz%0H3H10$<Op@?5DI(-5XMogGOdR6<?;gK
z<(3h}yEWTCuf*p|^}gF<pGNCD(f?jKm0v0HZQ=H9B=uh#=2`=w<FB++e)RtSM5Mg-
z82leV?tih_e=j7NIsc#J6INEH|MPt$>%Zy$KMP5ntth;I$tU@B7I)c#McwNEf={w;
zur-Eo7%=_?p9nr%Vd8eTj^KPe;(Jz1md_@qs<IWafwW-Bx{pQ1@H$Q;lM|d={6@U}
z?eq3l_uJ=vYObuzz7Fw+``<cJ<<}LUh#y|>cU&1mzWl$Af{U_n^Y@>Zz0bd2XFuOk
z(4PE#KhN(o05baYGHpN7ueXPzp`|g%t8?FAxZCg7uZyo}eo4po*CE2W2kL3j{1e!(
zlBbhgE?8Gj@!#!KzKMslpC`G?XRp#)x)ARZ2DO+)WqYu<{v0``ui%EMMVQQ|7{3)Z
z?`SSCM~LhP<^1XW-(R!C&*BmH$dUR!{vMeR-fj8+e9h(e$q0~vkU;*NbE3FEfE`!o
zwx-AX8|Q0siM8O9qIJBs8&~&8RLpLp5}x~Gj_)n9;CPQJeKJyR@fm03IqLBu)ZNEO
z_u=|7&(DqELPmzxI=nA9ZAH`QjG@;8V4`?E&tOg%E@^WeFw=F3M^1J;Fy>Am<62{3
z>PfYPJY?-8aK*eFWf2PJC4caWe#tn-QuWnOae)47v2Ypem+8fBK7Tc{`51+7rqMsj
zj$j=Yi6p<l)Ab?U8|5P48RPScGjobtEIq>8IMp@Z>Lq5dFfHU*ek4zbkj|U%HbuZ8
zU|^YQJ}g0cpdTEG;pq(e0~USxRwUati?x|YLqM!w$tAM<XL=FQvBuDb@%K0iZr4}9
zo2yE*X$D}6BTk1{qlWU(?R`)$Y(y`zA!)*$v<NQ-Nv7?nU4+?F?3u4=uuX~|=QtDW
zI8E6GOb}Zf*|(bvv7Cvb<SL~&M9#ir(f>_C(D{3kKn9`nG=39+F4H^<Nl!&dQHRA>
zS%vcV@~CQsy6^Ip+hXH!69yGlf5qd+y-pTr84jrNmZ)MHzhb(lisQ5<evl8_C%duo
zWJU5rmPbup&?ueWBRg|StxY{#C@Z$gTzrkXEhP(+4&>2Ceea=HZa0JGv3d1lUT8Co
zTV-du6W}Qz$SiA7VFYgK-ppU8B9zo$Q&eFjBe)39B(`$kE0kAg^6)43BMVEML8Vb9
zPu|gu&ZKj$FGJ9^d?(W|+26Lxje(Ik7$QSW^~ox*W1WI&A!IXqO=XDKBLjxYhn1r|
zMK$)0>W*jy+(S%76f8*Gy4-HqA1%poNW!<>M5Wz~Oc;*C9HgvkL%z*g>~MQ^R>9PK
z+4i)S9c9g12qo$50~QCjDLJnxZKkd#O{$GXkOng6NSRqG()uxOEx}5t8cG{o)0qU$
zFd-cC#WRUqs)JZj4q*G1!9l~sO2%?=)JuJSBMrAzVh;aCNgsD#Iy(YQ))BPH{(wTm
zpz5L&WRvX95)7xDNbqcQ_ypP|FI*@+Jt0H4Oyb;KSy4Gz$2Yl<Fhm&x=L+=FqWTx;
z?XgorwK{wU962dBC2o=I<H7FX>+8(l@BQK8%s&M&Y&unK<2|ySEcNIhSk_%{`IOFB
zM|SE17ap|2a(>FbyrW`Fv~)&POt|YT7B|Q{%fQx@Y{`hM$VJpgpN|VyhJ=ZWCAf2<
z!^1h0x44>Wjdq=6P1_qt00yh*>*RytW6X}wbYD*X8CEfIkKp4<!2+F`+ikATg>qks
zA`FDZ!kcoPo&4OeeDbrxcA_~myFIr^e;j%Do}n7`aM}39ie<|T24J&NVk!{bdNK;p
zV{<qNnZv<EM`%qM7dLpnJ~>%35y~p-78y|&H(3@Zy=nX}7jVaB`iO)7JHJ#;-uWo+
zs$lK;0>fQxGBknyG&SL7&~~nL+|?EKZDn6g$4DDJYITJ~=Zrp0e2rCh{mf7&FG68x
zZcoR|KQ_`+Z~+Iz@}dfdM4rugWp*<!!o;2F;!Z(444LBN9i$YQmIW&u76U~1rUK;v
ziyKUjkzbaaCErg5%&FPZ!6U6`@B)IRs>|rap_*?>ad!ng_CQqG65WE%7hCvtIK&#O
zAo4yF9+hHGn_U8@*~W^sd{uu>+O$4_YQHKmcW6cdPl|b|&0cJ+5KUCn-I|1_<`fCh
zxz5CAR5gDlRrsFtBx-2dSeT3j6n0xL{!DATD5v^Yy>vS|3A=Lql9RjmPxZ^c$oApz
zj##E<3g^s)5%5?w3%7xJBU)2%HR0(a1>S}6aOF0yMK>g-QU=V@i0M)M2<@GWMdQ?2
z%!oa!AWl|p#`|{0!W4^Ggi-;k2h4^~U%L8`<xHcK6MV9ju;j`kEK|gcs%tEgwhYbH
z2FCy;0geu-%}xi60KcfK3<ZDiV)!f=P*pQ+!7Q<g%9R+jVcAZU7fE&Q6bEaahar9&
z(o;h8Fs3GSa7_k>F^mt1x=JA<meRA_3><K!{^9HOJhf4bp>ahO)qOP;sT+|{Ns0n$
zH=8=!F^q{2(wj>5^{B~fkx)&t|580hF``2n3zH=6L`~fb2V)Wy(0N+V+8ajD7TdY2
z>_yqGg-_JmgEks+?|qZ$nk%MSYRcW1|L7Y>8$lYs5L8lVQ|kV@ttqeNQLJeYZ77P7
z_3D`9*btiRoZOsW{b@8Ni}y5x+6W+CpUoq9h<N}7hf^|1#{4WCHUm7+-Y2NL95(x#
zofH3@6Gub@j(6s-@g3*KV2oEg%b(xQNn;8l!a%H=L9wgx&8tZOZ%Fcl4=>H2<Us!>
z=Bi+d;7ai0jt3}X_34!IZ>ZBu=rTV2X*=yCbOJAC<qONCN|1jsFI5tdo0<iJx!lC|
zOr&9sXdtAZ7Rzt><L}HjYjpGN<QbbGFCermOe8{-&Hkp-QP)_;Y&XIoAlP#k8-LDc
zU7_!9L<CO8BRlgHp)&6UDmLu~ZCn!ED~tuSeX+qVH(U}RlI8(<5z7*NiO9S8x^88T
zlL~@D7%C2=7agXWM$RfK1dgMYW^N(Cza7Nh&Cex8i@ZiLd1?(@zY&0-q#y=K)^F+l
z``$5yzp^bs;{t!*qI&yZuGMwo0gx>{|3%H2tT_5tf>SdrWbt%Ptw}6!NJ=7*&=dW<
zJZ03#-$&>pJ&goY6nkJ<JAE_ChGOm^p~~$<z%RWTe9`4U@d@?;H*TOL)!MTW0T1kt
z!@dtbY^DYsO>s+dW@B-DVQiDw*eEZJZ{0I3OWFy<Y3$bc<46{suB$}nYR2O?vj!NE
znrN3^Jf10$w0i1{25*h6hON+ldqgu<P)DSzjb{@QSKW#IGLOkh*fb>fi3-)cnzbUk
zG;@_HZ^sMLhd0mW%T+G7%}n(qfyvdF%*CTMDVU>yy_2{jRi`gNW7W}J7p3OT%*n|v
zP-m85OW><Uid(DrCeTWFa-&4&(8^4HHMMSI0qoSO?Pp)bHIZ$(31xU3rWA$oYc<Yu
z23I)sQTI_F+4o4rZ$=NEDU%33Zr(tI<EI;dxQrW&WnCku!|@oDL4Apk9Bzw*0b{-G
zpdq0HQfI*`4YY8S6lM5=uHKsjrZB_b=~(8wWQ$FLSh!(mhw1RM@fA1Y?Lb$_E#ZaR
zy+djdP!Wzt_;}c=Z<lXIFFJ4u8udBBaFUK2bRCwpS@bn~xli(Jgto_qRNv1hs{try
z-Q`Q?cDiCQx$)!+V*eLqUjY<JkZsH0&fxCu?l!o)yE`=Q?(XgmgS)%y;LhOg&ft7z
zcjN7Q5gY%%-w_pEb+alfs{2NEpFDZb5wG05u*xSz6FLF|df9m1^hsaBfuybFvT_P>
zYCYJ!5)@L|ax}Ti%bpshLC1zQMVeQ9bc44lMiwXemILAA{uGQ)9dBE94!WH75+(jp
z(E$PoH(9{MLi#)$+t`=^tPzBkxTxz^IWLecd2G|dG&7BfLT_sx+%<Oo@GH1w(5-A)
zqC3{ETWJYJpD1J2CAg{rd`=b|zK(Wv)t~e#TJwge1dnfS5(W<{o<yOVdxqajPPCdw
zt;Qa~wR;K~8Z@y9><vyD5Fg<+88JE)JZh3eIjjrf3<NW-H~i+Q)8(t#P3{94n;5lo
zPzsNugsRq4tXwCqteVO}z6*c*jR&_;+?!bZ<UhVlr8GW%M>{A|<})3ub%_~*G^3jZ
zNt*aF&WU{17JV(;2YalIFN@C9Tn)QqZ6*d^-#)a2%c=j%<>SXGP&pEdT(+Yhy|UlW
zvh@oAnibhXCexY2P3W^G<X@BxkJ_c|ot7kZ#@v%p!-gV%1h`=rB}t1LtK?vx^m#AS
zXLu|>(#pHSu)vgIvkV2=2DfPQYu~tx3U=|d!SxI?=%qs;oX>>=rO1(ys9!G=yx(4?
zOn$0LQiw$9Y|&lnW~Sip-|2=&4z5|)3`_>B&Uy!l34{#IW2S$vh+VZBD?QMCE*ONi
zun{^Nu3QPU3TE6tR?AIjp@P{8t?0w}hTdR^P>nhjH&FW$)zLA~x*R=Si@_C4#9V~J
zu;GYT88S7KH9&O@HzPQkk~1~Dh-tC!aZD%yR~E0g=I-n3``YClt}?fZyg>dVyr(;H
zph4+ChzqDPk*s;2Ea}9d(2FLoR-P-6$qF`O=u(=c6&vOd9hvFR+Xi<%PKuZrji%v6
z_vT~KSl0{|ZK__z9H<(9k@H8~y|@B<RZ~`VK^;(c4adMG{gt?$WVWB{v@(x`b4fzz
zM+q*APzQDWMeP%4I=_DgsZD=JGM`d?-jvhKR0sMW9QcC;X0Yv6r)AgD&u`3y@mK!|
z)%_Ew{S(!(F#a3Wu`&ELnEM<5cUd3{8w1Dx0@XErp}PN4y)p1WX@`jjxGV?!MRn`j
z5PP9@f7v-JPYfg9Zs!SQW2z)clVye(UT>)(sNfhPL9sEso%^lOSUJ7!kBcKY-**p>
zkB^t@D`f6EF&{-)-iSo|-PxROFTVGimQp=@-M8s4bGU!3FvXtod3&po)8q4gKT5rO
z-uttB1t526<Jr0edF!F?;o<4wRX@lzNpoi@ZON6z*V_SoxqrOVXrEZ$!q?rz^HJwR
zEh!bavsfEDvDgKj<iC*n>v%qh3Apw^G&}4^&#Eh(fEeZ9%^JHV9)cZ>L^11oL(q5%
z=}2Q{zM-b0+wnXxxKUVs;|cT4{M7k)d*n8L#pip!UCsP>{e0V_&o#5P8~0&&Q7{C0
z*$-e3`ktc4iLCi!gudVco%(GgSr32?=_8>Y2thy?-Ag1akEsJ}-HBYY3PR;Z_QCGu
z3EM+*V}*Q;E=2xDAUrr7e7>z_^9GLROib4bzjBMt+zvz|0yZdjBLs_u&jbIi2wg<@
zmN8hP8j|w-rBzZAt;O6E6KePRd{~o;@&S@Y6CRGu&%;!pZ-^^h9WAjYw%Dr-apbIf
ze}e6Uh`QirKz)S>&i3)6=zwAR`4|*r%vFD~aNrQ#wg@t{|31w&@I^TBNimPA$E7Bf
z6Hr6h`i{;s)v9l1hm7vUP#9(*n`r+r6fx_TI;I~u-g?VZ7tS(?oqNP!DB)=F_C2^C
z@ZmcAgDp%7{L97`sstr2yhBX8wojYDYX-LWBJ`YvCpVNFYK*gI%xd_3<ly?Z9VM{)
zlXJj{!(=Lng}=Pdt59G;TzI!KEfbBtI9Y^#k`bSghW`zsLcDN6(9n__Zjjh5I)!>h
z9rh*;RcE#&<=&}`545xHF0srqyPSh~IWTET3L5;vDoD!Xk7Ol>1cwCjB;Deq<s7Z`
zpu&BRZ`<<Wo-(>X0NofLchI%)%^WE5x-0$aL5r#Q_7#<<uer05i$N!Ljm<+`(!3Il
zRM*uwO76)Tb3M*9WCt$F1b>7$S_*BCl{JlcU^Pd}44zKdZ3!>zpH9{L4J3gw*nVrW
zDJTu7zR2>(RPF)_xIPD*2STr|NCNdrBzh-KBHcb9ZBy<KNiN1M2pq~Y%EWD3sk5~@
zp=cN+O(YnzRowd0tOt<r2|+*1a~TTkA?)Jz<LxjM)W(@qgD4ri7D7j-P+asw(Mj5V
zNc+wngP5;bL@accJKlEZNdKu2*}bsFkS5l#@75FwywYn3Ao1rIQ><%OCtW(9I0)pS
zhm!mqm@7=|3iZHQZ^N&;I;Byhj$Btm0^ABk8GOsfLSwNM#=?`y>c6njrQAG^crvkF
zZb(X&B;Fx9s+MpczXb8qW28fNbu4ZDI4J1sfPs`tSymEDM4mBsKhl^l(V3~9pu)SW
zYo}gyP9r=PF+94Qnr{(A>Q(}j8mFcrNggn?`;Z**3c^bvK~6Zgb2CBWLLR#x6*MB4
z9l+vI4=<;cK?|~nT~_c)KklJFnzezugjqtwN!+(kz3Ne2Q6s?P<SGK{Ah372C8?50
z74%0@MFcM+2wWiu8I%Q*5sLc@&mxD!wXX^G;RFgO0mXLH4-h~fJD05ohm%jV>ztLC
zbf2qMXSh>3=e)LDogGqU;3UCT)3RM&9hJER?|!zoandnFmbRuThAuHK?hMw&@W^0r
zEx?cVI*`ns9iO-qE{*(A9Zwv^d9YRxvsB13nJbMk-Q0u9u(V#eF`bwgbbX(>tbiQG
z!VNje8u|>$;C}5xb>K?dZGqvZUwhyiMxX)6I3_`9f!5b}S}U-YI(0PkN2j;i0^~M4
z03;F=ys{JR1Wm<TNz~8#9jC8K<DA6{N>lEiK|=GWNifx-810l|HxeBIyAjLxv9+0P
zIcWoj?+-zMBpK?!CAeuH6N9w_<W%|PE||Q|xWh(WL)+b$;O=}FO5{@!V|~KtOLx<b
zq}|^t9Yes^Z^5~%ZrzSorz<luSOXwyhC1n{4Xzmybdo>wPqQ={y==FD$u_za4Cu3d
zaRNC6j;2*V2BJ#id0aTtjJWHG-CX+z=R=JL!L!uc5Jatmg2}2rJRwm-pE_e~mA)I8
zw=?Cx`+toPhU+ENwFOjQskKL^?;nUZ*zY;DcJT%fKrJU!#z^Z@fB5_=)<&CQI%m4n
z$zcWExu3keoQ=_Iov26yKxX2KWp~@?7bxx`JlD&V&B<!4F3)wD&8EZ;Z`*g&2b}4W
zZZ*W?M8eX|(AM|-??(~_k8ro|fI*FVjz^j&#J`s$qq?<7zZ8Q&pfs1=GP=zGbkzGB
zH`t(2U6Kd#k^D|pFxX%)gY;}61eaOYL<s!_Or6qwLk`w#i2N*L2b`ntoMn>A!cJzq
zy;5*=`iF#_@O*&h(Un`_s0=!%hOcq*&ykbSuR-a(YA?>sJrs6Wpwj)P`aNsKH4(L6
zDcA@s*SZfK3_vg-+%SVg<^pQ{>ElsBzFJ3XJ9Enw?Gb1O4hU!xD3~e@hk(A`k!UW|
zyI}Oyom=uC2Snw+5r+#JpD<QPbjEX`)FBb46YViom)wBSVN=?roYli#a8Y`O)W%oF
zw;zlqI1nt&P!U;^*c)4~&7AWYdB!-V^x}dDGleiXaK8Bvfi??ZYTEQ8?iNU_o;0H3
zLyBf_MbS1#>923Y(VEEIJv({FPttKOC>bR<78Q1M(T78bGD&f`DX&buQ$p6#S|WB<
z&+k`WX#Nnic(vh5f|UsaF|^DB8}#R=Z9ehiN>Kf7*4Vk^h4>;)0X&AfHTcrGZ&U~7
zm_AJq!Qs4uOTsR(t$?5%KJZvU>5qm5<CnK!TCLKVPWe{TTE9|0_ltXGUih%Gl)-rK
zV~TRdV=qXvO_T9ZA+xIbZG&A?GoB{B_wb@e8mMuN1EjfKLD)f+!ef@+Rf4$#kkga6
zW`5wHeh-b^1|V?7MqS(iojKh<hv&t2{WXG2&-*!7zW?@P=<xzCe>#{gdiK5GkV`Wl
zt5p_Ci}{u1X&3hLWojJXJine{yhhu2xHm<lBAJ;1V2P9~>lpD>r?xcVb<Yt|9d9b)
zG?aqqgl&-mym+{;Vzu`@LsStJTAJmtR|ZWpG%FQ6@!=w(H^1!ataJh%Bu_#(<bw<g
zkSCnKIAp<9w5NQ+I<|2H+DlK_pspOL;|Pjh#ehZ@rXR-&@?`#CH+(daYdb>?rm2sk
z%!n1s8DJQQROI4Z7hJ#MP&J#i)#uo_rhaT!h?+iQV^1WHEltqXKve~+`ayenU1|G-
z)A}Yd5eqVFZ$0@#RWLFFnN_?jv%{2=WHbR0n*!vjz!8CN^2UmSx1j+1h%)f{q@TKZ
zGp??9|9sP=$axsEo1ph765uM{WG>>M?rVPhATjen43pP1go%azz-fl8Jr#JkuK8r?
zFe63x<fP$Oniwn8u9mkrDR2vo@gx1>GTU1-J4*+NUzJWG545vINl+>!*hyeWD}+wJ
zq{3XukoN8fAU=<E2%AvXUfX`qUwhj2a<bP7HUX`IfXrNFD7yh_jLNk&dP8@2<kM-(
zkY3v?ySmmYgwSU@hCi7wyO!Dz+BHj1A16SdCH0pbE^AJ{T{J<XjhND%EvIVG?N|<C
zAE&W3ttw>MUb3|eql;wa;bRbjixhC3OE5P$pDUSTzhnZda+#tqX*!ywztFc_JBZLk
z0;f}Ext{GjXu#5`)QC)*5b=viYlFwqWXqlvdZ<TP{KaIR?&L#Iv6Tu8pG#3${i7#H
zn<%IArCz_2D}QLAOkKG7yYz1<R0|bnNz}HAEuVyKUShXr(BL(R5r#R`G^pb^Qjl<@
zsvKG7QJZ(u#LYH&E|bgbIr#n((uIC-O%c(l+WGdCj=DLI({o^@o_%BJ-MPe;0}fmm
zaQJQp|B|05HswD2V+$G?gJ<C}%YTLtRfreIj(KLh4hl+@A1>p`@QG_#h)HYf3t~^Y
z4=(JAMIuW@yrzeF2&jnfZ2kbKLsS)x2#_AEL~8M<$>+=bo0k-~9EzQd+s!wbptV>G
zSi8rsWYB)`S=76|)5Ys^4k}T_RL}nEPb7vyqYZkDKjZ{TX8?*&{b43A-;;0bPEoh8
zfKy3m9`DG3=eiOET<&TFZ=UQ3K6J{S{QKE0Yl*RR&z{BW+d_vDc%vWZH(;%vOcJzj
zkq$0AOXlhI@&?NSMrbG-!U3ujW+=l8CrDhR-_IWJIPfyyogkT6JX|kO<_c9t!|(gS
z$PJHp1U+2yyfx!-;NRo2!Q4|XEeIV%tBp61oRzA&IAGgeMG*6nNByNp*sR~c{C-Hq
zGw+}BvI#K9(rqNzlsb=CZ1l&@zvajxS1G4h8{GcL4PPSs@)P)})UXZ8O+I+AW-k;K
ztvW!Vm{DQvmQGd=E8~fNCMpOrC<W+EPQ^6TX<Xg>5$0-bqpa0y?Oj7Zzegxrq%tBX
zl4Md_@{#Wodh!-`4?Wk0uvbvmEq<_jo+$r0Ydg28-=hZ1Z&j-IAjM&SMDN46X85-D
z`BcWmufp|SVB%44@lmxa0NveqO!GV9(3j&KUkS{__dj8~f5NqYVLSGJV>@=v|G?OB
z{9`@l|FeWpTgQs@OVRXCO>10>A1{?R%w+IQ7n`-dPzvk5!Po!^cLzzF43o9EkB=n&
zMmZq4x_uq5zt?S;`Lde0EJijtrrOPK-uIHv>+SYT&-dj%RZmWCOZW1_8HxOcK#nX8
z!r4K9_h~+Lx|ILp@qS{1`Q!B;f~I%AzQn;^UT@bI2bpIQS<`aMw}DS*6VtA8HLmco
z@VnF9A8s$#1+oOPHT>__kRM((c)?LU11iurH(m&_{n9;Cz8>!z8+T_LuFpEYPxp6b
zUW-?s?|=AxKbX1@TL1XlA^3OC<p6izC{P|u)%X%mTkocJJp~Wis}JD|e@#(FYTv|1
zh7L_w?&rkflpI-Hx)1MuUm?KLM&>?t#Pwo;3X9%i+D+*06*<1^@(fCST25{7p0o>=
z`Xu~-{F$8x2cww|Ayb(3L#r4(&j!B{h9hBJpp^b;-zp&Ulk!t+XS*Gt*hoPVU16z~
zEGh4YZjrp=^Zg<v=Z}lmpH-f<xC@uCyNEbb8EJ9FSNQ53{xAejCP2u1I(F%s);^!l
zxw+k5FAw;vWg2K>Kuw}#lGCBcD^I{6fjht{B)5Ag(y^H%Qkc@mjr}!uOm-YHjOeEI
zirf|v2dF@93@qRY7Z#(9NGH@Eso!kBNs)_dqX|lNmh9JQln81fC>|Unh!c>%@%^Mh
z^pCm|4JfMsffnY?5KZB^Wr5zRb<7xUpM()4t}#pR+xc=E*0rPA0TMnX5?F9Y(Msi+
zz=X=WF>Trwdjs+gV5nXlI$Ra)pPuNuz(GlY_v+<!^U=u$IC_dq6By@$Mxlxq<3zE{
zKY5Ydq*Z<K{_w7+oyjVdwnT1Y6YwVX(TUseex~k3flGK0jSyVKJt;Ej+gXb1C`|{u
z*GZjxlAj67bX>O>P>uogQW2Ru!(^{S!xYO5&cU%Ae^|Ei&hYO{W$g_4N-n0qLwD}u
zC&a%npy^Q>VRaA-4N~L&#w86F3^8Y6@h&qevY_myi-0{A44w`y8Q|0IY(}J9wZcgT
z64H1cDC_Cd$kV#0N=4Q}%CXjjaJ3vuzzm~MkRWg>?H=~_0Fv9#XI6fV=F#iRRCJjS
zupaa`Jb@naho6bqr$I|Z$zcn!8po1;P2zrv<=l8&<n9DjjHi{rVI}7B$SXLNz>CK6
zqz!<{YCLb)r5_znsY8|$+oMQw+`n*+k5cV9wZgV}{_P@uV8Ke^Z(!z<nQW!O_ex$?
zXlo5>ihaVS{ot)qDC0#2Q%Q6Cz}Cf|iaJ4AH@tNJ{yHXEM-p#u;NNdMuOw+BtF>WO
zVqT2(&Rlb(-BO|0Y*cVcVi(pQY7yiLS8{2d<L8M9_4Cly>^pU*ZjFeP`D25id&X!x
zoNyBaUX6uvmJHI2{OYogwBCeyCAu4}(y}-jfpBbRq1R$3$1J!++8|reZbTEktnzjC
zMwPxw^RE4P3f1~-0gHo6&RnqdSiO&`*A)X@XRE!vHe}3uam8gM_JIyDz>apU9qksJ
z^<*hkI^KD#2ad7E#g3E%OT$K`Y_1%Okj=ZR(2ge)4>fgy{kWSDc|MV2{8V*U+gvJ-
zjWfN@NlDI0F0rA|39Zk1nX{zS(XPX`d8TF@J0z8tY8($~@{zW;Rv0D!#B}N~z^1O}
zpjc2cOTK;XJCZ@rExjZDtNAZ0H<O^BLeVZORW+j;<>8|y=APIsug*!Je++gX;-hpV
zki^!Lajtbm#^$7ip{f-m?iisZKDn0d5yGlEEKCMqu|s>wlkY+XFec_up^G_?SeJI*
z*t~hyuXrc&$nmncJqPY$e0;?{%*~yvqf_61gGde4lk68h5!2@&0LEXAvzk>nyrW67
z&D~zVXPGLj;hl)@ttSX)Uy)Lcr#48h+xF7j*9A(4IcwTFYDhOd%0@KdW`vW%gvTc7
zw@9T#w2N^lvft9cT`Q^LBwH?KvNj()gB$kogfdprQ5WHLj5_75P!g2LT-y{E??Hj=
z7LeBHDUqk71t!_CLkg9LuvkdO4a883h`r*{w>h=DRGfp9W_SLc^*fCZ(he0&)-mQl
zp*h;m2U=B@{{>qSTNgFjAwodjY4P4Y!e}c7-^bKTmE#NyKOW`xr$eB%>%nrb^v<i6
z`og`d7lFLW2$OO!gdVDdv}jiK@TH5e*V{w~S%!f8qu5>Q4LVVE`yJXdxpNOnihI%l
zY2T$M;EX+{x2;5e_-F%!D$|N5dxj}nO;lgw+Ha%#<XM*<s?z3<MnO4wA`GvTy1aDg
zm(-5lq4lZ$bmoDs^WpPSVq&Xp+>=#7v<v)}6|es+E}{w&HL3hq$$;2?_uhLrI3m(F
zA)MkDJX+?hWtBY4O;{*AWiM_tRXG_EJnIGJ6Wt&QWlF{__fNEQ?yl374g&g`Ns<Xl
z<4_;!q8#N2$>K6i;Ce(;L(9ezXfW$BWe_UYdU%G|qjWLS!!iR{ISi_wIqJYW?5v5e
zU@Mn~MAy3#V)0V_tD9DEGy>u^49OfvJDG~@m}|ZD;jr=3oLk$Tn!kXhNLyEkZ<j<l
z76?#LqzExl%qRx4+n(U)oCY}Rxzt4!xUdv36A55F<NZk^I=MJ9w@VfU?nl;XMEp&#
zO$<xp>|p@n;3-_t+Qayxec8={&Ib%K_9vpYQ{Pj(#toTdew-_)O7V^0z!IoGDvV_?
zLNMc8o^~ShJR93-w$QF=mP%Je*3-+Xq5<~PcLC(qDaA<-_SuUJEj7&FY5pVyml&6-
z76Zm1&6@WoyB=%mkNotZWZII<Sl4);GzzGmNbfbj-y{X1P`QI8KJ#rBf%GwDE9ML{
z6XIL|{S>pMvF=-u?3wCgrUK3(lyUH3i&1R*whG6`)YlT)kQ7?5EtUAQWFQ2DWKb(h
zA!~Py5OLCRG4Tx*`O1MVt<wg<Kx~BKDLVF=##PhEuZ4@6h7UNpaQs#lJB(n@os8JA
z<RK(FUc&FFtJUp;A<nwmw5qXrd-s`mufCj@WW#Slq6-~;8WU43`ilj??lg!x#~Wel
z;5iY%m#BxgFDh0CS=AN(X6sBhBcIO(MjxCaS2n6q#AVC}vWXduBOvsXw`?|<e0yUO
zEXjIO8f8u?qw327)o5o`FmvAuu0tcPg$$i$d#z9<fXro`Md5M&+pR#v(XUC#P!kFv
zI~BX@l3f}OhVspwUSl6}u7s2}MMYpjoAwPqTSf`En#=j}tnjc~XSeuJSNx-IGXkzL
zpxymI3^1`Z?Q{L}y3Mp<HCp@EY=_$Wads|0bvFC7hc^XE4W^@b^^^e@0SxT9fSFXb
z{0n8}P#R}>-q}MoUM}}l{+G^W4b1qc8iOi-(IbIgt?Y>vt1WH{ghBfBG<O$fn>Iwp
zAYeD6Mh7ZRBi@F+6zbT4g(KWK6Ud|sC)S_D?e;MdnlYWPaD?003*%yi+~Ka?fWyd^
zVFcdM-pq=LF!AoQnXFaV3nuCA4MQ$@n;xSIX3iYo{j;*rapBFRs>))8_+Mr$-JS34
zQ8j*>fXrWDi*Y;y3Yt7!YWdTdb;%(n)&t0l0V%eI<c(B~e=ay0`yUuDb7VK;s*>bN
zb`N84qbP%1jnTuVTxFri?luNtshR5;l%<kDjzC^D&AvbBwnn4ELb+oFT`t~abakq5
zo7pBoL<hC+4@6k9SGVLLctZQRY7)cDVTAk~UD!N!9}!h3{C0f0D8<W^INiRU+f#Q<
z(QN?g)-1XBE!^!BS8}^**@VW)Gnp=xw=Or?THx%fl!BzE;ReTTp!xPDDO9-a9Ul0)
z`7A(dEJhGxM;8^MiO^mg|3>#RZ8~CD9A}{dNrD!qwH@b320iLM?Z_R$6_a#T7oxIo
z;i*C~Vlu-bzj(gdRY-2R#FtTmtXkQ&qaCU<TRU=JF7+3xP>Vq$00-BwF}oqVu>`VZ
zA!S-Cu|z1d?o6nE)q2>HKg6#k$gFp6{jh<3SYym}@)o3y&Rp~2p;f=`6U!s;*@5EO
zEwLrR2NT-f(dLZ@ZChs(tmw<oWb@mqW4G&ub!bSw<M&qR=EvfaSld+(ZX~w`H%xfq
zwUGCaoz`YEKd~EEtY`Zp(%D54#gmXfwc<zK2VhONHr&2_->Lg1PhcF(xm0Qogy2dN
zQqB$F*{j(jQ8uHi1!)){iyn@&kDq~i<rD9k@0rZ!n#{l|1P0pQ!wSE<QFGO^IZ(J?
z)oNGvXSf!c8PLu<e)5|zUMa_#Fos)-X-r}-OhiF_oFb_}cE4>>5(7wHE+r1LPsWFE
za)qiQm*Mlbwpk(T9c`((y3mx-#361KnOwMx@=6cHus}M=dAGPp2&*R|03g-Xwwp;g
z%j|j9Jr+?Y)2;sgX>gM#?8dvhwwvMcW~65pI4b+m@f#d9gN*=^@wr>fPsO(tq7TOO
zJ{REAEF~^!Ii%jhYD#~Xz$AGYHriM)mMr{0Ulk-X>JOD+*yL$@q^94o2`zae>%BR{
z_3wr>*WK3vvg=E38nb;tV%o%gROwJlhahQo+lhT{a_)2&;tZMmsIk4B_9dA7dHPj!
z)Y4iJuL<tc57-JrV;dfRf0B<<;KGZzgD*lOrw}9#o!I{j<?|55iB(##v-SNhPy84t
zgnz^&#TykvF@EAETZXk!!N6*915P5>pDlHIvna!}hw1Ykp~OCq^o}8I^%B+DOC5OF
zIPn#(68HO0knx`=@E?$om6_$=kdc$)KhS}k9RDjiFl{~Jx9ImTl~791Hs*6{R~7sP
zf-eAV*GotS(gxY4zHXH0cVWB|$Kz8jrzl0GQBn6Rz{R!5Vo|UB<<vI3s`6vwH@|l7
zhui1VW7%5Qn(armFln>AMQMw=M(BEbyKcFjo^mdm7?<zo?R>|CFTdZ@!R_+i!_CQE
zlf|Xpg&rQ&Y;%W@rk_tWK3m6K$x>qqs*6>{UB~GM3AIJ}-K*%?<J-}p+h!+THPxM^
zgA41PvMwAorFqj9*2}KIxt4X1)zvZNMfM<gZE`_AbHvmruQwT1{z*|WLNUBr`Quax
z%-+_V9u3~Hp|8!0g)jf7y724WUMLLM>pVaHmNwUWuLw<55eph&=D7PiB!vM2Fl)ac
znH?W8>zsWCRGVDAG`6F^H&RdxuxB!X;hdr%K)zc2VA$=zJ4}O<j%w*Hf-*bA^HH86
zEs}Q&;?^7X>$kvbMO5Av_G+F~G4yRNmz=9N9}Hg*SJqHNsKUYg8E0w1M})x}9xQi2
zR*SbrW>JfG>2ao=<a@CiK?1N8>;9)s@lc&+?IS{Mk9$6;6Y!$QlMQ767~5pw@HPgV
z6XSmQC4NkE+YD+DL|P8uG|Sn86o$G?8&f{zEM>3`Cw%vZ?PBALv#4%wt_}Dvpm2xC
zY~C`0u>kUvxWOvyBlm7fBDaCnhiF3gc5^*35gg7g%W4m@JIN^{QSNxgc{rMe``_vr
zg9nw_iZBuGA_u7xQ=;ZpT-bbZ5Z?_VylM4G<S?j1zR@9-pidH!L6bek-be(H-?5^V
zCPSbE-*+dx!De2wD$l;)9po!>Bk2aMr^drEFmV_ulO2HG$rBBK9}Yb*Mz4pt0~ZgR
zn0NrH;XUvO2^L8HvgzwFws#`aK31}~lxdb`b19=AU(W`bOe2taEQRDYa~E+r(uqSe
zovVCMbkX=3bbz9<Y2PrOgd>$)YA*a@30Kr)0x)V9(si_&XwreENiwF$BdULB1VNLd
zApMqfcZ48?X>5<QyocjqKuz@R{Ei&4wn*SwXTp73AUg0a+knzZI@t$=*RL32N#J5(
z7b`0rEt|yHBA$ei%$4E<n-NiCczea-4>2J?BP?3#R2`PYIjRY-d|gDS8Q*$sY1B}|
zUls1Ed)J_@QQX0e9e2Z2)Z%2wJa12umj-#pd{gdEp_KyqbkI*L%c6%-Nm-SlZvfkJ
zksR`+_`Pg5^Wd*~tkmBux5r^=hUYAyWmmgmapcgL)9tX8$6a8>5#*A}<4?|_7H;J}
ztq(Pj1+x9**8rlFmQz#R&0sH)HtG~f=uQO_xE@($rn2)~ZX{H>vN%Rl2%wQ-@?J;s
z>JjU2@*)j+Wslq)2M{U-GhU`;Awuq`HID5PE_*Q8c;-#{^+u1tQdg%a2tO&ZR-yBd
zIx0QL+jqxmue2hP_F7P<kZYPj6-?2uwOz}*^+Pc35K4=KeEc=DUPqAA6}W<0^y=)a
ziIg`EDm)L;@0PlzkxIIhJ~HXzfog3}8vAL-Oc6`Jw~X3=i&ErvC*!?1RX8f@jDEA3
z`G#HiJ}XFVVg#i)gJC9nc)Ug57r!n4CqA}8tJ-p|d_28S!QO=XRR@k0bJIYW#9W!b
zrsDJ4j*%M4e;O?RIsW|}EE$=Y{ykW-GP3`zV*a0NC%%Gzb-Vu4{2INq3Bb(BoRNT$
znSq1jzY8oMXhOLuEhl$h;qs29u#c^nw&a=&BJG1A6U>-eucip}X&KiQ%Y<8xH3u|H
zG7U3;ic1pM`!RjTrcg3dl*C#CAD>wmf?`lI7fd0u$dkz|ksvFg442Y`E*eOi$nxAu
z?5qv)$@aPPW>&r5)S0@?{mkm1kYM?JN;qar`%Q7}*fm(Xuwf30u;x2a5j$P%IA!~k
zt-&j=;9x<Cd;`CkWozp9=x-)?R*y~W$=<9Fl;>Au!szBVt-o(4LvDgd$oJkR(Qrod
zzu`Vo*Yf8N;p^C=`4AiQfW7W{^@%QfzJ#H@>KS?WSc#Z7Tney#f<7Mjed)&>-tJGV
z@QaGe>QZ2Y1Bk%Xpwc};euehu%)AiO<B$&)2z(mZOZOtY3VjBoJc!JQYw8FV@KL6}
z^}L-C(%)V28Blj;K8=Fg!y)eF;@u)=p|@$rUe{lT*<q}EO7QdH6CHu^b`nhXFCi}I
zRE`bJ(i*cb{|3g7S9Oc&l#oqmse6cLz?N5YOWcRPDrgb|@9af9e+SL2*oLG*a{%RE
zCFTi4`}&(oph3K=<&<}z#%jBLTwx62(;UxB5@r)}PB{1p&ne6`3RW+~BX!yLXy5>R
zBcD+I^d&YYWp0t{R=N`8Kt8iZS1;ujmPLjLhj>r%-0h^96`_h?02;&+w=rj70kH?N
zRa(ry3ro1y#JdKogD2YOwoc7ME{$w8n)$OQf@5dmTE$IEy=H8_u}`C3gv1WNEw_^_
zd&xA8ww<S5WSykZ>T)kvg@&(A#xb`xHcKQE?i&64h^T&p$50SH9KKAnye}=&&YIm9
zppc^p;*Ls3e5EBqH94;=2sKqXryP&FFR_pnH2EDV2=ka%TvZ}731Kxf*UJLgsla<G
zgh8h>@f<BP2wvC|Y86%xEIpWSSn6ohW9R!WS^FXhQ8pP#AWuay3jy>X5jK37X~*l2
zla0s&^wj-Btq^CEKv}*Yr|?CM6TE6QOSDT-$tgH-!?-|>{okTFuimj`x^r#Q^;*;~
z5k=RilpC5~sqAWf7}+!sLhXO6#>aBn<Y#A~Ss+}>awXj1%tAt@m<LCh1%sXtDhNTx
z=ALGX!j`_sKA=W39Af=y8~%+3cM{vX@_}GcO7}p2G_Xc#t=AgVp-ejblN?!!IZuk%
zMFQKoh?<d5E)$MKPF#?9<aJivK<@_36kbMxd2&9wExk>!oFSBtc%h4A^4!-xx1_23
zsCuIGPrk|y&1ED$^!)eS9gW)}il~vQ8x(d$5^45BD6`ksV2gX!`yP<@BZJ^*V%Jnz
z!oA4^RV-Ey*eD#UCCg%_z?-t9>L^*b6Qpnfdgzz)crp-a4BKNd>5&-Bd9#XMx=zI)
z=@ZyF{3v3xhUL*+QZi=4EXKsi3{J=43*<X#&5fvZ=2CPkCgw)2DphmT+!NaiRMB5{
zY5=X*VsxQj^sSp{2`Q~t99_0s-N=G{{FUeBI$dp*Z^;%zX1P6A>I*O2!^^~K{4<k+
zorz=GgWLtwN?Y-*?8Q=<^MqHp%gM`S8|lyYNtKA8OrmCTEXIM9<iw0-(7PhNr7z!c
zN{X*wfiIb}I-I8L050)y$;s*YW6UyHEX34S9*iRy>_RrM;BZjuF7tA9Y@Y>fC#7(n
z2zbBitkgy>s}Sfp=jJ{--<JdKA@`*{c5ZULne6+=Fk4&!9(G5Y$seQTV~Ge8x9j}c
z!BXnRuUTYat7sC?l+?cv6$yfYijok;=bR;gt))>C9!R(a3T32n;w+D^_#cM44T*`L
zVXca%Rn?cWgd^nW7@-8|q}gSsCz%g19nHe7<|zB=9r=BBf)mx)#P?qL{ncJeukt&<
z{wRDUi!mL(cPzPUN(M{&jZwSPF#Nz_R5eOnq_y;F*?KD6s<Cl%9y_9tESuDgJqgq^
zm!qgjB%T;3F++vuFx1#2fslnzvo12dHYcBR{K209f1hiO_3#XOd>7t_fz8s(&0v-8
zSO9C$tRw!PS^n|cilKRUp65Y<2Fz9U*p+gIio#J);ndOz%#Gsd6Q<*yioOejh7#(E
z`PzBwaWZ5jX|4+n1L2s}nXTnz-w;|R(sX<*hIG+M(?j7wLI=N-bWFn>8Z0=H77i%}
z3ub2JylcSN;i(Zn?Han<83Oud{`*ld58+<*#eKH(dP|L`+n(sjjKLkr3*Gx@SCr4=
z(cOK*43#yiDs-kp^%MNns^b&HmhT}D)0+QkR&bQ%Sk&BXf(9t!B$k8{8DTDge;%SV
ziCCz3EVfw#j_z?JEz+Zop&;3;JpjV%YJ9{t0!qzPycAtmmt2Ol6@V`&Y8e+#k{|{x
z;a=vh%yg1bbTK}4C3!Wu$$4^8pfH9En3&3n%T7tl=3D|@wP@oMNo(ZGVI3B!T+py(
zV`2^ix*H5<28e~!uV^Zt`2xp8jbexwuhbi?@13y&JhQqR0cX$4TO2*kI%e#}W>Yg2
z8;e%!YSlUo<=$0p1!uEjt}eWfqwr>z`K%CIZhPAqLTzpIE<H|%fr)ZiC|IgI*S!(R
zR?Bs3dVz>4w_#*)^hp__<`Qa4u5gsNW0`O|WH!sKvh%WckhGATC4=Yt;e{Fz)At4`
z$tZU(9iz-RAYrpWHC;}Hs*#+z_MR_JoY^K{Ge1t%>tA-$Z9Cp6C&<Ax^S&Qdd7N@v
z`ME1Ck=b=Dy6&J#wENJ78xx@K!TeC+_X=1=*ybdmCWNY~62>H#LoaiT*B68L)#v-w
z3Tc5*>8nOfZN`<9wA^3SJk+B~ryd4&a@o{W?;?bhD9}TK6bmSl!E1s#27(5L`P~d<
zK}nFLhEPf7l0`^1;ngJhBz3}i3CdEI!J2iddYO$$G^i;NQV&vz?Gi0Bv@Sv|C0eIT
zE@$n??Z_Pu8xpT$J_bFl_>WePQm;*~&acRi<d@4=a$J%z&|*V{cFK;*T;;sw+!=N(
zH$Okj6%V3&e^%?4nU*ywcPO{87+4TFdJzjDU!q>38ZHK6_d;p|LYz{-13AL^@1DZ0
z1s*23Pc6;17=7PMVq#=6xw+VUJ#KbOb9Gw@axzua*w11zsO;IjvvZ2*XP1MC3`!WJ
zC_DnH^UjU~oq}r>+<vGNTayHBWs3;Ls4Jz?%e?N2Bqa9M#D&IYzYg~XBgyR(m`22b
zK2-mDaPr~unW<7D5c&k|+^OaMB;{dr-Il3^x?(!B*Wnjl+RpsW>~k6x%0nN8e2Lf{
zNbQx;D%A<Zznh{cj<^K5a|~OAas@1`8T7|{yFo+H^7mF&tL?Wxt(=xxBuMr@ZF+A+
zEVTkJ^43zW*$2Rzsz{A)F3TF7k6$sHvi;b9ZIxe;EL<q9Q-%|R!U+{h4C*TLE84&m
ziErgMixe#XDgWvK`ELi2mRdxG36qvuQl?}ZWzEj}-9=$*vIKhxo674Fkb6o^*$I4%
zC-b-ZKY7n>0O8|_*rlUGA|mq#Auer`*wMlRc&S@N>mbo!^@~S|xYATa+&qYKZfzqv
z-&5n!J^Ja|Hc`Vy7yEw9Al`QXvuAYXCyX4~i}2hw23UyLW0Ligr2Y7KnDij7mx>9|
z0mN>h>XJcZhJfJ5nRTUnv16sRwN+JBd4y~VGZ^<<ND!1SXYp|bpH_s$$4d9kIkj8Z
z;ckK7$hLN&JZJPAS5U(|extQfp5HJG4Wp^Gt{TM`3ap}<rwZlRfuaV$DWtM*!?6_R
zih@p&6w>0gQDXeiuNI9W589O`SPNM4-V~JsO3$_~H%2O<G@qpHAd1&7Tn_#)cCD>j
zyn+(eQ3xp=JG&F!ADbjni#rRHnPpR3G0NzV-$ppLo7q@9-ZA~H3;Sz*2J68NRtSZr
zo_*%n%9)wOX471%mNi2EO?MG75rNveV08&{yups9e(P&mrHSpSGahY%03YqJfdM0h
z7*85Z(i5>9>w{q#7AFIav7nI3`L}|W)QoQxu#}LJ6^9=@ul6i%60txej)hI@);xv@
zG4u$ZUTrkk0tRer7fsA4PKrFaY&%xK1TPPGaSBI}8zE?bg0!$OrinWg+=3qyxtOLl
zhH9YL0i3@ZNWGPKQ6G@1sQM$sK+YLBo!Gii4jDQZRahSu*OhA%Gr~vS`ue`f(BZ8}
z-CM1{sSbcWRyQ9ZJ5<|1c<IzJxQ)7neAfovj^J1Kqr6lQWgV3>Ye78Zd>CN_?4Kg#
zY%RiH2OZttRLDb&da?Rpp4LpR;uJ^h`tcrZy;^CkgfWt7*y~7l``Yg)w$}p;T!q<&
z)C$9&V`N6jn%!imEYh;6oEKT#?06YFs?s3P`fu~t;eRy{MVyJc1Piu~YQym%WXcza
ztq&m0??#N%RzqsugND=xT!LHvrfmWLO=Ubk(=}8y=yo?L8o<}w?tZFXpj{t(LDXt$
z7(l4D$E3y_5^~1)J?e_EMORZuduKS9fVZ0rY>6jRTSIFv>CB2cJF*f!)4C@045ta^
z0<{@>)wpV;dyI&_p8IH#&TgDyr*?@Wb+jqDzR5J4XG>SfAl@eO45#_Uqiu<Bz2dC=
zoDHX8IZ2K7XYKN2@`QX%$r7d7YQ=>t%W367c{ycARSsrFGw1k`!Lp`lO+9z2`o3gG
zL&$2SaG`43)T!Ot1iG>YuEPefn2t>soQ-ncDwd~AF-X@+xeW#=7FA7^)^6=|_EBSA
z0x|?`{k%a{t%?@z9WAT@ZOD0CoA|c^VeEPvLZ#|lv#RohiSsFs(gD*d)B33FHrA%a
zs6sGSRMpb1W>LBZ1B#`3s>}d5A<CNiwF+8?;HEXMWmW#|pzyLC*qJ_*!!=85c&lWQ
z>Y9e+bqx^rMsDi^S-SAw#K<Z*0CyXiu8T`B4nGG*^t3p4wo71;+Fkww9882B@BtH-
ztR{FfoN*%0u3to2xQ`y-`Ev@9b{c#NfkUl8&&FdF3ODsQb#+!1AjN6TSo*=gG=ss<
zFr%!D-Mv>;Sv&+4RJTrv)Yv4t^Qk(12CG%qW9nm0!)@QH47(v)VJ)Nc`zPrDj^X+W
z0R7h3eb6IH601QQ6TGd+qAMu@RwScr$!xYkHLhQa)de2jB3r$VVViapTg}?NexijB
z;I#kzs%WD)7fEieWslH`IJX>{t#vK-APHS0wsHfVoUnT{kRu5qPjPJ<S=RNdH*l%8
zC)xa=#Bi=Abac-udNlYr_w)B;bO+<Leruaw(jF_j@R~%Ln*_7&V4*Nsq6Bezz?EU=
zHd_42iscWe^rU?0B;jl9VVJhar*JT_3lhIuu$6iwd>`XZ`4MXox9LDzgj1T4Qf$(i
zCgQ|k?f&2@4=?amQ&vNm?PY&Ge*AYU)=v*PyeK~jra`9k5c5((h~>3#jqueljnN*H
zM%~NwrUI|QXl7}8>69Jy@4k@UczeqY_?fS{6IRf(TMnk_=Ud#Chk@Q_tup*A7=7e>
z{H8s@)9wpT8EvINYep35Rb+f;;hxsQa3T4aBQ!W#afPsU@84U{6nH^rEm4j-SB$ny
zS#v~_Z_<8Ii1m4awb_zhiqaj4Nep>R0w=20zFu#HWqfM_Cr3sui&|&6fo0NR_Z8!)
z7G1C}yBT{jA+9<e8faRPj>;voes<eTJHQzJhG4D2@TM>~jCo@h3zAhE|D7-JxHx$a
z=f~b5qOkif)@|#g>0z(mD}ljB(I(5GnwK2pHl6UA^6klIjHYj1)^@^-uRDZIWqCFS
zIGW%lp-t~Rxpms1^5y>PF?r1g;P&df_Gksg439)!HP=Hno+_%Lrk{rjBWX%AA-kx!
zxT?+|h)wo<Z!P<T%~%->Aq+K3kjt3Y$A@x<1N~c3;jan>@#{*);LD7W?4x%D#y{g<
zT^t8>QBSg-pq<Mz=o+#1JqLf_fnQ01&}erM*YdKKSBH&$UtRIQ)VI0jWB8K5x9?c6
zX8kz{yO7x*mU`9(NKi7>SY__-j0m8b_>x&6o1eO2yUF%jrE3kT$~<A#UE5=PdZxO+
zWyM`z#rXKy{z^#<tvOubDSru}mW$*b=BdD8B|=SCjUGAvYqmZM44iQ;%7LZ;&6$SB
zoZk6{O3{+z(1=4UemdIXTK5P~(Sk0gR7;FuVcL$bI`mh;;qQ@$PWIKsfm8VXoz^#@
z^I=h<oARit%$?FOv5hMpp)}h)g|@ct6E3qtO1wXIaAf%0?lJ>ZG8)_}15+8`-H(BR
z*UjZ;gek!X9A{ndR(SORj=1t_PLTZL5{J7T739^79DkrMGi%b&y4NS(a1|Im+*mhS
zRg;dZTVfklRq0rh4$c^<5e#kZ@IF&mv3EMm&(HDHo$FAC07%_WIwX~ruuT}d$z8Cy
zzbu!M?ihQYaeWY;J<m1SW6A||s1+W(tg-r+cntTtEhXR{(`q!&Imd`P4Y;1Na7T<g
z*E#J>2_LEK8Uv0-#?4kb!)qo*R!q^X#()7*bvwP}4PBsOX*TJ9G;I0Cm-A>#tcWAq
z5U@2XjuPMj9av%&*EUKAX`-AlG`)OQ)1>Dv<xdp?wB&k1(y;~#aa{IZy=U^uE|-iU
zl~|tejr?-iO$9dGEhE=j97>fs$RiqML`@DcX(px(IEX4Yc-T6AS6oRIM_!ullhA8e
zctWI8)O9Nyz@*5~1rA=z`L<+?==PkP(1&AXlA3NoG&#`K)16aCh0yhytP_>I`o%vE
z6#M#~^f3NtPw&<A$4>6K?uI2E4M%(lO&T>Zr)vF-S)K*P%T2zMpWscp;T$H~YoMY#
z!AMGWm_nbx7SiqG)!-z4SdJz!wJ~?8R>NgPaCG-#n^Hzitro+xp|FjOrFbwus!OT(
zO~sbnu4Y+a`Mu+SM>J)%W41!3ijw*WV2&~lZSVw9AkU<)l6w%yfj#OIow0H2R&C{;
ztTQoA)Qx7NJwEQJgKw6fP_t!;`WzsDiZ-za+{9<KHyUz_ttH0TrnSnAqQ$r+#H`+T
zRwgN;j&HVicL9H{$HudV^?a3U?)8c1k$})G0smVbVoQWJ@bPyaJBSH;&V<SPz&^NW
zvbQE@54aBqT=&Gr`4$v~>zjY3-8oyq`Odg)aUZ(@drt$kYrptgN<kKJ-;+#n^fY|d
z)p(5%e=5e?D}DbvReV!9)_@J=A8GU+P6pffvs(9tM9U}o;qUyfsPs0SxGJ`kG~KEy
zDbY1JkJOwz=W0tw2LxynM>qI~&+uhEb)8uTE<H5z7a<bof7XD=qx{MEj_^|+{7;RR
z4&!$IC=LtU5$pq4_XK=;C<sn{xyjW^6J(ZO^@M$Cs!^E`06l8;G0033<lnri4?b&f
zhaMq6q{&a7SZ<sB`R7OJyh?6e#{1+BB~=^Z1XYc`Sn`{6;fR~EqerARl-KDaf@3$W
z2@{gdrEB|bVj_G*$yE6~l<LY5ALvh!9S6oYGx|3ZRxg(m#uH}fT-<r>_EzEcdkk&O
ziZ(Zc0w;SYZJI^xG)P}QJ&N~drY!m(euXFEV7bU0ZSc2z<d^S;_`%&d6}Cybi(X9V
ze0*mqe3wBDfG6JISRZ!Pm$3e;;r>vRDVjh8iZ?O(&d*KrllO`1O>?&vWFM&=T<9Km
zZlxEv;1=ec<?QQ<7N%l71ve|DgnL!8HwV@?L-?%WsS{4Si2h9eWhq<5r#8IJylbxD
zWjt2Nn&`k>lfDWR-IJhH?#a0c6x{+l2i8vU9WZGAVmm{%2&b%mIf^&#VBbPJ*bCeV
zzrr!Q{b$`1$l#;g4mFQ%^c=kk_v&RDURQb^wel0z0Rw3M%b*-u)e|w4oT250)SXcC
zv+u#a&I1DMZv?3DMFT$2(=&6_*WS=uh1VNSD`Gn*S4EO?=mV~bJ7ry>CuL)`%aB`}
ziS*u{tmk8)whC?u{XOz-1)h!fLD=m*7IE!j1MG0u(;h1_JJ`qj*eEW=y;HbgbF$Ff
z(0MTLuFir-dtHj;!6S9ecvrzA%a+Z)8#FdO=*_8?%?eNC&{}mpP3YZ#5L)qJG-~T%
zb9S@d5)wC92s}q2h=e7B5V7cM$lz!cHhDL<E(MRYeh*@==zbv-JeCv*grxy4Xe+he
z3<y;zD+-=kELF1sens_UXllwv1$Ehc)(o1a5&^5&ACkUR;bcPhX=DlT@rp8O{c4m!
z6rdmvinYkVA7hGncyEb)Vg?$FzvcS0U};nH+t4#8+$dTpS=fxFqEWEI1T06v(Su(p
zXo|0sJrjy*iu$_%Pq&fRq~~6gAeR!rmB&MvwPF2&&@jU>DQGBxiGsXf5WyX4Lb$<e
zus`$VY4@cTQOZ3GK8#x@_$1q{&{ihqNna__%&<v+6*8cEI&R2^ca7`TMh8IS{7eHo
zFcB@|!5#M;oSPGtNoSRzViweh6|Xg;l}WC&(7!;8F{o)I(V&tEp2IVseUwZ<E>19}
zI6;(@+Q{(Dvm+O5y<_r<??)#az=3Xv-(Cf@8m(cR#5^-Z_D{aST95@}-t9aVFwR}v
z8E|!%C{c*^8A8w7d8}bjV1Wd$P~m`qg=;7Z(C=%Bia%q<Z4ooIpam+_M*+bEu9u~I
zWNKtc?yx0w{(@B+<eWo+PNbABU|@us)G$d{1xKDEhz+2mm0?mCO};Dsy-08*H03oa
zI=zZAtb`HzJEo8Ut%1pfB`TjGqn`qrc(#93a&&w$wSJs{d4Ry=P$=Y^Xx{HISaGp;
zCuq^A-|FDt_xcP00y}iHtQwM1fh@rt3n*Pl8L(y0u9TxX5qOGm9YPuV!s4b)tWt@>
z0<rPOlq9AC0pFZZ8qGDO1jd1Sx3`(XI0&Y`eftLa`~#NY9`f=bGpOv-^<(st&9CRi
zmgm_Pb`fpxKafrT;*b84N^ESb4FAQ<f5rcsf2Xp$oe90DEx<|G#L>vX!p_O|%e?dJ
zP}ac4gkDPE?~7W{!s(w5o~kAe21*71M;TjyEv=%hjR64quhXZQBLVBz&ev6fg0^m2
zv@8U)Ow6nVYz(XfoJ^cL^b$@6))qzr05fY70tRS$0Y@VffYVnK2Q>ZPyZ$}+Iv<)|
z$iPnA#KO${Uu{ZGCN`=B9A8)b?fT1D)P#xPUrd?e7w2UHF#h{&&|jgy)}#NEJY!;K
z{eM`I>dgKE1QC1(+UAz)v-eyHYwrnXTwMd~=JS_bfDlBb6afqHJUyD|uaohbcN>^a
zav00J&R8BasF?{v<iJZxK{RM&0j&-EWEq2@O1^HP=pGuR9TT)|nZhekMJOp3e?)U=
zaHZbRE;`wXF{YOdQ1U3sj4gq&Z&7~*LpGPgEVH6AfZTH5eN2~&8>+UU7Seon#@76R
z-c*BW471M>MHKC~ZUY*5fGjesELnWeM4q|Tqk9vyK7qIy)1mk!L}>(85g2*QB$j&e
zhS()_1m=;eU4Ssgeb49~%SVbobF@$VlHet{MV>n=!xRa!MK&;N-@;FwZ)i_fNv!+h
zHwfT|#Zwot6^+Z#5%!i&DC&PsA=ZC?wEvYV^h(Z#PJi=8*}>W5A5lRAN0Yx_(*G`F
zEF2u2gv<>b{w9O8!N2wynV{*_ER3DZ9ktjPn7)$d|8LXzXO{dsi~pv|KP--*>6L9&
z02Y6(X#d9kVN(nJKl6v}-w*juX7%rhf0wWPU&&WiHV&5mLB1|@dU|0Gby4s!cg$69
zR{S~bs^3hZ8A~zNiV0`8&vFeTl!K7QK@#_ySpf(BHkYOd36=EJn1p67VLnk9tdvC#
zpS1f34jr7-Sd7wIT*T`y*k>~imDL<x^_m@zBRKuOG5!4K=wZs!%*?F&>N%zwxAT(8
zSXd}b=ya`O`M&3E!&OfdvMb<wbJd1d)viaycHq5zP*4lqm7ecI(|AiNanUQH;M(v5
zc8j)8*F}Xw5DhuvOJ6ZIomK<jqL&gzP>w#BFN6I@-{lxB@cvbRm(#%F@}^y>@4De=
z?2p_tHh^Zwp?~S4&$oPh&b*J_MJvFuZ`5Zd+AY1H?sI=e1-+-|Eq^A#C!gTb(F?nd
z;{_K=6~TSvh`IOYw#mD%&q*Q9etuUm%s7Mg{WPQm?Jwk*WpglvQg#d((@5i{{{v1y
zvA@|JPM2HuczymrFr<X*BGFhpkxbR6GY#2XzOkuLEH$^ZmfNPapEtcjoiVd>R@dw~
zbLY)pu;~27-4|TAWa+ZyD^{Za-~4IrhI=6j!R_bnL9mvUKfrwg?)N9>SI%gzLXpWU
zE5|uIH2(M6jZh5Ti*}<ZI*A+6Pth2fj~+oYP&c{<%|WlCCy^O#!7n2oMbIqt7>eN#
zB4{>pV-30wy@@VHgXmp!93{~L^m}ZBe!5UUa-nkN0|*zOJ1U2vl^%7XAEKx6M!W>&
zAU&64a2npct1^b%C|NmLc>{9aM(^TiWiOfwsrQf-CD1nXZ^(wOL_e>bfssbhrRY(7
zGyVXDQ6IXKFY-GpSD|U>Ao>kn0I5Z2i{=g8L9`K``Yv|kvC2D@KcOG<7+nTEeF@zG
zBi@I`NS5o=>_G~Oqw~=DXbsffgx<t<+{mewL}g~>J}7+@eN58i1x|o*q|rRI8hr&l
z1hervI)OgH23*45#*f4GOZ*qj8!)y7=sI*G;MTWc_8vt~pu@NkHxf5-!)&=x3N3@W
zUFczW|9*4~FTg!`4F80CSd*XZs5mOl%AYC~RF77|2zR5Oz&lRiJhXu~aCO|Ze2~9Z
z(=>4leBnCuEp!b162|d+nD<Z6-*G)$e;{8Z+bSz6k5%4<v4|*yTG0h)721S0qwCRk
zU{!yLj-bEc(?ka?U*(_I+^9KO`6|q99L<EWFNW4jpzk|jmG+@gxL${^v|<Imq7|Qy
zFU0HdE_^Q@#c$#_iI#-P0QoaF!oAG>j&IgzDs9k{3kBi55wrqrfED;6%=TB|dmls3
zqnEG~$8iIE(d+R1r(_zL1=n}UtK|3GZQL&YjOO;q<C7mwp04af0zlaun1}1o4`3Gl
zid`^<6uuH)gZ~3YK1>d9W=`TFT#1{(E#-Q+JGgte7r9^XgZ$(CTbg;AHJZnTHIrYM
z{AFc9<;#dt2`!8(fikFwS^$172WYwq#@7$mAi5ddf_9?20bag}_Mpe%yPrcZq2Hjl
z(MPZX2!~<JSHRn^2B^CY-woG&_zC<I{5*aM{{eqWFH#3rk~EVJ(n)5M_2f3V?jgs>
z>*RgT&#mRQaYJxD$Q|O|<Pp#F6-^Udb2WEr9@V}qB!#)crQ$1R#wY40dM189i6*_1
z7fs$f`IE^%RhCz_!1!aR0cByN+hLUV0SrD2*AD;^51|);cK?=*^<zx11|VL>5rBpa
ztXc=2gXh7u2wwo#GPqXYRdB7rm*Nd@ZNo$OOZZm&W&9QVb#{FdzU^WBeS8S6r|{Eo
z{RY2--@|{#9}@s#!T~hLNP^@@8NRfW%pr@(g>bDWo8amvgJd(T(4%BOIZR&X>|Bg%
z;MQ;h+<n{+xu0^casS{6pW$<SJHMP?&)>?w%KwsogFmeaX}UBUG!JTis`Y7$+GW}+
zwcpe}seNC2M$ih~!llB^!fQfBi~+U!8GQG_&yl>G_Emh1#=+k}-T}Ojxqi)dybNYc
zOO|pQxx2YvX)ebnIR(FkcXC&7S5>~t%_e{6HsR&uIb6quG;Q4F=q^;jkCQ);Q{+#)
z6E7tn;3WTV_$ji9>m*u6SAWer`CB!>m&k8X8`+A-$n)H-+^v;oQJdyL{Ep^9@=K)f
z$B7-i16aMCd;=c(1-XLUiB|GO&1rN6%=`B>H^6*PCwJg_?lt~F^ez`6|A|lHdx2^k
z#q;?nxrCJQ<3MpIa1f2-0o0Gbj#T^%ejAS>j3473#S4iMR%?Wqa0{@$qg)uj#_3TH
z9V3ntC+;RE$ujOo+GAV^W1tehLN{U#=K*%6{wC2E00ZtJ37~0RKuvy)n~;pY0rdXV
z<c}!D*1Vy)6X5J2E`u&adDKf@Ms0u_@4~eb-Hw{j(*T2apgj2|y16oh*8$yM1oV@j
zQG6xJVFOT0H;io?@Cz5I16sHm-uic-|33$+zX1OQU5^#OtTB}2Y0X`H7f_}?pucy*
zwGQ<{?px@q+Jl;3qs7>b5U)%=2vGhzbP4dB|A6;<Q9F!p6?%xzz^E0V%meVmw<hNz
z6|URS%b1|8Fy`ri=iU5VpuG21u7oeV0(jIy;E6AxD=ObWov?NnR&K4_iB?x0s$7iL
zqa~Hcfc|c->_g3HyQYUM*QEI((Abyo5#UGv8{Y|ZdoFql=ur&I=+AKd5XL`U^9<U_
z{}yOxN9C@{Z;%t_qYh^1QsAN|(ADTKFmH3YF;tj5pX{y7=K6s{y@M{OJX#51J=##&
z2$c6n=wU$vv}XtfH4g*q-pOB1@-W^Ma^W15UaZ-TkUDeOQnh3HdF|8M%B?NUrDCC}
zF`vseWYYDiWFj7mM(V;!C>ZejydK%@a@cKF$znDc4SJm@Xf-@XFv@gAX7?#0@xBp0
z9+^A0f#xG?pkU281$`q56wUs8n-QgtHB&y{QiYb6|4U1?+EP8+5=%-uYH!FWT@hvE
z=&Xn`idS8*64GCp73on%##wq1OAoWO3DV&(JfL*R8)hjZxKHUCnZ0?#&aS>$(A{2x
zzBAH!nZ6-|_Ua9gG(c*^9qHeT-P18k5O-JGUV=mu3~Iz1nbkGoiOixS7~x`FYu1f)
zU$C-kmM<LcX~>M=&b5(CM^I$uh$YRMpicIh5pCy)z+R(VLB9swsqD>+?YwJLLYMZX
zjq4)o)?B=Dgj>@?-(gL|duNTfZ#*G?mW9r3oh!GWTkGR?cF9*LG`n->c4cJG1uM_3
z4b!lv2l^NxvDtk)XTyu{f+<|EM1gma+j>@x;M?GZ3jGfHP1UcvEYd|w`mR()bdi~n
z4Lh&wgN5<#96=Xu3GefI)x(wJ$lImtT)Hw69_jE!de+SH?{%P^7jD__Q5DbUYZ@|p
zC2MtB_nIxWgwb?v;<B@KEXA7B)Pf7o&MT%Pip&FW7*W<LFp`xK_@-7GT-J(qu5E>8
z@YjRksgZTC9#@R$I{S7?ZBQ=J=SMU#DWdHB1i|`8#y|Re$(mY;HYR<7Xp%z7SwMsO
zsq{!XJyKs!0YvD86@@WQXZcb?X7eZ+iS$bfL@<4*8|HRRPg@QqKOCmZd*`T%E``j<
z&;={2c?DhS+lSO#x@Uy+(VDTT8s{=vGc;9m_VK<5!0`d5r#MH%_}PDp<g#~dXdA(<
z|3~#@)%pcXA`329wNmNY*;kv}1xr7dtJb%kt*fPQwE`x5gpa{Y&5Ho&UASr`Er5Sb
zY<8sUioUskYB0tTd*@2dM|!F$;^SCX0KXTX?U`m)8fjmAOv~VZ-KZb}0J9RT%pQ^Y
z=2pWVeK`C-d}y?Cl0L<v&mOCN(@0zT^Z99?%YSZo#+@7tn2(bMOIPjOssCKvY#>%U
zcg~I|vv>CGTr*l3x-_Clk)4ORmE6jm{at-i%RgFq`cB`-?7Mp4BR1eR0BwS1?v3C(
zF4(K$JC>|kc~}Bf^p2$~_Yq7w`)2m+jY8eZ!wS%6R!V3oEu<NRW`O4bR_r4pYwtU(
zA~eKmc~-#kYez9+W#UvBMr%h&wM?2SBT&Xy%T!iI|0t#CT)OgH7+{Fi(?GdB!G4fl
z{2Bxrzkn9)CHNWgV~~dh^4vb8;YZ1j4{%5?(8NKEJfc?f9MluU;S|#0tMDaAPD`J*
zPqd#eooZh+(T+MGEuDd&F(0;utuY9&pGRjDZtRSzL8n0q8iT>tA*B5nw9q_$NqyfU
zV>1%nW{)XpNm=UoykI*IpO@>AH{lKP)wwP5H}L(rm*uzQ_wk3a$s}XFTbrMq=bGi_
z{2ZBc<r8u|&uL{%-tFenC<VD`sLfrLOP*4`qiJ!|29TgO%Ue9x=69kU@@@J1&^Pkm
zM~~$9G>tU9;(kdUYx<r0P5D^UxckrYpFPK$K1Kg@|5rXX7teFg&aJ{d?&Y~F-8Xn%
zke|=LF2A0CSAI8dwuF4TaGetJdBb(tkS`goBO#v{jz}S&D;x=je2H+xEz5NXJCN)_
z*dxoM<Rx`_KIh2G?tD(p;T(+J?e%!vL??;}<@1T8n7;@X#gog{DN1-xcqBX)J{CS6
z)`lNcn{X2*v<s7DQ7l%n%<^F4n%~K3nE5oF`bARjr@b`MZY}2~VIkTjc6G4OUB=e(
zb}^gQY?Y2cEVG21W`B)&+}k?<e`uf=uu=8pB!{sBR|Bam%hs|i*~&<i%kI(2v4ifi
zJMSoCcoJ3b9^8w1!`SL@y9xzoxKwBY0mNEN#N&}t7~`-rQYUDg|5A;)*%POHvF`k2
zGQT|Pa+nt^0gdA$d;$;URzzL?Sa)t>EWaY+n)rmj?#$+`q54>?s0?zOS0w|9*y;bx
zv+S9jXDfD|z7r-7q(4Li&E3d=>d3skghKye6s?S@0h5U=vzbI1nZmLpk!4}oVu8>u
zbGp&WUk=#qWEmumAD~Sj@%jN;4T)bIqOEl%d9-qhwSvSSSu2?~r>!9I`a#-CRz|r$
zs_w<%P2p`}E?l<>;Jr_awJL3;9j%N#MLW>eY3(T2@p?Mld$d=2yLTMt=u#Z5hSHH2
z(rGDu1Xd>P+pDGDpqdn$Bx#q0SxEaiuwX$gF=IwGp?X?cw98a2sI+^uguWE0QMgX9
z)6e@<_0uPHx@g2iXv#z^76^?d6NE7QlLu%iBtAVrD`?46v`&_z5v#3CM|Ko$mOKh$
zfBR_1(cXc<DgdR^KGicE#eLEK=x}sT^kh_{M7yIzr9l+Nw!f*V$l}(vYTS^o#*r9{
z)vU)`lv6?b{5n%AXqz7iCp<HhV0f0%W3&&$r<4(@GYWQ_eprWfWey(M*IA;GYUwC(
zR~d~ak0~mv>9S1Ayv=RJVHtPJxKHkvhvhx;Nm(QBi|qR@rC4m(;}kPaK|Bc90@wH;
ze46yh_!<03?UUdS_YU;p!JZ!6<Z?Q+k-B)P*lf2tTrLX8P0dqaUMD1CI8{GwT77-{
zv@d!ZXH0f>W_>y#==CSf*rB<bR<zgGPn!%+D9g+KXw=)j46pfmM)6pp{Qx0W&}57N
zwJqFpRhU)NULyr34+|9|1vV=SF$<vt%0n(1#z!mfGiam<HBBFghno}G5DqhF5AzJn
zwMHX^Su=&dtjlJDkS;cDk)?o58)YdT&<-FmsY<L!!qyNU*So#3BzqB*C7<E`h~lUO
zkZx;Mb<jg|3yOP;Y-mP6fI~W?iQx|S$Gv(j>KIRtr*i-^>2YZyJvKIGwE;=WRq4;$
zaF4wJFfSdU6OXDBPa*2Cr5q{~n^wZ`|25s$^}~i?;{%ratq<7l5A81R*XzrkvUjz#
z+PXTlQQBnP6ncQ@J`9eB$dK+9^9$SymJi4WmT~J}ZDNPDL+%K*Djnt7mO=e>7BNTa
zB_*cBbLCdtDhW<$8NN_js_+qM1zur!Px?gC%(Ko7{Z#i;{eS2+Zk<aC1wx@NGSi|p
zSS@yw*BGz_%^~d)ZW+Hs(<3dlF12etmOvmFT0;05(&n0Fic|`gIDMi7b9A#28*c&t
z)@wZpqY+*mX1EwOQj`nBq`$|oFiX*q7D3{l3=6Z_a%&9>VZO#_62XKX1@ZxyNT-t#
z3w4=f!Nh8_+a*uP8}wvT!9=1?Pjo?jI2DX1BF%~1j8d?97Rn)mU6P_o$f01Oge;Pj
z$Haj#0sUJE*)g9W7QH0N`WA%Tqxd6rp=^A`V9;v;-aQ^!Z^#>mjO3&dA2S{|l78cu
zkr;Ds_ih=>-cT8r!_h2?=5i=2Wk<4O*<)EvcNPz2hqENx*IFLMH|!5T@&({P=bsuF
z1jZ$eOXKHDgOrC!r+R@OQDLISz@Vz5-9tawRxVS(k=on0n}La$r??qSAZQ@h@K+kg
z(pWXzPV0^cLJ!Q(;NZXju&P1eck~Yd#{-6U7)gLO4x6DPl(dyG+yNB;FKH<gN@WaX
z1C6X@OEuC}BO^q6t&9z(r$81MVGp*pG*kUMo+yQ#TCE`1U2eE2y#R7iOkheq+?0B-
zcGlt)`B?nHe4`kS<GU}sdd7zzURsxrdZtfy#(l}jKY6l?CbP36PJ_j)c%AiDENSjO
zGw|9ho6+b95Je%`X>U&c_NH*otdB;q)9x<d^^?bXT4fxKS`F^-1>DTtb9~lFKk&ze
zl@r_&ZUi|{fZJN5HA&Isa3Z4x@E)02WM-IbcIH9WR8StCLlQOO0JpI_pcSRDRx5}h
z2pN1atAGSaAOfwXPt(Lf+73iV;G#4IiJw13X%63LFi?7s24wH;7-t|2Yrz=c+v%~~
z(Xqz-6weDdhtM80f;c(^6@*kai0T_f`Vuutu|*OTVMG8Cwoe!m_6WT2RsK8tKAxkm
z65!K-xT$f9L=HzN2;WJQh+!Q4T8PXpT4Xkdf>jio!m#wwV@F}Ey+?X`(@kuwFw&zi
zKGkDeE%$o*P@m&<PUBJhWjEX|)n5+LQRzG97sXJgskfPC_a~D@R=lJ>Tl8r?x|Q}z
zT&vxy<cqul=5$&?CmJ=*dD<Q1F70;XPU*J5cgf@OLHlduP0L%-De|A3-PR}ciT&_(
zJ9Ix0UbLJPL>>#KFB4ApG^p;{%5immvu-w-qgxzWN|x#_C4*##eTU~h`}cI;(~pV=
zbtC$pkw1~+##4HScuc@ZI3|z*8q>KOhDjR{w8B>2f$}aV9je_{wykz<bMAJ&<K&%A
z->-QLD|l?5qYTme`|LD&L!E0Y(>cD_hv|w4uZXUsuWWJQO|EUOT`tab%HbFiab6r2
zNnYF~z9VvysEY6<;)r-$)QUeaJ9)H&!WEZMZF#e5?lyDCESVKEchZc_bR;^MOLJ$i
zb3s+s9T*&3G%?UFO#owtXuNj-&>Yrikb+ct5QN{}&XxN%IRO*XR2czUGB8MKV=roL
z1pya#t~{Vcn2>=UCc7~79b{BMfVUYUWuw|qHo+}YJWrN|YDDF$eZFeWSFNk%^wpfc
zn$xkIYSxvVlBeuZtYs72h*AfXKIac~GrJbZLQ`{#TML2(DHUx65He!nI1?zeZ{c<8
zwy(OaA>{n|Hy{4+Z-?%GVPZReOe1;LHZQrAOnc?pYuDc3*zpI9-~12@FaMxzWwcej
z1tf|2l|N`KnyXM06LqF82zmy|ak<dFmivO=wS3oh$nuoUAO^9^jkj_)Id5=%h1==+
zHg~W03GNwAXXMO03C!hsI89EJtWh5t#hQb}hw;;}Mhgxp_iK`V4v&&|4qDSA5|&1}
z83%WncAJQ4l*_3(hmJgfFvd;N6Hi)k$l75gR<9bzab3G2V~ZS;iOeXAJTJCxZFNO^
z2Nwb5@BMUeVA1%g0a(k4fm6Mw-s>3u=oHZJ@l)f{OO5%?Evn-5X^le68#lyVF|AM6
zfQ(KEM31HcR6-Ldv`lKCf4AI%fzA)YYTF}hGKte+tIahZQ4%1<*`kFeI{iR|`Co=Y
z)8Bh&`&(N#kAL&aKi?9%eDdTolTRMrc?fqr`?X#5HlM?5&|EcHc=gbZ$=BW)o&0!s
z;4#O+$Nu^BnV0d>XXd)>zC6`Dx`47C=AJ|r6d=YLW%WCZS}IN%jZ~DX$w!jG0HK$s
zLKm&13Dr&udDe_~$3%k^1C_jEyrZfa)D(lyNTZI{({^6^u#eI&FYjQa&0&-%Q8P+3
zV}#C6ss@_m`JmBQC2@czpkIJIFC9&@mr$D4WgBwhM_q?p&*PVLM*?r^w6;I#@myV(
zYlZVRe3x#A<xQUuQkzOVBW=4w_yy-nUZRHZJaK9?Hl9L%8hGhq9;-Y)M#FBtkMHM)
z`4L{re`HjlQZ?=dap5dh52hE5Q#?&C7)dT!Fw%X&s=dbGyuBfQ-i51HK8uW%F~q|i
zs*JU^w)S+c{1NhUO^8PhuIU5m1K&AW5EXiA9|R!Nj03iqIZk5!xIU(hTP+R+1+Z7a
zE*+#~0aA98q+lNhfz#ktkVgYSP5zwvy9EzoN-G91r5>vFI&z)%M*WTE8*MkZu9L6x
zi@iM{R8Y-X=a;NyAKXAgPwq8Pw5N!U0n$Kw04%4F*WB!`(`o@A0Ukjfh!b?|i&t%a
zb=#{quHX8~lG0T(cYkTk7q6JZJ^A4FCvQ44^zfbk{>6V>KcnNpn_ry#{ht4I>aISz
zXKAXO&>Z0IK^g97719pH!$GT=WT^6KM!L8x^2u08YtbT*zB@W{Id@r_I0k=XICmC`
z4x>0oKC_sX=cl2_LXcU3tBTc7j_Y`oWSwux;0(GhhGT~7k~nFo_MXW!gu~f}8dTAD
zb@X;nm6pA%Dwwiq^zF4}DRB5ZO0I+=Db`p*$*#^`q3h3n5c?qc_t@W)M%rMXy~NtR
z=nECY*=%ZEbHL*X`65!5*T)0#OuQUl=6=-usQhSLG{jn>Es4cwAzmcR6X!%{Cl)0a
zrS1@hq#^59Vs|9(NDXE0m+qmBW6wy3V~3N^WnYZFn0zz#X7X4zgfzUMb@FaqOi1XG
z+EmHiDRo-AH5UrY<qK0g47;Q|<Q<+Jkvn2{#D}u(?Yi6D+vA)`*MqN@uD9|!ofwZN
zVlh1yNDxbIYfw@m;h=(2nIN+0%|T1Z6AS|DzkR=$Oemw3t*R==qKYVpIw6`$I#Q`5
zQ2SUSFX|kksFR(t#~Ibf9D02$5{>3%k3*I{sd&UAyXiKK9@gO*{1H-65P!5kge_K@
zlaLvtbG-#5_)thu5TS(_WuOU0TKO4#C5j;tKcZTaDhxInO&XLlmdo^b6z@GShAvA*
zMzN?mRbQ^#gZFswvz}Ky?|3-RSED(36#Jf1EHNy>qEku6U@XR-!4jx`PP|?<s`}jO
zI9B6BaS{g=;ec*yA}2nLeegP;s#j1F4<%0~Ns@|#@Mv<6Fba?Px>I;4g;7dMDJeBI
zk{U}LO9`pIhR1i*l=E@m3IiVR_{51*z~JRm-f<6Q6a!u;fNJ@KcU(F}@9~<F;H~Ni
z5J)w<msCwdNI`JBCR<e&sMa9Tgk~x+RgzB2h$#&J?@*A$cCo!`GNWcMJjkpBX+Zyj
zacVM)0_yLF*gjf0zAr#6W@jS@jZW@!mt!<?vfN&08J{Z?P@Tc)aNF$(fDEQW2-W;q
zl|sM~4o5IRo(T_?!qy|t7v+Sj9Uqt*1ljH<jzk%USEMF?k$QLXli1{2f!22Jo){nW
zhcXj?!~ed$-EHP#G0rVT9L|Z4@#$v89wf1t>54NSl6ezPab#Y>L@CU9z|t(5yJ4aK
zZOV$~u6$axq5)IG0%o=a%xnvo*%mP9L?1Kz7$p9DfEF323}r^D2ry1KTKWA!#tb#j
za(_f3+yb%#)iT%}%#r|_h(OItX-dp%b}?poIwBpBUI1b;#R3y{W(#vTXlRGW5E3xs
zfS4)ObZA;OsH$npST%C6MAfuqG`d~qn6}`ppi5V+Sx*hS$J{5~oSTAu$Lu1F)wc4q
zB6jaHt!wUfW7Xa5?sNCMhuwRip<qk}h52<j71Smoj)ZB3J?NMPLlU%lgrg>7ts5gV
zPL-w=hmE+~i2IEF#$n?g<4L2&xX*QtajKme(>vNfGe`B}0Zh3PvqpX10yU*U-sCCH
zne6Dudd(r(o3vu9=I+xombV6&wTV+7nB$c|1%$O-S2;m`1CmN3U#!U~iGoVkt)NmV
zgkWYJ#mqX2Ek3W9Fw*iw*h0;nw9Z1MjwV`fX%xhSCCuB>8oWh=H)^mZmID#6UhrHW
z#A|~%7*o8s&)e@MUK?nBpi2R-&p`}PFW_beU1E@Lj=pwOdX33A>9b4R6t*NpzTOqI
zWi_O}QK)v~u`STxt28%hh$dDq%nIUl!E1vg7_%8L9pT5SmoBcwQfTsuX2#YMHX0=o
zg{G=nmp)RBk5KKdm)_EmBfTBc5nCB57|-&lDP6{sAvRl9HIy?+Ls@q87+1v~knV|U
z^nyOAPxTf03qu91r7(&WbvuYeFPmOAABi4`{WkJ?^v%qB{Cko2q90@owvJ41<_is5
zGrRCEvWpvX4ta-sL;f8NyRs$=wh%oC-devt^J3jg5z)`N95%lz;7R#1_v!A_KcIXq
z^0lbJmNq3b^D~PJs|z=zZphqjek}52;eGBszcD2?2GO&?fI>Kj2~hR)KJ;vM6nj-`
zy&UvB>kE2AUMzVPm^oVMdDcZM>uk1Y#AM(t2^MLB_-81at8YYzPOA5d9*;cA%~l<*
z9GzJ5iVb7itKoOTe+_ftQO=<n`YpK6(r+2IaF$Wrta=h&Pc|fCF|#{?`x5<$p#-NS
z@(Gf78Y`#?D|@T59)S0v@xfC}gPWkbS|tp+S~&*<bYBHSl4^4&pdN%cO2<!BDLAG9
zNMHJBBoZ|l943<iNH-(uJwUiYSLhvN+CnwWl2sr&kX3Z1B1-o#k<gz^g%ruE6++gq
zA8S*hA1PAMkA$SgkE<HQE%1k7WUB78@Tv5v^>mW&?ZJa+0MSCvZoHf9=5`zIHw`<7
zy~Dm?|9y4ei0p1Kf*6>_0|>Aeni+DDT=dS&1JMUEn%*8N99ol#r>skQ%2?Hx3EaM_
z+URALdwn?zMHzPM%0?+@>o6-cpsd1IW|5~Htt#J<Y6QgO{X_P0Mz&Y`vQ_)C*x(g5
zc!jN;QEc>?ld8o6%`9b3GQoRHw1bnX%>?f;K^wSbE4x3ZqW-r(n42EdOUX}Fs{+2{
za=WXB@dTwo5o^KaVq$GP%0%6&j@8^khQsmeFP^<z39bI>%g<i7bYs}*Hig6f2QTef
zv1ao34Gj<6)V!!*m25`t$;lVLcIEtr)?_L>XYF^k-WSw+@tnKvzM$N7$#7eF#lSb+
z7PCwxV1&5;1pd@acGYNDpjD*?CP{DAGuEV+qcksjYa2CxpW3K7t}>&#%q-z@9C(!)
zsv6CUr9=Y`^UP3QHJvxew2y|-%0C%DYnZZ_H%wW~A@PxFp^rDP{u;2tTW08it=Zs?
z!JULVfr`N5EG5R_O3f%?4P<z#-_?xb<KrKFWGkO*5+9R}ywC(<$rS$s?spFFTUlhh
zuf#%lW1<M1(k`tDJ!5`)E#-82#t!u|E0S4}Y^-kTw6;vyo>_626^9$9m}LWH<+K74
zXBe|=XlQNu%mQ6AkWDep9Ozus3|%hQHiL4lYJExH+6Pq860^jIT8CTtk=C)+W360T
zi@RI<TKj2{+KLrXP6e%_oJF<PHKc-x`E~kKP?{g1_Ucj2tY#ynM0Q3oSek{EL^EPv
znTW@&R!Q%Xqq<=|9?@fqzF)sv|EiwXkCJEASOW@2v!RCWhQ5aW27ahvxPgo`VALQr
zj5Qo<;2Zi{9@)ltEl?wBC7P(lQzmB+C9UOhjrUUS3xvbr^=m|J%oq1-Jbo;QULoKI
zhAg$$><xn;3-%6BAr4!c0q|Xb7<9|iRo(LZ%+{+F&T{XT&#~`Co4z#T{C=O^tk0{H
z)17LQo(s*&H(oj4S)M)Fc3#9GTS8uE&WvrEyC*Kav1|Fo>JKJ=v_g^nQNT9od_3#k
zOLE1<lm1Jxp=i{uZ(Yuv_wBh=o=?!c$~d<JczzQ)kE`vAs!E4SVY!3xey2~!f(8$K
zKE})xF=Q+-+W|#@f{Td<AiFX4U!d&YNx{Fs+7`+Ji-iWJx+yxkxl}+wK9$KAjjE2?
zJJdjchE^Ms0bf&tw2{%sZ<DdiN@dnUmSRDnJ;S3MFaT;Ju7Vjz2on^%UP~VZB&nK1
z(qm(9Q?c;1s?4BnGWd5Eh;2zTwke_VP{(7sLwe4ZwrxdQ3%8>?4R@Bb0h_B$>KN+a
zb^e8#h1xEqt8QVN+OZ=b>dk_J>gM4E`gw+Vr3EdWZS&4sVOVdtP4{K}mkpMsu3KFs
z)UmpQ^oa#jY|o||iqC+iW2DxJLqM@XK&T3LZ6(RrZ6qoLeMU}U(PkrWY?rCYG-W6+
zmRHN0WG*LflZpJrkc8<M=iAkG0-xRAFw{UAN-%Gf`&xNJcB}z6^u<uYWHc6wF!5&?
zeioj=>roWN=o`&t6br?MV#6_Bjh&2<A<)*C@*aDJbb>JL1l|xTJE`s!^ySKpf@&@+
zLbos^aFT#e3b<RqLg)0(FHA9LYL7WJo|Y!kR2XfaNKYwMpY{TdoSHb%D~%6yj1L0Z
zq^;%ZCUCAwnf7r;3_JpOcDYIo0Cnb+ruicpdrNC`E79siy-2j-I;D<iONO$7tO2_p
z+3c2($&c$I(==s2Y88tLE)@+nzvRc}Itbdd?S9IfU=YBDAfR|xUtdpI^&l|a0fvAe
zO?24k9!zi5rhA|fzBEf!FNsBm%;gpZzMZm9BaM!OyjzwPL)i_tpF+FWP}ajzwj^n+
zhgc7>4r1MZV~&&;#y~w|yTX9VEx`7er-OTHr<k%oMh09}OQVyPCqVe1Ivx~}IbVr3
zpSSv^VCv<MRxIg=#Yrw6%Z=>5@%(9io8E1ajL!D{%NyJ9H!_Q7EpJ`;<*TipFJ0N$
zIO~Sx(H)o9)n(eUO~r=g!>Q2B^lg(b-8#)7nA%(Ko%J=`+wRHqmFKRe(tZKZ{|0*Q
z1N}tZ6jqtz1H=2Unk;$3Ypm;<#gLDL>*SEn7OwMzd^jA@g?!d<#AYP~i?WAM?DvQi
z;XOQk)KjPH7l*{-B3GdX{%)~P<W`Gg;xUmEnMNowt}9ZmOP>|#c5;BeT3n;_hlj$)
z!(2Yx9qtQr)W?M|R~7&yx*-oZKLF%-(F9#@rUg}rFb!kpx|e{=5h<PHT>`QOxnbg&
z{L;8=(uXqnJn3p&68D(&N;)5l#Tu0xxsB_?9-GY4XYOHX>iblO5dR*`P!Oe2E7_{%
zSD{tG9q5kWj>3K3ZzrDcK9Tsq`{%@;a>iD4V`59;{-*m14@ZAcc*FZf;*F%9ZyP0l
z+HYCk+(xxLe_fHr>VG)h#ey2nK;Q`$o76}W0$-pwD>^H-!}}(FJ^EJR-I%~fam>^t
zaZatz>j=7{uB0=cZR(27FRs8VJ*yJ;603xywq<x#w6CqdZK!Qeo9NAZo4OGouQwV@
zdUCv$a6xx)ap8{W{n0lIg3_k8b+@f0Yq>s6pSDlv%Wu|R<Gse$AG|htP2$Gnm$kS1
zZV&D%47L3{_g3!1=s%;L9<l1tRP|pfL=nelP$?aXa&@WJOo7YRB}*lpE0qL!k7Sdg
zs1t|dI8LR`wi1hG(r9RZ$BZJ)?(dw<V$}iV3s?KGKA86t|1v%uYRxp#3aP7PQ~5nS
zK@c40Ic7N4o2*5|gFJ)zQT$6ameEq+$uO&UhH;ooon$f7Jw}T{vz7<TZ9l@lL}9cB
z%ZP0!1JEp@dqI>q^$v8dJd7H-h7Wu!8t(zZ(N1@T2FDo=Q{NA2IigBNIX4bE2GujH
zRdu7r`Df&ck)#~Ng4gHq5v?{JjgeR(o|NMSoD&)gI1-E(xFT*Wa0y?kfb$w)eX&3t
z@V_RmRKOSkv1&iprd(fDF$VD9;2;_tIBRf5)S%?58H>*WbPDD`N@#hE3E0h5Qe&+N
z+f1t9_I+jcnxS{zofs-Ci@5`dMFleddu#7~@aBn|Vynwv{o46IeR^H@wF3u#y!@xT
zrmyso1HqXW-*(yIWwGYSAh+?0;Y>`9K6U-&4_O4E<4cRKf6R4ylkdAXEdJ_JUPGx!
z7;uE19BaV!dy~0Q98_Ck>zZ}EPCt_4zL|bH{X+Up?$_xL_z(1_`O|t`zouWiP1q(5
zX@<1Bgk7R2=yml(2pf%~IIfyRpAZQ7+~GQHm=Ic$()hGy27SShFCLDhGfBN@<TXHm
zBCzuA1{8^-q(rTW<kxB}k%$wQTTG;rPatYb%%{{;e~M2HYqcQ(FBb4~z|%(YK{boa
z42aAOh-&-Vb-@5r0RpTrz-U$A!R(samJ|gcMtvwVq+D-c;shf^(qDR|iFSY#5EiQ(
z4gdw<1k}xs5U|Ty+?c03jR1exN+rL7HIgNfNR31l{yPb?(|Y{f|5~=#6pP_R*R1~n
znw7~nPCQ+sWdMlW-%Js2*JW2~$i#;WHcgfm&yP(m|BRYVQMSp~SNA08dKoImHG5&b
zviR1+C=VD}pDX4mW-3t@t4m$}Vp7|tU8vn+;bW0lqAAjp=!$eD9!?0UL^(ma^Vb?~
zvfQ6|F7fxcw%uIi5uuRJ6RxXgJi;FG$>E4cmSK%ZENRl!r$#G(V*+A|da}^DWeGaH
zDeAl^>2#uMEQ@MKNfGlR5vd$$bvS@67#W*jn`N~0P?d?Wk<RKUNqO9#-;*E7AJ6mo
zkiu3}VT)IFjZ*4twrzI2$&T%8VeMvGXAjakyC-+*J5vkWOC3zu+MX}L0)5KZ4P9@k
z#%{)|IzW}>EVy9H-WCyPKs=n(TkFD+Fwt6KiCEOEG$6?uH>Mh}K_8Yt;Yb=FNHc|i
zJzdW*958x-VmAJaPidJD5T}Cwx$G-Q3RC`M5$>1xc%eJ(ykPv5-@lhvx+p3amqtB-
zg}XM~_Nzty#3D^17V8WROuY5VA0E2@OFf?u+t%}Au~Kw!V(;Qt2IpUU@C_2%revzV
zwwgBp4m!z*I(n1&$7Zq-;ce(Ta+7&;eoN`b=I8WJo5ZUTw((tA5CxjaGIALiB0JP!
za-X{2bin*{;pxubn10)2vKcUECR(Ctx)W`0dJsK<_n3d#BpMKqIHECzbU{-+is78D
zL$_FW7kZ)iCi=K&(HT63JT8%fI#ccLdIW!$Jggofhx8*ekD}k9WB4`lI`<*^5TC@K
z=ua9yHp#Ant5|Hx7nkDu&^@Mmo4#Ju)wJGl&Qcd_4|dIRB4?hM^N35xE{{*v%3><+
zOH4};O3o*qX91<)0~9^Wxruh4TGpBbpEgKAwl2p!cH3v1=WEySyia4HlqeEnUc1wZ
zZN6z3p*pk4VK$p)AVdLoX};*l=ZgrNiZe7_c{HQQx0x`Z$7ck=+;4u)Ow4hC7X+8f
z^Mu?!ZCWy!IIpcOm5M)+klk*rR+AtavHfejIiJt*LmJ$#!J1Lhsv1>Ow}}jy@Q4YU
zM#(?aOwPif+rpsR!l2ty7YZ`44zj`^qgTNPXLbDuw=>q~nPPoYgo|2{C#Zu2Gohi5
zj+y{J(Jp;<RWmR{y*ZdGYGk8ZCFX2;YF~u<2v@f~(&=;dKx!H0Q3W7AFi34>xkAH?
z+{}hfo|?g^y-VLLyG$K=#ZhjeqPJ95C36{5(Hry?DwDI^7>MT7n`o~zC0|o36WzWC
z3W{r<Qf%)7|9{g@hC_fv%`J$zUa>MW5wrqXhfm$~!xa-ZwH558$qW+(vlBl)M?{>N
z&1FKe<2sz0?yGMK;g2(OH!O4=Bqt{=H}z;^v4kwgi}=;a1)rm}buvx6C3W588v8~p
zU6c&EBS5=d9kU&W0qau0EuR9cQ_zU&1Nn_Q)nT=61zAt7Cp(q<l<zBt6(g=2#doU(
z^Sb6`<l-O!nVSpOxmtYI^Xl{=pA?QLp()R&Kl!Z^@ka<J0@`gPqvVL1bGaF$xEWBm
z8Kk)DbUHl)6+J7}Gf>e#7+%x+8EdPOx>IcTjFP((z2!0^cX%+3d$F7Q7tzBR*J^9F
z3`(Q;d&AeBey^}R=JZn`<MNFw6v^0h>)LO9aRa_ym>iC^D%WyX0ri3Ts8_d~d16V(
z>BwG(NaZy3kkH(XTqufvRkcCv4QeP4km!&#4kMEF%vxupY@@c5bY^M;=?vp2bQ?!C
zRh=qiH{yxTPB*=+XLpZ$F`XgYL#o~r)VlVWv+3LEG3kZexqcLJ=z@bT;5qsXeKx4k
z#AB#tC#zb{j8u<dJ4U0GzdXe@lZ^4$=bgol*4|fh#`LLMq&WVb_K^0V@aGV(iBq2m
zC4L>ZnZKRe&OgFEE(&u5+$K(K7RhcS;(ab8h4I;uG=?<88q%j3(mbi*G#?sW2+2{S
zQ39ILZyGl7LlBIZIAoGciYX7tG1D=VV4_~;?IlxR?58!aDJsS+s^a?uh`wy3gB@0P
z)yBo7+@we03_@Jtf(rKPWk2%B2BTkuT!;@V*kkbdQ9$ccsGAK_!E2T;;BTO9SDmD(
z*~{q=s#@-pU8`WVP8o$Mn&N4<-T#$eedo@{yB}U|QDlF;8QU8QSC=pP_P5uSN=fqR
z;lKUz)YpgF+PH(?V#ce9<iziq3NJo4@~qEMwfmB%xF=B(ADr@DtY`KsZOCm+Fx@jD
zhp?5IZ>=nEWxJEs(3HtGG-bqv#9ve^1*MRKTDd~Zf(xZ*R0C^>B@P%2b#|6foO)I)
zPHakSOK^##AR9S=u%o$-w|mE>2?_z9cW9<Q{L<%*wh`K09G=~z+omHr=s?!ONEx76
zc?wl@jQ?bS7NR?-)c#5n4B|qe`qVidz|s+v>o{8T{w*_r+oTZ1(nOjpDp4(8;sv!H
zudc_TR8UUTSyMsx?U6)6nGp{rW+A<y-s(^!%*#X6onA6xV-Lq6L3Zm`Yq6@u+H9yE
z*CT5*6bdPLNEucLQY2+W8B>la8l^Aw$XRPq6|x3T3{)NIrSZY>UMt(NDVNbX4)vhu
z(9Hv96-p?OP<Rl|8cF}vA$H+4TUzE8qmdO(o3kNrH_e<rnVwze(Q7~u4kh&1$vydt
zUvy>?&0UVvC6n_OCVbIo)Fnl%-FWSu^ZeAY9^l1M`5S5He}a5?q6ROqfNFzf4lqlI
z!N?5!MyDNX>?~<#KwzKRFR)XnVPYgT4^@RrgP5_n9H655_R*gf={P!Z>}YQMNNxS!
zo}w|I?PGe}M!JM97CO&K`>01fO?amg9_qu-wzT^V*kJKt=M@e-&w<(NR6o|jyA3|9
zVT4H|QV`KF2-4WAzWZ7>QU*KrDerN+J>WmbcF(+8J0_0x_KrzMr6avlryT&bK~FZp
z0A?7=tMO_=Is*4u@AEw8e9krMdEX=K4&WVLyx6$dwA#4Z^ogv|%1${Ub1tXs@p703
z4&NTkIrFvAa(U1Vw8j!0wCh#pJI=p4Ip<{#-z&&KeabVy1C7~SU?e~SAVu=LChF+6
z;~_gncF8_sAG05`AGd4meg3n)A?-C0ruS4Yb@4bwEs_%_s$SwybpiwEA-HYjsungd
z*oy|4RleW^6^w016_^YTB6y_K3^3P%=fD1XAsL=-O+<!fWmne!Tgx>K?iBx%$zRW&
z_+iiVRPxfbh1F}xhOq03x$(;=RMi82KLGr_fSc70wY1)Uz5jvy_vI(@&*YDn#O0oT
zZ9nL~+jK+PA<%ty>2%SMFA%Pag?#C7L}ZXBhRx=X&R6wg4$~3=RN;`;C-@~FD7~P;
z1PbWkbe3*gkOr#thBKKoaXKCj_}=&X1ETH;QPe)sA#4)}b>v+vaM0I#YB%d^bM}c$
zI@FMZM>l$(P<*QI9Utdg(p~B=?J033Br(}RVp4*{WCy7(7G>}qWra~DIz%5V9zTq?
zvx9zAYG9%RJ!>|8s`tdir=U-bw@b_o=Ods35KZ>BpH-1531AxWCpFFZ6DDTRof2#f
zQ+x;2nEAVgnT?cfle83S^2cWa2=(HG6n+BNUz;d`P-ZsUE?hSGx|D2v@0tzy=`)ho
zo&GSNPb+S3bZMS<S`yAeQ}QxUmEVtKuboV;^+%GEGgc+sN^bhr$tS4Xww4>XC76s&
z{`RVFr-iPl4<YVP+&!q3`?y9YjB&kOjPni1AIjuF#5mAkmq;r;+=3c{)~aJ&E=RrU
z##m4lGbkb6ZtK$HU8Y^;UDoaK?Zwv(ue;w$yj9RyvT=RP5H$|!uQR;YB>3C1mQ~Gs
zwnNh)by!>D9m#Sr-!{*%SXykI9h?_mm|Rd)+m?Hl$GY3D6Sf()N!zU3T-)4V7j{d#
zt&hsj#DivyMY32enUEB+hB7IA%AIS|OKr<^tD3vprcR+mVcc6<aV!0h%{iRQ#*4C^
zM_Kv}!E7K<&Su-nQx1H&Tt^4}66V1-Rt@PleJ3u<9-!2TVzHz*7>xy)sy?20u~aOS
zVzynboE2M307x!lV5_G)h=aM<rpUGkiR_Bth$oiKmJ1CZr&5VRH_Z0d5-w>pLd+uw
z(NfG&D#eVhL?T}>Itm3NND8vf=q@B;9z$y`F6%jCQ7Bpb*dKzG$Ytp=1d+{Z1-(<7
z<r{EALogW78%J^1!A&mg%Em^qdB5Vp9*SB<sib;FJjXpJJv=SgZ?P3U&yZ$RKmuOB
zuar%UVsSrUa^V^B6I4cRWYPZcQ6M*I3gq;>Qg3<ypuOg6)>}JL2|(V?0;#>1!Z{;5
zHT`M3d23aHq6sY9%3E{tM<8a?IX=NAn(AD=P$IFcbn{1$5=5!p+`io`wQoIgghofi
zBLYMslvZ^uCTL9^S}{~k?$gt=DSv-TS9Vih0Z6~UA7UqEAv(Xc!vwlVhfGT$Lu1wM
zHg{;K2d*GP&`eX*Sp5{lsicMWcJh#=98)Z1{b=QleHQA}ejFmE!kM7L#7d}-L0qA?
z70Rsixi|J1=rhOn*{YG1MXJwKmS6&`aJyBY29l+0g*&4<%l4`loU0nys4nQF9t<Z{
zyR+OZI?Kttqnv`<D!S;Y8|chcPN`P7o#iHa!<*go?Qq-9Igaz+|NeFB27j)Cx!p~<
zGgKAGs^c9!yfbxHr&LTNs4E`JQ!>>;>6Q;anF>b?t{DsF*2QsiW3+ME))PzTmM6O#
zJa+Z=ugz*`nEXxD7hg5@!}%AS$K4b2yX7XSZo`JPUS}W{<K()*M<++OG;-0X!|ZnV
z9yxN6RZfs-RO1L-Upcd}rFu3{n+J(^1^4S3Wpej0Plq11i{q||y2}>krv%(Q6&@)i
zrzNU|68e0awMsX(%${mBd#V*JQNy&=>=|=ruy!+;;5>r~&NCJ=;dtTHa|@@$=Y>-p
zK;oaOhqhg)r`;?}v&Yly@pKE@MWzKU5`C<N?*1C+b1i<_aSL<6piNr{t7p4SEuWL!
z>6Tr!4<*m+eWR71R{K!uX&;b(OEu7@3aQnD49~2DE>EthYc5q0l{rh7skBXQ8D6|>
z)3R;LxMj<=a~kDX#vrt3G*yi;M_n=i)sBKxPyeQ*dg|%$-;*`RL<m9HPqX+1c5?SK
z;jbOKhu#f>Mp(LRxga;ru`=P!sxX;fNizqGG%HKD%wV}0EH`7JLZyEy!70kh7Alg`
z;+Cpx$`T*5+Lo4;3#s%+3l~nga4e*xfz~cu*t4=G{aMe35{#VP@Ck^0^U;nDDntRL
z88Izby7D<RyYfEjf;$IyzViM-uk4X!xwZP&1L9p#IM(x57dHgLRS)&_NSp9*4^~74
zRE|+{=0IIbD%c1K)lj!E6`V7lX(6MW`9LI{3g$;S(}Bp0RB$#V)aj9BiA6J(2A9ne
zQ!R_saw;hzAvS0E3c4_{j8Sh8w7f=`GrKVlI!ce*?Uk(2a9+Xvppy_~6qi&>ODda=
zw&q)Kf6GV<X`yAVMJr}R7cLAf>Rv>K77Z^VXpyvtECOP2$l)q3>RZ_}N>=R;KeA08
z#p`ZkHng)E%_%Buo~TCc=XYH;>pgm`9{xJm|03pcT=PvUqqE*3Q~n}#AV!&Dk$BV?
z_G7c9&Kx_}Ut|zbXECY|0WD$fBL5esk(xr3VEa3Q`!lc4v&F(W-Xxzpja<Op>ue1h
z3d?VHuD^T1yn(RGq;EcNvfVx{?AG(X#PZTr3kh+y&7N#rST<<FnZ?beB@Ld&1(VY{
zn!N1fa>9ZgY4XuJOT2#F>Khg;Sk`v)<mTmyD-?~onU=M)KdYAJ8q$*sn8!&pYP}H3
z8r49iWzxB-8PqY~v}O2`Z)C#klryRPV{$(CG*GexDwDbzElW*f+Iy3}o<`JdiF$6?
zJxJkFc1DZr3UfYDs;Y4nw;3T)&RT*LE}6FRX07*WP}SYknHWGd8#6ceXoUnteH~JD
z^mHQz9Dh4au^jMR8vnd$2=q2U<y_SV_3ROerplRv6pNbll#a>Fp-Mlk4MxY*E<3|i
zyHX{JS~{q|0NbUAtw5`!)|^1tV}`*P=xFEwn4L(f>h1Wf5$Ra%$YGjFTVK>qqxPb*
zG*7xn+F|8y&){j9j%f=r7iF%rUYWT@++y95`Lg)1@PYUbohd(UWud3IvB;~_a8Bfs
zDVrTo&~tm8o$CG(ln5_Q1ko&FOD8!#D>Y*}5+cwsd1P}_V@N-&Cw=-M{gZl5|Di(c
z%uQcWy2JfpG8D!rEY*IDLKE(5qei8wDke=#*^{Wx6g@%jK6`?mGt-^c_Uh5CTuCsA
zv0~g9&&NtalY(<52nxDp1veV9%D)`l8l=Ww;L2RA;B0126jh^ABA%E6_JZpi-ziNM
zWvWb?AqBzS_?%sfcV0YjNB<AzHz%9i<pq<9rzK%`N|B%(!$qC>>Lu%@UvROyGM|fb
z<-ymttl9YG*Tx^%=Cm|SesD=4NR7FM#&z7KJ$c!@ZSn`3B5f<rzx?p82F{mlR9`p=
z`hr%o0lCmOREH|}$$RAEGLK|cCY#aih?r;C@fCOm(&0U*4sk3kLOKEu{~cNI703l8
z2!E`aF#xlUV2w^R5)M6${|lPWQ*CCmMYWdlmTi_{%N`4F@wlHRQG5bb?Jm@gJAOi{
zI!LgM$g?zvX;=fj_E=%+tnqYmmNcBi^TYP`izi86t4lA$ys?@5&mKCxeXy0D0w96L
z8_DnPsaJv_7+U2o_<7z+%!osQ!-#MRRgaKYgV*zO<^l-3d%pB3$}OS{BU}pe*3)nE
z5&Zl-M9{3t30|YQ8--8<Sy03Cc#dhkDXmO#Sj&7#v`pR9A|>ErW?z?qp|q88bhaU=
z$Tf`ryIS4tW1i`XpW=CdI$qID+>ni;xMWv#W}p@h6pQJEOon3~WE9(TaM!r_*xSIZ
z$C%&ZIfl6lZSWLQ3>-%v_4fy`8t4m<K*#{y7+eg`U5r`72$^k0VP^}dtU>WSmrb!Y
z?Ble{wAx&@hRZd!I|huF3Kt+(9POZ92JD=H?=Y~|vHf%A6mwKjnVHTO`*Jt)H*0qC
zL%An&V>v<14dn>Rx$2$iWtwH;()7K8Fjv4zu0=mbzg+)K{?Yn9Ibke!GEEc(DPejV
z*Z_iZSG%%UxkR~KzfrkS*^PE9KM)QJFVq|2qCH`pVGG)4IRgpT41X{%D+G@j_>7ay
zS}21vnGk0PAw$@xP%2<^_PK^!PrA5}YuH6xAEvss>_~IA$bQRYPD$ID?c7$|TUazc
zG1%Ka!I&i7TNs2-K1&j6ra(pzyzw+ICSq|hrJytqK~jh*xL%VvOA2ne1@%%fgY5+2
zL7)df5MtV@W0ehPLg_R6a@D=ct%;PZS;DqcnRC_8I)~=pd;IVJYs+GbB6~qLu{K!3
zE?<LT@?=)qzBaeA>!Oj37p<Rt-s$I`$8#2azv?S_`t672_^pwFm+%|2`pb(qy!i9q
z0=63g+y4tVSAm?B!AndA&odBiWT9EKxFS@T&C*;X5KW1Ufz>>sm?SH@m{YQg8CP5k
z#$8i_wQI_~(nWbloHlo%0DCyVIts8Z0x4#vOffrUYU&3&QdOfLOMF_}aR;efPoGF3
zKZ)iUA8cfNu(8SXW56H@?z*a%vZ{+(qD_J~Q{6XV%<-d-B({6<FP80dBwuRap0aX(
zCh%U8b5R`0GYe-UOS1tqR{OU^MTRXR<D4RscSRRNB^N7lF{`G_RVtzYYZ+h#0ah7c
zAIh+8O3+PFF_^YUrAo#Bsf%*jr?!>U`jS|pl54)yUFs|KmxfE41|F*{Jp{Rtl6ItY
ztVBjixDN`(N?bs6rGl2KyK*WOjLxqUQ$h3mNFWuA08v1$zf|3o8x!?2^1;SgeiUgc
zurH2AA{L8T?{-CnVG)mr*dq3eyTw;UUZn2IzEmL)tq-NTQ+?EjWhgbA8cA{Vd>l!!
zBk&-qruvFim*w>T+-2D&dpIp0^KfoI)@WsocS-=QIv-K*1bTd}wsG@+^;f1&M&}fM
zW}PqK1rL37!A8YpHZ;zhoMu-GdVa>D>o*(BRD^WQZnT7^B*^ifE?C}v^W>HlArJFZ
zwk*ciZyos3WT4j-02y)4I=uAZx!&sU;A8;L9tW-(#2eHv39_N=mi^}yWfcMs4J<*I
zD<!lG^MvmUT2;A-UnO4TUL{{8UTeM9_ASG=&G%WKFg#&?N%NBXMfpwloAPnxAN)Vu
zPA3lV9*xiGae3SUS<tx+vLR6P%<=4S?@|QWLx|h!F?zHn&O>0Tn8ab{O`|XjolbQa
zJLopaC|6L8lE%BsgLiwL^bpU}Tme}1SN3CK436Tjs3xTS<6`@2`zHG~I}bvXpxWtg
zwRw@EDnkm_r|bb$#q$jQ2XIsqR#nGpvWaXXyU26oRq_t`D-nq&^fbO3;~JA+bfTS}
zjUV{5cM&spQ=&?@^*bg8s<`&lE**YO_o|Md-hrO<3Ff?3bxJA|sdoNltLG~osP8ei
zZ<jP%kC^GtN>LfBxB3%am<yK>V!Lx%A<{gxhX?Xu7*vWD?(x-Uj^j00dGHJCcE@9$
zS08xz?fm>l{xKb2x^cy9FV;++j^Ua3o8Q0Xk?RHyzwp}d`t{#AIC-*FYHWZ{pIte@
z%?G*}#-HpHc|7HJPP{eNZ>)*|OeAo{EIOf&ikxBg`yoKx!hzAsYwY(!Ao24<l<Wl>
zDPyNUAJW@#q;@#|2;I-MMJTRZQ{PZT5h^>oO)E6SZ(qtU(Jav}6;}FI`i1qH&6*)J
z6h7d4UOA>5NAGHMEqD%IE-&-1j`YcW{>}2Bf2Zwk`>=IbeguDyJQ>-Ke}aD|{LJ%#
zc*6f@<rJ2+WWH^M?at7h%24EFM6fFON5FLzxI>lW`%nN;$L+in#(m+TFrlKe!W>=u
z!^7wNrrXJ|DSUb09SgSn%ms`$Kn-Y)GL6($TNysm5Pl_O#EXr)=<n)C%nP6o^`l`l
zg2vEsq@x7{{ooq!tzOdY#k;-OJBp2}?IivAFG;It^IBD_(RS8#9wz@*1t<Co3%!E_
z69c^`2G}NWI^8ioKEO8dPS|S1TfZc*HgHXV`&s}~m;z!+xiI6yKrPtmri)h|K$1+)
z9GyI5FKZ-e%8^4k$B_e5x-x)kziol0_WTmel0U_xLBZwb$KJU0Tkm6hVEYdnGt+`r
zLnJbN-FX*0wByqATZ;JNgZ~R_-+2R@cP)zN;?B*X;QUJ;`rhfzEdAwc0?;+V-GgEz
zUxO@Hf^lWBb~x3bBx}~8+K#RgtjUunR6CO-y{w_v#w<~`sZBrIl&%ShQ|xEmY|$yz
z(k#cc2E{CE0~xbHpuhHUkg`-!k3h}@>8=BCuR|LDsP>C)RYMV#JI@g~R|wUgLE%Kb
zK{3eYXv_`0R=YG{ksa#MS5L39^Q?-O$(vp#gL?Js*B)%57*`l$RJ2twG;X7Zc4!mZ
z)UUYF1hWCzY>D`}HXsNj#=&VYMp=G`bW~#O5u{Z18#g7KpsZ0z(9?V)3BG7(3AHJ6
zLvt04SF|stnq_!#FqVjj2|PmxinA0$EFg~JF4e9FY0~3i-(%Jr^aewi36o|tg0Thn
z<K6gG%wu*`$L8^ZMAU5`wv!<UM(iBj`crC~f7<`U-kS$TRh|9g=iF`Xo%PPX&)nH3
zGnpmHBxFJ$H|%=?L?A#UECC`*LI@xzB~=k{Db%`aA+4eywrm;#SVgP0*4om(UF@dV
zms))-)wa}DCByHWb7ulr`+eW{uiroKB=?@@?&qF+mgjlS^L!q2d-SDk*UmKK4v^^G
zOSZej-5ck8SpGqSpXl}&j2?r_14N@+^m+gp`Y>Aw+ma<0T7_#Y%?6^eO;sHz&Jh~1
zyEVNOag6?$zVPSN#+%1aUsvuKF$p%dHYC?f&CjRr9s2n`!YjViH>UNjKKM{$r5i?u
z9_eeYnMSE*jG!W@j?TXP9z6$*Xq9l<NuWkOgq9#k$@SWNqcC1QK{GYT{8)fxWwm8;
zu08kT+_~I8)GCmJjl#Cjmh@BMli^e8*V1o?-j4hx{a?ZNBihM)*&w{@cswqGLF)YR
zvss8(yWF!hE83uK5bk@{D<?BK?;sp|T-24tPs5eK0tD(mWlb|0g{VDb6hdR!@grKO
z9fW((e(ZFzC)JOq8R@EL7vUL2)gbi;SuN*af9_0<%7H;R`h;wL!AzN*Ri~g2zBfEX
zk@4w5+q#Q*bzZz!PvG7V@85<IlZr?j>5MO`HZUBvp$rEi0fu8E`e;-wErA&(wFLSM
zhze+8OQ2dvbJ-=(uk$WJ9SQOGz&~O$P2}1hur8T24=V<2WVi|pJ6zc8wj#0y7I;Hg
z_9cAG%DSVsJvMjDsjYq8_Y^+ZwKNlOx{Np4BZ=h?gk1jQ{WGMdeUrZ2{>VyZ%C7rv
zXqtcT-im>nj(qvRxR|$`XB#-p-qlT0YrXMCpZfaSnpSLk0&4+`s0X@$dLW5<v53PV
z2*73HESSAEqD4XrMgRUNo-M>2bwkFKzY2jvu5hRYH!ldm0J=_NA<VMH%o!6zLu}$G
zvWJ44L<kAr=Z)l*e`T=G{O%2rNR+Z*nysGaSm30cWJ;zwi0j&7YqiB`afO7SI$)Gc
zVTa_DTy;WTU1!2DsdcU?{A6LAdc0%2bF!<Gf0Tbn_`2(1_rBmkaDd-0eAD?&*8%tQ
z{IkM<dcbkQdCGO#eJ1#G$H(fA9iO>U`ve#y2#@VKk|ryZ)K{jYNWLX$ET*KPkdhjW
zB$Z{SCua!W40>P>)y>{4eVN^E+#M9^_?$Y2MwwT+Gl4f<s-5axjvY>VglUq4GCM3j
zGjK~jU{V`>sE@l{E*D%*$>DTn1+_&G)NYq6EbxdT;N}cZ`JmZk!t;eLr^Yb|y|QVM
z8j9+$dY^hg{WCSI-YU3p7bVJErk_8_{|NQXTLtF^7k2WJfS}A9;+A{d=_Tp0%4(dP
z&{hNCj6ey4@Pz>}2>XIcX`r)kI$$v80@!%LDJGNadM>u%y6hTqyz4}5r-*FP*5kOK
zn9h)%3|lblDB@MHMR2<>0;eD#6xijkIF*Gvwj{)UPtU3)o2~&3P4AsRsSws+P|S13
z%*vFU+MMSlbKZ@XB6=MxVNWPdy##DRL2o6qU<%qqG-iZ{J+U(D&wpX(HNhNA<}4vk
z;dEKyq%H0@R?_!IqEaYZ;3!?KS1%YekqBe-O}O-Dnytx*0*`p!QH2TgZxA;)5=;iI
z^aJuOCR_6Z(T8eikP;VA8xtF6Qy{^mxmkBgOv8w#1zjUHM7tO4W_Gi;+HZ60uD)aR
zt>br3y}ju^`+bgwng*GZ>@)Uf9IxeGn|fx!*#+koe6+yrlB`u?wWY?tfPIpmQq$lD
zHo7J-#SNTeuOQwFX0t`$`y$X3!6LT_@s|YN1o8Pel{F?!!@kJj$O{oVG6?rRJ1^N6
zfQTu5OV;6YP5T0e1214dc;y<BqDunkT-mW_3Y>x^hADV*bxJwrE2cDCpar9>n7eqm
z4KXLO5u3bMa}SM$V+ZL9S?ipl&NyMSvkyrX-=ThrTDd?^2leQXno~Jv!kOjehUw4K
zS;PnW&^iyM(^=UsW?@%$cXnTv&N{G9j3RMotMh5PuLZW?cf%;0i1@)XqJ<D|5&obB
ztFqNP#2~ap{Bei@T4bBumD?SMP4VvdnfTc_6W8N2<0a)p9P1=Zm=%g|kQQVY$P4;W
znX?NBq>o0MTcF>4{{%RJ_#IBDkZjOk>$d&aM%yqT1F^BQX)$1+V)tajW54;K2G~%M
zrJHH0nTCKCX^Jj39lD4%LzfVDF>wOFBi%WF!6|qnk|@+i$s|3l!Wc8AXNV9Nl0E0e
z<hqZ^MpAL}Stp*qh&Fq$!H@zLH}o!sjzer3_Bd;6LkT_~o!mBd-ZL2HfNE<^_FTMx
zn=9TEc{_sk^eFbyM8+DHvr1l$Tc*yf8y~Lrc<m0zMkAFKRTa4knrn<UMbnW)bWWtj
z13e>s9x%0fx&+3+1__K}8$6&nHQfVdC0iso&N0CQuZzv~z&Ufhb#8RJdnA}vF-3w?
zr&QO-)L03PIHQ?*51f&i=>fCLW=deZeXNI=WGYUPS60buros~h)d0^s5yR?r#6410
zr$tmpt3?y`j{NATNdc@vja?Z^6{P?gT)9xF$h{NCMLYQ$R?1`NNAyRog32^{aR7$g
z)mv!0x@G<w{kOKil+@E4OB<4#YG2+zZeqDVko9!`XjEI*4Uc~I;`XT;W3_5gE}4hc
zDa*#?nx`!pUsd>LCR?}cJI@@d%02uJoKg0*)}1fQEGO7qYL=VS-8W!~<}F4^#n7yv
z>z=i4={<8RYaEWq7-6Zu!XLVx+OcuV-nnCXw(Off=F*p|=0&pM(c32FY&M2NQj`P$
zeG>6#YM=wZl;buXG=T9s*+9z%n9xG23Q`=T1(t)1R-*%qR>xqObr5=FlZv;fR6I{J
zDo)D-zYgk7!$(p3)xdqSj)k1Sa~#hyS}k)LPDXto50}dtK`_v8AAJ~Cc=!+50UL;#
z03&Mj8_pSM11GDX%BjCf7qG6L@LBcKFJiO)cSWrFX+TW8f^{_1Q*Tt<*6`55pb-O;
z27{p@3wp3CQV+C-j3Hy78djkM(kBP@54}WfSi8Rvh8Mq5co;74qi?x%7xj%H;xoDg
zajl!#X{eR?<gt%4(A4Vd^lf9eaofCiF?V}a)l_xhI{G?kZeW#XBfHtNgSx|YhvzZ+
zfY2X07czhlB=Oa(Hal<8Q8bN<$|waa63s{fm)k?D91M&0?mI3?0rM&N32@M68I>tS
z?9%T80l<J$a5QkkiO*t4PsEMFzawrm1m#eBhzcP#_mcsU>PNjYzKJYIve++DqBD33
z-Ur_&C3e0IgUYty(jg4$c~FFsy+GJfXe6$FB~Wx?yHkSN#+*oxbPK$Nx<%qZ8#caK
zSA=-etYW%M%Y5Bzx0l6^#!wYdF^b2YYS`<y#Dd~M6VjV!6jruE;gRigZ=1P(^Oml3
z$Q8>>oxb7d-aFSk2N`zSQv<QRI|o+{^u<QZuJk0uK<?<an|@xGQc=V*tqIl6E$m$&
zN%18M))bjbNfAu(6tMzvBk@MhL0(^06n#y4tcf<^;YV*GPH&0>9East0m-pyJ{<Ac
z0Wg#qupz67<3Xn3!Wr>Q!yCiEOJ}gb{LA92`0pAW?@3fw@ihROd3wvZFuD_8R+LtW
zMz@H;gtPIcf<LGy`_cBVi9NGkpDHg+j}UDwv1cxU5sto7ddT`vlpaTq(@t`3r?+d_
zhZ&ejZ42z-_Neyp`-HvXUgMFJAabILT9jCnq&&R-86SU75I*Bm4br^q5Bc`_Uhq*q
zBNDG+vRQ;;Hc@6Wa=c0{x*=lsW*y(1f~i63<6|(99E75*i<d!@!6@EiFu*W|A3fgQ
zo+D{posu>*C~3HYq_WKu$nDWX3|hKK->pBRKda~T&hk?<N2`hwk^(b2{X#twjc{|V
zN6EWw=M`(|`g+uK8-|SewoFND8;MzL(TFt~vBf<gW(j*>aYh7BgJ4ukBE1fK!r*z(
zP<0gs7E~l6BFz$;0nTczvce}kk<qh<epePB<2-h3-m~jE=hfwW_Npm<e>5$7{zOk3
zdZI5_9uCLHEurR5s^9hehH<G{Uv*%O*<7*W7h@)2^oV(=KRAkdNC$|6OLAg^uu;89
ze~a*|$omnFqv2M13$w+x-OkkWan!MgoN*^dON$VvgQU;_DT;;^0~~~RA9ny&8id?&
zgASqwF5`Xzu}LnFkQ0=gXixMf&Lx<HQ)&C?kfIC7nq~7IbH7<-c9vn;Q|S^fwM`#7
zPqd@cFI-eS_XtGqg`N^#P*DM@;oKZWnlUQga!*7sc|AT4#Tg^IXhaAhSyOZ`0RcUt
z!s_S}=rKu4Kv0WTVAxhHQ4~I*RZpv~_&LO)#+)f!Qw5cAvE=5!(f8l><YTMCd%k+-
z4_Dm$!#fv0e-AYLbJfrfO%o?nO`f}J=ho<4c4b7@^v&<>T6*rtQ+GYJ@Hq4iz)6L9
zL*sVLZhvP?=J5v)eJY`n$G+)F;=NxEZ#)UosLp+@t~!(6;OKStdTx$)r|<KqHakv)
zPsM-Z{*C9?Va^#7)A49Nl8=pyXVddzow4q8Ut04jfG$s&XR7Cy&fmD%19A9+@UQH@
z4*x3lX8eON=aEC+IIqV+EP~MQRs})^zuOuJ0k2e^@WvZLO{m)qsjP`O8u%$*#hZXj
zbY)$#tJ}r8CKK3?(GArg4dwKaG_{XFe$(l4NX(2O>3bC9dKfh5mFY62Ln1R_`n{?2
zAl!63fL(B}@noAWVtk2@+ooer?x^C)9mSs9MP~ye`Q(HTE6sa&!ew@kBNC66*`rl3
z>_MxTGf@R2?od_9(g1zV$t{~@(H9K(LnE1>PZ|jVk{>|AK7k}bkVT^=fptlKL2L`+
zlWi+Dx0vmUC$<Vc?uky%4V|u<6S25s)2rZL27bEdH{Y-5X{?^*UHQPI+ghrcshbKL
z`uydQNUgt@UX7`#$F@9iRzFd#{zl)t2d0|Qmk$BJ;xX8UMqyfR)wng@+r|6DpNs59
zaie92_@MbA>uc`Uygw6phtXv5`e>CE?r`n&QE{I0yFnnR^1F3`kUik^$Mt$0<wV~O
z@Sgf669gvFB$=`%*~B98`K<w>>zo`aenm9SN+H-C!ecod3Ve~9nd%w^KKX{+-r&DD
zP#3=*0r|b+YM(E;)_Yt&gH?=JqCSIX4s==3%4_t`fo`*N&Q)Iud&;-1tGc%ECB|eG
zRa_v3iXIq6fbplQ=7ep;DJ>4OaMX)WzgXDtn{9L6gO!CJeKdc4WJF*+y&5~F-BEb{
zKMH?%{%1=(a00YLCmiR+BQ3^8-;YXM1717{n9Jvmo86;XEHWn%;p8DpCxkIT*0t;U
zbw7ZwQE$RGsdGBieL)QbI$1|kEW-@KugNZ&vd}ce&^lJ0Sk3+(awy?`4-s242p<~g
z*FcR^%bud%12pwVSqm7E!7#b~49h%6y$iI(K2F4J3sJIN#4|rh@j|kp9%ETzyW$cM
za4*}--NxR=F-1lN`#Ye5L()8w+XL7_EcPSnmxcOncwgbpb=j6GFFP&z>GRAh?sU5b
z_wADkU8tU|0#*<OLvq=8I8SvSq&YpDi>T#rBfK5%0r&IYGyDMvj6p`C3q6OYA7BQl
zvvP*F#YGzUp5}S%sn`wr&@0a3c^#b$*89yFGj*j0XU&s|py_I;mf~`pio5Eu+Ztui
z`E`_Ta;yjljjPIZaUE*%h&Yc~wKmkZ*Ee9ePf}@QAu2^YQH@rur8q|<9EyY}&TkE-
zpjU9EfZc#rQ6t(6SbQn;R&Fgy1m3B)rC`W}Rz+D!sa^^6S8VNVEVh=3;yKD#l&Tg{
zhX9Ng08tqlMFlLHSkch8FTe1>9fem5e_Xz&Wy=nD2XsI+++O&guw|g@uCJ_p_PO;t
zrsTh4IP!#6Vmpp^)HN=K?iW#wyr;0H@Wv;Foy>pT@>t<W;l#0ByS@qQ|Mo=RW{g5|
zGa6&>Kx3>EeTOQzMLyLEp-|<oO2oRVwgme$eOingcuS-&dPmhk$9~t7k>lEDTqmNZ
zW3Q-R(fm?pQvo&Pbd*bo*>rYSL>JLdg?GVQb=&m^fqo>YgHyp&I61xuE{H9xx&hn(
zJE;}X8)7S~Zh|+*HkRL9g*7dGsy_Y}<1MD$mff}onfv*BjrW@#u{{y}R_t3<gUkT`
zzUIHQ@9W=>y<b_T(h0FTkcYLE>^L51T``8NL^~ehk8x}YCuW_uQ9$yPfJS?~WDzYQ
z8At@xay5l#+WV`|RWsG0=g<Kfjr$2S?yIwQ*}lh4+nu>n@Xtkt9yJ4OkB`Rt3+FE?
zK8(bC&#uVdmC1}RXtXiBH4<P$OMqYHT>{H3i6tOy$}WLHMp^=WJX$4fsU;v|Oew>A
zaeODjF{uQo^%MnQ+_|f4!vJ?^U!;h<K}LIX5yeLlb$5NE?S}^+|NiPjNAlBtee}iE
zb2h_@8|975m-kgy)XZ+ad(G-wq7$h@xAo7t?S*4K)Ap{~Ib->{-LG$6yng=CU##BR
z)VXP6Q*LFZ@W%=J+rRwCmbsJiHvo9~510RoeG2tRG5Df9^$rs>?S_z&o2qwH(B!3H
zj7phn%{Q7Kq~4}3Qz~;XXcGNybpQ=&Zg(I^V@#Kj1xKk0nM_7VQ9)DCVloATgYcWO
zA@(#>3j(CvF5V>2B)XK=G}~yD#H=Wbw1~kzvC2j)>3}dnh6-^nF-#EAP*Db@GT2{s
zu8b-(TktKcfj~A0&jewRj1WN*L?);xoY18~XMFJ$G=_C#N~bhRpdE;Qmx#8CI`qPY
z9Yy)fl!ti|uu3J?V*@wrbRHK>PE#2Yp7W+AFvYY8%r|v`8%$eFkHCZQG<??dI{Xxx
zKBOQX#9P6-Bvf1{sLKbip9Bu?aonbBFku`;RFPy4b|ZN2STS*vWWbq+yaSVOVy_32
z&6KA^D_We`fdP9xP&hCGN&fk)B~Qs$U=&L#7(l?H=l~q{s8&E9LZ9a=2;c68-Sj9N
z{|df|BV&ax-QtcmWeaf}7Hj0Fk=~K)v`Z>lUkZHn*)C?>rSA-f!8$y?+$^A8T}0f&
z5!9=DfS+;{<wg_qBXP(J5cdnbeu#KrGEZU07`$jv<G@us<?+!5-edCue>d!d6okBi
z!m=S|wB9)TMkYhtgDzb7^PgZw`H5S1y!^6=7A(2BdA-4)6V*P!-yGnq2D9igy4-G$
z!^>es>9I&P(U)fD<w%-Llk`}bvRjHOyInqIx1H=hW+jRIfN0L?3>tLvykUxAf;idN
z6lgWf6|b|*^W9)rA+Gdo6#JMR`a29e#2uzxzMcL@43CHp86WYTG@KN_<2vbk-S7kP
z``#b;eq(r3{J`*@_@3_*!#~AOyr1~W1;bP~<wqkgDkR|b`8<MN?G|hvyW7T7DmQO6
zTHMwfeFhN&hI)cV(PHd2LabEQ<9ctTd=`rG`MvuAPznyi&uDqkKwE7#jF{vZgrCZS
z0bN7w*UQF1Dto-i2YrLopJcs+V_$rvr}a-ttL`8pztc6;cEN#>txK*)xJg_j?seG7
zh=g)$BVI=A)-RkOP}V!dtuNQB>d`+@V+^YV5lhty1J}5;z^WqR0*O?kq3DA{e_I$F
zxukI2b<V2M@OL5jX1;Cq(EBs<@wM;%3BLM^rkFpYibM>K?AMrupFOy9CL4(`=|K4+
zsH4I|zr{S2wlIOdNZ$)8hb_J>f{;wm;Kmq?c}<*!Sae#jTb+@RModzKq%c`Y$jZUe
zBwF%9@=xfmA@fFC$>FZZ3i*U2@LG)2mP%L&OdQ}sTktas7E2WXxvF7^`roy^+|ZzS
zwkhUdN5rWu^S%Szm;VWzmp=lo%O4$8i$y1gLju;3>XY}CQRZCQwyfq>b~{H20&C)(
zyh})0Tu~ux3cI4oT3BPMc26{|6jrJ`oy%QI-7Cv)<TtA~J2$y{-8Yu+Qtxs;2p$w3
zaNVCg4bJBNz=Z^XPbSL~2{j}$R8BmtRbE+~){63y)8)!0)E0C?c``{Rw2}#QNx~&C
zYQ7w$PPM@Eq2kn5j6@zmxs7E)d9NX7x4WEp*1^474c}IOgiXA=)gP*9^;QhfvPhtX
ztw=uC%iiQK3=%X*`y@)*y{H^!${Wh5a%WZUAa;zv;uvDZ&bO^QKXkDT$5R<9Izu4w
zJE>I6lE96%Y5J?sL$DI^-&V{kQ0j0Up1n%`yD2C#2gO~5sfXw1N5Ck7NY}zc)>JC+
z_8UeOA56kTB<>KLg*$5w&m1{zL^hC*t9=v0jfE42fK#+r(f3AT-q`p;CH%B3ZW1&)
zR9_tdeZ!@-+jovDPgL0qqg(e;$NlM$R@9=}yS8u$J_x=K>|nMWYo%K4FWYFr-tIi>
zqy-363}Zlo@PJ9yYM45M)o<;y($+zkkTrh8A_HY`Iv#zz$hr)*5nyAJQc%iUo0Wz}
z>|us=hltx)yJDT7QfVS4OGVw(nlUSO7Y>yNcQ>1Lf<>sSs+h2T(Tbx$K^dV}qqb#*
z2jz^3XB^BvW}j}K{vb2RsP@^R&b~ocQPT|O8JexMo3ZQ7hU=MGhPRos234`m#360B
z(FRJ-YNxXBCKfic?JUJ+wcI!Z>@~nehA#9TSxOBWhI-oC$m$C6Ro*QN;A2s2wED0^
zcUZ1u*=N)~4TFY&FwGzth@mwUV}M${U5B5-G_#P+>a?7=$N&vlNU05{snI|W7;3a!
zPQ&y*^jhg=9n2zes#{0vTp4?Vy$NxG+O(z`P>^!k?B7t_GiO{}H~k`30AWetV%vG~
zJVv@9`ZT;M<*_(dgZPLYTVHk*{g8_ZajOJ9NyHuy#z24htSlhTfX<>7L8Q|m!XV?V
zunk85`|W@&&%`a5d~?8(XSz+8+%sUxGY%^z-y5(Z(m=?ghHD)XNvupdP>sYgT&F`L
zkc<`}KF{<*&80V~_QKB=*PGo;oTI_e!*E9DRJ*8w&cYwVbix^`oKlEf`dO%4T7kd)
zXaJZaL@)Fgxo$q3PtEtv_pO4fs8!xoK0Xs@2s8yAWFK%JV4rZSDCqUsFrrLQ@VgCx
zkjfE4Y=LOt1B28V*(|^$knQ>glL6hX863u9DixPqyg(#>fe85mk^F_A-R4jFNKb>W
z06x*T$k*><e5a^5uwDL>;+0plZ$@`NE-h<QoX0P=VHJ)Khg7Tfk;rO>94e6Hd9l6-
zwuW(pfQ-JgJbdU~qUIT@$H-c*;YdIv=z>}C8V`MreIhVGs*suah9Rmk`&YEQfH<ej
z(2JOjdTdcVH$@c{*=dEBTEcZBKD$_AnHa6!ym}#$JW#3jU4DmQ5!X~p&6S;|`^q84
zXV=icz{Eirn{0wjlwhnIgcIbmHMKP^)TkCY7C9HW7P&cA$Lc}iOdZp!>DBe>HyXNq
z-Tv-OcXk(lyJm-OhyFIhj^qL6K$U3HRq1lNYHyV{=dH#8no^A9ll*06DKyBArW%;6
zGwaLxvw=~$QPq=llM*eOIl8&xoU%Dd#I^Y;ca^`|UDM)dakjWxD;HKR%q^^5STlcw
zp4Mo}%o=xDNF&vaEX&sQn0m~+!Vjt*%siAmkU0~7G4X2hOx;IymKl7l8+1|b!|=z5
zPuT{G@ttH{^}`h&x3|mh_W4eE@t&OXVG9zF>$Q4|R;y2H6M7~pkc11tApp2|1s#gx
zxKB{_1#^gb!myAqB#Rm23r6Z~Bb1DXjc*%i#O~}k;eXnf6tN{OI>Em$4PQuqn7*8*
z)AGb>IsId_L4&lE&Zf_#ne=mT0+KB!5LidtgSI6V<alfV+cVUY&m<KYu>LB5_!1<%
zf(U;N9{josMfE{VIIA+pqndJ|3X~bJg3ydssw~=6r?gc-qb*Oy#6%S|=*tojQ>Y5?
z8LkQvTcpzTYDs29m9dA^+NGN1x)tKmBu2l&!GZ`_{K9!?TtHm`lQrb4(4x$)5-`A`
zx3P~Z8ATG~TVoYLfg=+~;po+)9epTbYI}O&%ALv4?>~R%)DNE<ne%_w<@6%v%Qf%W
z)my(hqApf={A<(BeQWjRTDvQtW>*!GJNmERHgj~<)UC_c+&lB(w*|Jrmw`XI=d10v
z&97Wu?)z@<T`l+gN43+R!8QM@m(Rm4@Dk8~r0fAQr=ev*uB#U0hU!HE+$S6sC}F$y
zhAp@)lklkkPt-)Nii-+CMs7@}8yjCD>vTrO+NE)YDGZ<w120IzpA|VkSCsT6QL7Cn
zRt~Cs#aSyo_VXqFKSjMT@sQA$!cOS1j77A@>?tL9h%BnSoWW-bMI2mNt4X8MEB<wg
z5$2WfA!mqZpW<A1#+|@3QSJnum2wkHE0@9Ln<LUNMch~=N31zT$*I27<MI9!lXYbS
z4T;)hlPJ67KvQB;5)G)XR$p^qeqvFwOI+ew66i|YEUt5H^Q{YPOKx}FoqW`Azw1%o
z{ecG)dy@xjPq+?wzLh*_dmiQB*NA!jESZo}>m%#qyUh=nAF!NBsb-sDkk^;_RIy?V
z5x2wO^V1<$8N{y@ig+C=6{mN*f#0vkhDsUWhkGE^jwFr4kS^Mceh{q?t<6^I1?!Iq
z(h9N0u#PP+dFbF4G?Z-XQQ#{xq;I`|#&m+0Qq;*h!f~@bY>!GHZbqw!EhNF11v}~}
z!4V)a9beZ|o5aSz$t%G~ikKZmMhy_3))90O^jy)D(5oC(Qwo*lTCc^iVCUrRKY^C-
z=G&un)wjl$HFWnswtnP7`tWDV=T&+l5mA$$1@Bnh^w-zlhY?BggoiTl+f(P%KmX#%
zGgY|8&W3%|JjxDe&>%|`+vi<YvyH`2gy0BG14@L=upJdqKRgRLB#Y&q1$|7*d|ZEr
z+OYL#2FI7c0}9ra24++2&}WqW0et6{!W8Oe_A9^)>g3S<#wU%`?b=;NO8uZ<1P?+p
z1VAku&<C42$n{xTu2&SbMUzxAe@PHdtVJ#22*kmnc8(f5b@Kxqdme?AAK$chM!+>?
zYoRMLZTVN>9Y2FL@bcQkxIY!{f8`g4?|AZI%mkr4%prNm%i%I6!B1jo^l&4}gc(36
zs8I$KBX64Pv(9_`Uo!#Q%+)r#&14mU3Ne}{#A&9f^n)F{A1(a&A2;or9&k>*nO&Bc
zy8NEPrk@vnP=ISA<3E6_UitZvJDzwLmEz3H=jj9NO2qrdpjNKBDfTP&m%(4fn3c?C
zb}PR{*rdHtx7oZ&x|6@vjKq-LWz<NXjX44_2TS`R3{bJB;8Ng#@-wk!0>(O47BZ2p
z2o;F{A65<OS@c=%dd6-CItQNdb3wxiWnzLh4Z;rD1j^*HzA{=aYcInZCZ-JHIl}-t
zO;*34rqs^(HI}Fs6jRh8Wv0KOI2kBjRKUoKh*YGGC){D)sEvvdPc#(u>jF!F*Wg+L
z!#tuSjc*Bb8__B#M6R9!EX5UUv*XenQNsOJCS57S!NU?3Z_(&w^)2UqQug(2yMMU+
zrdOZbbkAF_e&czn$~0#4^w!&38yBU&<cUxlVEAyy?@k=M^WYtaKKp%P^OtX+PTn$O
z@jEy6@BNQWbIJjAd1+w++|BMr{c;(6x!8Yd;$~t1VD{t4-WQ+2{iRUCsS-*d$px&k
zGAohGm8j=xyj$lVyj&ocAmUFY9JJq-kkQ_h1p<f$xH957t&J0pv3Qxy{UZ^znK!UE
zrTB|CO6Kj!Qpob;tEg`sc+>?sCro1guwg{CE_n>~r*g76xhHu*f56+H<RrAwm!w6s
z=WLR8;lOB(F<*R~6TcF7o!KQMoNlR1tFmFyR3`$URiP&v_L(7ZORi5S0l*Q<K&O*P
z#MNqx@yv;dJbqKO4*UIkut*EB&&@{?ElI?BcJT7wWgRh=KbA=TB!B}hk;%rQZF!Qw
z!eZfe`o$!wIb`Ocp+OOqj&N_dpCOURFZ8tHiL9c%jVW1lyj9H3JwCm`8}S(Y9_Z7%
zv27MC&D|pbU|rkiLy2D{*4nB*7g0Q(tglZd>g)Ty-@jm9MZo1YE)F=-wkvVPcay`3
zWPL%pwETnfV?v=yooa4m?pLY19!M6w?!lzX@31!_o>mLo;HX^jfa!qhp!%T5Y=WCr
zJK#<gGnUuI0d0+Qf}`F~XJ`tW;z@LtmT8ur>@CgNcx5l;HP(xQBv1yykNAPfo-dlS
zxe|Y|61oi$P1F@NNA+4`3b>&o1uZH>*;qu0YF!FCDYP>2))cTa*3`AJ7ZHEe1|>YX
zhi78M5jFPVsTh+{M7`?;$irI;TM8c(-YeYt+ZX;Zuy)s1)*OG~lU-{O|I=0YS>g4<
zO86C656AxS=;R#-3eOduIldDnU?W_3XeYt(y8I4pL{d};yf2R&Z-R@=i!9VKd$)bN
z_K@LBgf%%}HX=tT7q7q{dkOHd&EXMkP9%(GEwY6o#+|hKS!Y})cs<y21oJGOlG5Bm
z&{c3V^8^JU%gg+3ejk6BXJ6po<}dR!PZa_3{|m#uVGmK_GwO=GEkf~JI5J3891ooP
zCa$UH+r*EDwdP3$t{9s!)+;r!G=hsRw_5AcdPYKx+O2VpEV(`?USI3XpTi<nI<cbl
zLJ?H;hXgv`G4}D^>sLDi<x*A59(HF4d@6<>u8_72bw2d`-EH+1PJd!S&6pN?ZxKzO
z0#h!(N1s6Bh6uvo)Um}pnGIrDD^7Ge*C4j*5L_TCM=3el9_^2wi!xCo-mPB*y1+KD
z8}tJfI3rg~J#gn<wDh=AyQaZ#C>#t^9EJEFic>|9<l^?ZY0ezQwa($RJ1H)}7?%J)
zhdOtQ9#J+e?&hI{dU!k)WD>1QfKzQ<a;4rSlsUn~m(4ko(zzQg6yecFhzc)WQ!FEl
zGce_@-udm1-u%eU|5)<Um)E>JKEJM}*O$(Q^JR78swd^Bz3;)MS&jQ%DIES&Vc@<$
zy!em8dq?kE-19WdzxT*`B;d_1Jc{`h#Cz|dkDxx@4#pg%or5qUdvz;n_Bi{|E66~F
zgQgl}D`LrWd#wFd%K99P00;Of;zY=}e^Ie(RYv{fH9gGL40-^w<!C9-G>*Y3eMI5Z
z(~U#sF$y&Xw+j05d1^G`J!mis3FPeS{uMQd<rt)6vW}uH6ouF;KtT-{gnrqAJBoI?
zo9?I2(Hwmmev5jY8H8O&-^MvB;$|tc)?106FoYpUjV@T5;RozjKApoph3m{$3Ww1B
zkD?L?fu*uL5P8wKqUKe@%Rx%3bDOQApdD~%aY>+-HbeINWCxN@luoF|E!G(V{y<-V
z4t(G33}X=m)flXB6UozuFx&?Q1}qut!gbda5&dtpaL`pOuIoRqj-!vtN@>ZTe)_M9
zIS5{)JK$eYkLv<WvR81TO3aFa1q|q93++Ke7F%bq`|W)=x*$v(7oBd;b1(q{=zES*
zfShsWuP9kfCC&wNbTuQc&FqMhG18w`L|huJUSo0@<D>nFy0NQTN75acQPt6Ezrmmq
z>Qj}T=(?7Ti?K^89uuBIIn2Q}xkb%PNK?+3D^7_H(Md@)a!q^9jeNJG+j(PRk7JMX
zh~tP;lgez=?9kATnzXCArn}}Y=3C6U8b(Xst~pafPvSAM_TPdgf~1`zaifouxY6)9
z0Q6LOY{kRnc84R##mi}ZJSf1V-$!J-BBV7(AgzN&W3y?Gi87d)OcZ7Xx0x=R7!yN0
z@Jxf3&ljEYsDH{Db$xRb8lrw2d-U>0GMQ$K5`d}b<mzR26sH)`fHd?m;!za165MB=
z2a0@{sUOx66#LDblvIg)Bpxe^C1NzEjfNwJfN><0{Gw5nRHuM0gjS-Y9|?pQmx7vz
zK2>B7i*UFJg+(O37+A5mPSI3_Bs|SxD*2T~ugn0V4p=H#P?!4P5zPCcP<6}Z=L<tS
z*4_WNzNvRL`Wt6aI_C_pW&OEbg-t(vXwLFu_q{%4b62g|?55FB*U~?8!yDiF@TJ0;
z`=SxJb9qA`8qG!46c&%JyY!uZ9Dn?~opT*!)=*W^s%Rw|@!}vyQSz}c3Gx^rA7Muj
znzlz@3B8h{Cx@R*Q4YU7y*x}Kb}JH%Oa${_7u6NM3Eo7l_pg^W25*eq0e46brVhbF
zkrUD9QkTP4PPz@=6}~O@aCkp_oO&XBIQ2s6&FqJ%%PE}+*r1Ct#a&rfMP0fsyFA>P
zQ73rH<AGMJlMI4L+zrqut4HIj-|Y#6WU4$84hJcSdK?&jnvy70qHI5b%e3R{szg<@
zs$E6zAqK+0{j?`H2)`;DD&t<Shcf8(sNL}<GJQBtnLZrfR1E@$15{I>KR^YZ6>Ff3
zYVz3{x+cdHO(##vfhXDtK4`O&8Eh-rX(jpy>)z_cCkfp8HD*p?ThB%8iGvlK8O25|
zQ?yYl&f8r;J+vv`){{wM{8Fb&yf8dRV#>Q5MM(7|@zAcwI<Re2s=^oYM^d3o6|C@~
zRXSK+1w!GhREf1wMJ?17t5BlAjt~b!h#~bX`8WpcvyiE3M1J(Fn9qt>3sv;`!C{h;
zfdEwCn*SdLZYn%0h<eOn5NCE};r>E(m8A2Dp6Ik{V(Lb~z~P_Yd}H@xhoGbVj;>3i
z%pT#TSN7dnx0KpKL0H&$t-)Kv!3|pnqlKGppQokng$Higw$F^m9y_?3nZbM)7{F_C
zI0G^;!(>=VEomgZWZ)&0#J8*3`F>SD&*{+@q2OschE4|b%wsgK8l-2+0;i$Xg1~Vs
z9<j6x>Z95<{TfPhTEIKZ?OZ=cai`gKeZQX4pXM=OHrnsT##`-FKSfceQO%L-s)1Zn
zja@EY7Y8AIR1x#>$3EXiOcT%wF=Q8!yx9ga^;co*U&Q~)mZAz6Q5`S_&{Aa#SP^Bl
z!@m~v@UPAAVnGZ4e)mlH%~|j-1;ebu^)u1q(95ugQ44LL%N2R=86%@|xG@4LS2rRa
zAz(LAV*sR?sI!)eQcj-ZN#JcVF;DPFFO>p)%i?Au)H#J{9lQ~23a}<WwrA5D@)^;R
z7aQfI+(<X#wz1nE%54NU8n*<ylUq^`2OkPO0iO^L1`Y-fhMq_r%$yFLj+~C3svT(f
zzW9p!73ur=GmSqt{apG)^HHP6lo2IUPzopG=}cynm^Edkk%5|6HaQWXhTkYPW*g5o
zGOwm!Z|dgE_T;V%Gd9_(Z4J;u$QiPYZfKn98XMzGmNX2fI|BOy`_m=t(jen%l*^3K
zG-U*VG~<roqHw!77mtg=9j%QPV?Mm{N-@EO&{mwBnwpj}Fcpw8V$diCO$`91Obwi<
za&s;T-6fWayJPu=I(MFhjGIOLtJ@h3;=5)>xNB2EQ4GSA1;SLO0gXP?Yw~C*W5IAg
z0V80@3I_AFwKx`y%jrZFj$hdT8<GG!IZH4L7s7Vf4UfPx@ErUIs^K8@scaZ0&6buS
ziL?>~`-4<)koxX`+<1Qg&-x?z300@Ib*MrOcN|5JBlrc#qW`0S)mN_#=+}y?B#xAZ
zN(MVHpdVZ}cHTe+mIX7T>9$s)&+ZH?OLk@28%Z<=*n@fttj#tok9F2k2^`lUB<irm
z%X_j}n-4iO`7~NWlWh5D)`s_=8L;Jpaa*3jeuuWa1@}anyhAkMgE*#OKE<2zLCKV_
z#illfd`wA93hJn&BuOP1jgrq#r4^^s@aT)*0-#mNc436V&c$fRU1i)*GXi2S#_Hh!
z+sav`7~7nR9tT64H_RV8Rp+s~1y%Ol!ugb`W?I2t6&c+<3Ce}PuX%7OwZ3^|_UvC0
zX00JT3BHpL*UX<qeOQ?B%px`tff^xVw%d&p;ljebbup`ypd%4hbj@1;?}a<|EyZ!S
z)1Ju0!fUXiCT_KgRwG2a4E7nFxaULNAA68Q?D_dKEPy5w`{qDHwVb`)alNxS%aq%1
zvTu%Vj@@bB72}+&lcPY^s<OtVY;%@nS@afhE5!tW1jDL$EF6!dv)Kty&d!AMRP%lF
z;?3Fh+<Mje`1(Y5wh#7kx2bN6_a*wW`x1}A$Eg17%if=R&t;|U+z!=_I1N>Ze^Vw6
z{ZYy72l2EUDAR{N2NJZxQHR}*#3Bo-{wkiw%_A6#qpi3jYR|+~Sw60cMIEePL{f_1
z@59rLc3Vk2z8duCqHG|ug+ZAYsG{cT;t8V5dRihz4JKVRjwLL|nn_^cJuy{mkb3ZV
z1~(e)K$~=-VYuGqxDqmMxZM<|fAc$-qG<wCbg6~IrU}=?HX-Yx<3L@sE~YpR;BfEj
z00GQ_Nix#1xEn<c0me<527p%%C9I%INpOWes?C?whuBq!7&oBN^mAh^ajsQZLR>Rp
zQH@BSg}-vSmd&a!ob*Izl@Fc4vzUdu#$={gqSQEFrfC#(Lv_8kriPssNzYk4G*o!H
zG^Gg}soG_gA$25DULL-_Fcp6D`n0Fqi6yNF{0*~^UXNru6}b5*hepiU0NcbYVkqW$
zdKx-`M&l{^Vwd~mk!T16eSm64tA216oI_GM>f~685+OVbQ3of(en<l-qTY^%3k4O!
zAklCkKaY%+rI3+?^(Ja*#3G?_@nZ}TR*}U@cl;M&Mtt@fUg-6+F3v)ajvx+T0pb8O
zV4v*DP#Id{C4tERiIupFrVDgwxONV5jRtxqP@&AKQK})?rVs@Hk0^njIiS&ib{4YV
zK|2}D9{`4qoq+8;<WF-NJmS09cJ#Q@5|yQ7s+&4Xu@VKTg<2*17|;M^6c6qf&SR)%
zG^$@9|7gHh#`VZmqdH|D9@6iIe=CmXI^3=?$NhEGuE)bo%6NWaB5~OQk-^I!6PTMw
z4g-{!FqtE4W{$9&IWsyzHj{7!Fi51OAYn~|xZ_o<E6IsLS0je<@}i|2Eg7_=fmZSJ
zLTtqEK|O}V90kJR^e8IrQKKO<L+tt9P*A?`O3~+@QSeHBmpp^fO5}Cj6Z<Egop^2{
zW1hIzBiA$|l0q_`CJ+o_9zB@zyVHT-c)xpeAV^`$Qydh`9SBAI?o=RD?RSp~gir~D
z!eRI5QKK{(HI+`KJRUc1G6yL+2;UAuDVPm*qoMF@@LZ5X!=WU*#EI<_&rGDHiE!fh
zNU*v&*Pf$tdne!^k<-PCI5cFvh<)j=LBLWBkqGX5X@F3)A=u3AUt<M*KA2G8zYQ-0
z_fs2*1}saBBVhAN1fiklva_Skp*zT-iqD0g%qIN~>X-1gl}hj+yV$tw(tTGV3Bj)y
zmR=QCXw_Ax;kG)KUO~@BQo0SKz%6nd0zKofN8J8+kT+`La&W+Ilr;muP6Ik)x4R4^
z3M_V6Psj#$T|er0zH89?^?iC;kM{{o-C+x~IMbOy*n2#H=fbdU*YpcR7|(yGt*CKm
zn66axtIT|g>IdtvKX27l`jf~P?}iiRO;ZaxUAd`j)RYlpS8t~lbjTWwR#R>(8#TRl
z%ni4*tIE>LMuv2H!>ID?_}=T5eJdKRTR7UI*NY>Q6_a|d>--kDe7RH#sH2$%0P`3?
z@7!I{S3v<tCFn9F&a{!TD!fe3CYD+maHl-#QTL<igPFn1_cQNjxGnk(_B-_3?To|e
zL7f|82=EE5V;~`iHHz_8MT4iVIRy<Vf2uD<r$_<z$6)Nc*I0EOH#oBuR~H>t(|p{9
z5m2#G;XL{;LAsVoY+c*Gv+-j8&HnWr4Qh=}ZL`@D_0va;S+xT$ojYBv*6M6_BPz(6
zajUl%UQXoOMxkQj`TAsbQqSDZZ-*19j*%g~j^{@wvlBL;q9id5F2AGNih7<r?JJ>^
zz}m8?1)Er6V`eHwd4#N+(U>R=j}h`PGGzmnAcn;Ur@-k{T3#)v)aopkSDEw<b6#7F
zIDecMa&8>;6Qv%M%I_hfMySqA5n7pf!jl3Q<&u24Ca#T}<E}DyA|9)#;qtCrb|N=U
zHB~do-NMaN&Es3u^R)9^^Rg`!o!m0jYRyX5O82U&jm$=FqiUo2M$Jvyn_M@#w|Z`r
zHe|Llcky?4c4l^FcU9b@dPws%^Vb{?xgK=i8^14eZ}tHHl<<`1Dc1q_LC;g(Co{)Y
z$N3ZLLDw_c?`1#XKha$Bej-g-nd!)`tk@+mweHovF8|sT)1m6%R|@o0VVZwZd}@Yi
zb<fSr%+k%OW`4egW>jd5(P%ujOu|#<uTbSRrGRu^U>aHH&I%qzV^m7kZQ@lLsNwT5
z6BbPB8`>19M3GC1VoAB+@$iD6MjfHo=i>nf-N5X!xXtlQnLBRMqPxU=Q6!pF)VlM7
zm%ER<HEP5XcgdD4uadMHP0)?bcDp<tpP*I~qkFdp?eJv0JRi(vEZJ<Pf>WvR5l^-P
zZC02~v3NY6HvvkcR`a|{7`d0*UxB{aF}b=z3FAt_vPM(cTo$#iJr#6Q#iEM#if*!T
zuHvH#zT!RpkHRdC`&pOf6eR%{{8ZN9FxO|bwD!rmk%QC?$4g?&h4W7Fyh9wiNYo<9
zp?8OS>7tNa@?s(gCszo5>s6R1|K6tgS~F68JvJm&iS-Jjru;w~F<5{EuS~YY<A_)D
z;gys{D?bi@0E)rp&;Vf#7J*JM)=4aSH9KaG#S}}^f8o*a9@W<BF+NMOaC^M)df|<5
zVNFVF89x$!?5M6ShnjcdlGUX%JDuh-N(|TLQjmdExz`pQg?P4TE_B;xr|G4azRoQF
zl06!UM6$uqmxff-j-CaTQM1m(b7)st)wUr&^})?qdz{xtaH~F0xPfX%qk;;2S$4?S
z3{{{RHcC^Xii;w-K|n(R#?L@smR7zjjoW5uL^Yn(>!$l?rjOo3Q~flgcd*<M2%D*P
zilUsnFbFG-2Y#w_Zi;KhMJ2j-3I2Tg5V6J^)<?sDqSBz+3zOhr;Vl>}+@OL@pFE24
zIknJ9(IlU@$zfUO7pQgtqMUN7C<G$QL@C<TAV8d52&p3+t7H}@vJYjJmDp~!k7fFB
z477g4$?eF3!>Ff6`FsvmfB<MA(;s9AQ?iM1+R5~7+f`W|?uZo~OkgU?=OmQRx7bzx
zEHrV;5K}wp^7px=D5o?qf*_~>jc~jiLgFP&9ps+S9uyBoo+v+<J;@DdPl_ia1LY^P
z+Ix7KqA(L_fxrSG8jJi^K##6*Pf(jCs0U%|07EmNazY4^va4=FB0*6Q&`=Yr9sOxd
zZF3rmX*o@$2dTGY-56D^|5IzN-Z=&jEM)TH;|nD0?8g^Mu^TT8T@dRPJ>nIarZ}g9
z)rH+`V=j_KwMdTEM$04h5iuHw+HDS-(?)aJh&NJIQR4-T;n7~0Pa<k$8KTTas}}@W
zzZbeRi1G-Cs?Jn;VM7$HMx^SzU{oBfEC!PoN*r3*bZ#&3@n|(1Q{yVRJTXiWoHg8<
z0wtCJ4{<g2qT$;xS~nc_p)DR)6?qBeFx!18+)DrU(seuTJFv0owx;GgCsZ}rjA5%k
z8?3C5=z|mQp8izt<XufoyC!BssdO-#4rj9gcGahC>|^J?`t9fEKHb@QbZ+g9XYQOl
z!e`1&f9Cn=RYPm%KfU7U>G@Bt>iqVc>Y54PJwCB&#N=boO|3$;c0bh9zh=fFiQ+9e
z1}OosDw@}D49x>pEl?VceO=&kXb=6mhROkfVgbPQK+td&4cdz&VI*b<ltmCIfav5g
zfu*0LlYpZ~0g8GPu|T<g;fR3loTCP*H;<wF;j{Q0hqh#+M8EFWK%kK{{Tf>HPwh`n
zl3MOW)uG4nuFE;(xahp-co(N2({|p8p`?b2J|T`P#`i?R<;8R2IkLi<pQ2Ffq@64l
zYRwRifDm<MDhT((#fAPl*bduk3;l3OzOc8j4^D!MVS63gZqFC`3w!I}lEOahr&s}2
zv0LaPI3ymZ0;lC(4mD}PBv|Y^r)3ATGxk8$K}x+%zs<0%awmVn%5IT1r8id6o2X5W
zjXwH*>yy?e?euNdhx88`>E)HXj3?~$a^EUxMVfAvR!}P(bTu`enrEP6P90!4b1aHd
zR<zY6#JX%Ym`DUYb*QJ>C>w)yw8}q$b5*A%n4P&&+qp19ROX3?E*Oc&2Wm1#d&%w|
zlm-Y~KWl2P;8Mn}co^8sS0a4918`+g(<mC-b}~sOwr$(CCbsQ~?M!Ujwrv{|J12gb
z@BZJr_f_3`=hUj*y_)Ns-Cec!Ub`D(-(fETd?O6Ua;4R7`!Tv@d$aqYeSPRIsN&h%
z?xvWt1wX@cCNT5K&+8F@4n2a4uCL`jaMhuWDLbtY%hUeSl}Jt}Gkw+LF%?U&@fEb(
z-zTn)-*s*Ei%dqosZ!TtXZiB2x<a&x4nmG3{aLR!peGAUP?+1^UL}5Hmcd_LP;>T(
zDAK*LuwNKYIDxI&wUkebBV%7fY7GOZ5oqyV;0lcw!l#OH#5~**ZI^?nfbUG*Un~*~
zi$hLsg2vjQW7VcL)|3(oyLX(XspJ&IKS)lA=`4WKpUWtMS9D5j>${c@E`$9qPD|vL
z%!2k-8@wS}732VHuh2#PR*?u-d`97k#;Oi~s*AXZ0F;aIk%EZuI*U-~%BYI~8#D8e
zQ~u#YI@-Kv-zVX-pMZt7kfspa;{ko3d}NNP#{Kz#s7hBLZt<Ugd3bdM{P$F8=!h^r
z>0zLDLG~qp8HYfOe#3?dfhQ&Xu>RhUj(Z_Iz&4=(u?j}n*@b%*B!jtpXEs|cdTL(g
zypK0dKm4nRLFb%c77+{CVCK}UGN|`zPW^#IN-!Qp`#12ym-tW!ZOo6#;V+r<U;Ks7
zx>}Qmr5&(;Id2HuzXF9o4xaop(t6Wi5DR`u!r1m8V3{if@i`*5e_cPq$QUEH?*!+)
z!J=x}Yi82*4EW-{p(_;sT7;OEM?WF5o+Uqv+q4(DF0rQKEg~ie5YeEBfYD0C@@Laa
z<Tnp8S)R&keNa`Urt>+%P8e^I%KI+Kob$pDGh1>&j$fiH4w6&48Z=#^J5vX`DT)4u
z_D1Ta@R;-{iTf628EY8(*Ki{nXv0F+?AnyA;tk}&dqc;|DL3d`r4Cl5>K)|q@l}nQ
z8Ztu=mNzwPs!oY$WKoOUf6SAuKe=q*dlRRnj)(}nKEM@kIA6nsM}RPHku8<hu)u~2
z-&eGS0P^qdhv#HBdn0-YTIeq{8h_Er_CBh1cu#_?i<Y;|&%Oz6lLFZx$xbPBkq>B`
zd5xHXO}D107-0qgJVY0P0+k$K65-Nsa@}NuU_+d3_(^Y>N;|Vkypm8;b8OxAQmmfL
z7{8DYD-L9c6L_)u59Y>n3$VCkO}NL&7Y05O+=#i}itCa1;;{{kR4z>^esQNDn<4Fo
z7pPJ8$&`lI%dtOaO-$zPcE!?Fl|~3>6eL!MRI1*7sPWQ83%O|d1WcVoKzR7{SV7s~
zW0S=y%#qBNyIQ2Xo^EdbK?6ObewN+s?^OvAiQm+Atq+jvtC@FdRz#uzZOnwbx|s%K
zrI|Dn>!;sTQz#A8>Q<%bBX!DfEzBLx<X{(blp?!u3<T2(^u{Tr>r-7avE>`y+)fqc
zGu}veD%UGrKoEPdXM$NnMEQadMHbVejvNLa3Vq>dB6`uQOw$s(U8Zdj>Q+KxBsisp
z5+Ocp=%^b$cmr)r#}H15>1?>vKanH!_p-?Dk9*76L{a^_XW{BDx7Y%uq&4Ju2m!Wp
zThh1uN}FlPyy~0{q+VzurnCsb(I+-bL8)IJiwWwB!-ImOdd@h+)3k{C>vGA@m*ohf
zIrw?0m}ZrFI;PQ{s}?y9TfbZTg^`aj)0b)O*{H_SouS&pj&@|$s+ON$)E3S0!q5IR
zV^l$~?yPi{dB_i#D`GeO*)``i8U!DlP&vp2?#F4DUlFQ|pwC5CF|4R#mEwg)&63IZ
zYnT-hv8`=9Q=~+q%X%7co0;IaHEMlW5uy+5-$M>m`2@e@vq4A4wD^_fcIQqHIQH|@
z2N@!4c2Ko3bt6$CI>D?_28TK5+nm=N5SQvvqeJAS8thT>P>A(ZC-GrV6Wbe^0#=@V
za)0s?_#G3S-(`TkzMOZESXLr{&P8Cd90bHwEhruLBCjy)KaulYzS<jhT`u>2ONRh!
z?o%G=16k@TYTm(o?)$oU%L+t_vT<^FMr?wjQNmm^@M<A=-s2Qo(D@4~za-BYMas^s
z$L$3%4CB^EL2o7hEh+CLTI}R0@3Ln9SMK?*g71DE7LB}#<NA6LHR9I+_pIPYw@_N<
zjo#o{_r!dm+mwSepgj5T=8ViOflzuk_jAm{DHuyzz0uX2{wZaf$`tY~fgcylx$Vw;
zo->GZtYk^#m^zTPd_JTXg?eUud)p`5>b!klY6T14#dgf^TLATiDvXMwz(@M05`2<B
zRn;z6;=CI^{P0mwzPu(-KL?)0$cO50MNP#~KaNP|Tg)2MbJR4be3f1b%JDg=o-H5O
zGGLp~UwB_y&VAV(PbgefhEC7LcQ{|8A$$hp4|~|2q9vnVt~91r9gGp9yI8Igp%cm9
z4dyEn`O}$9$Lq@Yv)Qb)Mj8=+y|+_tIa}RVr&p)b&t&kP2dxQBB&8tMR1mQip-+k@
z=wggTu43|m9s~7?rXkMq>4=_{o&X=4-d;o07fZt5$J5Fv3n02;Sl~SPzeTcuddJbv
z)7bZ##~%wIb;KcSf%}4OM6w{(tF%kN?z*165?2)v6i*|r{Iz_N7RAZGcI%W-78vSQ
zDYS_DrB6K%x8GMvJOx7gi)J2=!Eu|o3WU1VIsO=#+e1GdqgUffTT~0O#ECGETR2o~
zX8x`KDq33NkQ_CG<V_p8iujEiY6{g8G!I-S^!<rAdOYr{R-%9j%~=#DId7M4z7#H`
zBa($mcuyf-%#^~r<sa=+p->UKJQmYJCG_lz=9`5zD_HHo`^-Yf%6|I+Lda^&mp|_@
zSPn&N&|@K%h-Fxd>F)^Yy3lmGv^jO#jFQmC=;vdwYl2k^^1AG_;`WgA^b1$sM=+nn
zDFf%1rVu$)Ri`n`ipYmN!xZ(4y7`f2&p@Nv+81A5vfB$cM;O+)lz*Oq74i~@S|CD_
z9Hg!Rt(Iq>+2F5zUgJ46#Qa-N#`PV^X^8@oXam;Q#9o?4JMi{y%t~@?e2PnfUv?tr
zrl*q_&ff5A)B)HOTO!kELT?xa+<W)x{_v-Ak#np$e!g3NPE8MO=jRHrLo<5%lO<r~
ziU{@Qv;iFLUgR1PF|K(Bx(1w{Qfq!rUw&>a)asNgI&JyblVUR#FLw7^k}))5()5&T
zrl)^c5AoIVd^p^`-f9A`+fz0b+pf48m%^KG+~O3vJ;&PchsbM0y_gRXP}-iQ?y6C!
z^5|5utt7j-#@7CRxyXG!cBU9w;&D2mj-A6aZUt|<aK11B%q=-etmfD+1=K0!FMs?D
zz1E6(n*4F{jN!x|orFs#_{R!b#h<5CsHr2lGhAdGediZwS-R8<#Zk|n&AQYi$n7gK
z)7sD^t+LIOI4fyWE`sDU7M15@E3ay<d0ES4riY}W!<g}wRgvr_w5lFJ+c+Da8>QzC
z{2^^hyi>=lCpPD{tmX6ZUQIDiMT7hAq9HFzyIAew2YS10Q7I>83-GMcW$D6ZT5R8C
z%p<GIp3OHuJt_68ZfgMdb6k7jVtLU3>rv#+rxb5Dn?6Ym73e$Jc*jG+N%9#{ch6n*
z#B8?g;Z%nN?At!Os+8v~Ytg!*HF}O6ZmWvdoCoe`GDi#UZ>wrYLhoZs=i#q=T>K=e
zhBd7+Q`6rpT~;>g*T+`~7S`(WZt64p+tbxe7G(~PmKJI!5y@TWMVk2M+@5T%G}0~3
z)qgeUr%qQ%r_Qt*+%GF*&~er1uPAl(pW6nMZr!)OAHh7HW-GaHY10msxY1qy)!J$5
zY`Jhc(f7gO433EdooXm)@&4S-IxiYhvYXjA#kazEu1si8`PxvA=US2KI$d?K;`ZWB
zk!<k7e9q^l)$5>HSo&^(O~N}rUkz{N<;BIlT=KOg8~WU|yVROJl*zSH9hZ?pf336r
zqv%F<rTS_$>f5Z&PE)f^#zI>o=9cgJe)hK+uc8QVRa2`K2#cxxsrk@Hd<uSwuZfP?
z_@VQntC(!otS$~aX|}{aF+H|gBwXvlZ0%m{DK;AGkvm2U<I_ddHSHKhSyrjl+qH1I
z>l;65&vkaXaCm{baN5gJvue?@LI`qF3g-tpmaDgEhPWpRV_2ncRMoGVnw_68&BFh5
z!}U1Hk9ex6NIT@|Ji03l4|zqCa)!C(mpr&u_WfL42+wY>v|3nS(v7U~r5JxO`dM*G
z0_PW94d1ne>se%qkL$3P@1*8hdG)!8n+IGK=?oMpxgaD<c&4z_4Xk?gEZL&ZrFJ%&
zN{P?%!QhkhiSPlUB{yGkTJjYO{lZUn_>~s-Wi0ghjeG?`w-sad2pv>S)AKw{v!3j^
zI=FmQFMiT@pIACiA6K+s6Ds$~n36FS%yRinp)TjYeRgzA3Y<q5q9wa_p%4V@<O07m
ze|=`q7e{*H+H?BbK7;op=7xMOIB@ORnK#a#2y%b$t%`pEcSd7Cgqg>Nl|nQ+le{u%
ztxo(pb&H85)TczuXGtgfTj#EMB<a1IHlh52|B8QRfduN?cyMXV#?E=ST*qh}A@Y5l
ziYH%4wPUNYU>ATmCp2d_XIBs*R?S5qukO28D$Gsv@zcN`2_VS-!EFylix&4+pAb=;
z`ngNs3km-V_yfn2)qBlq#CcfCdEk1E+#ee77x;B;KmJ$jd318F1FsLe|1O+Xj_3qu
zqjxX{g!7zyppE%jbjpCap+9idhxu4;5%hH);@ocqzGvesRIOjL^C2l)=7tK$d?8OY
z{Z_9)KA=$fR@eO+#uQzNpE#0);$^T!J0fpB6dw@l!+*Q?pGYW%MhNMy{Ge<$6kZJ&
zeSj|A3LbnLqZi&HHgNyKAGU8Bt;^T&AKynt^EvAXNn_Bm<X?#{c9ou94Y7h${qUjg
z%Ha7+Aw{j&E+(nyV8e?66>r!0*t(^;78~JAP4!w;didEhU(Mbeejn9yon_4JK*wfb
zU@OeAks4I!nzUO9<7c}nXRWaxhSlFYjWkUNVzWYJ7{gs9jXNvG%HkqueAevx(^@y*
z68Olwc=UZPjLU}b$&lf4BbcS}&f=}M(ORaey>91zJwWN!bp2<~j??x1`}VWPb=UKB
z%JsA_ILR|i!w;6O@^m_@^+OBu;=J@wGn|6?A1872;yIiCy#Df=(muGI#P4M8*sYZB
zJHR;*(~6Rx5W{uoU0gr;?V3u{OvEF#3-(4;U!X#{s0b<f*3hzjG|H><!lAU)>ul#^
zB2V4x+EY3YhDtKVG0JO(&JG!$Xa$Vmcg=Pq1@LOejMbbvJVm#s^qlL>v$#m6Mwy$_
zskFuatmvl>&>WehB|JLfG837rHb7kCRA*Q6>CrAQf8j69ovFAi1@n;1j5GPj3y2WJ
zHPpA-jMP;nR?lD5+nw`Va-A^gPE==BQ!R8`_gM7U=+~(y*Ax_93_MA`IlNiCaeA?S
z#09ZjWH{ryjS-~IEbT?KD^*i1_00^)jTby%|6B!?0Vx5-9p-@Tk>>+5sbjCliV)s^
zx)K(^IHM8!M0yfWQO!FHorcfC)no6pb;nL4rZm7xs}#9JB(89g=n+CTK+Si#nJ)=z
z>7#Chc*rZv{r(ELD8HidKKT0xz{G`Iv-xX+>P5S#><{?s4yp&6v0@ap&zH=_%T82n
z7SgXBm1uh`h7I=50hM-l^HrEWT1&fbv*pR2qSB(?Hv`)U5SnABwTL!`5m<yzZmc)C
zc6Al`Y!_RWS2vg5H?MsbeV%`?zuK&QhJU8}wnbJ?YxTv{)&gf;cr7Q&hjeV#UCyJh
zk;7(#e!`8)fVY4m8-UbGN*k!Q16_l=)7JtM!K&mz_^e()R3u})oQOm%Q_%6Eq}J`7
zRM}*K*75yuZ0N-!D!9B4%fURmTTi&j+}-HsSD4E|^+oU05+8=PmH2ZUY7c<lJLDg%
z?=6(Ugti@pyxF(+*Mg|%C9MTpJ^b;GABQM`dE=(XMgKd0{J4oqy9J?!`O)f6cA9wk
z5S{{{BhZfqkhB}Ndu*<o<5(mAqMCE3l~WH*tpvOMMfv_a@Iz5urVUFO!br+WM$k&%
zz_(b!3Vb8{We4mU122LNkR1CluG@2$r|+>*gLhA@f2Z8_$l;1!CRiJp*7KuP{${vT
zTGh9L3R0y=TGa@Ke<D811$LXLH9pPHc@E#L;jH4Fq;pP<)E2wSQqrjZ<}C#|=q1+l
zBJicf^iRmkAk%c|3SdO1v+&kS?H-@CIpr(pdA-!T#fbl~%Np4g{E6ZMgt-;r4R(S<
z@YPM>OE$@G8bogXE2>DOi*uX$-A?`NV-Y5r_*`4<G;{Qo3^u%yzh1~~m)AH%uJ64U
zrVEJK>hEIT3GIOeYjY@}=@g2^NE)4@{3|tfPgIJ&|CVa?pIRXmYB^}B&XIYx0qcA{
zy#pNSaOd)(@MvqJ409vi1(6cmbUJH%x5#N~8luXDdAVHlH_?xnSNa1g8;&<}H|<|b
zh}DK~PXz$XZ7bSxzgC$6(=v9UpVj(Gel@zPehWJLZ?rC)DvreVyebI*FH7JcYa!}e
z=`*F%QcpqDIS+Wni!;swSs!U!CBOUv>oRhol~UXbQR`dZVCFo0%bvQ@t3_$Ny;4Da
z4#fi7h3;zG5HIQQXAI1xsi~i5QjqH!orQeSQMjyg$u-Wp@!5t5*|DK`$}x%~z9R%9
zuHq#HQ+rM<oXgxee;(yx8>ThSD;>D9TuY`XInx^i-{U}ZcP(qZMptbH+3K$1!;0=y
z^}@M-;&C6NIx0yaxH>iPjU~LbPgNV#AGY?aY@*0yOfRZ0fKT`2d~a;%*50?)$3acf
zA;+Ea^hC<Me@d)jPsrkX@gy5aJifz{j(MH*3R;cH;1xDYUcNLv*Nbo`dE{QU-oo~S
zgI5PI$KrbudO*!>m~_YE$z=9ekEa=Gwe2KHW^_RKKrW;f8PAIl`)X#8CQ9lb(@T$_
zc#X~I$NVA~)ey)Cj>0yPP%{Ber~{&h(d>yc%z!|-6(Ul==$i484E}rHjf79zvJ{18
zPAv+-WC3c0VZ$noD-rslU_1G-Hf)LQ7CF4xB*W62Eds9lo3t>oaJEQTVYWlW{nk)p
zVPb2HLHBUZL+o(xJ+HW^vX7?JoRpj;$M4Vmm)3B{7bGKn%qAC43f2nBfR+&+7F*Br
ze1qOSpmau^!#fg$PkEbzhwF)EE#Bcig^hq6(aJ&J(By(~j}a!;{1yaP`a&9WIRC)G
zij*s1R%}0gzh6fFE?%dE;P5QnL&lhSQ3LTvOM;K=PvH&7k(5$3>5*0#U6{^T*A`E@
z6y~2w?ggh>>&S!(h>-#N0{(@rY34RzJiLvMZFSt5RV=+`oxUi|3YSb6fxKo7?I<A*
zE=m>1mJXD=?)I%6_mCcKXpddJ0+$A&d$R0Ee!$F;qjIn}A5`|ZSBM=9WR)L-#nmQr
z5*z%2MB3b*yV#~qQVk97-_nzIhk-b<C~V{9H0G43a&JCRw~xo(X#XU5889=DhJdzS
zrCzy!puf_J#&kE&{(nZS_mwqJ9O9V~BmJo4j+`19NJoK>ocp|M$?;)p8Pk1>^dR_w
z%>~FApj7JggTA1=fi}UdFE)0Wd$|STc^or0Q*QV$OQNuEFA?=PbuQe=I*Y)#9Sf}?
ze~+`(by!DhtioD}a#<PKcHS0iBM)4-_2&5ZfaCzFI%*(94&NVXW{%bA#1*_bpFE-|
z(s2y^r8Jit;7x{w(5!w}VHqLFeXHkx9%VUb;~7ve_}wc&+R0h|-7%nD0jOmE3q)zD
zjS0ro*2Kx#(bUl9A7p1_2?N8*$j(m0K=co0=44>u{67gC|3l#6p;z&+H>DS|vvn3R
zbuxCeuy?j|{0}N;Xk$t*BKYq^tzuzg>Lh3CretShXse(ss{%tWW^MS(iHPkR_!bos
zvUAs_Wo6?aqGe`aBVuA;U?5^-U|`p!mvlC?wlEg7{bg-R!~jDt=wxha>rBMK$p}OL
z&)z?TiSb*Du%W$#sl_jI=YMkFxU#dUjT#Zhx5z*JViwk>Ohn%cV*B=6iI4C9Tngv^
zUW$yV?Js9@B34dL`fmwm)9-~?8#<ecm>S!en0`zB&kyAOM>lCAW?cYD^!XEpo;(uy
zs@j&F<OeB1&>%5l$k_MY#~&$yHrNfj*9Y1yi4vOr)f<l-E?eb8SFQZ6myH0nr$<V;
zm!iuI#_hKejgfb}8k<z?Om-XIBJz(KyQMhV<IRP8zM+k}j)w}>W&mGLhx`Gv-x|vY
zr|&q1{s>u&joXyI?}gm`{a;47o_$(ZWj&K~m+ip`of9Wk?=oA5Jk6RBGv6(_nHA0>
z{oWC$u(qXN!b$CR`#z;-9BNyvW)=AwClv#RSwqz?*IP^sN8V+AY6p0h$FuqNZ;zE#
zXLs;gr7g2D>%v}3&Hi-h)UyGMkf%jwNVz-i-9g(oItML0`a;*G@DJIn$$MGrLWHFg
znwdgPkg<~QyDW!pr=}?Uj_@x*mUoblS%4;l7f^S&7io8+Q9_2AA3gpH{yP{D4QYcl
ztYiA!!ioBg^e@tb+INr-O^2Ag<bJ(TY_|i#(!PQ|(!Sr1$y0IUeHCSW5zVB1OWMNq
zt>*n=HECYJ8#WI40XBE~#-oHcy20-le6TMA5E<_TUBT}JPS7v3mQr_wtRerIr^O0>
zSM!S3S4r$y)H`%*wG;9!IXT3fq#N_&CGQdKB<b0m<`}pRd!^eV1RS97cW04&VNAxn
z6a0yJ*K<nzN*ns=Tb1*^0)Y4GV^6(`9ZuY_(!cYX`q{IRHW+(-HP$2EsqSmFTSeZJ
z+fCkc%K5@;_8d<5JV@>fI7s{wOch&4&>&p3^IKNZ;~#d=lWYfb!8C+z(tYnB|LrS~
z^63jI48@-Le+@wnhW~wf{=bn%uk2#v{4eZO99>NRGb?21Wcu$!|Njd(3r8nsVRJ*r
ze{m#Z_&+cQI}E+Lg^9DdlQ#QzxN~rD5;1)rS-%62g@u`jiIstfjg9R;I6D*5e`w6#
zJpZLLGc*4$Ix8E@Kl;DH#>ns=`ajw~UH`@Z>HjD9e;ePnVE%9O|K|Sb`45ei?LYee
z!T;?1_xL|B%s*fM`TQSy-@O0u|H}W<@n1dveEKKz-*x=MzX!~}<3FDNtl{69SvdX!
z|3^RDw-4XrAN<e8zrp!E{;QXR`P=`0bjEML{)hL!{{8cZ@%w+&{a?B0f2YZR3F%)V
zRf3^cu~W6R_?Kn=&Hc+rN-+PQEXBe2zfXhzW+_Gvrhkn8msCanzgQTFnAw=w82-=1
zwb|)mptAJB?mOM)_H;SDncmiLZDl6QlxULhqfG!L7-<azg@~r!PAExKfRqjj3_Nwe
zI=3|l1*#8Nu~byMsmiscxn`+l&WLrWM$`&6-D9SW8QS3O>G|#BEi=<=#_{=tXX3;o
z+o|Cx)Fsj%#Tgjp23BoKzu|4|w<{2kFAUHktwzss)1yZj;R-*5z+LY?tF)SrkL6Vm
z(5Nklz(d1NYIZt4CZZlFe=|HF<`WuS7Qa2bBNlj|iR_V;QmqJXf>Ad~d)ypEZ)x?a
zuD|Dfv^^jOoY5N})avwUU(*N!#G8D-H>}jBdMu`LN~_#=BGy_j+kHRFMPq#c>nfYw
z*g&=i8B6TdkA#aSz^#|u^?p<Ek<0Hc8=JyFo8K<*`M(kAjmn2t7|n~J(V|EfGPMbn
zDOq7v#Vp}Q{TZ{aTfaaknYg@teGf38(7^~F-VZnN5H+RJRn-Ok{JKNE96krz9ju5x
z151+&k-zbbseHK&k<Lf&&D7Td?5Obax!YOLe!lN|)Z$Y0V%X!FgP`wP+#qNGFZ++}
zGK>b+>|Xb32pkl!`7`YH5i#_?7{FByS8e%IcLqIAQhCSlfkN@X*@Ei_x$L$W0K3D6
z^^w$~00iKV>ybl#`lEjks048LZTA!U2g?Qg>b-{bqdDy3xIqK(PWG3nq?Qusz_JBo
z_UXn2nbtyV!+`*>Z9!@Rn8V^9_ik;$SNz!+Kxu$S%)_oJK@xin0l1bd-3xHFu*G}n
z{Xcg5<<Wr{8Bo;nB=$({{h8uGTylY}LHU6Y19tj2@C1_=$bo+ESnzQGFU>;n-Z<|u
z?hZ;*r$y&H(A@yJBX`1XhsdplqAc>v!M->Nz^fgQZ-Tf6?D&5LIJ(nzLLZf;-ob|)
zg>3h0db_fA%adTm=6J!nBlT=K?Q(E{`i5EDd71xC+zq<1d(cuG+O2xgKjf#wg8c$z
z0ce&46zzJ}qF)Re--Ee>dPBYTxy6Mlm4?{mlD@_%Ey#zpf>2nG6dZ#<GoUD+lhxv1
z^iDu~4`<GTf7hj`4(SoKEEJ@kqdg^hO<0%2&-;}5Dq?8A@!k_pJI(=xzS;i?RJ^OW
z6)0|lNYEj?YdQ<*xJ$lUvrBCctnA3S2_D<a2S6+or_bA&O%>_E^ig&1w1=i(X!;<6
zNpLS4M8kv4xNXouB<Le~WCLIWNC21s%*KAWPH@}bTlVamu!R18fjjx!b6%$;XTWFR
z<-cE{;s3&Twwb4%8sD0Xy}yILh{MnVE;YO_(T+1cWd=mkFzp6;Zn26F6mMWSqH`_@
zcZrK(BX^b|&v((>Q9H4>VV-+GZa`TOXvHh$aA1^N$ECr`@Ea5PB)$Sa6&fWQsR>70
zF!%j$qVb%B@qMqb-P2()4mzy+C+K8;5A325R1q3if8aUYv+ojj<Mtm^`a_(C3a$pH
zTDUL%>gBZO(}8K}1-&79NBV?k91Z3%M|=h5^7jq@ep^E6SvgjzYq6%3M;D1w1l`>N
zx#{4Um*Q26N48U$Ny;(nkn^uR<OGBt6F^Zfo&7NArR;_Kt_H&lZ5fjdEt`f%-M!4d
z)m|)41?IjQ|2`F#UJz*{VF859pA+z+?k_i)xV1}QPp_9fa6Jnf6VQ-$;0x>v%?IMw
zKk;i9k6?{H*zFZUr~ld{P){S~r3hy_bfs^|9)6RQrls%q?!b-WDyaMb^9??L8o&+k
z0x;@zhkW_({J=L-1W_#zW5JLWQJw{9gsKwMo)bP*e4z0J&l0iQSNx=X#eYRRqQoT#
zC$q#`5}fKoTa(z5;+5<Y`p9^NfAl&-J>!<a#fgp2e46)dPtg<Fk@KU0G325}qs6=&
zn7}m(ac=|EwyM8Z1OAB6KuZowl1XMK<0Yfj7UDrX8&Y=d|K_~%z!Gb?QC7MUKgH@K
z{Di|Vf{epy9*{*7VC0JM=tTDpbyf1!klzBU(ulc+m<sD>Q7IUi)0o^kWCxda_<20Q
zHdkW~>Wu*8Os*60IOUb*r**@~-7C3E|4v}u*A;@Ei|DA4kAY4wTt5r0y^BpFEUiHP
zO6?PF#PHi!$jATXn3?8{65tQeWxy3>Xo&`T^G7zharXsd6T*xLO5ZiKge0(FX9!~Q
zEP^_>2e7)Jb%qfLaL?8CZ$SCe*KKD?#)kNRVx505?FQ@nr`|Sn1^I@!_Va1M<piVN
zGOtol9>)@b5_;m%<Sz^2xa9RL^gt5k!evN`?yWd;iUvr!|FQkvZU{>O{(Benl=~FI
z%MjD|O@0saRJj)89Uo(ss0orbgg<~kR17Vkpp<m9Kz`Q+VBx)MM~on)$eKdJcw8|v
z8@Xr%pa3MF!k@)DQ@h~J-neK)(<#y|LTQ&}^aI^Q_7teR?4XGSiK$R*ic>?(7@s)@
zBEtMC!{W^$@T<Gt_X-PoR;&<VhS5K139}V{G^jgu8iT4ujvmI@=e3SR2x4+4&}7)k
zYAwM~jwrZpb4QkiaD703hu8#rHu!t9$8Ir@aloJfk~1<AQEOw_tG26uO0=9&wa8WZ
zD<-HRZNqN3Jxdg}HcJzx1Sq%)jCM6hoPqrvu?x<65Xut89bS7OsP!0$H}Rxz=KD8|
zF}+2!$4qH=pb(w`Qm&)zf_Den6>q+Ue<Z1QX-dyHb1tvX=SdG6$&atMr@*>->m+EI
z_*=VCiO~?wjPp<_H(|a=RU|~0C^bl&A%rB7*=c;-<_U7|dFt=B*@|W1b#f5%qV7C-
z?yy(Qs7|<WkU@@j-2N&-K-dQG62BWFdD$cRaWEceO><^>*Y4@NeCl$vJ2}Q||8XT|
z*HQ6HptJ?%(JQzeW@XFPJFsG`v2kt*^rS7rbGTA}eT$_AS^p|bh;N<SGoA+nT>KD5
zM|D>V@kG}N%<)m7l&HGw2?|6B-M5q=vZbzU<idtjepdJ;^O*i3oy9{;xnSwiHdfSY
z_Y{2l+|%DpC6<gB4@3;M<u7vVRXkLS11*UisB2q{$c*z&vT?7=J@I(RcF6s&nbW-E
zmP9Xe5<qt}?`E;@!Vy__tL;P7<@bXdr7hWFQ@Z(!tL>|^HGYrbWUnogjqRA4fEm$G
z#{2e>UF{vwFmtJ0$RDxtdPM-G$WGb9U)zrAv6I~69gSWuJUj#`R|E{E1#hK8{W%og
za5S>jSIyXZZt_7(8+<);t|Ex-CDs?L_jLD5UPf~yQOy!lB$l#e`6{}ank=32rO>|<
zwI-4b9fj^hw#_ENd8@(c-btA|0iu?pW{U8qdI~{^13j)`GiRD%zYR5GtsgpVi&GvF
z@4ZBPhtJPGA$AR)5xhNIX5N)zS7*FIC6XCN82t7=gdejd3QH=ZZbD302qfO49)-B^
zBdcffdOTJb=yVM30wkGlEH0a%Wt>_vqt2@F5UU5Gv#ZCLBWy5Rr#;bb!X>;AGsK_%
zV6Pjei9I>PUt;t5WMej5GxjwwJV<~J_~8tXve8yu1`L1Idnr2jO{myS9Hukt$Zp+B
zHQHEol&fy)Gk4agoEwVI<W`od2&+l0Mshkl-SibQ3a<&j-R5ZQ9)@s+qc!Bug6bN3
zrg<DhY`C^<e0<#%>g-WFrYPv}RXwEfHpN$LxTrVPc=DLChY+SA<fb&IZ*ARGJVp0e
zmUMVUt*{n*={>*e<ehWXMBcjQ^kUVPc*!nw<{?j^%U#t!MYUDn_Y5j&M7E&^D2jL5
zj~tTlY%;nWN1?)rb#t$q;fW$eXS0`ogdtvMI`oI2SItI-dPz=*YUP3($?-=N_S2n1
z6Zq2^($hLaU4nB$1@rw?AOwSTEL|Oe@&RCyqyY)yHn*}N3mT)$+Qao-4<_JgO*ROK
z_=y9z1%D!dG^o(LA}DflbgMrt63QYUZ(JBW;T#J!yD-4w*k`o`vmZ&eELS}qz&FnA
zCPZ>Mg<~3a{>`7+h3usl%|fOf3ag2AyN=&3bC-Gbe~){}y=#0ZygQlC$viwM>zUWb
znsI6rviPn%)9c;`#}0&Bxd-nW!8|91+)oxVA5Iy=Hm?vb9Hu^wU@2m@@M~3tD!Byt
zxBe;NDldw0qMi6@>GVENxZ<{lL4?kL_r^MZulGhQVH)-%8{E@*E8OBf{AVPhH*}id
zXs3@zlvvBut|^X`AU7qoY*5V89qFk*zO5Tht?FNu-t%~{igGIITAzU%_?@!+@^+LD
z^IFiknPykoZm*P<y9@Z1CyvCH?5P}o8|4(IAKxWI_ChyOx4X02TxR06%^E8^o(tY{
zaF_@0?P&fKWDh!r2jye|z4l}KMlCPTB5R{-<F2A?;CqoiMZJSB?5$Rus!Ha(2mf`J
ziAH7;iF`PJkO(%xF-=2J78@_|<9RZ=cwA+NfUa6OkN+eM@iBML!xU;dAuWRV(Rx>^
zTEqcP2<8|(g<@MS8n2wDfL8=Ue9AX%WheyORI-P<3ZF0lD<EhAB%)*251my~ig1zt
z5u5=(dgG?k>MyxA$7yc}!~&;xYKMh2Yl;H;fgh}vl~vn70<xgGv_q1rVMMB3w}J{+
zsN5RslsgXNr~qWvz0KgWx5~QmstkEt(_?qyB%QkBRQHw=A1~E2)NhS_kke+nA9<?W
z;Wrd)ikf<%RJmpUJibOB6T`FCcC<fTN^)2g7cp$#qrrb2fFQHLG-*XrnzdT;Mb3|s
zo`lV=M?PS&h_{CKl5`Wf_+u)v_!mvRO-fgaQ1H4WzYNLm1!%#<x0*bAlt!UKw;$wz
zSHUplj`oDtb8kaN6wrn%*c@4OE!#)^3gQHg9chJ8sj>-*^@(ASaw7QfJ(uHqhEYz~
zm^nD{j<<7-k<WWeLFy&2ZmSoRyZtD2GcN0o-RGSZyC}vy^#%0%`&49U#K^}&;=c+3
z=Y$v6VGL^$!mb?@1o5_p(_%94K+N`jkjGn5Y@jzOFJ?rJ(7p}2(QcUOO(ZCWA4%1o
zVX|G>0!Z}kG=oK=`#&dXoU8mVpYgVt+vf3a(v1FOilLMVRn!%hOw&6hh3g{b*jqf<
z3d6Iuk=X^r!$%8#m0C~knG7kFW%OLtDJt9T+6q>v4ZBE*g|fmxVNB22<Zq?vp6%kk
zqoP1AdQE0PfZNGU+?MZF)KhY<QOJ}zOZBO%?3;;lnI>zaO&m_3`6c)jBC%tU;T+=>
ztIns&-!B%I&rii1w_Ds^{)OBvcom162|QpRziuFuek@+H0fHcU_rjr)1t@TG>Ty_r
zUCYPrcJb-d6+L<etzbgcQXeT)OB{l70^InJBFIsz^n6UouxppqJRZ?t1)!`3!H!Ho
zJyYOSUUd>=s&Dob#mN#2_B;Dcl&Dv&DSDZ{-wN*v7^n<{Ywv{N|22e4DcXX^u3y$K
z&-WUh!~-dQ?^w=Xhgl03sbS3+BPZKHKBuQ3x;0)=rK`N4_8zCUeI>1V8!j$vp>(tE
zPUW%<Q*}%;QK#uK<P^+VFY*a?40snRZ1B6;kTCJTne?wchf}lzjSmgDJTvtD@h72g
zG9R_|r}81j@ny`VC0S;&Z66P4<mU3)+#ImI2WV&Bpda$2tb+9{E;V&|ML8#NhlX=S
z#ZZD#)u<63^=NyqtVP5q50V_Pv-YP)rdsj52bst4){Iwv%x)KMaih$s_eb57ba^$j
zPDvaED+GILbIi<U0zW@h%v7QI^H9h=o@3TH%S`Rfu?Y+F^>J*;ij95;rko}ptrqmJ
zx9A^{f>p@?NV~(Du^F!}Q(|w>iuV4oe)0#NIj{>agg-#J_QmRBEMQJU31o-X#*L4}
zL@*iViPsKq2cPO639{20MTnGTaW%s&lag(`1gX$M6hf|}2E6;w>j4rpuB|*8+q{2N
zHwyfLG^x><)F}=f81uCUv+?i-CWd;P4Npv>zne{#GIk2lF6{i`Dm-SzW^Jn(R?EyN
z4YhO{9cmN0yMVUjp@<=E&U2^GhI|X390>3&_A^I<9A&U%HbD#5$OK{rN@vC|5(*SY
zh}D8bet>e89yEdu`CZ6CCM-k`C&*h~jWMZ)6fG_`l+X;wyNj6f>-M^wqAk-H-bZNN
zhpoo{OSyACJ&h@QGjQw^1gUS{WAPjTy(XzDm`ak%=AO@Nr}>B?l+`St6m`TMPP>d)
z=L+x7^6t+*rlaJBvkiPru>nh1zpekI@UC!l8%CT??LFuu<ukA_Tr#1ky5^3l<T+_k
zw2mrOHr5SS&0>$*)`rJQ44uqlOI7zLhrt(#12dPXzj?*{@IAm^u#5=;6&<)Io{n9F
z`Z55o3G*N^cjf>%0V&s_<VP+$7D%|xUThbFu5h44DNH7ONFEg$14Fs(k(E75E;2Zr
z2ESqrm>$y&fCCg8w`nB@1Y$UjMd2AMH;*DCbfwl@tV}xqVU_XAfU+^sxJ`h;bfmt0
z#&<jB0$mkiTH$96U@lo0yASXXY(HP90Lod`(yv1!Th!dAO~YE``%WY@hOr^uIvID`
z)M5loo&vP7-e*^Xa{Z&30w)N#n9!0rkds0aEXoATifGCRn_n92&#21?yvQ`SfVBMD
zVoJ7Fl)rqC^WF+k$cn-qp5i7eU<IM}@yZ`<kLc=4@TTJDYGH1IZ?BHn$Bnp{6rE~0
zTwi>4@!J^*a>3ryIk}v<p6}}?E@o_+^-b4UtafJ&V|)4eE`{aE?xZFac0m&3lV)*I
z1@YdUBrPQF1Uuah<O#jq!N`umgxmz-);7oO*p4rg4TzvL0J$uc;aatiw-e5&f?%NH
zPwj$nWw+k7A@h7NvPL|spnQr<ysU$at4(mGF*p7UL=Hlh2svoPn!W2OOQG4g8JAgm
zsp-CH{ZUMGeRRwe@a;qW*xzJeOBf;u>ZyHnA(c=UqKX>Jh$*<DMAa%F&jO^uCy%@q
zJf~8Td=;)Lx~`=&5M%{(2QlMU3fDg*j*0zR_>P*!iefucMxe75Nr1ZKXMELHaCCm$
z3irlm^ViE&%2QC}$v=vl6Q=n?Swf1`XkDgdNeV`&WX>DGw%M%ON+$&jmetLUiql%O
zHLVS!5yG7kzEz+fADG0TVAaS7RJXIH908nTXnj8!kcZoWQ=-6_O-P%W&uG)4!B7L1
zWToZ7&9bN_xx{s{Gh8Rtuxy|Vz?Iq)_VcQ1F@M^Y5eQB1Ppk&9{1kL|-KgNt)@7XU
z9_t-VT6Yd=Ft)VWBz&x7)zZ+mfB$?6ZrBevpsNx63l&zD^#XV3DOS_~d*6_O&00Z~
zIc+-uW*l(H<*qNCzHJ@R^?cYUI+Kgb#aWPv@y0M?!Z`D1h$k@w@y<=cYN|;hm5xw*
zJ4M%a(|py0$HX1=eS#<x!>&S`u0RXU#-KQ$97Ge;@pnJAvjPNjK<Mn??B*<cs9p4q
z3F&LQbxQIWXkUg*RXnOHPQ5jeIX-etC5?lSNCLQ#fZ<Kt(C&}Oyuf7q0FNINOn0_x
zJXF6awljRfkHkwfw@u{gI)7Z6kk>n{@m}z$4IV2*sH?qJdE*U#RCjS%#bZ_m;xNKO
z<*D0Iq|7BL+?m-?BsbnIf7jlzB>2(bNb}o{YDZyFE{&Xy8C*@#M{T>p3W+XP8R`g`
zWRCl?_OV|8l9>o^jo;od%`|NLhm^RAQF7=Hcv1t{P9yRNk4$rXGVQ@!FllG!U9VfR
zAjx<}15R)P(_(}g$xf~tEhQ(B6*SFbshF~IG4=ZxtT*H(^#&|P+r_oiAgT~Ho+U;H
zOBYjyaw9Fh_lI^4!mj0_WZdy#ZtZmdl^-z+xj9>FDq)*LVf+~$Pvca@0++g@_8Ev`
zO^MmN+slmKRB8(k%tA$#RF!eIgN+O6Ud?*4-z5V5MD*)@EI-kD2?ITUXgjKt61>Ta
zW^BrUqq2>bS##RJG4k=RIY#GsN1CJx_ejr3-;wti(Isn}7P<x{XAh=$q%{%*={8a6
zM1KoXlLo1+BVkHCO7W5otL=Hv@as#7**u4nUF`05oe64Z%IM`X(e*e-{1K<KP_Nbx
zyo^B?2VT6R{e;%o{R}Is40-i|(6jI*r;4&OyrU!4hmxaC*$oA`Nu4%>_V>L--lMmP
znbhx^J00Wk6+D{Lsme#3Cg)Qs-lPC$kTk4bQ~qPLO(Y$}3pzyKwYV+@qSo;tR!}eo
zN)4=6YveGIUHDlIu)rk{tf+z?q{I;FM5qXaDk=!y&1eK}5DX(n@*~XbO0#vUkt)su
zCG{J9O+QQg+;6&*m>HRJ)g?8{B#4()*k>YFO0C4O%S{%i*G2h9&qsLK_MRl^#3~dT
zlCSJVnfY(G-Y>2ZjFOQLP4k0QNS~v6stIg7I~6a;v&YCPp+94MZ18UaIsjJl!(1yI
zx9*Y+#`#Wx715c0waj%!b+22u+xnaIoC+Lh-6EYD&e;ywu54HI4!Sl`t3g9cqU9YS
z@qg=*&oT}u9xz_9j##9|evl)rIod<p#aB#1cGS+8KY1azDqbu4<xeYvONnTLkmup!
zL^_1UECUlqRe^#X!z0}Z3XzjyoB3Mna>imwhSE@1EEI#BTCePFEYD~rWVvtbVM{;J
zcXYW9EU%}ezlV)RD>qM}(SBU&Z;#V^+Y7JXZaC$9f|p-sWMw3O0cKuyK8*e*%t}!N
zLgpDgGF2kB7+eFiWWcH2f44}`*mG$GE*CT{T2aNLNnj&5;%Jq}9~sEjsDKQSpw~i3
z_=6Jw!6_N{j7Du>aD@H9DhNP}3&n~)W`=q|0=buT2iBlKr*F^-kf2fo0Z^fXz||6o
z)+mFra#D>_W0?>5#09avNTLP$(FN>5DY7u!*@*i+;i9PZL;MZg9Y)F(=0FVE&DW&L
z-`!W+<(t)fP~r&h81-AaI64i=X=nRtuX2p>wpZXCQZlpmn#M*#x7RLLwXZk-JLChK
z|Cu{@Ee?}K(j9QePW@2HUidHt42Xuw3ELj#3&C~0;fVuo)1h9Ht}<#_%{{^{teA^o
zSWIWGj`G4|7VP-m#oeLZF>=%T$v9vI@ko3kgy|{sR{xZg;%L|_@LhZ~k@!f_OUqoV
zQmBDlk2=Y_k%o3*^pYuZ!m>poZ;+1FO4hX@)DRCV8AuE^H^s2iHg)^b^$6zN10Qsg
zE^>_~Q8FHPR04?ncY7>T%XfE%M*z6kBQRgEB5@msakZ?4KQ^f#W^TY5$%JBJY^Na(
z6MSvc*9PndzUVk=Q%@G%8Q@YW3c315=+lQAjZHhZOZF}4sk9l3joLH$C$l{W2P`4}
zP~kXqNYE-?mw^*hFcNxlXUn>7Fccb1jDDPR9351}iiCLV{TOmdt1BtBx{T2JUoqKE
zL1@B+)Qt-DD#F67hx)%U8q3$evuhp3igxn!t0TENt-_w(ETT<c5;1#*x%@}Ca#7Fi
zVQ+$X^otD9d{K?>7SisEB-mBCG(&~znf#(Fry1quX>3xW6K4|iCS>k+<oQMU2MCH{
z->~;p??^x_(jloe%OEoq%4DceH3L-4>;r76>62F~DqXEWaKC%joG(a<2!`~lRxonF
zj~YM+nk5ay@Rtlv2e(tRlnKf<KJx7oLlE;b!Ka@s`#oVch2)Yur;CW2<Q`6d!ab(9
zM3N3;$>i2l-XPZ<Gs*1gRdot#QT;4TqCA&;qo9ivOGV1+vUZ6~+h)gGA}ww<aiy2A
zP3N@TxC{;0*?JDbW7+QUzAd%V*Km4*#Lr|enZWdeVOMM2Xj!DK_lwu=!d&iT>9Rcw
z1}EvquxWkWE3RLJ9JED1o6hSo$RO{d?yLb3nl?7YDTL87R>ERw5>%AfTjG&XgkA+A
z?{A9><&?O;185UbBER&bI3YaUQVwX7$r(OdpqJuyf_uCdC)QScHn%_dtc+CG=q#$O
z5UlX6U}Ijc(^tV?G&yJPFhMhLCbQj2cDD1DeH1g3nY6dPlUfJEN|N5=3Z1}Wof<^4
zhlOv`&vI?>D{Q)=+2E349Q_=Ynq?G1N*rXUbG)rj7Ars+fJ=cR5MN(9r6+mMFRFT+
zdb-;n>vSGz<+Rm}x{tkyw9{b7%c^@++wNL7RivL2yTF?NyqK1amUL^jeCB<hC+8jK
zu=YMpv3UF;|Fkl(aDR=a*avpJft?oW5RXhDfb|L>a`UlSZ|!EQio9ue4rbR@zLYY5
z5+cF0b)10<N!U~SsX;QW7<-FRL|V8=F@RGtQ02z4sTNW|bLh&T(}Mi=bA+XyHHisw
zgrMly!g2OZ%Drg1PkTW`z{~1fDJB6@NJ=kM7YP#D2!=L=wKyS$7vYd0m6Jm}-FqNQ
z{iR>Da*P@;xC6fv#%^>diYkxBqy4h#Bj_WC@#mMwja)U9Zh#$Rs4g-OMi#y(VEk6f
zCkTf5!GUeSuq0OHjRiYq#Y8F%rJ^BXp96Wb?~^@;6n=-Yq6+r+xn;%9d;?YV59M>4
zKU*4va_M$XoK?eQ@pa8KI_j8o6;nGL9G;aKbIf&RoAY&l9eez^c$~VX%$32QyNR;J
z=#QPy)#~YQNs1)I!jBdgE+&dUmJ8YohF4_wHH%&E*`DYY^qw3Rn7Jg;wXFyy*fML9
z<yM;NP}-Er9w|waBnDs1L$WELvkEIrEv4pJxw^#b<pW90A~T#Jf%}5|N8W&*NPzSM
z)WtI<3#C8^E+C0-NURi7lk!8Va#HhUbBr-Y&U9DNf+W&<9>cmTK}mz@L@)9RJfDx=
zt~X!iVP`!@@F8=uSg$_)Cat>P2+ij~Ul0-Tw_W(*@I5_bMgrd}pHJxekbn;&i~CRF
zfV<L^@yQt$Tc1lc1dn#t`O-Dp&Ts|WkfYf&vMaldg7u;nO((|B&OFaYF=~RdTfT2^
zP)4ad^nz}mCZ5S~nGkn>f+4&i>I@r~=2O8Jlq!ZEHOn?{py?j-PQRh?Gw|=bXK+<|
z&b!Y#M4cr+V9T#f<3uS@|6<TA6KmIvB+7;V(<jtH0XE19Ft3>?8sz#l=0H^cu3T1s
zlAEbcY68zx7|&@cA;u(I|6JQ#2WSn-P=*4c7jx45fzCu!YF^0~+Vqf%6gp>`+gy*5
zwAw5jR*1uZMrUNCK+0BH9r%+AGnqDvE6va6V0^f$>m`T4=d5kTaAB{=!*XVvk^R&C
z63s5i+=3yAz7v0j*Ol+<?q$Re;#ol4*!*Vf-Rrt)6^{I~=1~`K>`*u8<;F>d9pPY;
z)cqdp#yFqWm<i<)=7`NUGo3BcQZ?P6!P2`Ho-Wu*<lH+mv1P!fc*AGoy9@0bT5S1u
zM;e?}?I)2t(c|1p|7-BCJrhKpBAz0yu|Lf|$SyCkQUc02d0`x%WvHT`lxl5=An*l(
z8Hs5EKLBVo6iPEX1pE?N!TO-oSIVqd$Jp&~gt+EGMf>FBbi(_6c9FU6HybEFn~EO(
zAa(YChTJkWs6d7e{4pAf%OdWhib9JZgLli@_PE@^=f7z<nQmf#2lRQx?0ij+!?U|K
z>f6ybT>H4cJ+kw#!G0M3z14*L{9MM*BBax5@|tXBo~iEs#5(ZvUD|iCS{MJd{(9cC
z+HJY<xnx7mpzdZ&3Me!OhYIBFoEeEyi!w8dOr=;JU!i8>xH2Iy7;PLimRf3PZ*i8W
z44{D2_DElJ%V}gf&4=S0?9SIUPXI<SDZ~?>LzuKLh=FiJGI5p30miJ=usd>L^R<>9
zA3kS(vz~3HXf&Td!ZH8wjth2x;={eL8%6LQdw?Bd+voKPawt#Rpu~QVVoWj9m;A$-
zC;f0pOh|hd-QnweodtO!|4P$x9uzb9_ySwQrw!!x34isr6gZ_ymRKXxNWA0i<0_|o
z(@y(Q;tM#&WZ&@wr0b?$eL(Sjs0!7Lq?GQC#+LX7HvPd==`Hh~U~zBx?pH6J#x8;_
z42xAjV2q{CCfg~|CD%3QNZ~BxN#&h?VH4@u_zNYix;TO8Xb%`%wfhdH2?vW-XWm@l
zJQ2b!krguMVCjea{059S1G0Z_#;Bs(Jpqb2EHLX$c@{>+wox5~w<9>8v~fVnc-&II
zh`dq@2z2PuZDVlmxqTfJ47i<r(a%n1UPTa(G14)dG2b!la0$nRey-36yavxMPS~+!
zl|tG<eKHpwgjU0*l4<SSB^`@Bn&dk?RWB1yN?>IcyUgiyl*wKLO3i1FId2z~cW=|D
z5HR!K{g&xpyS-4FY1V2I186RFg=h5%P%tSI8j^UK<r8F)Kj#q3(J%w-*s8czw|%8Q
z<9k#a$ugsL%2iVkC%DC4AvjAWvfI0TH7$=4C`mFW)IZDrtiNck?00Z~rOja3yu5==
zpDr4?>og>5ajM$6NCXC50M>Dzx*H7U8?Up69w<Ar2!+LO%*lJ97=XuLCVdKW7Q03X
zSO~B_=2r=}EJiA(x91$U9L+o?#LSE*NN9g+4QfRXYx3*q>+|asR1wOrbjSwCw6KV)
z5=4VUd0(Gog||@oC`u;I6wX;Z9w-E+KqRO>+7@A66^$gH>laY@!;{|T&Z}_J!%|yy
zQ4f$<*^sJeg?J6P+fU3J{%AviDoSJU=7$>~*V@S<5@F(!w6*sC;c!2b-UnRVgI0(F
za@dOWFad7;1p!%`J#9Z=fkCVYrr+qUG7JF^JS|)lTJ{UdfA~mYR%)L%z*O*pV|p~X
zek0JeU*UjCbx2Z5ODarT(1Eg*j)N1J%g8TAcj4vuu5o+ieK@gfJUVB`=U)Do3GuS_
zexhB^=dxe-3KRYEI$!nuCuhL|ERL|p^I_TA-<d0q7E@FFrTRuHhmnMzFzQKjXItwU
zM9H=p^#x6~hFtS|1|zS;dFiU5TPs(et9zc_^B4Sfwq4b(x2Qqq?^ae~qGu;95F=Q1
znK6={F<hkU@a4Pz4`cTLBuTKS3wXyicWm3XZQHhOdv@%Z9a}rLZQHi}X3xFnp8IZ`
zhmNl3s;sQ+u869N>dx%{6Y@!_l4juc!lMcrQe{&CjRd%z;6G8SA@D0Is)mgdEf5Ie
z(us-_w1pl7XeOY;0a2DWrK*Y@*xhu{K#YV18QQD;g2y5?pCQYSQTd<{na*EH_`Vyb
zL82V&G%S>Js{ocV3}|00ni|rJ3hFidN|AG;3^)DM#KMX^?Go+Pm)EF{@c(MUW8-fT
zU?I>M6~Uq<CXA>6{1P<Mita>1r!_v%cc!Py7P)xo!um27O=z;-ZGcQ-QQW(?YG2%w
zb+ctke{k_NY%>>4OY;4};z=lzwS~9pO%CHcB%&Ofo_Ljtr+lU~W4V04cpJp)fz)11
zoX`4m%*O6he|$b?hIPXVBD@r@$HIEKT#auF5=+htFpN&(c;1K!U6_}eBbKJD)O^wA
zn)<ibqXwO%w7HfG+UhCCl>lt+BA*6P{ExN?{b1CL4SmEkbFzWgb*m!tQ=b~#JGSy4
zh~Y@QRWoKR9D*i<f$7Y@5(PjY6)3g0YlP-1c_8rP@FG-Cqr8+!oClvf5%h<C$E0u?
ztNqTrg+Y=q6py3AZyX#By@wImRYngVL=B6&0TKjE$tpxXMVYZUAAx~HfB}&8Gsu?;
z(}}247wcUVdT@aRkP}muX#bkgyha3xx?kd|@;;A?mQU>~D!p7$v|yOQSaO6L{q8&>
z@wWUd59ujzwARQ{?dtb3b<X8bXvBzy<zQKtl~YF&fxj{Y&I6F4L-ZPs^=Qox^_+Ou
z2*5GVG)pt{ZOxRyWK0GXWfYc-lcGwLoVRyfXXIz?v5$Vkm{N3xq^&klU`D?p9ovwB
zyWcM<c5lO_Y#>S$8UfoyqNJ2giwaKzmqIG^OBl^$C*r;=yW={mqMVYavaJz5R7y%Y
zD=)Kpoxw7#m7brDo9tm9x<^VnlxMftik~13<5{M+lb*{ToT6(%T$RdCYBoa)g5ZT|
zj^L*`!9KsztJ#t&33Db*hBfHb1F2*LhYf~90RL7npdFl@jDz9&wD$Lw^BK8=7K5IF
z#EO5&CjzSF?RV5%+?T$OwP<}_m(JB(9Q(g>(&7e{9_56d1kxUDxhvz|bNhUEE7cG>
zd0oXWzPM^Xi+|=!-|KtzGn)__Dut=EC-Axvr1-upsP6n)hhV!%LYO+*^4WQLmxaUb
zRdokY;q@i)wdrdelrnni*X{a1exvy<lj)C9C|uSEAl50DI~Y!)*V6ojes9Jgvg>k<
z@dt;EnT9FaGxefTL7OIwn~O8yBzLlZ)p;8FT#nN8TqAMiJZ|KHAx*1T7<|_re8f2F
z1lhnpEr2gZO{bjjm<@l8VvP`Kq*dzYPkGyTCUTupsj+81I$|V&r#z>W^Qd$0m7%)o
z>-csS!o6Dcq=W6~p)7`<q>iJqy_on=G?rXkumdkxLK@Hvh?Ma+9>kk^Tbd$RqC2Au
zRD28sd<^&uBMEiotlcPMaiz=E_TUFIdPQytJ!^Ppv#F7sD6M&QI%FLJZILMh*UDkP
zMnm?zw!Rt#cVFO48zWx|za)Rv?nS84vRr;r_O=^6qC;SUMkL~as|9>1L4PW2m_%c&
zZ_;8XJC!4nqqH+7U;FMbsJ?yp{GR7P#4L>%AdifFc*_&v^*JldapjoMK_$%A{lS-m
zN3UzuT((p2?g3%_JDw)p>Y9~^l*F_!S=FXWE3t*LMfKCoO!wCOWo##KM5k5OXVjNt
zL?$-7Fus@rHL?!1BP&>C9O-)qlss@%T>~wG>DX=!$K{Q3(H_JU4&1GqT9{gCF$YHd
zJUkm^B8VZ%GWM~xoWOxN8zgXPrMJO2135iDgJCc6{wu@Gl7a7^!x9pm%KA8Xx!8lK
z18*o{c&i+itp4LvI`L@ey(J8Pap-M{`epgdO1++x{!G3}f<Rkx7#?%np+2)7EY|@)
zebZ<*LNpFuR-_3zEM9yHaVBaA1%qy4Dk5Pb#QZ1K=n~*QZH72%ZhR}@C4EW{CgaB=
zNMC$LI1LYi=6W30#}|RkI8vcQLS&c<h7)=t3a(2j_-bNsm5VAm9r{}Mv(s|)zB7GE
zc&H2|H(}<ykdF+RDes;8!$wKCb+&_pb`j@j>fg-4pO+Oj3)vXvzF!*|uFn>?vXxjj
z%U|c-izsLyA4o1zYEK$epVJk>EdwN#xTOt$x?w3g8pd&dzO$dM)$WTN45*(f%Gz8O
ziH+YeL;Ir|&`^l}(P0dT8<s&G+je4`^LN5AU*%ck806`5sq}_mJN(T0z;$t-eoV%u
z{<CGyYf}v9f__K0>QS-M_yDUwIj|gfYi1n0pi>pZq6Yc_i@{-_G+VXs7V!8Zt0ATS
z(eD?9Xn>f0&>P98=bf~{Gskd0JcFEykGeZFuK0)<C$XJ5UWDx8NTW;E)=B*vKoD%3
zpl#@I%tC5=f7>&0J4^YdN&R5HeDz$OD+e}5awEvQPum6wH5jtMj}_~<IyP#Q)L3j8
zk?cTOTtX}&yM^N;1;CWFbMm~45|mZZ2lJj2g_1_{6ytJZUXz`rX&SlklV!;KYZ0BD
z{h!vOBb3VIrYC@tvmoLlmN!Y6O-gEPq^9;N!}aB%b(`b4-K{_$eRS6j5||eB=wwA4
z5t?<--%T@#1m@$bv1NiFd^AxFC#@;G8j^uk)uvr9uW`Ep4HuyYkj`1D9kYamI-&jX
z>7OH<2KpXrqcAV0BFRTc2M?}Nkflk6`lrHZW1%Wi#8NLpoaMP_odbWLD%QvA<ZgPg
zI!jp+<s}~SETCizD)92$sKu;zK+&l{mq1>-{&jYaIvx)+&WCXBldiDMEhyXVq#v>?
z4zT=sL+E3}Fd@#$e22aQ>`1?T7r@7j)|b-whsdf>OCe5+>UpA`D)o-_waoqGL)GKv
z?#6|8|6AD;ZI!JyWW44+%1gqfgzW5+k?pP2T}2)3J=J67QuQ6z)l1_J>*bca@0lS`
zHqqnj*o70iP$h(BuMC*Gqcuf$eIxne)xwFlPPPB|aN-%VOUuT^Bt9kY=AO&)1p`^*
zm=$RG#vwC$yG`uo#iN_EPT-`xl;G>TM^}omF%I8~HA{;YNg<a;g{l9N_4J#WHXgau
zL$66Wi}A30fzHk5F8=GB;%Q%VStnc^j@&5#J6nV*e|D*~xgMZQ5c0VE(mjZa{`M}1
z_{47$|K0u#aF$Lrew}BkS$T<MSLi$RGy-jdTK&+#PdI4ekK4LBB}Vmd@cKF;&U2q1
z376+V!anq{H&8l3`zvy&$c|7T8x4-(N_{a_%Fv(6J<-r>KZ7$zw$`)g3hN@?Ee4(^
znUz-j-$B`=8+LaEktXm1Hx8fHmP_si1*=(<GPLaXpA@m-W|sCn!FY#0dxg$v$A@(C
zu|r;N7=Ac+Lu9oRZ-A~^9c6v(o3%*BD_uv3Lu%;TGK@p7Bs{9@Xv%UP^ykVIGnyfD
zhz{o((%?2Dt`(`?5PP>L+@ATtX3um~3v%>;*$q2oPTD8IO_QrpW8<Jh8#w`zl+v*t
zgRkOM>U7mEk9oi}FGYJo?9SXoH8$fKrtGR)z&@2lh(4t;aBQZ&;0XLY?z%P}dYVIA
zo`ey$=K!9<2L#D2l#6>C9s#v{i;Zy$tw4T<y9CCH*w1}=L7S*ZXD(uhX-Pbt^_M`K
zZwA7r!C&>ZH)+!;SPCiTypjS_z}dn$9l&fPAw`u1&tKNPLN(FX*%$2u)DJVA#n%Z}
zb#BF;$c>r9Z9b`~oLr15!GH_Nbtq9PB_;_6ZuQ#OrUv@OrVUw4lV>?CpSt*_GXpHW
zzal<+Zl<m=oTUzQa#s`p(IVAeI_4C6!ksv51i{{>oy*SmNcnIQ(%s*^-hJ`|n@!j~
zoDfXQNJD|^fI>$!725VORFTHvM!bq<iM#59X7xa#)r~<HHDhRd8u*u(J)p$z9EAK+
z0a&M+U-6xEc-t^)QQ%Mr58%goA0mjZJ0ZncTJ&E@Z1Xxqzfba~FN`WRN<AV^U^_Gm
zk4x^8Z=#H!kX~Kiiy#g)95XFSako}qj+s+hH##PrhV>hnl3OU!DJYSUKI8U${8@N(
z$SEg?HN#7B0w{c<;sPMzrLi<i#prO#z#eK;lyEEHHiBJRTtVUTi@m)kb#V89QH}B@
z2qdR}BHBWAOZQxE*V~Me1sDfOtv1M^2M4Hn&b<kQ3X%cyi5V{*;(3o>CQ7~&!5SN5
z*u98u?hQW&{sL^T)HQ@HYb`25Dg#{*TF^qNlxJ5KGbX=_V~Q7ya%B!9jW~)>jXa^b
z@v)D6j(Ya46|;gBEkZLK%M!34`_A+C_nD@H4`+f#Mw%F3!xrXT6gP=(rDuvXG<&45
zL!ATwOQT+e4T|L^@VR+X7#1kUK_Ly+g_TlVEbP+h^4#J--fXlm?nZS9VTNG0l+|@D
zvL9Uyu7sO>u^VgsSi=p;L#h{95aq@PJBv6$0d4H`JR^*y+MI3$kM(b|lX2q42`nuM
z@9Kljt0DniGp_&TsJwJ)y5uzPGCwgQlTr6e+e8azqh#G|9l3+NEpZiPBWZ*E)&5le
zp+Gq{)&~|xiCg_cU}9%{XSL6n)>PMuYkFSQvHkIx?JJ_JaA6Fylsvb?eiYflbRlLi
zG`&PPO<MWPf|a!j*A<Ttmfx3zjfLLYIb--DE!}p6A9D*eJt1=yQmGMfnM;AVIyjeD
zxoRPXDn+cQ6NJd4e&wgkY2VK8_CJg2s@2uy<zRc=^Y)X6sNRl_l6*5<Hd@-+m0atn
z5+P@28tFe}n=*t3$31)*M3o4W@u^ntdVL`a>|hIHs;h!SE%m9>q|8e8I!-t?EhH<e
z0-Y20<u0pzOD~DIfClkT)y5<hH*IJ_rh|GjP$7%u?spS|idvSbA|a)-C4VcFXH2mc
zm^f;tmhYvv*sUFutSU1~y}g0a#Hj}^(_<bV_kXAgt%Mv=Apx;rnIpmQmyO{!eNr*X
zLH<fHI8dDwpbi-nH{+jf&`1(b8%Z`nju|pWaR-tXArvxWbgKO^Fj+bfKpA|%Ramng
z7em_O&F_l*Q#HTMAqM}+cBXab3Jdsx0jon0k^aCqv>2;Lu}PcL;Bwr_dVtL4-2aV4
zHfrgl>S?6kp@m&>hs8GQ=QT-heP);f8MATtWd;cgx7)Od(fa4PCHY+@ZYG_$fQ)ih
z)M^@Tt?ldtGfii{mjO<)t&J7BGABcqd$|U6O3jRY$h0<!xb3YDn?qy5LfXRV@S-g4
zJEF7J(H{+|9zZqKtS{=-nZeO09pXPfgK^P#5Hf0H5kr=4&WNarp-#%38vW^W#aS0?
zkgbJeGmx#%J?7|<oH>Iavu3Mm-sm<V-vl3Putv@uG7ti3c5#kjJh+8Cfb1dFva*By
z7GAu05D|wu)ztFh#=>dw7WOjgjq$N9=@{sG4D<%h9=sYW`KJsECeD_Q+wR{U8hAtp
zJdC&Xbz^e93E8{FVCfQi48@-hq-@!e5hdDW$=vISH}o>i)-BczxvY?X+L9;ME+f_q
zGMqcDyX~J}_b=(I3><O^B<#>_`5v?{=Do=DP3yjXA>5#G*Bed~D;D$pzVE<ec_Y3A
zM=d~d^Vbp6=9aDuJJ#Ix=Ur1UOrikcDzb7SWlQ1w64dqS|56(>9lM)bNUYHB*Z@=R
zd1Qx#KH$xzT2g+gy*moU2;{82+*Q1nPVqQW1`SfTlE~urfO2NTEEw+M13dj6mE{z*
zd$!Hwv-an>5`syTS(IC}UaL`~L!&-@C4aSSvutJDX`ppCwiHK|w@6<gS1Ku@aUi)F
zZO|s!Mr8|ri@c-$d~&&9RCGR;&XY0+jFud(9L^G!eyU$rEYq)=Qnpl<vEybh9LheF
zo=2TtoL!ljaxob`@*&fw-67M1%TZLTBD{3Bfyih|9##iO!|XcSwG9T@BgqJg57gCy
zIH?pljvgWFJ&rO>DxZj_VXCcfZ*`~Vxozs?b2)llIK~dD1;BEYx*J)RF3FCyxo!Q|
z8UulY*wD~iYfe6Pjm&V};{^~dkkEV&<ujjE<J>k;1)#c`^Y2uhftqwLOb$DI2Dx+^
zc?;J#ypZdWft09gVc05U$JyLHP_k{im`bckcCg^;bBQ^>W(BJHgj-nCl4w0LVWMOB
z2aMSL>y4%>I})GPZq%=bdS;YK@<xNkMI93;s)y+}TV0PeCG@n~(_+keNn3D@({-8W
z*u(uvL0KBhinQ0r;Df|9*RBG1Pc|X;(YpuruR&23X^eX2uaU(1<afIk`usFtJs({k
z=m!>&^MajSB)?v81Ct7W#O<2~vB1<L5r+Z>zeVPoJUe^H{DJcUrrr#aPJ)eo%o~f|
z@^o?Lc(rT_ZAc-q4W^BG@D8rd7*;UV>!>NP{v=P)X9K?#%ZCvrfueMx@>(<*gR8Xu
zsS2<D3kc9GWDM?z$5%5_3~VgnIT=&ASXD2Ln|I2p(S-7Za&}BXeo{r{$nYG&mjbPp
zh*Tbuky|PQT?;3NNfGw}+z_OOK%hV%AXOjf;2Z#6=s92aLl63&%^&CL%q-&L>dr21
zlLo)<@!_IRf^mW4kE_3<-(?qP{GKa1d-lR7tn3n{k$A1-=$408g?9@j6x{<=y`zb1
z0^z@-AkioVw+2v6nYHxQrU5s+msn$U|JXmCTcy>{+CE^Shet(^V_&Jny1f`b%zv9o
ztz|c0gVL$kPwauHX`}0M^c>dMqR!v(Vf$bA{W(R^_i2JvK|^Ln3y5iA3XKNxD`>}Q
z^6SHo86u5MO@r;?Icefz3yAJy8|qK0737aU@XFv1TSeSxg#!jD;1W+1`SFE*E1F$!
zAT$ECxHKaG4ZwFwi2GwTi*Ji$*fZimEW(o){9c|j*oPdD8=fO+I@~sF$H9BDgvVnq
zPt@STr!06blnDdX&qEs(YghB=8<^dZK<N`8k+di`&N-k9w;~v##6g_8A5PKwjIw!-
z6iaApj1y}r40EL_Ol^qUTB?0OHBb!kY7>LV5W=WS87AFX*`dWE$Vjc`$R$U>Z;Z7s
zBym7Z_$_+)#uz)Y<Qm|$mv@Ky(LM%%6=sYR2#j7hP!41@?)Vh(9xUPGpvCT{q~B6B
zo=p~bICAzlUh^W1bPFe4Vf(m7GjR?9Hu~XH|K|heRCEP1S-<>)^_iqn*y3DJ(~Y<c
zw3{Hnq!nLUNtO4GTC5>~egCo{V^QZ_w*jqlMJk{53V_d7^wSsPQCXo~Ju1qq!ZY*>
z>{9e&N-WzMJLSIRz@TN@=h|_ik-U`ryvi{aK^t@RoYxPwHMU%)RriT9Dix#w2S(8r
zZsg!mPAreH&INnh$|YBs&czx$wm!a(B_~nxVv-L_j514xnvbJW$>s^84}WslO;$k@
z0H$TLZn_$UlpLI`A7{?_XI^|zaUanb8miS}rK(Ud$O|Lt9YVkgT$<R*g9LPwd*Tm>
zSErwQa!#)fZmo?>NI;NjpH$)EiDphBDL*l`zVxQVbBQVCQv#?ErdI$q0<31$zCBwP
zVe%R*<lRxh86%vZzAvBHFOqQI|Lrx-wW#&FRvfr39f=i8d$Dz9sXWzox}%Q16GnQq
z(YzfLk@b1PHm+i*-P(GG7QT{j+sp4sIcJQW&~4C>%pa`Ylb76<hvNUKOKvEQ|2xBE
z9cdY59mNBq9WX|dxCj0hfhYaW@1!ILX@xW$iX?aKJS^lp8&#~+25<>Me%joz-#c+q
zqkd?7VGu0>O2<}dFU(w^3}q0<eoE*+$Vp*z0n&p2;E!pkXLU95d1>0jB=}a1N1@|0
z)y5|mKk*Y1<0$BVeSKb>Can?Vlg^&*HNJW{R@q&auo%LVXw*E20Cd$0B2lkzMV=sW
z9Uzc|rw|ks9;*^NUn54=Dx__ma9@>V=O$6gtF78c3!{DZS}d5@Zq2FW)I~RfGk#p$
zWR#5W8u{gt=`MRb6>g0`rbS`oG>+Edi|mIQ`DgbMBK$b0$=D)b9t~Kjv)2<?c^;Ok
z!LkCy%)~T=3&RcXP;&|3)OO*h@>cPZ3g~Akur`g#4>&kzNKjr$g4D24Rl7H7Bi_DQ
z13F;3(0lMmUTEXS(U;-%vq6{Xr`}-;>J9*uC=>wrjl&A;^s5s5M4h3{oYJM~2EIRH
z&fYr4U?klRqGivLLf`nM+MGbcqyMp1$hE#u3y1Re-t~5E`=HiTa)Ps!c*1gg5%dXX
z)mV*MLeR!DjnxTFFO63U4Qic`3ME~?31#OLg<!TGf)QF_&7P+I=t+{5yc3}0Yzd|b
zTo1&1HJK+T;dl(9Tw?|zSmfTMb{6n2CA0(OUIT3><GRrF*PbBpGq$!Hj+O0i1BY6F
z@c^5yF-pES5jV^G?HYT;of0{a@i{_}ccpFsMfgdOq{~ggIZd4O;f=g-F?*R$StfkI
z{n*#%=mK~7j&+k&@Lbe4E^D*HqvO}`Ic@F6yq-*H2<`RM?V+Jb!$kYidsN!0O&jC0
z-$l=|<KmG)^{jU*&l)BD3*wr`T9zN8`F*+xqw<I*W5ZA!y{DRB#{eWV#t&v_AR_rj
zkE(eZg!O8-vews!AZ{9*&}pxDZL5yJz0SJjN+)EI4+KwSx~RURr8lq7Q#a&+1&nC?
zh~{SP({hLx@2F=Gh?iAbe1F6>D3xqR2wmt-1Kf<dO|&lAR35{IWra6`BSSKikz6!=
zfsgz{kZU?Y^if%6>^XC<Y0^{!?v!4{j1vND{Kn%wuYq}k3+2)QF?z8x$|6*6Vx9XW
zg~-kXoST~>O2tStp0?{Wzb;K$tq7r4B<y%fp3ot$#DS<gZj?>@_oHOnZROyaVl@<l
zqcw<C%ukH~;OW{aUl69DB2TrXxXJSG2yu_$UPH`S951J{7-{*hs<=tc-BwLo(}~r=
z44-@9(5|yx_66p}xXIJ64C)OFIR#$ZJ4veS_>mN$`R$fc%iGsiGa}<j)~I{6`_s$7
zmy3SI`e55)3e?|#2)>^}>uHYz(j2|=m~^5rdNCG$_3mRbukx>W-+cgcY08&J6mJy5
z3Z?UE*7>u*Nij1<BDaS|5u}(=ENqiz4B>2($dDj?`UPrHdAiEZ9Mn+3y~}#as$jui
zHo5c+F4A1lX%XWhJtZ(2FCb~4oN{AIE{$vZb#466gT3;eREj9Kjs`bkII3*5;BK=F
zX?^H}B)n8*u%I0z@i<$x9M~)wQ4H};M6u<+NdR!Zpf-a@ar$!MIPGzoM5wtTz9Pm`
z6>C_AO~NIUCVKmWeR8p1O}UJ`n#!BBU}0dcT3&VWv}!*Nx7sGf(9KoSHzviJ^z3Mr
zBGxMI&*3rkoC&<FfYk|)_=v3oLel~aMwB5z75w>T4&!Y8IH}=@d2Y8wygb>AT<PY*
zrY216p#<tu6g^iYx4f`&I6;PbRB-VM&{taQ(kyq>wYw){`IKR0(Pfx?9VQ1QH^zJq
z%r9SSI=~&hlCH#1Jo{bKT6?1Xr^Qa=^Ij`d=1i}Up-cBvY8~V%U@ca9AeaA)Io)JG
z_VYDarQBcfglwErcONPaV8{=L$c=dVY>KsHM}=9*Qnt6zPsF?0&m(w+j_Kxe>=PjF
z_!tXs7LU9`49{)A%0f`Gm$WGH*KZnRn`X;3(rl&S>N&AQhDv$`-m?4;H;_l<NtDSM
z@$npoYo?p{$@@iFiExL31XR2y@Vtp~JK{hKVKEZ487EktNlNnH#biQ?4#4}p?H=*Z
zj8>;)C~V@ve$X`Bm%jvC)cJD)&;W!%{K8hfpg9nPipgN)2(;}tKZ0Y<yMt%HL1<tH
zXp=Wd-9l6pA^B~PIp7UY^dK9!o?X`hpuk!2<DK`jwZl988Q`fdou|1sq<RV65O0e1
zBuJe;(Rs*bbpU3uvI<~jr^a287nd2Ao3?pevKA?PMVf@_#5rq+W;Ix0;3hj02KGHd
zo=8f$aKEr*1wNv91;|>7aAX5KL~jxmy(3-xl#$OurQ;-qQU&>Uv?;{f90U}M#&hLo
zcprFTj%iWxLW11kJnwcboCF{ZEX2|h)fq=OR)G?<;r(UEud`+WP(LZ6QTaTcpPda-
zE{I6t5qdcag}rRM$`sH>&mNFE_$r~uQK?Af2fXY6UCpP7V^HzZ{UbdX$p|F--9kol
zU+_<&B@nRiH(_@E<k<K*CL*Z-i22fbWxg87n&$DRYmo}&J-qyrHpl1Zc!~4)Y05{&
z8v+UmuS~qpzphS<pJ=Br$4dIW14*|#@*z?#o7umBnr~?=jCpw7NDu2MnjxqIK+d0*
zJ$f#{56Ld<5g6vmU7)gMDd*r21D|Qsq-OH3x4U|4YOFDfWU+CE0Cvv6c%OG5&U1bG
zn;d?YhxR4AIJGAGXy3%7C9p}66a<zbHHM*beh)8jb<woF<FfIXe+8PtpTQr9Tn#J=
z{A0>p9r2pkYED#4#iB0dQmZNiqz=pT8nFa*{xu&qtV-ApTS5h<dd9PepG92aFB7K4
zeth|%29cE7_ogBUKH;Buy)!!mi#B{j0E9hIjq`aXN*LtHe(T#%Rwns^f)_>(h)7T6
zL$C1e@w?1sB<P~c5_3lFaob1D+ifed__i8X9Te<Jhu-BQR;3BVEpbeZ<+INdt2O6}
z3$8e4>&wQ+`qP&+Sf10#tM0Vu{f2j|A&oHk2)SqjdtQbPRN@7MB7l&XPXSb<+k=}<
z0Qb80X7R+X_~nOJ&%43O9U&|$-JToCgdNm6YwH$E*PHKZ+vD+{2u5DVs|8KfWTO?2
zXZz}kCgZU>qM=y$H;!7Qusz`2b}hsJ!?AEN1NOR1cnu2y@syy1Ol$XsV7?Pe{G#Ye
z_%b4RGj{6GI;w`Xx$N1?gkUCXa{q?4S+qY-87)gO*s~$OJ`AVSsiwwR8N04B(rgbW
z$2(k2sx%Al&?!|t)Fw|H=#!FmOiEuU$d9Y^v}o|jRs#4-TV_Y>lUsw|(0t+4hvjJm
z<P&vbnVh#Qp}#ZcfK*ScT&{eZcMl+oc0sb)=X?NZ`4JxvwVJ?2<h6_^87F4nV}$CJ
zRF>A;h4zU*@qB}h+?E#Tj}o~4M1K`~nR>YZsplYH5{>yxWiyV!-5ql&`F!_=zrQ)o
z3C4(D(lcq?DKnZD#hDAFT5<X3`6=}T_ci=FVhSFp-#P_-->;ntuAhiF2>mhLHkvWc
zvcyrD=bX*cRX~MBOZI@uZZQt)dY7IQOw(D?z_V?BQu@T&9Er-~))z3CyCzQ@p_4MA
zrgmp+T0h!(Z{f+_MjL<avlDZyQO~pcn32ihXui8SBB~1hIIM6sd7w-UfR+A!ajT|Y
zJEcv$I`R30@wqn75qpzx)D2c7Q~s&kh%zBKB|Zj8tXYs^+rYf2qxeQ|*%h~7{IZe6
z+2@LWg_JEc<U|^wv+%`cMsA;yoYY)lcZC?;!<{&wptJKwSq+k6otQ>7y4nvRmv*#1
z%4oiSFDFa2Fa6c46|t^bcx98}O2!FsO&*A$hERbYTmdHjgF4U1+o9ujzwvJA&~>B}
z^)>FYGQ1wstV`fEF>Q|+%Q2@F?{-kzy@aC9B60#l^>PfT-W5KPGNg*Pkh$0@;6-M(
z`fc!tRQLHZ@5+mJ@uPN=K=lBo5R@eEO6$Dg`R$Rrb!RB?DrWr-w+Z*-k{50XnUlM)
ztTM5jvpwT7=lzA2RF{|eC0V%}vkKM|Y77uS3xT4=`?mJQU$o{@(a^1DN@Gz3>Oy({
z@`gRN#~Wl25v@$58e6nbu`6L0)hyal(gn;0Vhe>$rRvbShye#Jk3ma8Lt?9VIf4tJ
zlOo`!j%6fpq}3sO%Z=jL*zG(iUp%wXih%x}9!wSai#&N+HrmWd3(VTE6IXuyigo-`
z<$dDOE{i*?jpE^Ue-bnuL{ksZy2}kl7tD^U>E))LllND@=OQ7U))neVfG$#>cEh_2
zvF#|>g6G-M$OlRl!>+wnm@}L<@BQO`MzxezsIELB71doftu$3%R$_H)WJOhxV5+X;
zn5pd7ZyA(pZ-?6^xbu&*57{c>F_tk3(Pbf7@7&q1Y#K!a8r2hxLKwFj%B~lXla6fB
zFqj(7I2c^?rrVd&C1Oiq#a^*i`af7?Iu})jcZ#;+Ntdne<B`wChr*A_kF*u75m{3@
zebtOrdx}!Lo{aU0+(umezR~VM2T8>n?UO26M##>OLGjFVFQsz{*k&Q375raRUyxJn
zy?b+9ha>9awARb<=I#(0HmT^wBigk#345CX;lC<3j6BNeEcPl%Qr(Yg6=&mjg6r!7
z5WGYmK)G{<a7KQQF+QgotaaSWQ%MFyi3BPUkZ3?JU$+p<&S3|pP4|afD<Abvr)dkb
z(CRw71T3;p@;)1#sMCwA6dG(#(wbT7j~Jr0434Z-*B?T(DlH4yAWQE9l!X&n5LjAB
zIr;ZOdt6qkG}V!-`aDvotC!}+CyjDVR455ixgXfN;*WQ)@29b@Yc2FhMQP<{52eM*
zQuTFG!!R3nHX`+nBPAAB(^6H^-qmwvBFQ`ETi<&9yo->)F81U<idP&`0vpa2sYn=K
zO3|ytv2<F>Yb;AF%+z()<5w*dlTq!>?_J(=W{d0CxHqX`v$%4)UcTrhaj3%$;sD+>
z+H+4_)7(6UwZr&~8ndLk?#vBmO-W2b0!d$MJ%zQ<S)>D8XR~$S8mJkDCB&1}Nf1Ty
z%Ep-!#pZPuyXEQ-57`$_WSgp&i@%F~apSxSY^kFATwlL?o6OAc!}mF)-~?mzzdkp7
z+ke`gdy_lnp>LJ60^7LD>8ZH=^s8uq+lB(Wj<1qgkuB3#@p>8z90TJ?%<;O*x%5RB
z<u>tjmS>x9vf7w))!u5yKT^d`JwDfbUD3o%dv~z`Gu_hO->t;>(*0EG`W}|8)pfAh
zLFcl}_tXWvF?2&uZc$OgyeRI)pD#mERvy@ci%~J7Z-=3p-;rFM#{BS@+&b{c>{8W#
zbl+B{egKGQ_k#%+SwH}sA>xCD#w<#BFAMzV0>5`KfJa(#GH<5h_YV}9mYWe{Xfi)8
zQQ5T2>e=<k9zdzk9sTvX5rqx_ZRv&G2~EQ=_7e5$APdOEgnMC1w;$Hpb$AcAHv`&5
zBGds{B8mNg;%eyq0>c^t*^Ef7zVGnc<*^}8$F7_~D4=)Z(p(pkuF!6upA%ykH`_0w
zzK}J6tgmg5gGAs5NgZo_;mEIW1#gRpPGLeyQmiEMHRtZ7?G!V?S58`@ooW(OB&9Nm
z2{(b)J2Hb?MX9rlcpP@bXxxDi=R3HVXC`%mJVprROb)60Nm$#R0Oz>tr6{6m>)0$7
zpG)L*<YaO#LFdq5&Uzjg&t{WlvPUwlYB0E!ae#P=u9k6RBP=5Z+=GKzBDv|e>bWs1
z8^Bo4*WU4TRLXAM&*>NZp9Hw!s2y)P>Nl^B06$~uj8(5*?CH#IT-l#0ou`JLF4DRB
zVV>Bau=6(st4>cx3eO|ywwwwuJYo#OTb=kHW-Vf}YifJ6X7j1V={Rrn#|#&3mAp2-
z7P@y%XNGJ2c67c1<7W{6;9lMMlJx3a5Y;REsrB%gFc?=kE4MrZS$;#PLfA0rSb<+S
zqiYF7@z$R)sIucESUAkp<Pn}eqNXIwkfcW)x5-#JhfSOViWas@F<}r5w5k6YPq`I+
zCB%P>0+~bKWoR-!&74Zii=IcIpRD=Ao@fR{zpAdE6ZRYrlM*YTd=futp8b#Tgo~pR
zE@#YC{)r48SBErV`_59m%+)W}SRJR<oOa)t*^+aDtPW456QunIdd4H?)dT7RC+wTI
z$@4Zl0aEC(^T@=Z$O{(yq8z6)R`&PC@6qnVT20N>U;Rg}o6SZY+G=&}H_0Pg)Dbkt
zSUmlgZ)e_Pkry_VGe>i$kgI?89Jh3IzLKJ!_KaDb8)-4$>lz#!KEh)TtTS#1USA+@
z>2dcYDO1+3@1j9eKlsn)XJzHRgok;#KZ2odLp0{VI-mlbMqT5`at66qViqU8!2A4}
z9C;AtOKgaSqzDnDFf~IcdSK{`N>4TvN&R9Fc~i@~yKvSuyVplM{PA(btybpQix4Ua
zZ@TATzw=zilr5)yV5O4+-2vY5yDJpdrnSd+N=;i>i+pl<xE`3A;RK!`;}k)P_#e1#
zOBSWL;oOks*j|3H2EhV;t@(MTVWx8kKX<>wkJErke}LL`0TR-O&T!cs34Y$<?fIR)
zlpf*f3QcmwSpubC&1CUS?PjFHXBZ`BDmJQg2s-At6hBV22EJy%(D%hg=^hEbJA6vd
zaf8Uzuk@-HRSZF1)m>0}tWR>D$K-HcxjLt`YkG8^x91}I;I$L;TzyIn5N2O_%D!oJ
zc6`eCQshFs^RQu@R%@aBQE60Kn&$9x=<{af#>YyNhtY_Je^NBT-i4R9M|&gDo|F8v
zQRqAnIIYNhRU0)Ha;0F31fAiAoXDdXCvSjcw^PbnAd9G0F@t$!^{N-Jl>en(G0kyr
zZc;38H;$I}WTGLNb;=VwSi<*^FTf~P>7ksbUQ#^wy}d!BV4gDFs}QnAG}b9e@M7-7
zX%b{*@bw;KrC{Vdubdf<tA!QbPe-cX#<P!POrZp;Oohr!?{NZ&*YXmHib~O|ITTFC
zLT^wKmSWA5`P1-Klm!jRA-V<AL|)8=&O%?U+>kJ@OCKV60M$$6Ovk#qzo)y)x5}q;
zeLtE70zV&U$-WD}OoKr`Ftb(7rn`1xzw5JZN|<w#8~SVK<wb$;NMPcvt4tS8V@V)e
z6*a^+lmvhwrwh&is*{p{FQL9m<*_4ExdqOe5Nuh=nZ?<<D740f(8`-3(wy~+jM{wu
z5)gEs03+8Hx*<hL-#)lSoxA3xU<%Sy`sISip8WkGuq2@hCBZlAl=C2bSPRF<K6R1P
zw__DFa(Al9nIKZmh9&paE+AnXD(W^V%-vE1675>Fm66yN10i9S;*w6~Bp-MMk=_k|
z6&=)l3gwBjSsRK(&{8RxfzvuErY}nFKn90+kgtc~2oglhR2wk=XoR%p7q{b-$AIx0
z$=|RuPK*=Y9{VAEjsq?$F9d9$F~jm4Zblqr4f;uik>5$wEY5cY+y)m{j_1P(gEHe_
z=PIv+(d)rC%iO&L<e*UU<Xy_D9ip1qw-K~B?G*ZpE20EeAvS=z*Q+McfB~KnxCr-I
zK$YmjcBB(eFxk%kOJg3S<9+?Mvehb`9AgfMM3Q+E3>`6rUlTuS|9#XlQVcs6(YSMA
zThc#vJ{G)XT)|2~-2I1uWeITn=%#=qjlk!e8M=XZrvfr|%Wh^nZj(ibMZvH(Q*}m9
z7vSis?1P9wxv2xkk5wtal+5pSQDT(=am>g$$_`yor_p9{`x-)xbdLjh3$AksVM^6P
zlXTX#bv{NPPm1B{WpKN=zd4p=8d)lvq<^_;6kp^n7~4q?x2LJo2R1A`@Kbas<!hm}
znQ3(B>2heV$kueoZR%@8@I*)lZiw!I;fv7tYgsyIkP8b`6G+l{2l+%^>?RbKvbfGs
z5`m}&iD|ACr8UqbRr^1Ud~R#B;&s>-WivKVk5rbq78Po>-lMJFtb0x56apzAwos|3
zZ#rQT-5%6E@(<H!+%k3a(r7EF&v838q$^cLL{`J(FHmiVkduyFOr|AMj^Phm`#rZg
z->0HSieUCDYbF?&df;VkaHk@p6*2~%NXfD!;e>@%uKfw8RLp2H3hhrC$ulxBt)s1@
zXyj%mqLIBsR4r<Hg4RmBSV=z3GO=wXQ~6bpu}H)yh$mkWDRkDaXIjRZh$Hc2Dwq;7
zC87xY!|c6LdqKjZoaRspCY;-VWo|BIeKT=|qUi0*q_%(FFEzM%0jSifPWF8C(THE+
zn=+N=AS}WsA$%+f1*=O_av-~H3K|cpBv8>TGF7$Et8dQl;$6r<E)Spfw;tK(P8WwM
z1S{)jF5RRG(_KtFk%ToGSRHh$;N+&Vxmuxyg(Jr2jr;m!>c58$4;&ePR7&2rp0i1x
zdt4aPz-JNU4oq{}va?P8Ww4a2bd{{$zFh?B(FF4ZV97%LSQrA@#1AOPv@HRUizXN6
zC4^jzBnxM?Mh&WnPv7E=w9|@bsfXb`LM88pOYTU*4qSFhERmMPwNOi7$uq%E2U2R3
zxE2n|NG{e$+hM7v*=p*NA9sSoUM>g0*cgv92@7jF(77*@uhnfOZiCrgA~f9)ngrlT
zswI?y`FNP$q_9POybiXT6}ibFISaP;s}@_en-yxzC!BkPXA;Lawtg>VFC*~diw+=C
z@U&6SmkHp_4Dj(guA~5B`RfG&U5i<j!D2#q3WtBT0XC%Ch$wBRW!muKhwd$;hxpH}
zkZK^^$2zY$wwB`5$-aXzE=+HJAn}qGxGLI!PcYH-G<i?fT%O}|Jq&552i;LKyO+92
zen%P`1XBA-Eg-ZutRpO|A(RP|!~8FP?44t&jAak@PWEL>d5ov&a?|hdJyRMFzexdw
zV`&NP7+0EB>{~mi=#v+@rR~s?Ex4@9&=!*e(=Ej-tk1_^n61^4@6pu)l_HPi$RLFN
zFNmr1bY-QcD~Y0OYlaFq>vln{EqdSa5F*X*wQCwsD~ZSYbfVqu&>?~IG6Vq7ec47a
zxjztpcyXy}3AEg{1Vf=1=mbh(RaV4wES8zx9b?l$XPCwc^2)ZvfD+c;Rf14?$4vS_
z>C;u9`adh4Gm=U1PwlrS)$W}qo@Z+%%1v9C#u6}Q1pc&#)rK;GA2+A77~YV-$4GVU
zmh#_;OY&xVdga+c{vM|h(FLx+8_QEXkRXq~Bce18&e+R<Da&BEug7XN#r|fv&ul%r
z0Qb@f0~haCyuw+NWn^}$ekfMOLUYg)E_XzB9Nzlrci!q<r%9o}dK5o1`J9ps$Q|v^
zK7qwPC{e))4DoSkmgviWPX6d}D=4kuBo*g%wr3R2Z{v;oW0U7JvVTN<>$ibI@iO;*
zgT6(En40vs)NWN9j|tJ`?U}*8QD}iAhv7cn^}2xr!v&7`kuGBWD{5syt`?Pyn?sU4
zrT-#rn7V90HwYQegJ<b*6W-<Zf;KMW+k1HGs_IWxf!CK(@sYFg7|aZd-CEjb*f*JH
zoojoFEv~R==Kf6SyrK}2#hv=VZqk5GP~0cvw$S%D*+`;#IlQ=WC|0N_{;<J3r7muY
zX@e~hAF&^D@p4`AjzWD_O1ScjD6v2~Pj1qgSSESCS|wr1ZoQP^@gfd+Y|a#63L*{%
z1Y&OoO{0A`YV2fz4Gr<6DV1RZ@5(nSAM<PH;AwO+9}w$w&9;D&idw&mi>YIhkeZ6f
zO^6c+>`#MLBo5y8ux@nfnfSHjh@98$!PvuA)KIIhMGb2qecJ(MzY>2x3GQ<EhI9V;
zLM94cLAVw4AyX47L7QhjMP+`Ya}071aZlU9F^R32s-dmd!jJ<~SJAUvMs)#ci&sWz
zSfoG7bzlwnpi5oqt|<XMN2N1A<pi__FF?@?6zb<YM+hTUf-)aqGT9TR-+%44ikYB4
z+GYjijU#9|rH?RxU_>XxHi<)BxtNw$qt+;0==RFI$pzlM0kl|BY!h-Ieh&Q3I{@w?
z?r|l3R)+XI1=da44ut4j7>^S@;8GN@ddF$ZDR^w0uS(D&@YUIu4S(k*=+fM`MSQ`D
z-y*xUCfFL?Gg<d@Yw%l@w@5+2l;x72R`+w7+J<P>-(InovqnHn&Cle;-~XvOxg`)&
zH=dM(tdSLkkz`5VU)CKJu!Ec;3@F-5Uq;;V<CF4sn|a%Z@u(X4_8GH|QNrjC>W*l9
zj@?dmp2IoNQ@Po%*RCjw(zmc(oKg2b0BeE$<_kMuaiK(j5dG!^oQ|L1LbhWICP6At
zn~>%S+tkC7`WMqeVQcv{?hXfV5c~CQ2hcb9r0;FP5Zg}&L0$cK8ktC+=M#(t>^rKT
zT%cRDc$bmvJ5tooM1j{L7e99%R=s=SKHNch$=i2*#ob0yj($8>YCygh<v_Z(V*vtu
z$z8zoetd=oO^wt&d6FM1=8nsk$~9w0FrBj#LI<Ss$ci-cqc-*kI@Y{WJvj6GbgLs2
z`;UDH+2z&zcB!vf=B1!2^A<OIT*qUAfdBkGeauZb?`fui0B2lH723-$BakhRFULty
zQRNHi3uk`qL#I!k|8wSi`Zv=@I&AcB^Xc(9B})n>n`mjvh4e;}O8N37i$)9TV&eue
zOG2ot-hJk3X={?0bV3$Ub4Ecc5gqPsJ?g;Z{91uOfhWfrY$~{y!<I!VG0Z`ngHB62
zT{c*IKpV}5=PNq%wc=QwO=F2euV*|gMYmM_hKsQCwHA3m-G<{??ole0V|(PiwM|Cj
zt!CKJ25PIGt`PQZPn#PX(GjkH*fc68k_QK@Q)+CK&ehxYv36Q~W9n+(I9eB@v1!h5
zA`uMAD%uRK#8aAmHtY{o4)-pshtg!>i#<2&+f!Q_y@?@)BG+0?^`>)q0O-u-bK>*~
zOESB2onz&eVHl)-*!aDK3F^fX`1b<8llk*A5;ot+=XF?X!IOnx3KbwTj>3$h;|^qI
z1<R++s7J7uGtBLuBkw){{$7;C+e6X$5#>o~cJGXq&+Twu`Tb<_*cNcois7LW#SJ;W
z{+iWw*g1f|D6I-^-dlCv(`cyiobgzpW`SdwbJ1h}v;8LlsrlCjIYUs}(0z8WA?TFA
z{OoRS8yQPUw4nv~oFD%6i_H+Jq>LT7lFYUU_+e7X>EfvhBFIFVP#Rt{U$}#pLnkJp
zyHYrVU=0Z3H)nei;PSoC6}KXGT-F=IGuak_z5_o4x^{MU^778<UVuP-Rfm=V9jqF+
zws;QPYb!a|FU1;-zhqvLY=i&6lSCJJO92+;<<T8Lg@zgf8X?{8c2!`B<dJbPA<6vF
z&BG@kj^Zygx|4Dz$99el-h=gJ^YJ?6YBOEOAl<g%61oL@$CFN`7dn9DXZ8C8lLt5|
z`S&URf0Nw*LK_T>>`Zk3O{ZXE{8#S#KZ5@MPtb<ozlAoa|AWu?m$$+CpCHD6fE!Hg
ztp5RS(ErV`r>A3J`rpBgZ;a#rliXln{6CQ!|46R?-^mR&rho0!e}>sJu`>Rf9Q*&C
zT(6xt5tBiO9Q?!;oH926?q#hf5<y^`5dKTpcU}tD&o7aH*$=C3cx~wjXH`O*=+)1&
zidVDq<*|kn`Xkdf($EvSp8ZJ>t<SoBh$U6A`Ciauz{#7FR`zvECxd)U@$tENV#fo0
za?c{^U~8^v4GZ_sd@j29ntZHlkfz_KIkgyf&Cr8qv-m`{IYggD_>WEoO{QYb)Wm&Z
zONf@@R49%2<<XF1#5?7)n^aF2k7ikeA)1ZiT*xwXN?c`xfwjup2M3hk(^gZR!M>A?
zFAIIrs*(n>%wl-(dACf<;*(Cx?Y4qCq+Q`T>vlRb>brmsSXZ4a#AcjskFA#Eo7G7A
z26+m~bCx$#n<=WzpKZ_k+WYE9y;rEk#(URe!;>qW?)#_J&`)Np^IhFQG~Y_y_gYuU
zujndC-)bq}*!sHrCr-K#?nmPjU27z$56k9}T{zr4-{6YrEkjy?F9pkEUGwBm;&tFp
z1+~gN-*9h;kB%zIFU0J+=RK?7PvS?)d$h{puD&$z59~#Udo;J!gU@X&tPjh3`$*op
zm`|Ph`)YertPjfP=7aaG?)&OWo$Z67T?)g+&!{l-EBd0FY5)0_ZlQa@XU_ULHvGb_
zEn@3S@_&CiF#qcS`LCn?|AJopzYqR@YhQeu760A7`0F+No&L*(_)kybpXGmF|GE$V
zT>k4i{9XR8{|`IjZ}~sXiNEvzbTj^0|F18>%FO-`Gve>I-)6)=tct((#NT%QPXA?3
z{B7&IKJ&L@@sGB?>;IkqyWKyh|Mp&xf6w2)_5Rt$-**1FAAigKuKRcX#6PYt|HGg7
z$LaY${fWPD&fg2vH~8}}f8s9>^ndjynCR%4{-;0Thdi*ttE0@l!R`9A{&YWnkHz`@
z@EqS9v+1iFbD*M%03RNX#)@bw5AcJeh{#3Aj~Bd0iQY}C!RpNyC)&h75|hdgf1x1h
zFB!o|#Jh<;AHOQiR`1{c=<M3s>dMOEXf3yFEzdr?n^*L{=ysNjL$DTtRzTHm%)M&#
zZqpG0?+AwfL!;qseLNWZ*$y&V3_m-V@~CaUkYAXG5Ol8*wA`g@f3RAZa#qy=hrfd*
zaK}ocS*Le1rujvKH}48`FW&_XyZ%deOz?wlzF@4X_3_m`=Iayw^h)5PfU;VrVS8pO
z_6s=gb5E}8vkYYEDcbZj_sU<SBvggE*<xg<@{p%wN?@4yUfX-3kv7i^Adh<N_@&dI
z*c+~C6FvA98+>K3mmV7T)ij7e^ekwm2CI7E1V$uL9iCbxV`Imug<B_w7yg&PP8e47
z0Fv>@t&(sngQBvwVn$`Tt(ldD$k*4i;gtv?r|`#X+7%wI00{b5ulci2W{wiuP?eB_
zkMIt%VPH=LYFA+w`f5=Av0(#Hho8eSX%K%_Gvb5*#<>WNkR4Kbl<>X))nWkyQNc(F
z8v8WSy{MJIn>_O?vTI(3J+!nSTrPNeM5Y<lE6ZvmDKZZ~YeCbE!#$JM2e679pmfhh
zFx<4$ye1oDm%kj;YWU@l2~p2a?qsMdLAa&diDUMAOC>(XX&M*W``JhufpSRE8LfLq
zE-+n{>w<7Ilvaof0k{I({JCdXFReb*!vc;5co;pLHM^gVk~<Ld!=2@xf36*Nh!FEW
z`liox#U$pGpP|W*4Pj`gfNW~=G@dI2Vsi<PU6-TJQellm)SoM{S^+LhN4Ig>W>DS!
z99?^~=g_0!1Q(n0MNWe{LF&fFCepppyt(UR*Y(~R@5nUei_XN(NFGm3YocZMXeHUw
zN`ZJR<RhO3>8=LZh;D_(dm`}A8Ulpg2pzu+J$t|7*GIg7d-!0%6x1I}YK44%wHM=T
z39kIv(sE4|(T7AaJtX8r-ipW_xTn^W($feR$GlHc=g;2zE~8lVVwqQajkqfZy1E&V
z9dPve(*v^u=x!m{^SXLOdK~}pvDc${3t9tIwibdrBqooRF4B29?1C-G(jJIw#ls8B
zR}4^yq&_ux+~={XceS@k4&976G`Ty8a=P-E#R)l!uS?Wdq;DBY)nt3rWj(ShxM?S4
z1maM^gr;7wz|6%gd$GNQeMn;&?T&XUCqTaVLn#mEd4F1=0d~*>oaY<0FaUkCgZID)
zB;}XAyH@Z5+KjpC+ZuSgMtH~I3Fqzc9r%)7->137zU6Wc&cq{4`=K})Wr}04IUB^>
zwcs^Ciw?1`JN(tCNA?@CG58`F4Dt#kWI_EJXrQS8Hn%DX4~{kO;+W?iFX~1AUh$qX
zw+(K7%KV;vyhk+^$l|seTev0)sTnZ)Qh^Jqx<~V-<5~Wl;uAh+@Cckh1kqoXy_7U@
zSjz$G1&V#>_-ESBF|Da{BcGmk$@=6<|Ean2`tzf8bDkpav-Rxwr#rGPt}eo^VmYve
zZ>4R;@2JiUYkHk1^<ba`mj}p<Sp&$h0aoN4AUE^l7|#Qz19tWe*lSa;OYthjhsQsS
zEl@-b2Pst+)pAF%{fQzq?K_?P#SLQI`lcRdE1+px`+6nt3yK$d@6GWY>Ye5D#}|Mv
zz*LY}dK59zcDTogF%ejfyAeW5+PXMw-;wG5(mwaC=Pj*>5mi(_QL4-#<RPpHCF3xb
ziO<Np1kzH}f|I3+h0feNR(5+v*6^euTCHmxT>X}@uF;l}Y(2=O&Lx6P*jwt--Gdh`
zZ{Suh?+EYIR}8Hg5}z!$-O~tE|9ZzWgLH`15C{YC)CZvh^&QeJ_WM06(T+-U;D8y<
zPXiw@oOXTAJI}+P4p0K=H>W4`cmtaPynME`ww74uL&wa!!a4q2@38fL?_uX8Hd<2+
zW;S!}APT0`>qo95U_qpBc>_86EQfiLHDDjwj7T3SgI~aHD1!}=?Xfu|)d}K!BUkyN
zBX?%3tC7jupv`Rq$LjaA_tsuf5Icl?u9(x}_h?S1XKf2cB7^ZRlhP`V6Lf+@*Y~}a
zMC#Aq#z5#Z%RSB=ZSF^!8^vU<_c0vZSy!(*mH90O?kl@kC*CU1{{mM)sJ~SECv*sS
z@J&q=IOq#>jLD)ono}_6nUOd0<JoJOTk%;k7N*msO73Y?8iNep1+t3DQ8U^PlmJph
z<>)`7pW+CN;@jMB(fw!}dX90R81op}ND9pBnh?4NonofIuigmq$&a(p(^Y6WJV&VT
zQT|crVFhYLjd&rRgT}*|ZWJtB1$Vv=WRX&sTiDIcW>e^AcnWr)7eIQsVH9_;y8JM-
zJPdsJ9_q$-qC@$`=s4&VH;&;Npr&DVHM^aCiapH!i2W&7jjji--2=1udvpf0MhGv0
zvG^4I6KH)La8CvB&seyNZqQ*@lG)4;Q3v*-K9GTBAh*ZC7|em0yasx?1>FVw^cd)n
zpP|pOi07gop?86ET)^jx;P<uA&t!B7%=$HGA4tbr@gX>}7zI%|jMKlc88?z^;rFPV
z-2rm;INa0k&_^IS3hI4T;1)a{W^WPtC*@`Mg?iMB4}eZSf|@{6j%VINe?(ExuH%45
zABF4Y18ta505!3Hzywv~rxqH?a^{EF3EI#MR5b%M`xx90cOk%Yj35V|hU)SYptq+%
zmi4laf%Z*-W^fRP=2G?&xbNSBCi@v0D9pn5^S}YhxJzaz?QLUPTbi318|t#PHPuy_
z%5+7lJXw~A$D(p19Fl?ozt8J&yPOWY&1w+^v&m@C>$E(_Y8Zl1MW@^~KQtJhKd6bz
z-Q8(gmlwc+1s5EcKNx~TUEgdo7@Ds(3w^Vt0xg&RTT7+bQaRrei=kH3nyv_S%AvuZ
zj+aA2c+T`$Q2y3<d3I=USS|Oc<?U+O1m$oTE(mqHmyHh%;`yP@!LHTIwsy`R58WLw
z=sV<&CHiy)I-oZ|(Ez1Em)v&%yV|f?Ag<2l0|aSJa8rX`d3@)fM;=e_V33J*E?7L+
zJAGE?cwaa?J6$n|I~K_c2a!B(P)MmwP>1?6gIvcTul`JEIei**XXrr1@vV0aiD=>c
zlyR}Vc){FRgUo{2^fxRi_}%e?u63u~Uss`XYsak37oPPoTRYv$L$tbe>*mnl-s!V0
zJR7Fz?Ag!<TuWkI^S5@vPu~TDIQilb{2IA!_N+mC8~kL5J_&uQ;`1$$JL!@6D?)=h
zd7Qj#>x%g>HQud*=%TgZgI=$4tZ)i>J40J%%#y={?LK+-g7N+XcC_`PwTC=P$n(uJ
z>52oQr8uw$%tEPPG+kI&a{ioJQk&D#<crRaET(rPPXvM(3@r-5oy?NqnHp)bq!Ddh
z)CkSsZ#IUj1{cGOEFaW$%-<?D)8q8|K{h7Jp{-vapa6OJFW)?}pmc<biC-XEq;ztg
z)ZqMRc`%h4EH9@d!gs)&!acUB^}2M$>LK!w+$V-0gW*HHFt!V3H)mk@!(lqXcMd6N
zAyfu8PM=k*htNXbL8N3-vj@q1dgl1(8OJ5`%*N3(=P#cx10^3;QIBI#8$bUqh)!GQ
zvgSeT{9jHlDW0Evu{?SDoLQmHt@BG`J9)-8YQ^)7=g*Z&gSL)YjE|H`#K)*-fhgym
zZ%iw*jDwmO{BtT%FCOBxK$Yqd9O@br=XV#=+4^w!|KmkNh0p0#YWDSIrP~~APJOf9
z@{Rg8ZqK-tfg9Gu$>bSxwr<sb<6IX=psicG<WSev`CAtZ6*exEL!!L(7}zt3t$m&I
zM`v`X@Z6og!LGYz!$T~?%|NXLjXNOYJEk8{@EsS=nRQGAta`_cSqBLw9rMS{J`ja-
zvyO#8=&DD_`J=QJqBTHPK<NjGRz2lArXaLYJ*!a<sP#od7^%m!qsK5>G(?KWMD-Z_
zQAY2WG3&x9RQY0d8c2d*KWKD6i@?U@(YV6|zr^uFj8?HBR`U{r^t|RJj67P7eTgtX
zz+;gP6z@#rPKjq*M_Q+fXIgtkT2VWc#dDBUSA{KMOAHe1*PwGD=J+{<MPH$i<~aNo
zV7m|5&jD|mP!K<@)Gia3*>>sQvA*MZ*ZZ#joxq>0I^N9(UBqp4d0qa5n6M@6WnO)7
zqfVc7(Zm6ha0qgtl$%Pq7II}V6gb)n)5N+H?;yLm-P#?-ou++cpYb*JHQlR$cknwV
z6VdQmPRHq8*hO4Mm&qB>E%hw*U(c>FuJ)`B>=cf;j|ATFeXcdkG@HTvcGmGatHC3!
zn&nQxGxv1NQas2f`iQSbVKC#(gxW(SBv>UYvG#nDn=0nc_CxMdgl{yk_6!$K4bMjH
z!|lV>Rg*7Xdtkb@W3AGPgJLWYx5srcHtzAdy@V4?))<VFFNPgjD7iQ&S&ZfwHu(vp
z*rs>JkXHjqD%A=foPxh{nxt;VIn<v67CNlutWE4t;f!LiHW9bA$p~LERQULyrO7x{
z_zPq#t(ls1P&;61LaEZ<Y&=@R{W%;(7Lh06P$F&-5gXw-i|BIJ)-=>x>qHV~Twu%G
zxAXP<z4?1y|1Urcjn6HZw(gSMS9H!=xOfjc&zN78|3yCka{k<xFJlv~#P?45(F6J4
z<saL3ZH<CGzlURnRn&81E1YINV;)C-yh-s|0c2n+vSLkDaJFl<yEk~$cq;gLkPpIS
zA2iiLc3g@3rEI%%nsX+{@Mf*VYhX%!Zpno>ks};tCC({2B<E0Ji?TvM{*ce_?-E42
zAc!CkFBi;EGW*RKX*e<DG_{K%yRp4WR74{BT!Ihm8_fD$PAAWEoF5r{{}k6&35w7w
zFhb7!DOTVTtiUB9ycZJzOZWs})LwdLhgzp))jRabiEL0Y30W~XKe#t|DyR{Ico3e0
z1cF1DITZf!CGJ!z*FOM5eWpK`N{x8V<j%N<fvMVCMfg}<P1s^>YJyWx++3M5-zdJk
znXPoIg_IkK!&p3COmpANs;giYbCeJiN08oZklrj2E&g^)6Z25v)IocbnmK6p<w1kc
zK05QWSsYKq6Lnz+Ot{1Dvf1kEvTB{<c#Qv?f2AqpO5?v}EbfZ?*Vm<+a7{&HWBzqN
z`PHqmR~L&}oWa=A{KGhNOTCmJu^3msX(U4Bz%-cW9P<(&ju5U>W^vZZ_MH7{`!dH8
z_gXt2(?1TF=?%-z$<LX0P47DX!F*}bZ*bs<Vsm6?GE14OBWsuqkz1MD&7Yb+cIe8r
z1t-?(bSb12wIMB|&9NaT!d=cGTz1$OxAE){4jwWZbWS=Sh8j=1Q}INy&gBT|N1!SI
z>Cq`On6orj+?G1z%|zNG^CEwZXd<B`omqlwMA``2t9j5`%;QyAnkz=5IeSvXq9@#V
zw<;xabPRh&a;GWJr&9f?o?&2AmGRGv(3w4xJB`IR`m3ve|AUrbAm(;?T!iymr6BU!
zok1M5_=4EwfCShQQ|1Q7P621*ejIjE2CQ#zahx1U#Ot!w+8QSh(-W8JY&n?RNI^HJ
zb3yCE#>kYRwI^539C_;QpMNID9C9|?g1>m~%8NTLb?&)&@69iKiXERk^6>SNwRZL%
z8HQpqD1%inJ4u{S^oF>h$zV5%?FRa=k!Tk3KOOQ(*%Yl;XKB9ipj4+;1Hs~9K~!@k
zVRvT56y9Ojo+1X1$&wWUfRK_>Kn#jW4m+GK7m7S00UvyJIO2L$3ebWqN2Meblz^<S
z5tLwSyP)_R+J!4vM#G~d7Yyiy9MV6B=OGQAcXT^{l0U^W{1ARlF`%U2l0c@H%Mtkf
zgOlrMcBm?wRdZiR%@w=VnLQrCeG!ZzVuVC~TR!y?s?l<}emZBZBe^qYa>K*oX_W`t
zTU%k`;6KHi#n#qV3~Yr`xY!o{=-fE!>tXmEc9@IO4A41n*+F!;9O1h9`Z`NC5eMGE
zZ{+S8+t@L-vTiD`HwC;&M+o!AOk<uOlhW$rRm|hR{Pw)g_Kr#8HJmfjzTmod8k<C)
zhlxhnrgenvb^5(*3^=G9*hprtL<ZzX?<vmUMvJRmuple)OBT^8`Z-rrvZ}*sib@uB
zSlv;{|2+N-$%un7uw?7A`#H>k&0zF%R*POoN5&6FkxtYRox&uIM!_VRh^gG|QlNVm
z9nt1GnjH$sSv9x0)LhA=tFnVGyv>D?ON8-XuLOI8L{cT*U{I3@wg<OC;W&stE->{t
z3^oY7(eb7O4%{#dq^*wku*x}Dm0oysRO_<!HjBMDnhkU~>0rjk&bdrc=FEAkvLny8
z1?`pN*elfoigH=LWyH6rK@*LVh-(pvKrsfiZ7G~)4}ylNAeSDtA`7knnWsE%wP(Tp
z(HNWtmxx40)bJU5#+h-o+uNP(u4(pZ&S|b$>@4fd;8pBW{bIv1>q_TJ*W%z(X|=e{
zdZY6O*EPYlq3aXdDtD#c<vvCqnLn-g5`Cfn!f@97RYjcBa|X_=5m}2Ss8se=&ac#A
zOsrOm&4%=%LDIW}9?7jq;6$oSN)*Rmqm^_nTL|vV=9FCVP)v#|Lxt6cEDQ+^6|Pa1
zOQ<50s;KCaLUu_C*^mx#5<!<sL8t~bj1J6>%PpeaVi7@fA<|{BLfI+;OxNftf;KBg
zoW&5re-3>GmPslhr2yPhNUy>AibUM)((AYih9E;F<?o8RN;=&QjafAhh1Fbfd%W37
zg^EphCbGX0SGru@#C0KQ2&a!I^DTWAVtF2?Q3&avwS$UU-3DDj$5iPQU9XPOdD4|b
zWTvVEhj7JhsnpanKoedMh)u71#OoPxPwiYX{-fMLk<)+`DLca7d8OD7B@3v<p30OK
z)FHbW^kTpHKTE2vOnEQVmZ|?yX%^GXqPA5F<}4ULRN{gLJ%)mXQ-=(y)E~{iRP>f6
zr`F!&f-fFbnvBeh>dm6sR5_n&&HqrM%;^I9D*NA!2~RD4w<;RivPmCIXYdD&!N8{L
zz3~R@sH{)r|K%s&AGwI^+mi{IV==$ga!LMPe3g50QX7jg9+z`6RC~L<iKqs2Y~2kb
z9%@Tf6;82_vQtncW|W8Bf+s@U`b4B$UN3*ke7C$`{;6D$b<mC=2DBCtnLgY{HaIu9
zj+tLCd$;W4GBYbX%wi-Ij?2~IIT8NF@E0=KXFg&kwOT$Dz>$a)3b-SY@=#>}MWU8a
zz!j0*E*FMAjVq!$(NY%LAmMpZK_b$PRaHt=Z&hE_-YT|AEASFe__k!Sw;Y$>m>ILW
zs4!c5#1We0&gS}yxMH|y0?~n0)np`GrW5q>c+4C##IzZdC^N}o21mlWgfWAJ2qYjm
z;DX{cH{Xmv&VZ;Mu!S9R1SSAP2vwU!0TP$%)WbYIUeu#;dLqtOksrv@T09Lm&0n>r
zCmu*&gn#94nqo1vpLu(5{;gMfm6`06Sh)Gxk!43#PhIr=cS-WHse&sOtE>!NJTmgv
zUmnaTuRlq4UDpIE2F7@L;WYUrXw(|=lrq;)<q+F7qA6(?14#{MciLZ#y&C_G_^J5c
zBA*mv<&9!}`DVj?@_o@K4d0cA42NX{Yh+E@q{BGDFxki{2E|CMH4@rGB&?dB7|i?j
zhcL!NxD$}u9%}{;WHbLrxh2mYpXBvYLkF5{_hRo5Ua15<dz}BUTG@Dtw+7=@gSBYj
zC{{-nUuF#hfgje{xl3q4(d+Ew5)>B0B&?cG1|eIlMa;C`3`{MVvDqtRaV9%0J1={6
zc0+c5mdjeTA=(K|$t8kT(h{u#7Z*zrZ?bIE`YOY;sOZ3eD)ZDf_N&A|?WNP82|z;t
z^F6B#`NVcDZRUbYw2D34u5ES5kT_#dg=Z_-tYB>QpB(^O>-?o*YSXKaqJuudm&5h+
zNe)35Y7V`qIdnwxgXjB7%|4x?oUeGWQs#z1_FEtkeUO-4keHmsh7`=v9|{J8LOa;}
zzdvNO7jtMq^MlY_ZK$?8hS<WhiWS<jL1@SZp%rT%Z6f}KDncv{pBYBtU+4oULI%W4
zdq&X-kifIhX0%bU75(K{8g2~?vy+F4IXtRIXpf~`W?Fk&(Lo`W2KzrYRQTH=mqhc^
zN8O=zqu&#5Kacs~Nx&MV_GK;y7LHAhgDFFWmQzEuu*x7{+sI6<%0yI-#i{8DwolO*
zCEpPuV{RRrY_^ARJU8|3nH_yWL)aM>Bk2dbs>ZY~+npYF-?yer@L8-*H}m8CkMCaA
z5cPSIuiZIw>W<!WLk;fTw5g@Ms%yfE#)}qRxj!ZdGUcCL<mbf3u0$?0PO<!pU|y%e
zFQT`M69F7fb`0Sz#fobMMRaEcK@y1Iaj(0-WP|sd838EOGje7aTbi0cpyzDV9LpB1
zw4z~AG~Ir1?Q$M)o-vSWxpeV_nd`nseqK@Y&<s(h<t=mD#x1_>+HLQ{y<A*4#YMsL
zs>N3-PQA!RnV30wy>y4PDY_~4t>hi$db#A3FqU$zl$TQ{MF$j?@yiTr3~Qptm>+3|
zxTDdd@uTJX@p4yEDc_vDy`0@0-&y`R_g(%8!z;0$B>72Zw*r*g=f=U;1MayI)#9?l
zkqs_vd7Vn#+5nnE0+jvjN(9ZRdNLK1uqc^aZg+&OOEIRphz<}uXyY~<^wt%*P0ZF=
z%RJe-AK;5o7_Gvmkelk?o{m{Z1f2vX2=!nb(De)hPo>Vb0!OLX#oCl<1;vZuizu<G
zL<rUzwb(#NBkI!Vq%Mt`P&p?UK=s8E(FDWsF{7-DA#+$9heMJea^+CdCrmLUgiPa*
zHp#}Q2F0n8z%N&&H||%BLDY{eay$yuNE~3jQ(B{PT9%7?6y!Ijfw`pAD55Y>quPYM
zE!L4g^U$t0XUzTSx2mtGcXn3G<lf0GqVAUbpLYJZ@KQq;{yy$nGQHvztG~+5uFOYX
ze(UM{&mMj$|J$t&JNEWw;;|SjMQxMvA2qiue|qKCr*RG5Cu%1rn<!nj7fx%c!J3TV
zdyb(fjOxD0b-mG(QKB>YjOE6OMop9Pe*csHA;0FY{AXGcQ4FSRm?i>?Y!WNlG#~J|
z0AM;Qv9c^gC7Ub<qf$hcS&r3vmgo$61ByiKb{mJd@}iV34{}Q9ge<3wspFIm_%<~|
zrK%c|L>VN2(KscQh9oFKB3iO1I4p2D#GT+s(JwNDpI7uzB|Nr0s<hQbsq}+R)ExRz
z^NLC}KUiKo4Lz$lbV+l?15o^U6id;;D9J?oq9kgU9N1AVP^EAPI#%<B=B%1$s?{7i
zQ+0+d5Y2vW#u@W*^GP#f_Q+FjE^=!L4)jnwQ1plt|IXwttWmr$Or4IDQYboWR|zK9
zUxW-QKn9Bum*4`GTSdJNR##E~H>l*3sAJwL8<W4a<MxZEtuIfs;Tvs9Uo=qGm}p}j
zABnE4<D)nBPF!%yBlwyXS#50O=EcoHn|B&MLu*AZhNcrNtRPC`b&9;p^n~e{>8Mj<
zwKix`Pz(~6l-6n8fNx)sixv;XVfYbFg2H7-wW&=;qt*bn@;t@kS{shrdFTpJCkD}$
zBe&=#?s81W%S^Q-o`%UFsCaLth-_(gsAWtxqe=tNoxPcp8Pb>8n;{t~j^m2zl~8SN
z5mT2|uXs|_h@Q&E^Meg64eF8(?Ac;%I7f%I9T*x0cUb&l_#FNsmts`dtKwc@>#|6>
z$rg>tF~V8nWr<{haOPOV7EhpZ6C^Q97;ub`N}!_80{FQ6=9@caDVaV~pRF&_S3a0I
zp5gk;8?38c8|1#^`t<Ftt?6B+oz6WK`<zc#JXc}fC~UD1brxr<`Z5Dg3VKR?Vo+M@
z0Duz1s>aH}JgYF9ts8ZPs9@ZsB5t|PrV4t{VyeTWf%yfeO*iJRn{aj4p=C3cJ-e)9
zS&PnCHE#2yl`(fLlTEwIW=&<MeD&5<_HalO?)lElw!OFfaOYpwWyfOgN@u`dK63lr
zcIknK4?GpOZ3P*SM2KGoR8WtnDFZ<ftOr97>w@cpq^hyAzPIsl^g3c={(8Iyt?{o3
z+>SQ;HwShHo(Oyz_*cN#*LbRtNLI-v*~O?BV+E^V6YMC8V!C=x9}192#2X4&BazDH
zKs*vLgaVd`EHwvW5jhhI)I~to+@W-!fIkF=W|`k-_xpXQz8;};AZQN+f(X|K{EURX
zsJ@P15|0G{K4=kYX!MC-47TY{7(Or%gSS!D3I1SKy`e^`sdNr!wlOG`WmKqVq30@3
zRg&YCCo4&%r=f8O&o~qY)BQYf8=#!q3d&*t=t*T_4?whx8x<iNO(|vrz^2_?nPLHu
zX(=*eRWD|dv#Ea04dnV!4)v!nrq(%MG|z!;Yk`?n-UaI&%f)F|k2&j0E&){`Fed@X
zlvT7wJ%YhGzNuoQwOAhc(mnDyYq~U-uQI2nmKg|~Op$W@Gv=n4!yI-mId{vlY$68b
zh<hnB{8dWx*168buA25(3`^OJ;WB2<6}5>N^<PdZoMw)KJ#Ru`JVSB6=EVskwqB|=
z$4waVt~jsL8Ul)Dly@~sJe3tRSmTw8ysKstidnmw9cmhrrMVI<OJ$GCCuM?UMV>Fy
zBCE&`$wV$LFDNGs*iiCAsyTE`^CKVu3?51k8xJSys1dDN(I6I!Twao&XF<gFP~S30
zP57!DJsyX}7>P;2P>^tTo5MypF7ESt{T@F<S0NJclz||2>a0QJ<^u`33X#A;#vH^p
zy(@_PtSh0~kfjxf@^V04!12{(xCu|h6UDVgwvXFj+#vROHgemH+r*8Y*U77regh9O
zLD=Bl#&0xj6t=mwI0txbHeGP2ae_%k?K4uBwYnlIbS_EmdKJ3i{JLLUwPf8pZ=e3;
zMD0YE+0b2?4kk?Yc+AVZbkoOMU%UMgT=vo%I5nZ?4{xr_O_=0~jG2eSPi+V|sOC<=
zG)94IMRZ*8TdDVKz7-EzG3aFuiJ+M|QREC!iBo-OR6VOcG-Ff}scX_H!<C?+QAs5m
z4b($sD0;}$X-Q|*X`!Annk%x+l^rzTZ3c`CB5>S#$-37%Xk{|icI!6laqB57Yb|+H
zX?`SKnYE~nGOF0V;VDy{WTOr;IFA3rEq3T@ci5D#R-bo*F|RMAPB3`-sX)K;fPQ84
zH|44?I2_gC*}8qfSI8^!yZBT5d&29rxPp}1FO`<+u8>yiR_h0XJ8jR{p0N*+=j=y<
z&&jU@PsA(;J8XzC`%j`%z!fL)DNHoj4g(UlIouxi=N4@Fvpa6!!`&K#03b1iOO&gs
zHJ{Fs6)@h52jL3u{@7oE2nE07C;l3~)Q;vyfFn-wm><Q6yeC@nu%~jVk`AN#3-IEA
zYM~DIi>+YmTbgqHO<*^Iyb<4^Lq#>pKz~g2m;+fgT<Eebxy_48qMlKtaj#tc{Hdku
z-~IN}osBI$I?m;isv_AL6B{O1&-$DDhPBxH>I>iAf6ttz@lzMKdpxy04{iEeORADe
zheUpo28a+vPzGPCc&r(%z#$%4Bu?Z-3unv72m>KeYd|qj+Tvc3OI}*VC#N^Lc#D;@
zTDVwTGH|?EOyZ>C^IEHmvZK1B_i3(Fff?3YeX^QVRV&rK)qT~P>JpYOH(3=Ut}-gd
zUgL4&Nh53YR88$yz1&4_ma(W*jU}aOEGbp0Qz?~|3<I@kb+Ku6scH2EP0y;Zpp`mm
zXbOkEX)T1}74D!XmWl@e2UNI|2^<eXQtnMBaG5`L-bzrNH6SxuqDuROtW1*)?hU~W
z@eLK4Ywa66eSsU~zQl&qZT7q59rm5>-ND_FJ<)ykCnHZqkJx_@wT^dS)nb7DX2(=@
zaUn~D9rfyTpNFvtRhE=sAl~n)>Kgg8$}#wk>e`7juXu9SW#3!T(^1nfb78%lZHg;P
z#?H$>+MRXBVkGRE&%8(d$?LmAnOpw2>Fz(Tk9Z$l*EHiVf1llQ59P0T;U8p&W(0ZA
zF2%gfu+2!+#9&08A$&yfV2$0*IBq4F3mK{mih(f<=$4obgc-tSCBPbv7`;BM(IA19
zSi+XuoQ|~s0TiRX-9~3!3`DXS+i}}T8)Nf$>Doncxv8~BJkv^DXkZsl6=7<iirPm`
z=ji&py5iJ|RaWSyc&gSRm#kq|kq7E5GC<=7JoNtiLR=i%9Gre+_Iitc-AxC^X-4u-
zEgE@YdM2>Qd3@2B$PWD9^6Zz_(r4{LNYen+o+6rKh%0>jtf5KA;WWL^MnFSp%(5&O
z<Cx!&Uo*e*G7hee?IO&t@drL)70iG<Q<7N>i>dv>3xXE={Pw6M43YN~OC%nZ!g53(
zmCUm2k4m8-@>|6rC!$hHmcyZtAei-@rF2oq2PX8PlhplHcvhL|uETI+DNZlxu&&(U
zuv4642ec&EamaqcPV5vu*#SD)DRi<cb@h+{?y*zUWTzm?PC=BN;wL-BPof>$DP$6)
z^kAA~(tT-?2Hcb`;U+bQPSPd(lrG_?bO|`6OTbAT69G6j?H7<l7jY7axN0N74SpWS
znfUSe$v6`)A*Xl=IjK!_0GZ;RiV{##(N3!9E)_>nQLewZ<TzRbdJv21f_l@2iz<KA
zo0?)oGi6ehzeDgtRzrJ8{UN)tT~L>_Rix%LLCs}`#3MlB6WayK{bBp4k1RDCF#iBu
zkpy``jke-an9J$-rdpzW_8*GsrS45rF1y|?Cff3eI+tiod1p>a)a4T`9t*`_Yo|_F
zGP&uI{CBPdC>G^oo<(@?HLc<GdBgHXIKYLRR}xVLV=$N^LhK;Bj7E>+D&^h?wZxZ-
ztHm|)X7P6UDbrDr-(fmrA~*`R6#(q8-fRfyU14{?WdK4U+JMe!aRi(=sz(v$HL@Uv
z<f5ZfCgF5(B?YXoFex(&cC%R^t3jdZ*I97bA_^L(9JZK2`MG2v5-kJ1!1y#^E`b57
zMX%Rs1t)eshi^eLu2kfZ-cuFti*JnYh50@e=VD?!6j$QCaAbRYFwSqg3TC-q%$@Og
zdqzOMx<{d|mrm#iC^t)S{lnFivo__LHk*r!ACS9gA@_1h)qhR@Q*1yn<v~dEt*tP3
zATx0aht(DS(qd%;uEow`WmHNg5)8x4$cLN!mA)1EF%vKE#DBEmPrA~Pwvj&Hw2+e{
z{uOVY#J6l3mum8f+E~o6Xpg4(t0(>|DY3DbQw&;dx^e%&Z|Bo6S91&hVBQCrQH@&3
zB*g)?R+A<qHq|Jt<Fj|x-OKN(W7;VBEtp()qzT`|?@K?^dNloN`rYt5>38csO6%(Q
zPJWVYl51k!EZ0))eP~bJWB3R@qBYj?cw^gc&Hd>Isx_#sw{4Mge%pX+hhsl}toa3e
zs!gwT_O@Ny!gOni!|EU{^jBVXHT|^(*VJltT0T`#ma2%QDw3_WPuD(Q%V=uH)b`Zg
zSo^Kohibo9`@`Cw)&8H_;aWpqEv{{`Ys1<l+Uv9$qHWPm(XP{O(LSWzr+r=f8?DZu
z^=bRGjNPhb+@`pcf*zAgGcDbuW+%#JGQ_PU0TQ?+_dNI2?uXp_-7mQL58QuopK~*A
zw_+BvZX)r-AXG>dnTqxbO~v?RhY*v%Li!Y;jILd`LHB}A6M~Es*9)n95|y@%ZA59C
z-$vS=aA1dzK3!RFS$n~UeJRu+HjsuIKoha-)$HdisbUqjmz~dQSkIV7x&T*w+j+-8
z|C#>Ok8>iGDY*eEN6wxGJ>PC^N@d_YRVBmXusCw&v^Z=5D(oMy(ga9OU6m8x(2A`f
zUr;WE2M%yF{OqvN9dHwro2{A!HI2=FSuZjgAr^>-V}^KB+#Iw7kujtT;)vYLGz5|8
zHwCdi0!gE$B}feg)j60NwH9u^8LYV+8ld42RPv-!v64SGR#%iaDoLMTKK@!P6?LAf
z^ekMlRc#HK`1BpUD~52LODP*$?)AqfwzOX|@Ybr^_PES?yUFVd)~p=gJ4e5^B@y<d
zYqsuOK5gaGcVE7uAsMi`9a5^Sx^qfx_pM$1<H~pD?^6I$xhHi@z7ID|m|ovdDf_6d
z%pk;kz&wtc$;-;*L}0f>yneBnSRW7KX4Cam$C??d*)GMUHDrhR{^~dI2d!E#8MUHI
zbZgu$El(w}#P{-_^9;{(o@`w_CPr~IsxI#c?a_Lfqf@@o=4rpb{<(TmnZ}twP%>o#
zX35knpfqk4c#~G*Jpr%eiKb&xw7$7Ps(+5dYOIu7a7k`iib!%@CM(rd2F*yrsj2LF
zDDzB)%+1`D`9X%s1a=C~H2<KPncI9<^FIaVQem_3P%{(g5}NIT(3~z=?~uQ)+-`Mb
z|B%KPr#GgbNxz-eq_NdhX0>No?7%TRfHz@wi|HllpAs`ex>dSYdP35C*YrEnSrc<7
z-i@Ef%x^%JUT%`?CX>{xSmkyB3nn2WG;1U*nWT)=tZB}qrGQ|<TJC(wQ(qUAIggv?
z^m|*6w~|)4rK5r++v;+8=@=ae3hgK0sh`7Ukk!G1neBle;vh<sHK+xIQrDsI-)UIZ
znc=e|pjFjH=v40f`m-v1T}}P{sm<n|%2ba2^%rerTsU<IW(m_pVpqDD+slf%5LEMn
z#*+4&4Kh0iI$M?7(1lt>s%(evH-z_vDbD@h&Is_AOBESTu?O6GGsqZ7%rpto1eH`a
zWz*D+nVh?|_5D^T-;l|r+)%_h>U^QAPTsmyXNs&q%MDiqS5!WZpOKyk9g}`y`oyHi
z6r=-G$2RAv$^adaP(3vz%e$t&p@Atbd-EmL;%c~H<(sT}WJa|wGxE<dfzb5M45zh)
zEAsb@@4vF=;b~K=2<OXcS;jLl-Yci^<S{G8kumwV9!|MPG|D<{{?=VfI!!hpRv{Xl
z{Lla{zh|5#7Q<Fv6huCANByb_M*y@AnXnYNuJBj<phhH4#2}wyBJC)Tye#%;CUsI<
z>a_R~YVR3_5ee6YHR4wvXu|lxwbX_Od&0y{K{2#Vsb7fK;Pn7NG~4Cv(S1?oYtP)2
zl20xwM;M<RMJOi5`eGYndt+>D2p?0#P`Hd(Ed*<cHuekjARZ$76{lD5Nj~ChGw40>
zs)Ul*n_$M!*wUODP@8K#b7lmjEvWsG)-$=*CY9P$_n4}#nXmm|ql+M4`^i9-(FN`X
z)>Qk|lypnfYc@DLn$qO$7AOk_x9pkUf93Y&8T`9^wB+l$;cLIwxxLGp%(^L$?gcHK
zDxB8%U<6z!fu}2iwM(l8_h7fj5|vy<v>M;U@WHsjU>*<z(cnTzjNpjEd#%YLT1~1r
z0N`qG@??@!C6#1vvM;$eIhZ`2<dbGI5<HTJc*-qSWz<W3Ts$eVqNnT|XjLpiP_YC-
z#eYMqO&Jxgs!fx{rpZ#%<b`Op2v%Fg)6`E;gsLT=TH}prOl&L~_j&zZ!s+6nSWFX1
z;DFH+L?*MOhqBDY6WD7C22ofWOngHlm6!0Vd?VYZ>kDm&?$AEY?$aLCXm8QprXw3P
z8}u8b4Y3{U&M2pPB4%UD1%Nc3;N{T>v7%qIW^|Df?_Yh_{HNxxd+XLItDE*jczvoC
zZ{qY*T52a&*C)o!WT%Xbtm{8{$L@dKT2;S9^VoEo-$!C2kLKrZkXt4;KXdAx-e#(M
zEcq^G7<5ktFM3vu>oU@H;_urWZPaBm2~9F}duMy+_-0kE@UHMJtK8xn^1bdem)Xkf
zji}Mvg}O{va98kG7<Xl!Ku>tz@tB}jQ^sV>m^mXaaSo4Da)@+ip+;iuW}9R$cO=T9
zDRU;%<@MOTUXRgaa+{p(rppnw!;pg94QIR_v&o2fM<Rowv<PU?8~rr3Jt#y!4La;F
zI4tKyhWXW}sz0x0RG){*UY4x}F)lbV4&oTXjN)RG$xtGj7@uGgZ-i5bJqf7UQ&s(S
zc<t0Pxt=p4xzk|C6lM9q`S98vk-Chi&;>E5+SJyj&DzRTG0fIn3LQellmDAV4JMBo
zF+>A~axDJ8#{7^AmYrS2MG3ID|DONF__3AvZ`EZrd#`G#Zo^HL&ExZ5EUE5XcJUPx
zvNdBc)@lW}udF^!o_(;}4AL#)j`!v7!M>d>u?iB4v11O5OwONcoiVSYd5Y2jOc^NO
zL1%s(SRLcom7x7o%3LLbIhzzE)Fnk7QkwD<OhnQmnv6y(%t}fWsBh|(l3$9-sdgW;
z9}LKv_$>~cHs4wSO+eP@Gb%33NSP17Ab|P6Zq*~@@nzk?WJG~HvOSsk?FVU`{xw3$
z<fyCkBq;D-p9JvqYm>>ERQ*rTkx>mJOx9#W#*;<@hM=*^xY4-XxYx)bqiCG37Ec;K
zH}XbLC{vXom6<og&*8<Gqs!L)G;VBwx&VQ<`%m}7JgcRT#Ivb0KL#<cMv)cc3tQ<b
z1xz_b$P@%qBt-L4s)lz`DNFgV0aRHVp^lN-x<vMChavSI7TJ??xE!?({DD0*bL2Pe
zb@n^%z;7R3zh=^y>=;gC6kUM?*~)Z|thwABW1>;)tC~W#EbPo|KR&lHJ+3~i^IHUm
zUZ|?uzh)twt0@R^*8wu>B2yJ<0>M_Rr09bUTET`|QI})`itXZXeS;?|*@wtGha>5z
zR0ajb9vK^zTIEP_4OvOxNK{G;k#~>EN(*j?N-a=U%H?rUsY{mmNV-1EV@<HNW~nB)
zRIk_YsEccDDNERG`fdeGw{AKemjokO)V;TRu={worW>Z%Tnw)$_j;5ubsp+2dC2pE
z=Y)q*JljBue-e(ASEk`qT0ND1A$=mvDCuo!lKun<4HCeQ@^NEn&)z^JJAdq{v1ISq
z!Li53G8srtj%CJrCUg&xiw}jVpCeVAQ&k_T{#`)6r99WFa&dntB(PPD(gj8qhfBb?
zNsUIpxeGiUs+5mrs(k^2iRG%|{&+Q88N?hPFnEL5Xv%OkLF_XIi^0~TA!HP0poufq
zDpo0^)rCOpvyv{HK%uaf$Eq_06$O8Ee)p+v!WpB+tWoLywSk?+PSZ}+O*0(tW*f;g
zZkq95oQBd>|3Gn3vzvw-1=N8)Bs$u`DE;z~-B`@62FeegpU*9(;&I5;x?m{Qh0=Mk
zbRFche!%ecJ`UBrN>@osewq5B*7*<T498na_@B~y2|xX($L5WmTc^%h7w)~ccfmF3
zL|Z=4<g?mSfz+(D#WgnXPoxEV##a{3)WNx6$&IsqM#qeqb9!fQ*^$5b%B&VlxP)&3
zzURjA;r8~tehDbvXq3p+7vXz0C{c$rIj>*T&V9qZ!_f5_)(p0Y4@FTmzC`)<E*G{g
z@vSDSs~&ehUGZG-xr(>=-=+UMqc6jaxEoLOT|#F2mXO=Yrm83KYZbq&_$c^s<ZSTE
z$d^@?Zf!i~k46*bP(T-n2%&&IB3H$NOcYgys;bLTEEx48q_g`gV=<jQTIq1uNqMDK
ztJ9*87$TwfJr7zn-r8ujkdP7tp4sfFsU5<aLt$#f0o}G1!~W0GSQ=C*R+36JmZq|2
zm<Dc9kDR)|PFF{V)iqMOELze(bbS;$DGH;aX_88ZWv83vU9m{q731O+G1(c);0R4p
zd}RiQ-BFsza7<3K<p48P>OH@ON2TJN>g`jk>#9CUlXyj{swpzN;`WMP^Bg@zNrb{<
zJI{rw`Cg)nx^U4(VO4u19_K9<-d?g!;&Eo%kEiyn-<dx(GVSsXpKpAQZ2jcLzPm?0
zynA!^giZJ0hWg&k-Lvi|C(_Dg-`>4=ZA@-l#q_Oeio`B{EVppCRk?P~oNHR~$OHKv
z01Oj0Up#MTYcXE(L-tb8SWz4}hMdLdDgVDkQ_-zo%4`~D<<<G>Z9U%Gop*Y-`L_7A
zD=jOnYb|T7TP%-rPnaHaz2^FfPtQ3~yu&%xztMS{>vrEJ|545JL478^Oj^UOHm&yE
zZhKDP8_X7K^ny?-D2AW3Sk3H;0ApU^(BXL*3$}Rs;y7-NtvZHl5JeEc{5nA|>50C_
z<2geo`cSb%1E+Flb3LckRVhnT(`d95qE2`kCsjk^q@qqgXEMUXYIVF0kWbv?)W;C#
zhs5AE$B@peMn>ULD-%<M*00Vj4T_2v16WH@Q4VTNM(LtybTlZBy);qr`K}GWtZtwC
z@&g-xwR+&6kNqaU|L9Nf>=(B^G#8X9&#ugu550WP>Yc}q<bSohZ_9OSR(>CM4ZVox
z9&d|gYDc~Njlh2u_yg+Y|NNk#Nev6gOs>naU4-<~r~sa2IVTtAG=d35P=#a?BVq+-
z-EV%uOneyGqLR7j*-y|Ar-&{pnN-hyn0odX$z@TgLYA=)E=BI88a@&Zo6RP@R`uiC
zZPbl#qpo`!Xc(K)0pF%(s8m%$k|=`&l#Y#h?rqd_Z&M?mY*?`2knMzxh&F7aPBQE9
zN-R|lR+3C*A26oURt#;2t}09Z`^u8vzOv-EuPpiV)dx1)9N9`#T&659OPqJ#CvYZl
zJaG~%(31N;QF7lWO8aIKMK^vpoA9K+cH<ZQ_!qeGK|lOkwA1LKuj&E@xdDXqA0GU0
z(Ssiz_28S8V$5sNgKwsmnwfg=&D4W${&x?4aV2>GBmihLz$O2$D&hhUe$U3vSvMxj
z#^mEQ9;-FwE1Oaw*jn;&RrUim`NQ;%#hdr$?_H_7@Wb9E_~C0?!VR5y!(vZFt4jHm
z%#o6m?*WYR9#}tBXbhTy-%_T>M1#;?5!<Z0BYki3S<Nxs!Q_$3&!b<A*XwI_bzBqI
z5}L|tWA0c|my{Z%Zs{)VZRLA(kEb8+Feu&8abZ)^Eh46wkJ{Ukri@YbDtm+0_BO@Z
z)TYD}*)~cmZHmL4t!l&c^dYM|+cv~#6hI$z!<jwMu+wM^WC)|cY%)WPUonD-P`xw5
zcg6#Ps=p1^qQRtxyA5^Y?rwMUP~oH+d}V6J%{A@;p5OtA#~Heg&2UPxVjPWGhD2!3
zjKjh>X&f2X9Tw?9Q9USPL6k%y4l%4^k7ui(E0V=RR?3pB5{{=T=<i8zv_dIMW-F*u
zSE#tUVp|2%TXC|2RIKS~EbeKdj?vSt)Y=t?sk5n+j^z5!frUJ*9;S8_-Imrml4@0z
z67}<z{I+&Q3TIQZhf~GHrQ*?Js0|)F2E#{bDIjHmim2naq{5m?UrUo}OZU@g;;=(j
z^^3axN~4OMwGB1u0lpZZm#uFoCPi$-7u(dRb~aO7oG;bl<U!nWsM_Yf`h`i{Kzd9=
z+xLDkt$*1iH$QRH$vK^u-?HMG+pj-0n48qxJFUL8HyyfeX}D?ickg^i@Lk0`u&TPO
zzGd;f7qczNDCPg#F1a&YU43a)<wTD%(0NN$_1@)M-e|jS=)S90J#=Vn)mMMBNOiRr
zPwMbkf=*P7_adLs_i3T6N;<4G_}ecG)AG@c5pvNbWVH~2wO_k>)EzTja{DPguF@;|
zKK*gMW*#I&?+K~A>hlG%r^2`|d^}95!b*5vcw=}FDxA7Of(ixkYm<0141~r^rDBf%
z%_ZclC7+G7T;L0OC9V2`TpdlZ*#F=I+5}}p=$pdWe%0nmVS_T)OLtYvG!bc%qRADu
zW$r6t_a}$S*efi{p|aDm%lW8{TV&=#0ThX7LjiL{_E!pK5~=g~kk*>^3jrxW0&UtV
z9`^z}+*mQ@*-}8F`dmF!p^7Lj#!0*f*+qMmow3)08U@9AB;HeH$7+pkp;pbPVLAd-
znO;tn=_ENNdaX8#jc_zJu{^<WU)Kod1hnRMcpMro8cT`s7%r!Y?1dy@^V1{+$6z=k
zu?tM7a{5=aplG$Wj;htKM;fTu>ad$Bu4gQzFvEI_NP|jz>6Ugur;ho&e|+cJ=jYz@
z!qzdj&Jk_C+Q(;If6>^b-LY86vAj6?<EH0_PHg+zgY&#bP2sEeXT<fw!2NhUW*=Br
zApzyBD4f!S!76IPX{E_sb!l=<nBmM=C-5n*$}PB3X(1&hEtyCt6|JZ*uTNc(+>+c<
z{$zHj{JE^H>AYbxQE{L-LcLT^>YuC*1cGxy0VyP5X$W7hbOq-iujnP-CmqR@pp6R#
zLGT;=f@Za_I=M%9%<!z?Wr0g21%pOr>#7;K&Y_!z=i#gI2D}Zk_|oFU4Pj9+TfHqb
z)VZa&;{y&ImZ~c~%|p29KxrTSX&StfqA?_=i^1jUT9PV3XmEKBjOEdt5V?}=RB~>I
z7y~1aSTdekVOTD#GprSEPu`ZgPk6@gyx~p5n_z(C`svCv4GO++BSZ1yuxm;iH920k
zoZrn5PgIi9ZU)tIVqP>P1Ao}Gbd4jRWS;u$;*0YCd`lUaStWU!t+80eSKsctt#;X_
zV~<?=*|X!?GMjzgpb1Q=)~8NfH6bl$D#J6bTej@>r@rt;?PW=V-u=V6=~Z*4kG*W;
zf6aU3v}ha~8dH)dntuV8RpY73uv6pFkx*?_ZC~y7+9zD^*xzw|<oc&ew^o0x<A%yD
z%sqB?i+&fgOMkE93FZks7qWLcl-l0fwG69g^m<ZD_5OD>59l7%d|$WE&Vr`mryGqw
z(FXXCx>+kVy}J6tia?5+j`2^}02dAgk`Wnm$jF<JLv#>_Gi7%;85i$z9<o-ttILwO
z(r9!iiCfF@0zZu>?T~Ea_wy(C4|q=CujUC~Q@cO)LW*Qk?Wt+0d8w;Y8&ca+52duJ
zTSaG|bGwsqdX-vSi;DY6+rlAFO^NAMmM@vfxqgefikN9tR~j>Pg>iVebrjO)EGk5z
zyI%f+#F0`qT4hAGw49ylr^_*FgbU1JtwpXR#XuLedZF)J4f_HHrdBkRNTu)QYsGln
z*t2wjE!#Z(M}Mq|jrr=zqTFQlzWBJb=IVH0`TWNFHTjWuANjA5=4-!Go4=*6CNy|B
zKYdh?&UMHjO7d6VyD?}5DZ0P#Cwz{15gCvR)f__}8a!{cWx0unH%_z~1ZJYH;spnG
zc--%vD9XW}GsUfM!~d}X_JT5=*|}grCw#|uEm%l%=0&v%-;sfZ#ggh#x+uSt+yhd>
zih7l@&E}&5Y0&H<-_bom9@DY-MZ_3iG}%l>`nt?2I}KCM(9P83K1HX9Se$9QdWUL8
z4ClnNstH=UGu1`r;HZkRh*oMA#*sxt<ep{K<KtDAPR{23mOp@}vMVdckDc?a{rOk(
z@8*Y=bk)^N$NvDCrr=>1n<<6U%!}+Yy25}?fZ@vErOwq(qNh769aej`oQXPKb1>~%
zHsW?mtS;{OA$b#Fd>;aMj_-dq9v2Y{a!Y?$G(~=A9Ks(SLf)i%h`jNv;FUm%4KaGf
zP&DH_WncWQXm!&-cM8tW4%25T6544Mfm1S5A$O%Orng1oeqX>xIBU!tkLe=|anRyj
zh(ZFCWJ7!*_SvL`C~SfRjRwD#cCDmv4h9D_Lj7ovA)Pf9m0=3iRA5#oQUS!g`0RTd
z<ch%9al3x9>dk9z{N<YW@V)srv~`u?bY*u(YGN6?%wPHK6T5>t`~P|2_EYP&VC|mM
zc*`dvtF|gz^Z9IS<)hfXd_0UM05#@&Fq(Q~Lc0}ry9w7~%peWnb$V87G9r!EWHK0r
z@LbTZ*bWnJK$zDWOjv`S$LA1>^h8vQTFh#Vrs6h)=NTPz%;WirJELjW5J4kph{h`*
zI;6;BE)MBwb?<!7nIceW2d+NbS_%cQ(ic`}ZWLb@1VN3#%-L|Q8hRGCgd4(^TC!=~
z4L9V6^Nt00D=sk0&+R;sKZ&bO5EsyH4ZfPJC2fEVyo!;$hl&e#-}~0+!d+%`;f|~w
zIYuVnt4~mh_W;GuRw@1>B~q{1%-$gk37Q>bw{9PKQr$Ub1Da<LFY=)hty`v1TDJpf
z8I7hY+eKS|=Fh0)u9E%*G;gEehpKl%xA;0K&3l$rcO;4=kEi7i<d;@<j-7MYAa2HG
zc!Emuc~kxe`5))$3szB}@FBYs<b4?TAGFfFmR}w;HPK92V{8)renIpH0)nYIpjE9&
zS0qB31AIibgaXbfrHG_JC=eF?E-VBBZN-@k0BW`fW{d-_uvW|Sh`5|uL5FFyk_pc<
zVbhJhGL}V4nIHLZFQ9SX)nJw07%A<&?avKRx463ZcA&WT_Wb)tMrRTd8fmmybK}bh
z4!VnLAe8Dii>)`lyjgr1tJ`z|9iYOXlCsqyK@=L$K&UUgF|;xKZM0q39@-v0j1GrQ
znvf=3u1OdowsJ2g4izptXsd&4pJKDtX)qG)SQNM8z5YRQ(62=~^))mp>N$N@)Y^UO
zCTvA#b+;p}+18GR3ZIv1f}KXF{pk?2f&900>t&HMX<#VEROs_y9Gi*5LbnhUcNI`?
zS8?$zPac%3`tk9ZE#b(yl`A_#d8uz!AT<u4?75?4!n#y5iNy@^wE17{)GR;u$aNRR
zVtCG#%nzgW5klWDU@d&eQ*=;GIOWhb-Iqx+(Y@UBq<hHyy5|$mCrQ4^jrj@}ilKTm
zt!7?LZ|zFB=Nhq=YVp3>jiC1T)(+O{Uc@JA{(%003N`FCx@$bwmffbi)w35p?ifTb
zA)VWkM2WIYZ4;Up>Z%?<16YSdK=vCE)_FX<PN(;H++MHN0Jb|pf7IXrDsKOCSp$|(
z8PE>`dN&FIQSt@@QgwM%pjy!+HOMej*mTHk(1(T!>y_n6Eg$k01%Wo5EVCz*WyWIk
zx*_d$+1+lJPOsDI%iJC)dpMpiOO`{Ua+lGd*NA0a4}CG9o4ceOmnX}UW%Rv)MjfX&
zREH$0Dhzrpud8*rylAW*{}6>xlC&ZPxk)>e#lrC;H1v{sR>>8I!rQJoztKc}Kfr~r
z2l%)50$7^{=qmxN#kT^Se*=K_f>#0LE+_$MsIaxk`#(fn<o>hrMNWM=044ZVJQ{6r
zv^=CUWkY2cNOiWl2$<{dS7VdZ{fRu5G5lY!CWvidY^vKA`O!7P;vymcSv+g!n(~(>
z@`L%iWBGC8>lHF(LZ%w)f7Mu7Gq#<4yEEu;r~mnXWU+A?J0-?MW5#V?J<O~)w?lLB
z<6T@VMiPPe`jJ(HY+pSs0tBk(!w%Q#k()^8oN@kShN$t9z4^P@zk!r=qBwp->C_mO
zd6xOFh-tti(c2~p6K$JKcM4m?E!I12n;rV`xI@1zaz$*nX{Wf;y4$hO{Z#1D_?yC;
zHj|SA!O+GFHoOK)xme2G)K%LKg}C}+E}DS;*6H;|18d|&y;biVD^9ZBF5F==t}(6=
zuXnDAtd8BO-|2o8zpB?wH~&aaU(oZe;ub7fLm4FWg{OZpFvuYLTy+*k-7XNT$nrzD
z{xDO`)v-f(iDEHGzd%~<QmfgMD7!MeYS!rfR>g#58q3*Z_Z}~8J~x=G*|H*1S6|?j
z%AKWv^XLU_o~2EE^c7z8<nV0j)@?mYH@~(IkG`NOSA?QdC={(X#>25d+!Kq%Lryt{
zgGOHrxkX6gR;WfCQVa&)Z-UHd@CvRNj@lprIaOSI`r3Q{^}A+LNR5Y3M3ZP~a==$`
zTbpd~MI}cbs|L3@s1rD$8f4)RP4NY<?4rn&dAst(d&<%~*F2YhZ_?TP+jtjft0uf7
z|6+dC;e{8ipSg3_CF^_U8*jT^J0^Z)FpJk=4p)I;a%KMK`7iV9SoZk`^Y7;$ed4-n
z9>bGy*F8fZ`@)4kFk8X?NP#UU@q$ZOmRg&-&2iiR)84noM^)U5&zw2?-m`mlvq?7D
zB<Eyb+3e=UhDQ=0*^q}oSQ4HR70nw0Asg}l@dawF@0wPxSFlyAt*_dWoCq$UCHJ;h
zYg-F_c(tt+T4`;2i*Q@SPpb*P@60&~LFo^B?;rP{2EOzC&dhhdGxMD}^PbtXM^pYK
z?OEqjX@^oQg;`ZuoXZHaP#9n$1g!u<xt3}ZZb3$r%l!}qxgQ~DbD%s02YuFUe9V~&
znETOzm`#@{AXk!0c|pclXFdeOKnu=1kb`uhj?=+V??uN?QNEbZ<<nuG!=8@QGYjoG
zIEM~aaxw}I;dOWzsRNd+B7KI9PB6u@6OQuYjLcIDkjz~PTuj~jk1Ve(yU3P(iE8$V
zl!`2or3eXaQmC|1BxJAbOW8^GJ!`g5giu+MwMdo-*+TR?&$;(bcbS=Ln%?*K`Tzai
zncK{r^K9Sed!BRdbI$JT`lXRW^PXL{%y-QCWpmrdKY8BUT@R<kbyz3)ma=@VXV|u}
zAJH=oQ?-_a{Z3B|80$aYe!}O&AI}seitOq>mHzydo&6=^Rao0I884<k==M~2yVuK`
z-CK`2;_=(!^4&YerYYVZH|6j4`k9fv@zwTyJ3Kai{=9vE-t6VeW=}Bw;hN&s<X3QV
zi1v@}d4cBn2a3$4v58YI^?yArZ}7}E5mq-}oc5b?vT5w9)34^lN`u>Pwi@Dec;4ng
zA%;~Y9hVeU-Kb?hpuyINK-&f9KNRlmRjc*&%cG-=0>YP12p1f4do$_J$he@SWrO1<
zWHy?)R5!8z`1*phZ!YZ|hKR3LIob4SH|ssMQs4U7*-Y@Nn(7d|aJ#dUS9MpTd!4kb
zd+gG#ncnlw=^eA)&Aa{U$rGa_Bb&QZENZ?^(;OVL^X<#$nF)5DX9MnRh<|cwk;FLt
z*m2+dz!q=zYR&xPKEqUBC-1`a<%V0P1O{DiIlc9!Cm+M_rPkM;{x^MW<Kuo+Zbi6W
zsdsp3JN;$t7EeeXon+Eu&y#D7KN;LlHEX@G*`DQxpYGLL+IwrIE}^?N?%!}AW5Mz_
z;-aY=^ICPizi>sK?$@s)3c`-sZMK@9_+r(jn6%9WhiiTN`6d76x)*g$?|)P6=fWqs
zVXgINjGVo)XXn<}d)fN!$sT$?%43n0-z%3j^?Hh5WrTHjpB3X2Jb<@lZM*9yM;irX
zjO?((X>5mgQx{GNwzQrYaMiojZ9Og5*K6%YxUA1L+<MT$^L>-Mu}{sKZHPKH`pdDK
z1Kam};h$W4qU{o=&Ti}UI=MB`zi?+^n4arKt7?~Gm%eI|x-cTny=&yKI_Hn%#pQeX
z)=zpg^;3Pz6$yQvzK4g83LHId#ZB*A|Er_?8(iG}Eg`GtMB{6rZ^zuuh;8V0XW!G$
z_i9*v^Ul7<)A`ou*7IJEXDqRZ&~EK_e6r0yk&j~|2CZ+O*0RpT`4j3bc5SNRbfRT~
zyY}r4)xIR%yQS}+>(px3$45sGjdEx_aEN2ShM_ixYc%bz_w3|_X?Y1bSKEdje7`n2
z*J`QF{!S)S^bekCRcrN-!$*TAYEK(7LvLwq|2xJhdLz0eghXAGn)<f;Jm}oCJG0)*
z{q}dz?(S|Kv<B7AcI($Yvu(lB3-h&KF84h7YGSj>b9;~6aQd_Hqv@~54jI<bFLleD
z-xD9{-L+X{x@gQRiv<P0M%~|#{5QGZ@Fl6Qzl&VPt@K}TO0@s!WbezigALyG={0`%
zxl6H6W1r4k|8dcl)&<KNH=n-yPq#0J^Oo~XZrp3!{NRAR2<-`ZnTg>kGlMJFJDNXb
zcl!EQ!&)Ed_BGJKWb5?ZAIH6^H%zLR9(!|U+RO)5eY{rxh+N;|i<4K7^k#0YYD<j=
z6mA?9SGUdii$^+lNW6aC^!lxDL1wO&Mv^7|yw!~tBpPbZ?$m3*=}{Z*x1O_oVNl-g
z6pyJpVpr@~P<>jpnWlcd&ThG!Gpb=q?ID9cOgno1^OCAxH!rbiSnK#gr^!XXe1bk~
zpVe#gyaT&Kdra>$vr+%sdfu+Ps`2M-?>$#<Z1@-crNuiNH+ea0`jMutLHh3(><>Hb
zVbgeCm-UHbTJgr*jD6B&@7htD+a7R}+}Le>blkZ**42I9t+X4|;!(%b%UAb0k=tpV
zNAt|bw>P)Q+l%G^*NlJqc1j;47OsCjbI42Wt(oG%vzK|!8vn5J;o#3#7d`G8bKU5c
zdxIL@8&5xN_`K_R=P%K9Qy;i?xu>ajPqSICka~e{2V5QW?L*wp9lj^uN0?=W&-~dy
zS6ZkSn&qtD{OqeKskx%-83Bif{2DPa=bGU$iOa$j$x8y-y>mXSxxjf`^sm$XTo=B%
zdhG1=UZ`8l=ru>Wi3aqHaa^)qE6cF<<%^=LmV;gx#Tgn@PI2D*=;W1zd3*1l+WSiK
zefYYQZ3b)KH}QAe_`$NEMUVaC$Bk=#?vUX8t{vVx%%3irboOlijj!80GqSa(cl6oZ
z`p@UfBdcs3dGv+jrfoW1%om3&{m}dM)fd&Cx#;VTyE!}zQMQetV^>u9xy@)&jWNv!
zoIjJA=K5^n-*XuO7Jt1{XV1R)v+>`?Up^K*kGk{rcGN9#K&EC+%HDBa-hIu?R@F)r
zUs{pjnP3?=%HxK(t)}=u=IPdNV(S?BoP3@e+QolGthnabc3Q1!WcJSKUtiyR)RD*S
zo4f5#9%<k=A}8C$tx??YTIRF0szr=6`*e0n#;bd6=9pJ9UGLGYTTl((&f47*ss(vR
zSjWEY@p@kDl$TR4b(wf+imUC;@rgl`#%KKM{4k``-(@`afkhMkbUG3gGJF5Yuh$=#
zgs$&eYwB|+kBnI1$9;b-_upBc|32s3*A4lXqwM<@e*1ZHZueRjZVa(5^vgTcy`kOT
z#}TU!3JzV5jR?Em{NvwEi%fPz)oiz}Rld;2Co3{>Nq?Q6nm-qRGS4sk=-hGq1o28i
z?AuEb&zHYSYP5BU$YsVvJ8!Eq5iXsY9eZ}=X}?xYOm=(>7Ox1Je9&7odUCHp7lzc{
z^v|V52SRdAJ2@X65Ri2H!~@B}kE2bG>vV77_03yf@9@+*^ABv&OH6k4k@)`b{%zE<
z(}c~U`#oIFUkOUu7u!H!TkrhP<+t7~3ynK+Zc9XFuj-DKO<U<rkK7;LanapMqmR_Q
zt>rkhVAH1+pF~+zvl?gZ^tLvvk-pFQAFYO!q7LZSa=WtgnbW{k69yfLTxsLyW8F!d
zyZK&+_V?Q5X<VMD-D}LEu@Cz`PY#{k>8_Kp#+PmTdCiVx_iXq6^RUzr%bcv!-*@$E
zHLb=kei!Yb^V<YCKT2*@dG53^OZApC-*xAtXGB7$hcCOh-AU8i`l8FXbIvY$A9lPP
z8vShd{!O`wRX@fG`i*kvZ<n6)YqWjmO{Qk8_cwUcz3Tq37Z!dt8#5AZ8$XWvU88E;
zm=90lH%mg+-)Jzt;dqPpt#r><o%=h(rEky3-n!ea-?olP9JK5}*V}cfEe;G>(`r(`
zlx~tMk#+B$%Gl<gG&u2H+u&Q*OtVfevbVc)JAdVx0s7*<W83RR9QdC2_~@IT1q;Rn
z-2866XX=M3-wM93Ur{Hd;T<!}!f%?-a^GyJa;QmUSf!%IJ?;t%{ogDy>9aR;)zxXd
z=EoQJh`zMX-+F-4(j{X1)x8{_yLCd_Uj<K2dR@7fkaWKCV8<RNw}TF>_VXV%GiKSz
z(Az%W&6ocARDa9os9T#a<VR{}wi>*Dxm82oKX&@J{BEzZS}*-P-mkgoudBEGtIqAc
zXSVkA>_;!gW`wM|5P!a)aKNg2CoGl~c3!G|%{<}8Zs~zTYkK5f&0Myv&79XUha)^+
zd%ZSUf3)9>dqtZ*Z8CK?&OGKZ!t`mM;UBU_k6SLvw0w{e)9CZ?`VMXEHpR8=9UWx0
z|NEn==0grN^{BC7YKQ#?2G0%1o%1bVXRY2h8~gwMljJeI`ozFtU26|HusFSE^w(qc
zJL`>D95<)x?<JD1$;WEVZt?1yV8^hp^ZIR^Ib&6o#A7yA6VJD7H`v9XO?%&yPxS(g
zK0f}w$~(DzvX+h3W6h3Jb~F^(Saxw3(d16wUqkx7DSZFrfsI?Idzv+E4x0?0V72n(
z#uL0(ertDm9e?KD@ZxWWfIWjB@9uy0h!@}g+?-okIo7RT_{Y@uZ)3Uf+O$Qj`p+te
zO@H?6XG%l6i$5M+ESix!z4G5<pVBr=K3l89r4H+b+6HekJD&YfH~7O-yH*eLPdsXV
z@m$uSXoEbDz?7!v-QQ02_Z_2c@bgCYk7H@UTgUr+xP9zaZjr-Gk&EfQbm5-wR?f{j
zE+3axebCRh)lPL9VO{6+m%-KAJ@ZT+c|WrHq(KJKyKh~@bDaKWPH7a@Xzs8c+TlNI
zxm_FD@R3#e)moePnRnU!p;A-VVZCZLtNQMpapwjT<3vMyp5ui)n_|%TMU445+y0ls
zGJZU&9Ui`T>%P>SY4OQ9Uh#Jft8AZPI^SbJy1BdFOT(IzuQ(dn-FWpiVB@5hUs1vA
z+S~3UWAD3&#smg?Y|x9i>vmf3w3Q^);_Q;ZL0_}_&z^txwe;N7&XY9S>2)|?XOZ88
z>_^8QAGxz3ec==L-hB;+u1rd<6ByU2uEW!j@A(g<AL>^R(zowrcevs1R{j%ewSL!S
z=CO-UdVY#IF?D(OZb=cg>smE`@;zw4t?asizJ}4=R@G1P%ec98M>EG>Kkn7F49Xjw
zdh|j-ZeFJlfA1fwhdl8wnEHfQ^lbF8$C4h?g7W)3Zrs5qqh8CScB!W(jM}>}Wk#}d
z$Efy$lG^QZ8#LhVj{~y~4qKmhx7pno<5`g(?3;bwa`c>WAJcV__YYZ^|5`q5VdN#(
zlr-O6E(?Rb>}Q9&*LV?L__n*A|G0gF6YqE5A2$8KjwrL$0*P*wmX(4+JM>)rM$;@K
zXR?KnlVx+Q4Ri9x#E3V&t#ZZd_Qs==8*gdVZ1<hL**S0B#zy+>ij%h5f4B3ufgSAo
z?hAT%zGttscI(~;_WB&1@O|sk{9oA}H+gBD4HKBB9yr%`Wrx7gqc1I*{kf{q%grIb
z3qLpixM5S_uMq2TA*j8k*R8pS$3|^!5><3BJH$V|?f2M5J#usVEgW*~P^>{ge59kx
z#o({^r@y{8<d0U`&%3L?E&So%D}Hj??8nO&2(qmoY}eZzqF*CAtmwwqS5m9-%QnoI
zKRoHrp8DJ7>h*Jcx<9GXQ1fG{HS>(V{v-VIPr=B~ntN()OZ7IrvB=PBuB5W#x={O8
zpQ=_$w~*E^JXEQ3P8-*_6Un_Q2UP#m4fV)aH`l&O!N{Sry_Z`U|D5n+PH@A5SDMdF
z=B&*;ReM{bH=TP|`xGDF(CCElb>%*7>a;lhSYuwjfG$P)UFQj7<~`s1etP`AQR7~}
z2s$(`GRffQhd9%>jb9FY+3sq;LCd2qI%Q0L+U`l`!du@D{4p99;3w4^uC>#1@Ogv5
z{d;cw`#jH1U>CS<VvI}rYvZ;x(wgVb$m^fi%q!-{sSB?zc#cmi^2>aAuJ^Ot?FY9T
zyuPUO*UZJ=?1*=8mR{fAVL#R-L|%OzEj`}*>+)yu29}ez&wG9|SR3_qIJiHlb^WwL
z32*h0RW}^Pm(81{I_L}@T36@6q*fPpEf;Oj_bU*Msr$01s?OBjrk9(G9xWbt`i#z0
z^R2Jrgkv(ldxvZ|)ZEu^Yx<<{_i<NrZnYWrBRHbtq(gcAbZ)g<za@QA%VY1J>KyFn
z9(2*Nc}lh51(wZM+852Y+&DDi?>5U?(nCc}+dFURJy!g(K}625m7fP%+Dwg#m_A9k
z{PNZ6O%GO|e*W_|%P*ZL8DE~Hd4J>QQ#y6x_*<Ng*MD+wmo56j+%D@=JMIgy85?a@
zv`bs0lO6di1s$jJ)=sAm|CW_d=d0JVeW}|*zC6`I$LoAdM}K-15K--q{Z;r=cemqF
zIZwaaL@Ye_c=oMHwNCf^5P<G^@6fJ{fp;g4k4at8>i7Ndlc^gfUUY~Kv~>zuk=l0k
zmzEK`eD2MP8QOAbwTNmhmsXB;5cYD~YiSXb;9<FY-dU?bXzUZiJjS|*7xj(URakWC
zP3@~i+7Z=eFVfL|8Yt+QGg-K1Z}hU%3}LTj^U>E@ScI=@S`@7__~*sjlT5qYTpJd#
zkndl(D%Ejc>)mG2W~SC77JUt_8tc2o(!wIk<tLy2XUN?Zv)$T7kG`-;GFj+<aedmz
zwME-3ZGPA_yLBV+=UmIXGdiWj_O~2nTe;}QoG}sN9oF&F*7QEF5jv^*J7;~-gxu;I
zHXO`+c1yZ6ez(qrKds{RE=|>(-@1=x@`D<uSO2-;*y)|d?faP*7o52<$td$fxLzgC
zgSzhZhxUs9aXnH`zoGROt<jabH;wS>ZM88xr}u#l6K<rmO}uoX<*bI8TYEd`nidJH
z{?7C<m~Uq>{-4M5M{d8|EO1P4#_71IA$sw;cfG5B8hUZ|@n%mZEiL+-wte`_s6L`6
zI!F9NBi1dd-KB-gxy@se&u5NFZl5&hyXCsc&5p0@ZINkp_x`QZVSlsM%-Z1fO*rDF
z^i=F|PmP)FvQLDqZSt-ACTn+tH^&;9?>+im5HW0T)y!k-KG*fwJO1idOHqHD?$M+7
zv{-B2-D{%J%BXRBH?<jQG2+jjUmu+sRF5**bAI{T3AOG%TJ!ADsE1uPKbSjm{Uyn^
zg&($N-M!{vUp*o1cKdy<M>i+l*UE``IpV{bQ!Vp*CitXYn$d7VfMJozr(wR^)@{(S
zJJoT!!|IrvEwi`h@Ala;;n9;z7s5RY8n}#n{Akz9INP`&(+<C5C%>Kdb=g~=JU9OV
z2S<FkD|(f7=Hk%h2G;3?&3bGz8uo>s^kU<_P}>U|(zU!ZZll|be;DJt&m-<z+k*if
z;}bhwth4XFS!Q#mHtrs$2B(i5q4ny0rDa84&3ftevl@6K`+oDDuV(C!@J>e`wmCH5
z>yHk<?5m$`c)qWX|B&V9j?KJs^-`rk*Vnz>ica2Mw&VU&`ySP^Uu}N;YVDHl2hWE!
z=+)9@uAWI&C!0G<Pi+39sXKU!jV-^QR^r*mzZ+^UIfNRQ^6q52{>{8KYvahq$0A3D
z@NIw0dD6A+_fr9Wp6(x>ck2}Q*E1kHZ(Lx#!Utai>IMWP?XPBE-E8<|uYS{ZjJKXM
z<l>VpP2aVA|1qyc=U+3;cRd|x6Mgcc|IFzhtDQNzfB)I@Hu^iwXU^;~y?4sryt#e6
z=AJuwHn?7b!Q>Ag-@I?R#%=9-%Z&{!^4C3RnV-_T)6VK?&(~^feNgGl;n)zXAG(9>
zA8V~kixb`4cj?sD(ZA3s<`y49h1!oL0jIn+)o<cG-D~EZq1CIj9F)}Zsb+AmdX-%2
znEPv5^z=6S+V_}o<G>xK+!nQXcYA%$Q^!+>YP)>1o;IF8ApCr2&Y6q88n*YX*Yev1
z?Q$OcVAi^MLnR6Phi4Xe9J$!s=|lf1A3qE@emlHTgQxpCHm>OyCv0F58f+2j)9<x-
z-`LEIhZ%Q&ENOAndaCB{J?_rIXY%r#^2~(ut9ln*alPV@`QB;pl~)BL4h1#2lj(X!
zWa6V87&U8si%Py<eH`^){CPd$-PX{(AzHis8b$s>Z;HGPMNd!p6<PFJdE<QTPnPkI
z=Y+=9b`TftwitU!DDuu&VKeJn%EoWKZ~AGu6jpko|J=$U*|dXO@7z}nwi@NsYV&~q
z&L_+EP~wE#xu?&X*hGe%*%-gbW9B~|N5=Fs7;nD5rXcp7{?_MVrvsN9&VKzxR5<oR
z`0~%Sepb6s=+oe@b>y8M9%tf57e)E)@(~Tal{Grk$LMdZO?3`*coX_)THwLt%tWoP
z&0lD4y*WQB$NuV=mw7|hB$)m>@yB4`=a9x9O@A%$$jy8+OaGTvT*C7=9!A&guN^qq
zIdR~?AmMfUtLDdC4mSzx^eFM}W0wHK{Thcfb(0f1U+uXz*UEW7?>}ANjY#d-_@I8o
z`6}U7!`}X!_RMHq-m>AZd9k9nFsJAxk6PXs5p&d|;m0{2SLYjTTkbZ>y{qf9X<ZX5
zopC(me8S&jPv3pMF;~Y9>pJ51C4J2Vjb9qyD{ZQjV)3r!o~9F;W*TeUnX<;KQ@p0e
z%u3cn$923l%H#0&Pi+epcl+3OmB!La|9Cj+Wwc8^{>3t7X?;;;V{5yFz}R^~J41En
zhu=TCX4TRD^{))<Y<k0ZP4a;^H;uCbqK(_n)f|~-oLs$2SQGbzC;YWdYiV09x7!#v
z-&)h#_yzB)XSaK!_H+))`R5@os!u@pUcH|)2KkvyadArC(ja0)SoYyPHRf2fGmLLt
zJ#*;1S#ts^d&gfG(q&WMc5Q!OO+LBjpTgaa!@YGrRMwqj5E+@_tg)u(>!^V`jf=K8
zO+Vs&ZSAUzuDp(M(Sz^n=Zkl~7Ueh0wrKFPPG*bv!<BDWE3EmmRfADIE{Z2=N1xTb
z&}r_U0mn3ZOkOf;^AimV!4hK&PqS86zxyWcy86YpL!)IQH(tM+-SH~F_sJa@b7m$@
z?9lc4qU-6Cg4>7a2u4r(^>^puy{YT3w@#XvUHQ=J__g{O<2#<;({xTwd!vaBc3inX
za@G7P9nHEo*jYdNT2!-kro(#IOZd?(V?kQ{$IfRO$5fuZ?8&a3179w>z9{@di?x+M
z2RHVp-Pd_u_a5V>wjCcMnqSyV_}8t;<BX#dMmHK!{d(}8DswbrF4Ver*3WA0xw`j$
z4;}Q;BK2I|zF$msz6joPeDS8rt%DqnMxG1(m1K}=82_^O7hRu4m354h{t4+EwBpGi
z&&q=rFEX3nbgWl1LB^yTp2IhF3IEXX*Ic{vgP!$?&}h;AZ}(q)J8G>qIC7x&@-w}J
z@pl@nZfrX}dQ6jgpQ??iX0X~JTfA$DeN;8e3w1{BDasCLQcxIqzy8x2F&A|X)G%zV
zA+6@EGpG8=`zsdRf73&w^83Ng;+gkmM~+RbY%pv}OxjHso=Y(A?gOU|_iv`nT44Dp
zAaQlWKjIEU+gNtK@p#7h;oS~O2kC74D_r$z;G!z-<G0TltK<E1)abs)vkgbz_B%Ru
z<*a?Nt5#iF9F(~8!Tt@r*w9@&*YPYHMMoI*J3eI9{A*+14y*Cbz3R=WU7n6^_hnl_
zj#+AQ=*OLF8e94e@-zSNQFqw7=*}LM9@a9f9B<L=$~m2FH8QLC9$kHA#nUryj5X#S
z+Z=XVqqmL4#O+<@RM%Lhu}LF^m)=A}>xq@_!X}1`DoIz2svS^2xoPiO@%nSlYrNEO
z)2RKXbC>xu-h3ZaBl4_<rN**`aRXNCR$Z~Ia@>NxE<(pX{mpxxd3v<wxrQGSdY;+r
z(&?hjDVry64X@@@sk!6mVAOxb@}Ka)?z>Fx9(ucVMB~B7mPB{TtJ65<>%&N!@xy+F
z6|{aC64vnbImbUo=Jp&jb-}m-X}r6}yk$=Hr?h>T@NjeXq*tGB++CYJsc=T2-=-G9
zuM2wae%_{Et>xNV^xGdjy}NA>uXmSC4YHiZE@;jRX*poU=IlzBt#(G*nmJ_JcMD$U
z(8N6C`L^rkeZr<>E$lwCd%JbhZt}uB`<Naw-DSGnG&)`M*8XeoFNa@_f5x5P^33!Q
zKjCX()H|KL_1o^9pRi2Bdy;nKmGA~pcchWmB7-9{?Bm}%e{UK&I6QyuX!9-_t&@IL
z{q&)-Z__#X!_L-CZs1Y<lUeRxU+-K^bm`^nRyXt46*$kf{(5t^*3Zw)Oigl3vtC;k
zzMSoOE^gk;u$cVr{a@L4TkB<(bZXQSueoElY0O&jNYd>2#`qr{U(Re;(AmGssV0WM
zn>N;rT{6tX(5iFd`Mm`>8T;>^>1X!Be}ajY_onEXixMY{tkgbo@QxNwq9<HE-OD+!
zYD$*x%r&~lSI#-t^~SJaO)Q+7MWyEM`|zYyy))JO<W*{OuVW?KVUK@K^E@@&DsZ}9
ztr51vg3blC`np5d<!q{nhL&jFPigehO9!0pnOt?=dUE-kz<I-hC**C`n%*+Hz2WZ5
z4Ls`>KCZK7^Vv#cy%vv_u31;jx#R9DZwC1+TI0EUP4>8<=54p}8h2?lVz+k{KZ7G%
z&o}vWD)OgP(Ap_yZSwJJ-Au9$n`D{Jx_sAU`=jLUeP?@{TuC-H^tDOO(VqQLd)((*
zLw+qd{A<CL0*CCX%b$$eWmj;}u3)X*j8r}2*Nt0!t(iV!LE~|bQR|o1yi{*!=CQp?
z4!ceq+0CJe$+`vOZ(gqJk~Q<#r}^E4H_aE+eqV4WWoylXo5_WC6K@AjJE?oC$uYND
zi=>mHKHXp1GD^$0#RZ)j2?yru#kA+~5?*!vtg)?IhjDe1q7&>Y->`l0XU_071);-F
zEQx(Ntm%RNo9Zmr>2k7bmi?v2JK9D!xX@&Ub&d5_1C00151wN(JnmSfKZD=isN`q;
zc0-*vnoGxB4l#3RvG`KaLBC$rUVLsnZ1K{>kK1*B)QKO^VO-TG2K$b_)E?SFYffzC
zXp<Y?&ox+>kma_<`=6A%10U9X)1`5*z4JTt9@5$2Yn7MI1Jgt2T-f2axytc=HNFiE
zJUeXh^}s4so3$GHqSdEo`x5rfH|a30cIWL0uQeVWu)UzQ$9}KzfKbo)=%yaxJafl&
zX(MCw28DzVxtSEy$mv=7HlsoLjR$Vpw{uI)y-mC~uUk20ti`oiGwQc;9qu&nbd`r)
z*Lv4WF(2VuYt5m5w(&bu>2dYTniS`4XU>eN^7HttahGTJuhux*=JIomjsxD_sJ<rJ
z?|!BHloc!XH0nOG(>|9aKAjzJbm;0h`j`0RHvNvN;qzwPspMWcd$w&<!sNzpy^ijz
zua~x{P4DVEO%osQELz&hF+uN7eUmJ&7Aux%=Js6M`)aqe$62e>49=cQ`*9_{{+IrT
z7liHnSY>+u>nV=z-L|xgFu!aW_h@IZ!=THj=G7a79#QOIRD1i6fbOeX)#$e~q)tb7
zoeNcxr>9AKr?kv!nKt#3eN3A@HA6q2jhX9x@}73w$VZKK)Q_=xnzc5~GAXIrKX)@u
zn0eGO?R+BHvC9Q<Vcc;Kt(z7W+BZ{I4a_-udUA|y-7Xr-yS}T`C9>`}eoeEmoEE!!
z%v(9|*2CPi4S@#JQfj?)(D-w-?UkDg?Q2h6cz<Evl;_#aDlZ&svFwtopHAQCTa!c^
zA}phyB{er{$8USPuffK<8;2#uXm?5baxc4Ccc1smqJk<%n0%?z@ZicuY4M^1V}yKz
zv=zcl<Bf(lac{~KJDm4y^wL21a^cF)0ryfmF5hJT%F5}>(*2fx7y8af$e5!u(!fXa
z%RkfY8bsgET~%OQXWAmSgaLJ3oyK}!`_pP^?#I&?&oqmfy5GmnNU!CqZztBHCd{#i
z0<PNo<n_;PYyUmzN}c@=B8=BRHEs}-@bi7n!j*+1@<q8?KE0moihC6LWa82d=`9nQ
zpV<<(_FhY`15>M={25+ngwMvgbrQQ&7U${M4#<fAv!U6P8I3kg?x&|WVwa`yz^Ke<
zcb7qSdk2XGQAy`dFXY`{F|*lSXOH=g{j2wB8vV~hzh0e_+t$tvYPxabv50D+x_kBd
zkG709o6xk5Wz>(QwVt)P|9j)UACkS(8@#Ob*LR+WhehWkr+<9fWG*Re{nuarSL-U5
zook)?c4&X@*ZU_5-u0+7#xn2e$<$uQ_77gyZ|13Cbpz*Dv48YPGW^LSqhq(yNB2z2
z-M_Y<_Mx-$fAn~FKE<x*(g*hsj+4acKN!8gTX^>aUrsy_FYkWw#FX5=)1LNfX_s+u
zeZ2s^#v?6Xj=Auy!86n$#z!Z8B>w;Whdxd0uH5K*db|76J@vcq7-C^)e06m4rxV9#
z_-xdUSrWYV{oSaoxfc?B7xyb@=CVY%d{l6lWfhHgBStxl8hk!;^{#PZ)X{ico_)^i
zAgwGnp+WskEid$)l;V)?P^+kVrkA((KYx2))70E|=;^*|6Lv29sd+_rXz2U8(z&|~
z<Hw4M%!Gbf1`UP<ruN=B@#!Svaj)|Zx%PYe_H@rQ<2h~Xi!S%CVzz0;WO2$6XU*U+
zlY?I)3cOynPPi^@p4D1YddafjrD2?DHSfxn1x7CC@<+W|GLYZOw25h@b01sGe4WtK
z<=m%HSxe0ML#!@ooYkt{<=iK)&U`~*{IWW+Pmay%_wcSxXz!G<L-sn(39QXejNkh1
z_B_kpLtT2z$ga%W7Nm7lcVBM&f*!S7*%oFF&AuD5K~H$8sIH^Y7$f<oFv0OY_)s#j
zh|i-RN+vBn3`ll7Qy*7fXCHTOKQA8xIHSzkajL6<rTjz5%)O?#6dy^34q<{X5GRs}
zL{j2JGQJ@?u?U?=CT5;UR_gP}L<-L%gOiL{=aCr|%R`+<CN0HzWQQIZ)?4r+u%>~R
zw%w8s(n?*-UtI3%l-hdj_e$nYlXhA)h&qz_Ay;s1YK(sGYpVr<@g29!n*OBqHOK20
z7wql%v#-O#qjmq9^fG^aKV$qN-d)RY7N>TuE}VWU;C6oG%%Er5Aw8F^-|K#?aOSLl
z@t1ARPx<}!y{YTZ^pxL*;dbBheWx#deb;%5Y2mHqVO@{ivi$b9LGCQi*9ISMy<YV#
z=>5x=j)51ht_fM#`c8&kJGa4WJm38Z_UzgE(dT!uyE=>a8MP2cwf<eS<xFFn+w1e}
zn(r9V4;|~B`lOMipM#lw>e^8KW|EX;pGAI&GwL{m1-ux~^W2_3Y@>Nth~6}t-WQJ^
z&dz(Y{z<Rg^(h~}zTaLqJk&<}Ue8JSc5h-Dn!cNypS~yh`uOt}t1sS5$v)g?^~G^!
zhm*RA(!W|6<l9Atb_|L5k(PbfP_nt;(t(B-3$Bmfv1>r#8`lP=ITMo5>oy@ZW?Rhe
zbY@BGSbp{?`$_rD_g?>L|EX!d{od6%b;TC5+nrAu?_{#D(0WGFN5j?@vujnenjQAz
zShl1<e_f$g?RACL#!Fh)7Jm-Cwd=R$Z1lHr;?Gu_6P9~<TyJf0`r+GZFPA!3FFLU7
zU8^<;Csy`d8+>V3?dYPjH@^tmS<Sv!>G9+ITXJK<$gtQ|WUjB|WU`VXK>oR8QpUMt
z5;zBpJlhM-^1|ncq4T|{Grr*LFE|Sfe-6$IL;sA3Gr#b;Wcd6qbPYZSe}nJA{iuKV
zoHF<xx(1)Y=aPx>=W4>|@pY*Y@jdh&J`bP6_apB^y@z}AAauz=*Mu+A2Mk}P4o;&6
zK>b(l0cC(S>;uXmURei}8S#n@BRinX2#!@8F6UrD@(eScE>9|DoKN;@%^k1ieH&eS
zp4{VPtqvzbt-9{H+@s6ju5B9b7S`F(V9iq7?g2X<UfnYy=6z7J$B*A1eqYyikwx>B
z4O{3<>s+-)*Y;Z8FXB5aY8AA1>1pqM`vxv<-e8kP4Xpt`gL(z*Xt2a|&Qasvfggik
z-%5TQRp(Ftl!ks0jfU5;|KSrpt?jQ3izAwTT;LHJ7xC0`{iM;GbLtx8+&uCz{=(BH
zzs{PDA2g)F=Q<B#r%Fv826d`Bv*GuZCtHsD8M*ag-QS%a{_dWhVzHrG{`l0GsehJA
zEZxq2Z~ex$->JU8_Iq9EG~6fB^RjQKVZZgQ>&N88ea<uglq=45xqj%@+mPov3GOXL
z_Cv&<n+*H&GGo^F1+&B#52ZX9Vf}c`l)u5w!F!fG+Uz#{%r4`dj%z$;<-b|7-fj7v
za1&p{^#hNE-A+r>Ugpqs{WGWO+BXjQ`W}5hBc^I{d`7R6>rQW(5xQlE+st-?PA^wR
z+2$_}@(~LH{hW-~CWm)jV1IMN$yvEy79NtEY<<M`#F&FqrgR(8^?mSQ=Pw&}y?wkf
z?t9l3Z)-mKKECnN=UsXl-=8$A;AZ|@n~=2CZ)Z49e|Ir`x|eWT%bp2mw*R%dcG@;L
z_nm%?nFquJ=S|xDeD{~@R_|NAZ?SA^ll_f?taGyNnc5w$do?2VPPH>vs|7amyb<ZL
zY~YXqBQrw=_*5=jn%!p8UBRl=pA5b?ecC2YH!9U+%-ZBGR+CpXzLC=J{EdWPL)uUO
z_IzN@SL3MzM^2jGDj_-b)mzE+lvu~>n=CW-xGXq!AZ34*xX|~a>)~k!IyTF7T;E>r
zt1#BtdRx!rLj&@1E_R8!`_J#;$12~NzNfa;`_SN}e>z7ETh@9-vU}u^{v$ID23pT~
zzQ(xEqJpZ|2Nc-t4tIW+{PpXmF%d0JOwqZ}+;85{hjW8&^J<1|@!r?+Y}S~@sY|;(
zeLn5|P=|uKZ+mzg9oj8##t{2;V{&JB-b_D#(tXbt^SbTESLqOYU$aZS(4=PRCs$6?
zjhx=HU7r`d>r@XM8ST)_!?V%S-c$dsw+`;Pc)n|*&C&~d+^bpIPq-r)v(Ejv-TY=X
zcbg_GS-U%W!eHH;KGu3E!3o-9pFgPI>`hKPw>mZ(J#MWTz4Cbbpwuyq7Md?Oclcd(
z+dGA}i2?1d75-RtuW{DH%i{xQiRvvedvoB(0&m^)UPDIZyjtrp`Ep<Wo2Dk81gE#$
z6;|IjypPrvSAP93*JI}NC|J}!>8eeP@8agR@iF<CzJ@zO`)dvi>-y>Vic4)<I{z5{
z{?+~~FWa4}vA^f^`WaybA7T=hgg=gMa-qx2;~^Su<E>uEhivL>RU<L|WL2Zmo~$~M
zATdL{T|I3Ar#g8}L40M3qnod;kWO595+g)hcz}NBOhqG}L=kV17#Y<x0J7xj>8FcW
zPE7*~NALcw?rxL((AN+dvhj1BI#O4P{s6Sd(tV06f@>beHzsW{;vS>Q7x3hu9pf0)
z6@xtz3~Mj=VX|P|-Nej<ltc5j59+z1Z^)!an$nZ2baWnfzTNiJ;rCG|Qx-(D3fekj
zmGQT_!JkH77=B!HV&p9E`IDa{wGEg4)*Vyz_TyP2zMTpiV9xLPe)83rx;F27w0VB|
z)Wk<w-XC8qmY82yVUh2+@X9s!3B9It3C^0=#-iQvYKt1)3FN=c=+;@!|9#6-!Oxb5
z7dCtLWB#^%o~Tmice<nV%0ZFC{02vF@459veCFS8_ZBqm^xJ*$=I%X5M6byiv-a2b
z&xd^M`b7;LSva6tK)V;V-?T*5HC|}`-O@GDcF(U1l{%(-J(2GRWjs_=p55i9YrZU7
z<4h?M=}M4k<RvrgbF5^Bt;kMhw9_`_u#7-&SDt~nqpvGCh(UkXDFLp2?#_<ghd51f
zpXTpc)1a@XvzLpzryDxm)YHt<*PVJ_6M2HGrwefUn#iRnevi)dEb&(?y!?IKU46>@
z8}g<K#e9h=3HckP9zTt?mpJ}nEy3)gls|#OvzS$s@h8e=489?azm)!$N-YP4fymUB
zJb)8Sp$semTBHydh$SI*$diJ==(P|&gQ=H+r3hY=*AW{ehKfFeSSim4&!!A4rEnd8
z2EmpQ{DHhFoLkG2P;c;0<5Oc9uE;l}fiXBW+zoTLng&CCyqs-Z{p<~f_OUdub)Dho
zK>sRRYeOB~Tn&bzCm!G)JP9%C;jX^Od!1c<;kNKg!wm+zy0|-<d(E(iPl(W9QOG(N
zn0b17`T5!-(kj6Efgnb^3jLk^h+F#VB2@0@<K^#-^k`#X>*MI@>kU8V9B5!+gHS!d
z-Pv_`KXZcty69W3CME_JNEkF0UtKH>E&NcXkR7Ot?Onc+Ge^l&b(B1;9r`fYNL0RI
z7AshYT>{N5gxG`N1@;Sgf&C6%5JnIgqR9<18oD9^d*c^apKt|_7+yd&#DAjhjHW8&
z73$8YxIkXPcSd#=Q+F0qcNSB37E^Z?Q+F0qcSds<;yz;P&SL7$VrtBU@1cQ7s5?uj
zJ4>iLOYoi1Fo*zw4^wwWb3WoHB-EV|!GJ3qmqh7DHJ9Y!pI{ifqQXf?saZ%VLr5tD
zO;ia%g@l?p@}ZOERg{k~C0#&#v^9B*wHl(X*qx=6xum4Ic%(QY9_i^Exe$F+Q7!_o
zX>#!m!80pFF47-)l$m%`yz<C+<;aC9Z>q_~H^e_imkY;N1<1uCF@`gE#J^P>Jb?i8
z!DF9L-{4go7vYffadB!`YQl7M)H@N%JSxh0WR!E%EKym_oOzId54fQ|HOpd}r-%cf
z>YQq}5b$vVq1gh;W)(De0*5%7N0Uz#2QR?*OdmW>U+U95i^Hf)wFE>qrHxdGd5!u;
zTI?evMd7HKr!oZ-^4NM7Vx(2y=vjJJnLh{#5T)xGPai65q$)E3p%l{&+DJu)z^2qU
z(qfN5oBHL_G@i=&UWDdQ=$7=+tJx!HqbDgYPe3Gou4Aj5-bEaD5s5%o>N5h%u~p9H
zun5UgIG!(8*hp1Qhhk#RO>+&gnllPZrz+<@F(-Y9@x-XYbgFWq6BF|^nocDZ1r~+`
zlSh>ba)!$ZH@?bQP{KhCiJA#1(>2fz0Tr2rghNrK{0gH*<g}BA!vvKJc!XcdnO3Wu
z7p0hy((zh~r}gS{^<umx3nE;<Q8`yiiOK`b{f&6)&6O;_Q8_Of@!5INNX_#_)<{)O
zeMX$gA==rZUZobhgn%fqa9u*>e8@8tur<vy#Pu!pxim}FDrZDAFgDlY@eC_$ib%|O
zxw=+4PolxHCy6|w_@X{t7yAl!LO?+gfs0&0R8FI4)a;22kB3uhg$P1c5qSjmB8iB(
zHoTxpSbVZZ$KxxQ8w*rUwn#EO02*rY_&oTT3K3R;u>>loU^G}<U1p3Q*TySk{0b0C
zpmNGZM&?Al0IwjaZ~RPz5~!SDc>-b$imq#Q7qM7lRXN4-xFsu|0CUv})2qr!77dK+
z18SaQ(2$creuSJ9@{kKq90(Pto_7VDsR*jE!VjxY`^6Fw2*4%60@ZV|5U*;}nJ}sd
zgOMs?{Ak~W+`@}M^;|4OyBV2<0F>0=lKRHaid5CpE$s4SkF`R}aYEIzCAS`j2neL<
ziqfl4^~@+DXagOsMHM=c7OI{FMVy&5PmGrz)u&e)UQl!j^Bg$~(?Zo#q?lM`q$^#F
zH}h7AAPP#ILe<lznAqt>AHM|SllsQb1P-C<X;VV%lVFS$vsv|xRpvCXHxfWvWQbSd
zVdg<>Ie`~=x&SYz8Z^0qgOgE(s%KOQvE_m;tkkfgcskzWBQG#i&!|#diezL|DPDuB
z0AulZ3V6Cu^^7Vd3Y~QQ8>yMmumVH%jB3PXFGgz4QnbJz=5)yWWyF%gS8~@9Ck#ZY
zCtxFPQZrI>L5C(9;YMf~i<oz#7kILXLS00?p!Q+$sC`&Gavv5~YSmM@5vMeS_A&z4
zR7CI?QsyJ~k#Pl4InSd}<CH~<BJ>oXdh3bIC=#ih%F)&&?9hy{R#bZ75j%*ua~P4z
zshn@f$ryY?yfd~!oQBGQL=jMqAS&m1G-`H<htI?F8}$joavGJ>G#VItGQ%gzi4`_h
zl~Xbr7`tH0=iz#Pg^g9^^os_@^??f84n~x@5XzGqXt@Zea&AWDN_MS>&sQ^)Go2Yd
zJEY?BCK?zAt@(I+h58&smTY<C9%YWM#VV&wKA+gqLPu~u&dwDveq!4{7x=`gXG=bj
zff?hMR%Eq7ta`TO6B~)?V-=`*_W{eVRnLq9&JF|g_*q5KDRRp_*RNGihyre05(U=^
z@oNQhDY5EFQovbr;tMgaSKs(qzM^`P6cTH0biWqjofqmGs|*84qJt6-u{%l*n5dpX
zg#u2t7gp4&Cc!hINJ2elLJ$i%B?YnSsZ_{yBQy(D>#T_BMiSLiDO$~i`VrlYM0m4#
zg}9My21m?NIoKmnJ*SF@o$(Ao)Vv##77q#voD$V@DtC({U##X$PAsQUJ*SE}JDN~K
z3iYny&~%OAfeSej)$^=`8=z8py9+fu$i&jM>N!<PwA`TiwZKr#4=1t4s&f8B17q`Y
zfnmi0pUU|Y4U7$Z0z+IEtPtQMst{bfQ#oy-!Llcw0;0UEzVWmCLgj>r2FB4fF|Deo
zu|ls06(7ps5xkflZ^Tv}^^KK=ZCEd8@rGF4;)0x1<%B5Ub2f7d_;@Z`A%c)Kc0;0y
zAV(0DGb0)`2URL;R%D2}GQn~hCsL&<XG;NhRwNLpxtvw(QAE1|IpbG3TcW{okVZ&v
zFQE2pDOEXJ3WRuLDxJ;>h^J)K=k!cel&YRBMZ}|Sbfl4}xeCM@tLoWO!m0QOjPN61
z6{c6!Goz7|oo$3fca91htIC;CNVfQ(`G8QU=3TB#A23omGopd9aX=`>gs-CXYNT@V
zLj%K8O}btsYF=Yv=~d<YCPe+KSW|GJQH54hja1HMXkcu;q6RQPZb=_N4Tqo!mr#tF
zX8HKyt}}T0W-!PR-U*4NOM1T<^nF@|ll*@1w{hwxzl~N7K~XggY~B5)xEfpbwX`%e
z6rz6;^wgdhwThCUaKf+A4hZ~SVuCw^`PuV`-7yBEMvu{ziu8H9Vxgfvf(Zv%Ya2q0
z;Re>IAr5r4!7J-D|3Q~vEDSjfnIo}4zY4z$qd@;qQ$}J$=o)%!C_(ch3EFLnM~Ox&
zrrwhy7mE~*7Uf`lq$T=j3AIwAm17mSq-3;69;_oVj2cD&Iz%HD_a#P2A2D?uDNQC7
zyp{;45fernj`b@N>q}4{Hi<sc7k9)%eOv=TziduNs+=)mqhde6Awu~9(PxF}2O^LG
zW}sM`Xh9!o9o~Z+LJ4|}u4C(f3^Gmg$u>+S`vo;_hTe&ddQ2~Ykus!Uc?r_57<?9w
zqj-#P4Rnw7j{XOa7d{LBz^mZDNDlmW_^uTFLo&g8EHk_Z`}INJg=>^ui*3Y~m2V``
zN28_N2zxyh1Dw?e)U=qkSDJ`bmUN(f1tWoxq7@D_Vq_iCGT34u9c$EBDv$;wg@0g8
z^1p<pD9<ArJ`kRVBU{23p!k*}6=gxfmB`2;c4RRuNUvC^BqJI;T}Fs=JZ4Hpus(Pr
zSQN>GWhE^v^9pnkTNQm*B9zHW?3^f$vXW#aEGV-ln-?K_!X;(iT9Q4n9clIi&qH>@
zSO;>0-AHuCa>D)43yhDT2lN_Wr+kLg3HDx6Ct?|j6J00DU~9s<GWpqCAdviUsXX#y
z`xVQNBM{q6?XnZyfy!WeY;BqBxB|uWb57naV=N<ED)Vz}W3V^q1AGC!miasQ1ZjVW
zee5$xm&F-{=qEwTC?)zjwysQGjMGec;Zk{QjmAuu7l}h4F34t%{?X(U0#?C$_#5~!
zDI@qb_IKpx7z5xsx`1OH{g);`Uc4xa{Mf=W`MLQOFV2=new=-ZeO;DuWpPT#hB1tu
zooKp%6+|pIiS1YypaaN$V1LjV&Ri7ciO9x^vJ73KA22gCml<L9P#!%X*%*F+#w^QY
zv@DJD7U=`><dz_P%JLe%C!qt%Z-jDvgwhMqmZB{FA;%+V`?QHnhgz7*I2SS9qnJAZ
zrA*ExlxsQC!%3@S%>V*`mqRu{QNzsSpgoyX#D>yR@N_Dh(;179v;P1gJcp0*q%skS
z5-CM1@q<*X=>^@0LI`GXR4@!B9x@!fF4>WZo)=0DM$kzrgazCw2p+F8*Cj_K26&~y
z5|j?t;XO5anZk+25VTQ=Btk^r>GX;81ClTiN@4&j{Q)%6jf&@g!~<WHiiwR+EH6TX
zmGL3)6vcxjnmN+E10GJM@mF%Fq;GHv;37VKd!{^YS6XvpS0EWS&Rxj<B5Le_aYzP`
z3A~>VSg6c($eaM5#j>-%Z$w20(e;8b7UsHWLd`N3VIInbIGa9^21;N&rPcu5)hJX)
zl7IxIl^ADD%1z;WiX|2D*z<K#Qp(m0w!`Tcg5)lN?UY(>Ky9!r8ZVwh1B(Ha2jmBx
zQ1U>wEXndRd5Ml7^e}`KA)05iq-Ag&P7^#NZ3$dQC21A;r|MD)rBYU1gC!?}(-3_J
zn9u`BO$i{DR!*uKB8x$=Dr78V*$RtmGVUpEh%+VPk;PHK@d|-dz?!kM^u^#loJUfS
zUzAW4Dz&}<&mig{(WpU3WzYe7poLYrW9b0%92o-2NunIq!<_e&NeAje0xAc9&nZKc
zV#FYJu+ej&NM9*tU?wcn3$B7NV~N9*)SwqtF@w^FqVFr#gUFDt98>6wk<aPFBO)%T
z15+SIDF09(2U@6*)j}W!D6FB_vaIS?62`Lh#reKseW7h;ta=$Mo*4Bqq8AdwZ}6r6
zGkwYCTab-O8<d!hORYn)*Ay*Xi+NI|!AH0m6?_72Ar4>qmz1au<;V&)pj_nK#Yu~+
z960hyF_$4cN~RjjY?%H9m(-*hdHh-gtPNqV%CRSlEw1Q7BY}K^PSRGw6J)|;y2BJ+
zO|%sYN!kjOfL7v|locg&02>Gr)aa0)wDjOnBBX$CsNDG(Y?ZU!8zHWm*eY8{uqd6S
zKxU_`%yD24Tmee+Nn}vWQn;2!>reW~b_yvx(Iru4d2Vrr{y<ZCrmFIkA}<U|3y;c_
zKpqbwtJR4SS3~JTu@V@3mGe{-@(gwHRWsxX;Ql1PQsxCp=jyaDU<->Ht|+&-92;|}
zsHC`ZLUc=~DkpeHfU@G0+-e~TXsA-lt<zCe1+tqTEt_#mtYl@1L@h=|h}erq-*Sb_
zRsxljmB&k6ry@Juu?C6qD9yKsf*BQ3MDKhCnBq%HG6`m56fja)03e9611|c>%4Xc*
z2#xsq$eP^YP)N_9QA9s~=HO^gh!F7(2c{C6D2QhpC|4lb0J4f`0Cm(b$w?VFJDyb1
zM8NI<q_cEl5-s-#trPnukeJMfCbdqANoZYW103H>F@gIiu>oWDrNF1l#F`b{gTizQ
z^Er%}!hE`7fhhorK(0WqX{3j%D4vkD0fMl(Of_7hgZoXDQ#GX`Gpeej82mWmqGxhh
z?oWzK`30js$7y6K;^Rwd5?)4bPz{bkdX9ZzMx_Qt5Pdd^mu1DkXK5(FQiB|;bI6a-
zusHCEVg|8$icd7RW(7WwHOOix$Z=W+xd89MPr+Xy_>m9ez$Zx_#29{$d>n%Y)HKP@
z0WXrRQkDTI*m@B0VVf0Q6D*(rxRY(SBC;D3C_wabIs~d36Wg&s0i`iGC=!AjK3_%v
zU@HJUI?AH{L|X$H0N{EIQ{=L+9R<FNMFzWrjY}aiUTtNGjQxpqt(2^Y&sGCE0FT9r
zNHtKvKzKO0y2L%vfR8V!!w-<c{v)LjjZ<k^6bKfRyRekPsMT@yi6gWufnb#?i&B{l
zp#=f}Vx|NEfRN)q@Enek#1a9kkjGLIqmajGih}^Cgw1N@RT7?F0&D_&f_G8S`R|7v
zM|mQ|)|fnvr91{5<@9+)%Hz;cCDmX>Sfs?mD5645MRCsge^49>O$15w3{Ff^NxUNb
zi~@0@%QpkW@ul+ORT&kBH)4SIAy52&2wkBeJNYxckMK8{61k)Z_W&-h5=r(W+Yt`$
z|4*<@ATVUHBbI^~beU*`%=EId)CCoVrve2D0n^|+q{1-10i8t2;s3$A&=`~^2BLwq
z%)7XAP<rFg5=(1}lm`j{j)XF2X_Qh9PQ?Lt^f;4Ja3}mlrU1;anBJofZjB}ffIC1q
zOQV2N6HTaIs75}Crth>G5o&SEo|Q7eoOnl)Ph!U<Q&H+*<Wx9;U}P9UXq853<?$L~
z6HM{UR3sHE_ZkKh=bqTbr#~LAa@fF>6NS{jF1$dZlyQ^0Z7EN{?1<?J>R{Zo`8GWI
z_irl!IUQ@EhLv>~jGCCqF_eHWl{YQZlmL%|Agc4PD*_$Dpmb77^j4q%lyedWs`RUa
z9Yd7{DFCuaX*{9S07{WZS_+p_vE+ayPpTX&$(cPFBAlb3ky6xA+NCMwzh<>0)t9Yi
zl{9N7{6yw8Tvm%8qAqXvfP%=3@?UrjTPb3pR4K3$ej-x}cZD1GvQ(o|{@=VtgvuDm
z6%<Y=i6`r23gWU=deaV-(=N?x82geHuv@D5Sswnu_7wE+uyRFU-;gPS%UW?C5H)xT
zUi(5>h$@fc;upL}VfFtIQbJhzSL`ng&Pwb8WF~2Ka8~3On5zO2N3;P46~$wL!=fBh
z8da&&e*}oXGIvxk*$dGoM&>`5%P<uKm&)ruEX5#Q;N_D4DyaBqgAsF?g{2fmC7IL7
z1to2D@LIM~pl|@YSfMZq3<s*prJV7oo8_=ksHC|waj+!iMZ_Kth8NMh`l}4bpqx@p
z0MxAz+7njzNqv|jBOg$VH+U{2QwUzRV=6=qT=?G(BaRY;$`@qFy*?!O<s2f0jx<sO
z_r*$}!UjP0|HMN?V&#dOR3@byF7KtEPM~VY$TqDaJdqVAQAU!GJG)AgjVd~n1X798
zaueY<vQXl3Vf=i5IWrXXC=0bukD4q{t6l$*S0VVv3;wd%6sqwloj4FZI%Ue@@?r^G
z`WKW1&*1_WqB7Zk;AtG?iFigzxe(bXf(l74m!`LtRXHRftpiR$!2$k3XhL-dUHgAf
z64IK|%!VCEwgrXL(-wic8kn@~89_7}>_PC~{}ToA1XAS+VpN1BTt<yAl{W+_&w(i_
zQj9#H$1^tcceQv`@h&#v=uFyrfr$0gC6h}N9wI{|%!`;zNDW*XZz`ZvLIzW5YsG5L
zZyfaq(Yh0I0)<qO@DNHtL@P>$g6PL*s*F0I95gM(c?~wGp@340Um#^8KvVvxwi4eF
z^7zX08G}dT=84Qr)AW9d<x!68@eOL`1wjQ+4cmi(UY1f}c-E%cLLA3)V4A9|s6qIO
z%yaPSH`8;}!LO0$U?f4x03~1nA!ot$QYxjQLkw-KmA`9{+<rp%jZ9Hou8q%wEH5M@
zWq_y1+Xx_28VVQKXA3I}IPsT3iRJMuax1)yMwV2RCz^rE6vpM;xHI6tq%aXI0h25V
zdtxbxfI1Z><}2SkKpZG4Qy7<b<6X$*RTy{;U=a$%{{p<(UL-;d77^J~nAwQ-kxWDa
za>P&rzqqjs(I%68U_(G0#LC>ajk_m7oIzC;@;uCC0hG{xaT<cuhTH>hEF@zKe-=<2
z%}9!S=8z|7)3%oi;pb_xuy$U{F{v7euB;^rq#YPA`d2E`qR-*f1VVvANKnCuOv|@y
zlc5~LngS7<$Yq|(rK|WbXNJjC+|vm5qKQfEWh~FL2Bq9zO`Miavo+s{$I7gv8mNQ;
zrj<={i1y}8KUM>2r8*<QN=j*0QShu0AOP$Q^aT6>@KA}((PnanW3xoX7N_h_bh~7T
zN<WxSRffeDwakwgknXNbY?2K@jw4F6P&=W;GfQj+vE&@%Cqf>=Mk*EE9;`)LSXLCF
zO8jKxmL}p$V|lg;M22G4)Pt!6vbQN&@Zg-8f|Q^J0?D>Ldjoj6geRvTpkS&_AcI2)
z4+M|&&|oVF^~PjviexDW7w%=j!6lCP2#WH8BP1;tEF>v3U#AmDwB^+hJt<zgoB&CX
zh68M2`A~9J7!ZW@WukH^pAlSAv#5~IRTUSofF>?ll*5><gyXVoi>)aWn48~?)KDsg
zCdxQBqezE>1Ox*-$6Few$1N@a_~7%!cI60)>MyJ<0xUtXEoFjYH8ByML&{WuI$&ZT
z91Ix9I@Etj)`b}ubsZuWcq|YXWI<eT2j@qxF|So3D4IDbhcj$LnV>j_GX+%#W1|Fx
zSqXZL1%+#+!Ez<S37~<D;^-utn?h<XOQZMcS2;^lqETY0Swy~}K)L-Gtc%m&AEhI8
zur5kSa8Tr^kdsU6kmLkKMlrb4XjbIWxfKck04Tac5|_%0sdRxLqUhuT{svYAtSn{J
zv4zCPRVa2$I*&r<gK<TKOX?I6_!IyJRK5Xd$^a;A(S%~9>7TS12`J<P1x)*?gCCLh
zgAzU_h~;!j)LKGWIv{N%6N<xW1oUHy$_phx_S7L14{d`}f{)b09t1uLIOiFmVW@+>
zP?kbMVa5s3hF;?|P&QW-lZzxWw!+;|!hjOODAbG;onyz1Gj*^Px_}@Y#2J~$Rg5`~
zpd#41sR&L;%gLOR!&L+&ohL#q*n?fb@#Jv~V4T2JM6CWcr9?=MNJ7*+4*`K<q3FCs
zz&T_GIj0(U30|xKCj=e>0wTBvfoRN;GjQA+LGiHZoI}7p+l9DPPH2~Hyg<Xowt{#n
zDO*vqK5$PYBG{7Jdt1ti5LXp^cH;q7{L#4yaTYo&m8*f9;HfbZ9=K$=W(%Z(Aa?2Y
zC+B#j<u9bosc7V$Y(gBpUS1CXheb(U)p=lPEzTBRBor!7DGX-AJ@Nz{&{=+FBP)U;
ztN+^y5J(J_6+sE(%2E#JG*XeEq;pV8gT<f#oLUfM0i`P~2D7b+nv^T6<PgRx7KY1u
zN;=e}RKk!{8wA4jIuMGS1hcSMf*+@)m844|0EGT!vB;^<5bGu7jYZWmB1agJgr}5)
zVr4V&lgHsNvV*M1vp{7FLl}yg3qy44U^+&d9mr~E6e<GX0K0)yL%JO`lMo;aqVq6|
z(+Ol$U_fvUij2y>i#`jrIss%|_$-V8tdG8fQycnyT;?clh(?~NUHrHy%qW>Wm)S&)
z(X9<VkjJ5cC7xG82_SE7Pjgq=N*QO6d?{-YiR@-4b53j^#zcvGe2DDG3;`)2(XNSn
zz>aC%GPIbJ5<G?0;n|SYQj8ibvDCvoXBOcaOxsHtNs1h(Ox@Nfo0P&K0akz>$S@O}
z6HP|S$bUF$5`o@|si1&3Ely@poC}#2Ed$?Cq$FAPQzR6MB&89@idKcnDXzP51m_#F
zHic56Q~trI;c!pKKoMVlZ=n=X>K<(B@EDp>h-OK}FvMv=%2o=48xgIq8Qy^}sX2rc
zP3JIWD1$-(&*e=E%Njy#rHRnv5GXBkgNXDb!gr{UB93@rDy<CFq>@6a!j+}Od(i2E
z%<Rwd9<o(BS*+n6w<0LZaVv@xQR;<=GI$Q=bWneUIT}jwm_eY|v^kcP?G-!;i<q*N
z0Y;Y*Q|=ioL_#cYD51;_gIB9kiah|`9Sc!h%|fjL7-b%|&|Ln_J$ywfqB=UF)9ms6
zDT+`60fgL(cLxFaLZl4mOC)_MNtqFCB@yo=D1nqwgo5yAp`4i_zM&Ems?gcjh|@?J
zbxvfW55W#)c*7-S+;dH&vhKM8K9TpxBZ!H)zsjtPGg>qsV=e`eT-JcXN^a#34@ij;
z=|ll5lnhi{#3ZRVd*2BJF$Md$U`9?6aG*nwBXB4VZgh$tQOT1PP=x5*FO&*tkWU;R
zBU3t;H}T8Bo0N(HxCO(50+=E(P+-c$LjiziA0>zck7F@ImlTPz41*7GPXa-+t<v)$
zr2<mZE_Dltn%W@m;@XT7kil)ZM|TLybaV$;NuDEuHK@5Iz!V4z(=X~eIHEkkWuVJ-
zMn1ITQ79JUFbx6sFb(2TdE*O)53vTQi(bP&ECv!qSscN^*DUbDa7DoZ<G2g*@L~pa
z5<o(!fWbpWR_=5QY*T_zJduRCJyyVsB*rlo0^(=`rchAiQHN0AV5k^@*Q~%YKwW^g
z$a63X0ZRcLG^!&zM4GV<!WI~3eF_`7M_LHVbfkr{$WkCMuCGIs!4f${97Ld^NGpdT
z#3&algBZp!7U-CIAU90Q!=(zeJT>10*DkdZXwbv9ya+v(sw`;`ww76*OGV0bWQ8i0
zr@liInBDV6X%<x`JnGx2RCsJ(neaG&GOZ1l)MRalacVO$M<69a2%(R@;^aY~F*#!+
z&e&jzpbl08$pdmFDME>4O^G<D2CE!<87zi->IJF+tKTMgBLu=-#tt1tIIK)K^thAK
zY{_6S+*30I_>!6(j*YD)CKn|F^3k-5Q3You62^HM0^%75hCAX*<rNU1f=U+Xzp`1R
zoYc?8Lmt|ai9AeUJdx)cknx0%uwW*DGM#EcVH>y>q;?=+=rtzSFmS5W51&)yZso{!
zJOPin^v1Rpqr$;G#X?Y~Q!L6TEPYWGgvYUm{)@4(ocxDuwji4ga<&7q6~W*?#10^)
z+j7>xlx)ORqzGhf$ZS-HSxyp=XKA$TSJFI@Ei9*n9a~r+ud=$9kjruKrSiro5*7r+
z%WNPtdQIPAO&1=l50o9!3neULi#4SfNJCWIBa%p;x3HDKX&BE|0#PrZ;+)HSgm6jS
zN`S$mfdgR4);?LT4gx9@On|!Ape&*oz!;o{djN%?Ob1XXab<>eK`4k}SXd?JFxbLu
z;oyE?Il4u``slh+p;3PjW%CzotYVkOS(X{U>R>@Emqz0zC_1<$I_MaK7zn}^T8?{z
zt7Cdkepi|BFa<}>sMz8R#zZs-V+fBgso9kk36Ja8NC8+GYE}&1Nl)LH!F-O49pMbF
z#XS;2P^KdxN*M@Bs}d+M=#GzR3j_;^3iQQdMP*L53IruoGRSsuB+PM-cMz26c!$y|
z0XYXfyDNe^Kn%L$vxVbHS&w$JEX+7|K|r+0XF5Klb#*&F3SDe5PzFRcSd|^|=x@-r
zf^Kd6S#({gz(Q6JDYn22zQ#R9L4YrnS6~nj1Ve+x(F`RU^j-{P75;&{QkfX8lL-wg
z0V#qKnvubarxZM5d6l-JjVkphXDNg?#_<ONVsjSL%Ie@|bfH0buqa?O2#*BB3SbMW
zL?{s|Wh=vM#*qdBI8c~XXTq1tYe|Z3fYm@K<f=H+vfQ;4>nj|q3DML-**uEeL`MM+
zmtWxy^=c3hkg~Lkr>wd#M<|pMl+p~sPE@^!d!&G%Oh*a;fIv|NVhGXz;zVF2Ku#<a
z6>H#ra1B0>{w|9%CGN+UDkq7I;{gOjdw6C{se><3f{<<~0}oXMLWj{R1qlWR;<oxn
zy9d>f3RnVB7U9fX0R@#<hbI;)ElV=m^$WP|`iV>GiXCt}KshR}0kqSr?<`@6Dnaos
zzLKWaj5hlMZkv7LlDdQe*FuAbdY-&EVGq8fsWPJlzJO?L&WMvTwZJba;9>9p24D#!
z1a>cQITF50BTz}xUPk+R0q#}LEN_*meSK*J0)zu}gPCC&+zK7KtTf;mZRQ2Ir#wp#
zb+7_5;E_=Xs3vKTDwYwVv%{4Y@(Ei|xrJ!{&2%*&32KTHc1f7B3}Y$+ETM$p7r=AB
z3Yi;W6`4p}4uHG8SF}igZ&U_CkyV-~5(wElPnqk(jMnU^Aj4sA_)<j)1`vTFuQY=2
z(UuWq<$9vszRW^+#>{j&HSz#FH-^Cj901m-2n~F`P$~6fv^+<T(r~O(rk3X=V4S=s
z6-$a5o|v;C495nwr-Eo}Pg#X%N6oMbzEocKqUC+6At#>8qU*>&MCenm0r!yQ0Qcy`
zhSYSa%j}G{;{tBmapF>W1tT*JwgO-nl7^a-;%k&p2oz-3ODUk3^T+}d7#OX?1w>7n
zX*qRNBxnMbX{DSJyp+O<&`v;Qi<yk}-vXjVGgDY~?2-XtN%+Qyr$%cE5zH$?M{-Sp
zoWm0Bm6-yngJaMHtVnC3%863cWVF~8;C|XnLRF>~+lo+=CM@2nja*TwRZHor(2o__
zLLn1jw8j>2TVoTK)BrqqGLPa+#t?xy!g~N4HG>f!?QT&<zX%)3(g>HOl&RgdB8!rf
z7C=@I8oMwVuj;fg4{bb9MxPnYtOXJ-lfjqDYhjkKcwPY3h1{s3E0dkxWE=ELnol#D
zQlrf@9Cm{*sasIW`qb1EC>*+0UYBMIk4i+!T^ie!a%pbUX+fEqPE$froD^9S7vM-<
zs&3&>mn5Y%VX`Y6nQn+izl?N)FO}1>72&ca<xxhHX93ZWmnoPUSdqLw`?zdMJ5Z%O
zRFLhes0gPt<uDpG3%Ct;iA&|RCd46BRlt=I>dH7TYu?TtJRcq6rz~|ankEZyhh!!h
zC{xp91#zaV!H7ajDIf%F0b!e$vUEY%Lk1+=^%vY@L><-va3Kjh#bdFxAY}lTEgvc1
zv!8n@DSZ&OlnKtQ$>2_0|AOGMEtgQ~tN=xnG*u&;$WUm@Wk+S|uB^<(A)UbAsgf?T
zyt=JkVrn7k3zV>2c7z)#m)GhLn*c`O?np>^h>ZC$`a4ztfE3EP$oK?5E?zR>xU~?K
zgOQ085`1hd*#;m24Hzi~Us8vFl#mozr~ubRTeOr5%V0s=4#|Qtbx2m^x-_IM^ELob
z3Tau!HUP@naBr9-0G&jfnpRWdSRPW9GRu?5Pr5eIe1>Ux*fgOI%L8H~Wl^U@ps^DR
zXXK=Su@8c#0LE4xN-1zJKz?)&y70sUC#7FpBWzEhIc|B(%+qD+f~?FF&|tB}&{`BI
zp}YXb7F2`|Lsgcq$)-Y-mGKT%rj^xDYr?A{ASfU<G7Sf$KtTX-@HZM*v4s(eS?A`l
zw($^ll35LkNGz+Vp{_))wu8kW$Kt`G*sBN&3Q&&)Wh?Z!Np&$oa~YSB8rHX{r>8i(
zjcKU{7qY3?qv8>i1E2)1t;DiWXHv$SabxOYA-U|z2riWujKB?%i<Y(}38UyuS|57@
zS*9t;osn*o&RenJiiPGfsWNpyCWXU90jz>7gvkUYG*w$d?-~0FX%?1;xL9C_YlOUb
z@d<sOZfSC1ywpn>*pS6Sa~V~cIwGqeG?j)pF|B4rh<VDNIwv=663C3?V1pTPNnI{a
zvp#qQxULM?kf$hA3i2e1kg&r6<3S1DAcE~|3dtwY51YhuA-B^qap_-Dfub{+Kusm8
zfP}-c1`9M>P_j})dWB3uco!=@d!sh3YJ^3^$EaxrCZE8yKzP7>T5#Z5IE#F;Q2^Bw
zm8}qwww4J7Wh_P}7nZ4GGtv{L9^lw=pbuS^WpK{(26VwdU=S9_C1p|8ca=dOJmaS%
z$q~k)piju{=uBKvle=RYgA{{ZlAf?w)&$I#(H#2cXxW^c@|U*MP8hFPP!3NM;%3k4
z5)@fY;ih?-byZ1jY{3znDUVmouVrq{;cCJ%^?EMJtrZBa5X;r93?X`ER|&ckMlSXO
z4yO~AsYi54%0NMj=UMPMh+_r7g`X}^;@W6Sxw4(igaM0%;&3)0Zq`^{*QW0~2X+l{
zi8vUZ@<aT>-{C!6M*`D9iS4p{W^;1pjEXQpu{azyCNzXg<rN1F8RIi$6ZkKMuXLwG
z;>fOp*kH#J#N$boZV4jHArp|>?-@N)ss;h&^q9pCSnOzIf9>L@H%h2C6N+c%L~eIx
zA=OR{9Xbmsl<X&q&VYh<%-&X1@f@aWNU`!WB3y?mBsdq+Jf;K4Qeu%wO@ltJzJB(6
zsx=rR889}3prcFiSg7VhT=*}k%QAk<8;w!!#&=pQ6nAvx4hz8#GmyzHW)wJc`}Go9
zWB5A1Sic0aQ@z8mOicZjzN0I5uzdCb+|*zR9g@~%Fh6{jBxA6OAFNhnZgxjkr5zSg
z(86X62uK{5$c?CArRJJ=eh4!Q_zXR;A(-JG)PS%%(Y~vQb<$#owpN3?^6*e;lTq{{
z9bRTzIW7m6%Be0{kwnpu0q6chHIe(uWK(fC3x-iyqSQor74~VSS8-}dvi5mGvVSfW
z0ytN&LICUwwugU|uh8O^vOm%hkr2>-v9HiRLyKu4xkpe2HR!&~nC25Cn%w_M0S`H)
z<~Ft^L{Q=dP_GBfqewBvLBK;020$JO$R02V12YEvH}nPzNv`C`f(5)n)+3uQB)cWa
zECtDcfuTa&^tw22ad}2b9i72hWi=bnFLGL3uu@^TG{=&4#gaQ*%CYFHW<nm9Rp3iX
z>;Qm8pSXY?vD1Kqfgt32nSQ};q|=o{P_%IqXRea%LJ7*X3%7T2agrvx#F7z2G)Cn{
z5I7TdD9C`Mu-E|sQPJOU8w~V{hlIxO0a3xi;AH3@<%oFe9PM8CZzOZXufa(vg#tPk
zCwURs&84)F$8uM06L;bucqJC6Qa+xgfi*!8h&m8}vMfb`(KQ^INElE6{yShVQkd*L
z2nP2c(+w^9IKm0hq0h{8!su%(<n}ctE-4WQBOurhiK3_@Bpxb=f<9NWZAvE^`FtY7
zfe|w-uE3!JKaHFbW|6@Rw{J08J}yJv1at(ULHAUIs#ib>4T{iAO`^-8(QE+;UQDF~
zZpOn=sKk<Zy9IK*VyKZ(VJW$aD2o!*?N7cVk#HeTzZ_n|r{M)IAW)>9=*Xl3ULZ%~
zqyLlP1;jdp3l;k)#t247NrnzoD+WT0_$6dsO6jDUxveyWCH4zeI4HvLF~A`(grI?d
z!T|#UAPfN0z;$%Iiy<F<2A_C=-orI0UJ4M7;P0UfPR(d2aKxuuz;~(d%V;N83D6Cl
z6-=0DQnZtxD-1q`FDdgbb&E|xAQl_REFj<G6<WX<Bqrs_c%p|sL*Wmos4VJ0PeIC8
z2j%UA_fnxJCso2FH7N&I??FH$1<oOm5NY`W1jD{T+8Tt#N+NxS%0GCTg6>mZ<?xMI
zM==S>-qn<H7!(P2P-af{OKPf&x0c9_V#3+!0aI$_pa8-_L@5VpiSi)o5epo6q}PHH
z86E>lRuVuwv_FTHXo&!#l!ASP3MXzOW+d}};4z>S5R9%AqyTsiR1Aj{dV>{?*aloz
zrWB(4L2)5S4D^DYpqVPc<XNT?49g6JDXDdHh4~4IEI5eB*TRwj7U_oWA8b{KP`4`N
z0t%JEX!tDTHhd;7{o9BF{(+nT?2eUz-otB^Ah!es!3H-39Euf0q-_#%aR+H8s+81J
zx<b4K2}K<sMOToFS;3s7G?2?w4v)=I<WNCIC^4E-lT&bJC;>bCx4Z`s1h@*I1(}1e
zazI%iD7uaheE`LvH#o1sYd{=$PjVUt(!f27;g_QzbWSO&9>mN^gulqJ1}l%LAh`5j
zD2NnRrXUJ_OTwEH6vAhp>BdUZjHcFTmWZThg%hV-#w^0BHJm^g@EE`w(nILsq!Qk+
z6ht;2kWC+f_A5)+j3(GZ-0_;FAfP$_w#R^i$kG7iF*uxn4kCdu|Ap7+qC)Olf?|Yd
ze*?<Qih-EHeTgIPn4$D<a$maVutSN=R%Hg`5)>pr`%)2{DpnAK|8m=J3-P6Y+jEdd
zaKM=2HUPW;z$n$jf2k5NcoqYM0nBM2%nm6OzRDHD;K1BA-e{uoAA}SrhExQFIn;X@
z=|k8A;lxo0TvMVDXjX`#MX{$a7%;c>x3Hwv-xUJF$o<(MOuaAjRFbJ6K2a|(-pekQ
zu%5POWhqAMa3QyKIC1IU4kb_!ofU%zp?}~VWyTr+^I{L;C`cfbFgK#G6~ti0+}7my
zpn!ipOCg*<I>HK(g%q04V+8@$pugd{HWV`CO)EjUN|eHvDlb3~enOEwZVPi^NiEDP
zB&<LwWJbbDAw5V|e2~X_S&Co-E*#veY=%wvgG>=z){DEE|J&h%FoEG6<P@Pquq{a$
zs3o$p88+GHjhsMoTbv6^YH?m6UIEHL+JMlYdxc7jw*&?8L{ipDEOU-Tw78df3uZA4
zVpmf8^9oZCo$;a&l7VemST9pKoUJ}0L!Q#|1K}?+<zObmRL+0FdXZunn1bA>)GGo2
z$i*PbQ3&TeEOzE$uv}sRhp7-CH~%)afI`SjgTo0FLWURM3$-ppE#=8AH-LvhIMS5E
zZfXUcZjt;7i5<7aKH9ljf;u1>0?$Nnh^KB+*^(8t=~%WHSK^Wt7wPFey@#M>w?Hp{
zznTU^r#L#hPIdM4Gccdx<vh8jfsHr1VD386%g0q08C;)_F8Mk7_zm!ML7&p)@z9~U
zXqnD+hM(CKcQ;RizMd{M=~ge6(KgWA6@Ayo-`TJ46xXTfJ_Z(E0j@r_?tW8T(J$-b
z^-A=@O&4>Rng(XNA|cU@yrzMby`ioH<IY0d^O^LgQcA!xLPzf?87{5Fp=h{$9Q~Ax
z7FLkaUPLQ<9%r<)f?H`vi}bB*v=DHl{E9|v=I=Mj%SW+xNu68S^Eu<C)xSzPUMQd_
zQ7#P+6%N<M#mCjxSMhkUAA^1cobj@4H^hA4aDyRE9=aj~fnXMzThcee${EWbcTeQ{
zLv``j=pH%9(bKK7t7rESHeFy4LU2%A{oss-W*hZrj|QG{MvNn=?^H+kDT;N6@frIj
z-WI_bGR;2f88Uqjuc9#{F!A$OVsM;SVbCJZcxf6b<#=JCQcCww3xr{=K6F^Y+b@*`
zm3N?zyW1o`Ks=VJ@$L%}wMfsAgIe?+(~5^p_f?vla<zy=@bvR-$2aWn>geL`>Bbrs
z_D^D1M4M&MCI?J$6JxsEwD93H%A#+SkuxMJe2Be7MEsDWU<D8l1rX6bnQ2}6Min_f
zFx1h_70GMuKh+6Y4+W~6Uy=h6_`xkw#!{&s-<GZvcKVX3o`*+4<}Juzbgh$)fj}0g
z2VK4{u^o;jGkja|kJ%2f7=V8S2QNdZ=*IXbnD;}Pg`cC}k#18QSTr}I@7|E3a+ys@
z!DuqFYzm-AG+t(ohkgLGoFCxYl>19o_G0Ee(J!fxRweX+r*GDgGb{@)mW{~_M3WzA
z3elJuB8%7<qbt%SPT*#a7tgQg7GXM+avNiPFz<(cn3ksT@aZ<jh)=UIef?aHtdxz3
zrDukVv1}{>k+CM2<H5_0isj?jSk5n5*&8wMiGB$rC-15_ZW+9k&(~*InZB7qj^s2e
zBZ7<Ygv4*Ql}VRG*n&e{SE@@av@%Cb-_9cE$CO%`&<OK>NCPxF!Lc$P6y3^fmtZ=X
z%*r&rP0GcxGGa;OPY-7f2(J#7#mwBFLJXNhIq40tRkbq>4&<nwZD(Q?nBnO-nq{nm
zSoA~F99?2Xl%)qYz%n(h+|XDj%=;m2|BtqJS<)oA%?0=U6ltc-%tF=qUo+E;8+CJJ
z<dBqPMUI_CubO00>|wK-Cf1QjZ-3wb+~dQ=FA;xgBc`e|BR<C+Z~)<*J*qP+95UMf
zvVDDHw4Mfp*)#f57|k+o0pa~iLe8kq@m0j=5W3-R?W2q?Z|aL+V6+CmK!d_)*)?6v
zwxkG8G-)JP43-Y~edB}<V@5Mg?DOc&-rFOiSu}vr_&L$!^_9_5<~Gvo8GSE@7TaaA
zX)J&zZwQP|UPX+44W}$|$zztA-?YwXxid2~U`DqXOiJKSG~grkUke%U*AhAm87(xi
z&m(Gk8-a}Gcn}%w?R>7$QhPLq^o)KhjONE%K=@(D<baXU>KZ_CD8>oZ4PFfWAfwBh
zb}*W)p`igYT3rn#=dAKiGy@>TH%EuDlN>XeX=0y8)b>wAMzi<<qw%wX2^*?LOLMt7
zq+>Ki{`zX?qp`l1ydf|;c@;7G8cqpZI%vAF@R=a<rn`;;fCMt5RWPYCAoh%sD=8LQ
z$o%Jhu^KX3Xkwp7)b>h>jAkszXfGAHM$4z(hK#-yMvF`v(~Td2OUM}+tr`OK<gCR$
z^oo1Gk21QvsZV;(X!(Ypp#d{mV+vw4tNasXY-!QW8(K^0F{7C#fzdv`LPm2Mj*Rxd
zY+v6rIz~udqhAZ7lVA)hM@x*3ucA07RDN(3_)$ieH|=0FOL1VdthVM_pPZiZD5+RE
z#(4d+lpZshY2uzo4Q>uUFj~T5V05Ue*w<G^%a$N>NXKZ(A#d_(XS%VbvBK!&RmA8}
zA;-<&BSyoG&&edwSU*c}fj)CNObUC30!5!?=XGJTR*5Kumhy>ZOQ=X%IuF?_6tT~v
zH+u_#Y-YhgHjkyOv02>^SX0mDQV^3}*%lC{y9qgi;g%0d8F~_%Lq&|YR;x0O*bKLL
zzFL9>mjoFwnyV#J2{OQ#(Jd5{FGxL6GA;L}jt*lNIc9Vkis9mM#*d6<;{%KinV6Nc
z%IKOZ4j5gkVzN5h9+2la`{pq)I(Zc*sLn(4_M3f-zLpC`JUiS$j~PuDd;j(%wlFff
zg<_goQV+1qu39>T;)bR4kkLXD`#hqyS5jm&qr$_E<*YF}#z#)0sY0Nyc7_|jev^<h
zGCIDB@|I8+!zJU38XXv2-qaUC&}e3~WR8*18d3b}JNZ`56Q#@Y0U67fkn`?gG}FXB
zkErdVD`Yf>g~(|C%l7q+(R!M`MpLaoU+ox;G1C&G<Ex0#p)Q8|#}^sxO*e+^2{K?b
zn{G)c0;6SLcJa{~h*GUY!ZXX5kP2B!k2RWUVxM=r;#P9TkBnx~07eIgZeL#+T_cVG
zqf1>(CfqF`bfyV8gGMK>B1VV07;mb6%yeTkmmmX1vqsD3RU)HXT}&ess+!1WFB~0w
zgls82WVF!4K98t93dXo_g^c!g-oCyudK!#TH9%kOHM&S+-#|u2$5(MB!ue=kX#F6g
z%bWVh0;Aa)Mn<cv`PFyqGe1&S%#(Z%!7?U<PL|SRMl((9^N8Bs?V?8ex>!(u`})f0
zYM=TVO{E}xwPQ4@UZOXF(aEcb(V;Gei^&&FxA)O#{S#z?(VQelMyp`bJ*w2jsH`H3
z@hxM5N41n5GFoV2pGVa8N{Wp3b+I57_Vta?Dz*bgm%5lN+O~j@BMCVpqvNZH(J%I)
z^eQkEM;Tq-w64+eC4k6ijVXxHtn#HOCR^4m<X~tmrN@kBn%L(N34DBojP`Z0@XPk~
zjnR6V0i#P@OtxrSK-8W)q-W%Gd>0iXd|`|l@wdkw<unLOB7<I~MT|YC1<1z|jp^}k
zZ%=Y)Z`-^ET3U};%|x-3y-^eVMgu+ou$oZ#u1fFI?fWaQPrS*S4%BBh6@T>Q?uaMe
zg4b7`!0ha0Tzaye`i9%Z7rE_YZ+TT88?c*$?~`nSH*}!Fi9lg~pLjL+$0w?1$-x6P
zJbx_3ha6YR1eSXyBFkAwATT@OUgJc<H<rhE$z|141EiyK<YytBaLsV?j)dj$WyEq{
zDZ8O4EwbGE>=Q1zPOt&XISfDXHgGHY%yM-;bcxOsC6?ca<%v$p6Z%3nVR;s!-Ec*D
z(DGtaOz-rht+%mU77!ch_AIB0nY`S~HEzvK$QoImyo^}xTgh(7uA?lUG>=D?r-7P4
z5iOVP9;G;XlHJB$0ldTAqvb*w`$VF;cNM7REF`GqldkBE<uQhGET=l2zC5tJytOaa
z3CrWls9tdnCj}q8$ns#=aRG56j=*v;>~$wKI5^gF*5~5LPqOCsi3+AC=@quHX|85S
zjj@(9Tt{D`x|bqkxv!y}aBXRF<c;NeCOE2RIaSf*<qpyb_lG9$NLU_U#<fW2%TYrY
zSsn~K?wn1q0n5d(%f?`1?F!4QT`DYRJMcuUGIDTF4Sqsj0VXVG%2*+yxBKt_S<dQ%
zTE5uUe@eRTJ<F+{rVC~*q|@Hc{_JJMa$ixqp~E=J^7VFqVY#fhjVy09wUajdQ<+o_
z?pe-HILh+0>HiiC2eO=_E5mZ{2CQdkTFzbaHf-@Mr^=eVJRGu!X8({;%afN;*~<5v
z-Owm6vOE~}_3nQ$>@px7S-ypD+W$}0@>4beaC&3};3Sl>Dn(QuRM?~?3R%851V9^9
zOW<dY>R3*NU46M{`QABz>}AAqUuC<ot5i{1WO*>`>!Sdw<$3s4Cw$1T*I|Im(<vJV
zI6X2Cpp*$L_j-$3?rUu)?qct2VAFEh0XAegRoiaj>MW$w-kE??@-i+?dtVOL<1ovM
zdiKvBe0e?=aFcI+aQLQk0dxf~2M-GHNcbj{vGgUXkHR-!bvxlosU&>aSRNxPujN#C
zlb8EL?wt-e$!;(sUsTfyg*OZfM=b9)D#?qM7|xwaC)ws^fR*4)_J<3@C3vH%`6(L^
zkSFxtI1b)~E}r2bH~<|F>lIFmGXkfibKfzX?hWYZY(y-i)7~k8>}AAo-<fv9z-z?t
zLCcc7s?Pw>aq;B&pnyOjuSaHGCk5#8L=GOr-v`$=b{exh9TvES2pn0?nu?wr*RPCp
zd_FEf*ObKatoF8dUf`6xj94COZ<q%hX8E{c5LwPiZq)KEc+;5yx=^9@%_aQt3g9EH
zT`W&)Zy_E;mWSHg;@rR~>E`!ZUTSX=&bmYHogBzs##a^2lVhxXl;t~T2Tu9$z^!H&
zq~$t2K-YSwY<xhT(6=jNEl&psZei3KSsrR{-1XiE&^-BkgrM9R5zkquJkQ6f6mzuX
zZA47EMDa{t4Bz^`oZr+xKWMr5@_dZoCdn8ZcAX<A*Dt4RlHi1!WfH?W;W?X=K!-u}
zCVRHfvh&qi|I8cDr_o!vK_Z?@^kR5(+B;7`>%u}tSa|N+*l1PR7H%&pddSlFU404w
z*Ck7nkHG}nUX$3O=t6^Xk0wX=#+@J0f8~VhiMzPnLavRP&T@iWpR`>!uA6>qj?=!P
z1x{u&O;L1BOC8gF;%GfsRP^j+G%w`k8#Df+Jm**S84!40mo9MWS?N&1c1gln)um^i
z7D}D82i;L)oEWAo*B6mQ326c)eCmfh4+S{xYwn+U<2g&O%6HE5qUe&jT1cl!hkL^F
z<Ym+gV;@T|1L_^-d3ja;{E_EqgOKN}P0Vv`6(=><c67({@`U~yXFL}xVjfA9@NpsX
z-1oSha9B2RFOBD>3p?j|sk3V>!azEOY1EmXXD_3AOyD^L3P*W9X%7!PmstWU`>f|2
zD+$k;{ZCY9*UofDjlzS&JQvagN_b0(JZEm9ZJ+dIZ#?Jd%%0WR_EKn<f`x^2;$H3k
zDWjg7?r#+^vTLEz&h-g>@QCUCAa2qq4lI`-PNoVh8JOj&{)Cb#`jMI>i06q?o+iT>
z6FnEwSOOE-y|qG~hZ@|ZMZ59b^k(OJPS;!db|1A&df+3|v$qjBL#-XFd&ij0Z|ciq
zV0s+@_5NH6Zmj3pOHP+ur);F|G#Sj8FkMJvnU2NC#8}f4NlI~dWiv`zLem^uLvVG_
zs=rc%dXfa-Ns`qkNnoBNqJ7f!Xc}wC1lE&UBo$KSsE(d-WADc&=^A~~&RA_VBW>Xt
z2>q|9jPx0h7HLiYq@d-RivC?;pA@%NN~t`;a!UUzH5E;?DW8%e5-p1*i%Wm6lbt6W
z{5$Dfm}n>c_iU=<CSR@GXK>DDu<aBk!>s@N1)CX-8H&8g&;zf@({E-Lc?+d!F596<
zZw5e%glP09J=U86fS{%VDKRz?f`bPuk@T<q5K|d~C?<X76BMN~sFhITQ|Vt9!$0r}
z<ujHze|W;twoJQd%OWlM`~6RU{BNgal}yDc$RZcE55!0jY%&nqr5?go7TJBmbvn^z
zQ$y1t{wN1lyvlaS1>B-LBxj*K%2m`yF;0S>HH^)i`A&FRQs8K?>B6&&mKchGv?QEv
zQi$E|mC001ENm8&;-wJ6`BgU+xasxj5I0+BLZw8W`yuld4G2UKi*U<_R;}>)Y{SC+
z1?>zr9;uR%b%oV~btQy(SX^Dib~;;RkR2pUUQ>%&yQZKdlo_!8y$UgK+smyb-y+B@
zTn^V+SU^7v62$sACE0s0vqN|nYMiLOtZAUV^hsT(>y~C!d+Ecw#qCSnUd7I(FVr}3
zqgb~5p7(25>KzcSa7g!$|KpjyvWX%n2>O=!pMU!4%jchDg*WYjk7$dM)Z#WtAnoy#
zX@#;e%$Oee>;9YmMc;Cgp$$tD^6o+^`%HQ@==Na}j7_a20W-paV-hsq<hQz=xkvwj
zb92;X&n-0SKlA55{Ab6e6+$u>iBGvqfl2BU)X4fl)jQYTex_gZo52NyI`gJ^dV7j!
zu$MJ41e@lmVW(iW0g)I|LvbU#Bxi8SK3&ZIe;);%Lr1Z-3TjFJ^6AsxEcY5frd0Er
zr>C>D%RWVuy5u$u-Ns7ryYGMhW7#2Hlh6Y23~k#MVso0ojN&CqM#f)${_%&;^ud7t
z^}`>({F&0MOIeZsi%(^RIHh(U-i+-Ey_=4nKNpm0)sfSMkg_YOSo?F{0FE1VGOYN?
zhkyDLEk-B2&bnd)ULuXocb=uoolt{NGSuchLv)TyhBA<rpf7J1$|(8-1#6nYoe;FS
z&$D#<S))Z1hqy7rDg-rBIrgK!E3T8|aPy)@4rO7Ia9E6;QaAtu;a>y>3YJkSRTtIV
zz+JZR1!l-=@QNn`X1P047cgNNX5}siGl>i~52qhl3q)M<9AY6m>JnPGoI=|a>|FcJ
z0zsQIaWM#qAOy2>f=<+BR_mG&R0&P?C+i*~tiZ1fYoac2x{SjUb!ndEEUlaLodAgy
zoG--1L~FpXeJKN$sf+YiC4$(zOSo;p+rbRjE_DgbWlk7{yD;2gY>(WkvF+i*hu|G=
z88fU4-UT~^GOBuYQ4RL$BG-NeYMB4y@}tI?8AwaenYt`_mo7m!?~=Fm<26}^HL45t
zQD*cTtBVwsg~RGyvi`8!4eu}ez+&jALD1Xt=CMz2^z%30{PbVnmC|5Iy~_Wk&&JYD
zz}xl1*(j>`#eSB+F<o(>>VJY<G{1D#G0U@-z0blV?*Z@<wSQ3b@1eEJ>6n$^9?s^O
zV*Lnjwbmeo9ux;DGgY;1CQz_BqIgM&S9}>Vt6J8z)3pM9m<I`oJw%x(tFcnk8E|f{
zDC>eD5nggdL*LFfA_HNxtUlMKlmN9ksaWm83*9+Mt+h%>I*C0eByC>moHdzHK3QDr
zz_cdjY7%pbxvGtOo^bWHkircS*C(a1*J8Ye%&3TtNxyW*c~54puJn0gG+5XBD}9bv
z3>ICJd^lNy#n=ZjQgm-%u=HZDWOP{vAJH6G+CQ4nt73Boh^*9h43yl$7EeJLt2r@2
zTFQx{b1)z$j&%(r`!EI>vUV;_?vmAT^S@$6RkefUHa|r9u_qrKJ>%%eioU+k=NSzh
z!OHcGC=9=th)?d5IUdljV|c8OCrEsayey9A+6fRSy7{G$a^g+!oTAo<28v=+!~u$K
zZb|RYJw<_G8P;e+nRx>OiVc;I*TmFAuIYruEUffpvNS`&o9s1Ucsra?DhoU0o;iWp
ze2*`}-)?xjogo`3OenyGi*={v;v!*$$|#InI5RcnO4=(oZnw*@q9^K96!2m=Bdaxy
zXKl|21vuFa$Hp-vowy+{Lun~$6(&*?>{*6)LeVWplDVQl(Isz#HZgQ?I2Ml;rru7I
zN7kkYC2;@-el{aw)MW1d8EA5<FdYvg*U!w}kOJf8y$qRUuZ`0qd%<80*sFHWn{8QK
zCkn$V9;gT&h98etCHzoiE#A8(VA@rQjQm(LLkulrkJ$n}`q%QRX}B=V7VzRa!R8C+
z^$t8xZ1W(`PiGxiqU6>2k=c?$%j1a(V_QH5T~)ZpV--;%u#Q@JtdIp{@|b7}up<LB
zQQ_uH&N}0F7HT^p(wD>6xjxAosJ>9{eYQf!`Q`S3=Bl~Sad~|)Bsot;=_h3l!A&$E
ziffzUS=-3YX$#GrZ=%uipq6nIZL|z5TSEO!%QXH*5iVwv_Ee@<-*@aWSQCWM!{BVW
zb%uE|Bd=9*kxKDz(f<Z%Sn@O`uknpLXT01`Naq`OFu1tO?KX4Ohq(9EMRw4MXB&6U
zlaB~F^VFlH{yTBm-&5Ri#ay4chJ2EQ<Jab?*~4^sp7HiIA*h3WmJu*(_~|-Qz=;UB
zXh{A9b;F9-ufNgO#4`-XHNFuc<WklOll<=Bq4J?$xwp4y>4`eWW=%%uDR409DOpvt
zJWk?%^EjeN-|;^4cPDTo;F+6z2j|hxsh{ipC7J}+9Ym!ZeY?M4xZ}#Yfe00*ce{h|
z#x@Zc(;6cmk+Jk=Y1w@68-0vQ3<i}M4GGV9kDa`!b_boMzuUg0$PHUh`%EGXgj<J6
z;8|-$#gafP(a10+L38R<)^z6{2mI4>b0+VfS?<I8@)f#+i~@2BL44w)*as6q)8ONq
z@BjX(v~B$M&p-U>%aiXg!|RWPv%me@_n(Wpo$Gx{A)ZVha(lVFldX-DncE$keFpqR
zo9J7r<+Xicd7B8sRR*PW;uL>FfhHgMBYn8s@)~c`5=v~wvEIlbDM-k5jKMv0%<Nx_
zaje&o{)xhE^F$&mJaR-<^pB<U#e7ma5_%Gb+UVm9BTbgj+U!A}`0?Z&YbuZz)U--k
zAuk&$|Io31PRN^SCtgx#Qs8_K0_3BUc%{0@cXTMo7?!dD!mt!e;TekRgKACP3J%rq
z?|LWbWoLifw-C7CokW7xD`~y!K+wew*M>Fv#t40HUS!`zhiAN(NnQm~q=^x}grrCa
z=A{ViX7*53QgsvliAjm^j5l)G69-bnxGg{;P4UYrJ$rQC$Q1BC!Q{9EQE`=V=244^
zLr{#1`vw??5e<F?EWv2pd9COpKNzCgk1+3ho_r3ZdGp%qjZZGJli3Trd`S>TZ(gZc
z9++DSFq8v2l4t(IC(YFDxY(KNdT48GP~^wO&b8Fb)Z;^nr}V}HT*M-<;AZd>G6}i*
zLTE6ym^H>6YcVAfFSLbXP4PI!7F4=8gOnM}%_1EmMi7$Y7}Z7wXMMY4^V}YcCdlv^
z?gfibbJS;;H83(-I}3}WFfuBC(U<(qJ#bBt!q%eVRkVl<+I{aH3Nn?T)*u5ucL7h-
zGgz2J-uH;%B6)XN_=}8!SQ-=)ApMTT1h~49{KW!!FEBX+#JFTb4f4B#hl=;j$*X4w
z<SoI2KJp!<cbCpx>Hr0b7?YPHn?ha}+{j-HC{fEZ7cP+{(#y8n5<`A>@X#@N6AyL9
z3xrG`TyV3g*IBggNyUTySIP}W-AMkt7-Oi+#DlQrf>neJjfTn>`4WYd_7WoK`$B;x
zG{qtc4)qNRu<83zP<l!*a$*z?91vv#4jgv^Zq4aR_hb><7h)WHx2HGyN#fPeL3hXY
z*F8Fjz_EgG9C(XpLQmQqI~*55`a1Xp^YH{^sDoF1U|X<7GA>^xc>uSwh>hytV+V{e
zdV<wS!bK);tj;j(7Towv8}cUubJJ{C&Gyhdk_VO{8)w5NqeS9?FOu?FwB?DpUU`K@
z_2!h$2%`UO8&TJ5qDx(>Y!6k2MDJ<O+Z{VYSD74&IUx{W7=0!LHmejO>cVE}L@X*#
zT)F5MA41d09eZ-$?+h4$u83;y46PvLM?WvzF5Rb63l=XjFBJt#jNm03!;rrjJe=Kb
zS7iAxRtbn5|07XN@U~X8y{zB>09vxz5lpi3_Vlx#ea$TU&9@&*gnd!h_VsVR{pHV}
zo=LHs$H(sDca)$)#XbxEpa1&)uYZ${)eD?T!Af;onuA#b0ym0T!KZ@(kq$#NAgulP
z+m_1BfIxq615(m6;(ltza97(qQVv|tg6?&x*D5h*k^u=6T*fAp9}uSbi<*_7ks`{-
z91=ZVROTWCw9L9-x|N(~>_6mm_KCy}NCw`I@TlSmP_K+K4#0+~Nedh97V`KE4sCVv
zg3abt+rO!A(SnPpxh2L0omlqJVCx##@<b_{8;c-zaUd0RWV`{chKL>~VFh_B$%TaV
zAD;wc2=cMvw9iFUWaN8t)?ZKrhR`n6f-qauN5xf4_ajT`OndYNkCFg$qQk~S1jiuU
z0z1#+aRj8slxEOB|L?#4{?mW_y^!GopGatgARf6#Puh_8Jlc!<q$7LJqg}oGGHJcs
z^Jv%Ac$qZr?s>G&%Px~n=3UPYjD%b@5y4&04x9vg`{=U+E0+R=CE2Fn$6B(<CkOV>
zguIx0_WS81xl#M<NuT5{+@6<{_R(F>_Pm_5&F*@(=jEhBZ_l&I>p6P+aMA{dyPh3*
z`F?sy@utK5etJnB%su=4^pYZS_v~?qyNBN7WZbjgPcO+8*k@0g1b5-~yu_6%587Dj
z&2_jTd42TRo|lt8xIHu>)8uf!pI(yraL;}}y`*Mb^K42`KnVMx?Yu|TEF_bNt{<2y
zsYfwzfkjsrbp1{7A^$%V$zOC(>rOvOKJZFEajn0s9h8WOHW1R^=r9sh^)9+;mO}lD
zeyE3PJQr;Xr>e}Qw#1h|lUGqC;-U@mRG_|S6F()57ac#KT;`(t+$h(%=<+m5zAyTr
z4N3qm`kf65Z!fx!itt~w`IKN^w5^q}UbJVH0A6(aEup$-J0?N7XmcdJ|Dx@e^wNuV
z_|cmjUol$V!&gjVCf{aQ%N2xWg_A@B53(>(#pE!^vGrdB*~)*!9S;&r(qWKeH?jzl
z1)VABOxx{_xxitNU<wl3y9lz}%CX{-M0-ktkvs}=(s;KBQuA86TXlw<C<)f~Fi4Q=
z<CH8wgp#2*BuqqNRgsf()MH$#lE7(IMQDqKJe;fzQAO$`o}r+7hiL`sm4I7hXaOR$
zx;$O9#g=TN#|vuM$7@IjCrr?VI*v3AOI29hO3~M-37~3yAlB>JI?kkZuunFFkiA_&
z7}Nk0yH$kQjgyTFaJff9&O9za#Nw0-;-C|lF782$?4I<Eu2EH@g@VyXa+7}DJOYL0
z-Ag4!?76`e6n)CN;za&v=cX@{-o-tro!`1lS}pfHI+U;`O`^M=9T+(_3%j1}tkh+)
z9)8!e11rJqJSZihgvHhMY0SSQfuV$jO9URo9ZFa@`v2&&JufFMwtIN##|tl$9@$;b
z_If$#ZQb+iP{QJI^Y@Vxx|1*-{xaz~+l4#u5`u>Z<s_7_xP|qdXySNzopjUgp@}bH
zUBeXhN;xw3I=+N;#nI>o=}j@ck(29Wo%b%9I2(J#!Q@AA2VO#Q^5C<53F{ihUyt+B
zm$0rl#`-Akz{~g3%UGendxAYdrSGq^VK8gJRNY;9tj2!jidd>pCB&o}P@93e=;xuR
za3r%STolvskx~@X(UejY;|)<%Dx-RnEJUKO$k30H5R{^rT$a=JSo%?FZKWv2&XR^A
z>Ca>>42@vXkDO0amnZ$mSt~VK(2shzUj9t-vr-hR&AsK%_-#*AArd3?@rjCJVpHhH
zEBz>?JxV@BW9eUC=|_1Rr2<!No+fgL_<nq%qL@e<{aF5tli{aW)xk@eJ&c8H;fjN_
ziBvCU3$0*6)j(sVh|P}|Os+?pV_UAl^0pOBLN1F79*$CS(j2=;$*o`#(^<HGIt=n?
zrNU?~D@D;<s_lAqLsroTi4w@|D}6)a%M;hyP0KtLog^fYrC?I~KnCTB>!fM2%TSAu
zmAB9;@)Hu7RfKM@|8-yct7-r>I$4ZjF$rT}C*Hvw#t7%!V`2<Oxm!pI64yz`TN(#l
zrID4pg4%0BLE_5&aDCC-^JpJoO?pxHJldJuE4QG&4{BeKxbkSkJ3ZSaK35#0NaSP>
zNvMh2*rh8@KRo*Ez)G+*k3Ku_a;!UhXyOYJ*GVtqu4j8*PMR-wJ=^ng(mA^8*`Al&
zA^1M>O<llN2Jy4o56X!zNL;Zw`q5_xUP9dQ=(7VaAzXO$*@2hur<cB`=87!`590O(
ziQ65UQ}#IBVZtUZZz|e0VQapz1Y2^aFA1A?-H%U{o@moJB{kZhPSLvfAnsximq9;L
zQo|OW6E-o(^kexm36aPpU$t|d9x2v|vNZZLHYS{~U9~Bj{^Tmnyd`0~>c9Z~M^S{2
z)C564N|;LjbLEa<`q%Pj{5Hy}=tquw=&e>!>7)=P?_mIjwb;CnNXT0BsJ#;unfcNZ
zfrQ!7!ype{@>;oQ*&pS*#^e!5$o`lLaLFruDu!loq=aVmlJ_d@GCq2v6kA{TF~ESD
z(_vbHP$b|M8QStYs^?v~<ADkS&T`Qyz~m0_mUs46rd`ARx~+xbf|0AV7g>U`%C}69
ziWY{o@+W<BQa6lTrHRQtn#4J~jF;c-KQn9?X<}F&C`B6sk_ZX@rB6tdLA*3h*c{SP
z>A{lQ@@?TsNJrPcp)^WI@oqQ))|WqnP;70Mj;?)7$s+XWD3%(JW9+A+*g4Z@=LF-}
z$gI(^t}zSu<Md%Ku&IYJdb4SDcM&6(JjGu-wZH{%hcSXpJ<RLct`l?b$!5$v%9n0M
zF*a4~%M`yk{*}8I`(|d(qkW9e-H`9|=#YD3EhZuO9@tbvvn0Wg^U-Jf7$2jlN1yFk
zi9yh#&-T0wv5Qs0J@gK_H-1m?LEOF>fGiMLxINlE&L3E}rlL){2jhy@s)Qw&ke0S$
zk0>J7W?~A+wU@YL4cbdg*F0CL_i@%Bc}KbCxk^0DS%dZxm#jg0iN7jYgZ2_r)?nnD
zUJe#@4^1#Mz^E)?+M-p~A}keKouUv(FsX+@Ld0_%WD8R%W%HC=i%my+$LQ-zThsJ$
zkS#d%eI-Ompu%BFj%#nq?)a5tEA$133<3BE8Uuxd2)TW!fk&y~SLLE0#KoIebnuTp
z+oi`>G%t@n+v({Q)%4M4JITGGc0Ky+z)Mhy2cJ!a1EX<Ql;uaC9e6ob#62?TlmF{l
zqpWSFyXNvu*`lEdDL4S%qu^s7hxtXH)FU6)@+&H3U1fbTP3Y5)(gr|9E72b+Mo|Gk
zZdIw<n|_r1m1<H~**Hvhbo3*e4=PpBkMihJH(<(Ubps@MpDO6nCOx-(pH^4fvS)7@
zo0DDobnwBCaTtu?yA!UgVXSzQi&$)B=~Hc-RZhBq7csVs&FLx85vosnFnW16-(k4o
z=fM^zTR%HioKK}^;lFh6WS6s(M&P!D<0`#8lDXAKQ&mTrd93ow@Ae~6*>Q4}Mxppb
zRwMgFI>9@I%$B^9wp=e1_2XWFyagP`5Z+x*dWtvl*0mw{Xd<t+LK)k7oiss@$*X-<
z=7~gJ(BSuz-bsgVAg@N=NCTGM7LmJv{5ok*2J$M0@X>|5V$%&Vu9JT133(Z7klurN
z!`L|B$EX&J1FS8z#-ZgB&WT?qoz6gBjr2Wv6IH%WTC*qQ6?bbGM$!wx-MdNeZPIt_
zr1vKKdaXHQ>1|n%tBuHC49sNRH+6;O!;N!PkjuXIB)>a&C@(<j*j_zDklus2+E99L
zlNRPc-b90$ye)roA^&aCf8C__2Fr&Hc{5d>G>i|WR}h7}FLc50D80b6xpBC0V>Y=k
z)L<rWi<e#XP5xpaXjOV|uzc8%H&bQ&npJ{&LSEK1E4?D=1DJGVtcPJ}BLKzSQZTQ*
z$YQ|C|1Y=GDn3toPWyVYO;DuR!(E84Z<D>kPE~qdwB-O)$#Vu2BZ@vqgv1L@`(*XE
za5ve_E4Oep)=8Q|F<$Bev5~%+S-nm6vvz4^5w<u#G=*ZwxQfu-!rgccY@c|G7&&1r
zF@4BIFoHRZ5ki(k6BjYIz}Veq+$O!dX<g&SoycOO8oR>9)NRsoyXVo~WAonGKI8U0
z+M82uczvHo`-`dDkq+DrvHiu=?MMr5@7XTAza8np?LFJG@<<bI@7aNuW8K*!CjMgT
zcBBcngF9SI9cjYtJv;ES1QPEf-{CfayVBn2*`Ak2ns7Tb@lByO?wflb+<r>+cBBcn
zhuib=NE2@F*<LS?G~xE19eDYEdKsERxtZ~Oco|v=xjXWmo*j7ketJpQT{f;f(uCXL
zCG{fOXHVKU_t;oJrFy$#U1?7M<uhJ0ktrveve70aEzT*)n2bP5!;nN!rNLJMo{vxE
zv)7W6P=J4v0h+R=Ox!;=_=>mY248Wm+~9j-U-<DW`jeY{TBA&4il^ZQ-y1syZt%TH
zGjN&6ylFEqS;!k(NxCwjKhtJl(qpkfAHO2ixYcH0`ZH|?CI;TPE1puR@@JB~(IwSQ
zn}JKaXl({Ae^%2i8o%U^B78;7Y*r@jq2LJJtnyUMVYo}R&yU*8dLv!u@-F4ZjU5zr
zmX$?W0g?XoU_Hu!D=+PXTa3S3?TJQFZ_<_f6!-ICoo|o08@wgde;98o=EP-lSnWIv
zvgF1OgKQ;{ILeJX77l|Pd#Odvw`@O*CBNXZhQlC1#E+(j0)+2P!dUVPR$oUTzkL56
zwZ)pgJz@>+q*YjbgfqCcX@d-|fM9^WWb%TAz!5(9G@}1<-tB0|@XcUsbpT(hc)<$j
zVT^FExr@;TW2*yrll>CPz-Y4Be4&-WVf6$}Gug5>lgpWnSajc0SejLJU$E|Ym{LbA
zprKSzewH{g*nHZLPd;RO30pLfX8Zs{v$3jfG}BiXH&-E*-dv&?^T9dW7u>gTm}W<9
zT?NQm+Pnru4ANmt!H^9NUa*GRM~ifuwDX1%r*uqmiBsOzF&xD*s}Je}8I?FEy}*43
zVGuS4;myX8mR<U$l*nxnp8A^Dd;da_>F&c%H~z`X`))nA^A%;0Acn>4qDWL5SKU=U
z{SriEtBmuN-$~2z8tWJcqxF_y(g2$$MbeThwz3i>^yE`R*T%WT^6q)GPvs`frh6V8
zN}o71^C0X{`dn*9v;A|lZzWR{KMzmR_HN`3Ur9UCd)mY8d3mJwwDasx`aIHm+IzOY
zk2unM+IzOw$``yW+haM#<%G2n1sB~`1!t?*B1iI@Y&y7zAVYFxtrOi|7GdQg0xOaf
z5u^pQ^!tmLN)bUDC`%DR2MJ0MK^rKk!f?|D%FwX>f>(BX$b-(BTQd7DV9~H{VX7}>
zz2KeQVUS}Rx(HJ5cj?|Q1UV2|EE_v*TP-*L=(&Bu!x!Uy0_R4$^K734V1MVMxV_uP
zzRX9T?fRo`*p&F_vpp}dBk#dy`-b(~q!)G%FR7+v18wZZdK7oy<ye1q;SRh!QU}lF
z+mB-3um|Kpnovo@(i>Yh9(}gwC3a&x`fSfj?4x+}*`Al!|M2Luy<Xzgz=O}G1k>?y
zoDJ`hZ_3B)vtRgY#yj)QdFsU)Fm(%~AVlL~a%XQ8BXCw)1~P8aiA5h~p&z*bUj{O6
zx`&dA`C@(P&Vl|+H&IfdUThm(DU?6svc*?4ka5#ZlvFji=_X3LP!heQ`U?G-^d!+O
z1N|s(qcZtT+pj5Tx@q?p6)JCf4MS=8P3!-ZGJ0x5(dB5kfY%6#s4a#ILWDBZ=~eIr
zn{f7k9LJ@2n~=a(DIST$R?mr{G??i<kTF)on}h`5B3;`p07cH8`4EToK?0;ZR+AG*
zq1IG8f;o(Dl^kzRUa+aC4`fhlx?>4B0oJD#B9yzxa&PHsO?RxjCXY`o-d#$#Qn0A6
z3ALtsD3UHrhj$+Br0|ZF&j(SvJmZdK$_F3qQuF&{lk6T^`!dTN>v|8u_GOkk*4-X`
zw&x^f=8rzxvl7$VN1yF^iP`9b&-P`OI|d4mKHK@l`(&5w9vSr0`FHeYkKzuz1h@0(
zvjZ=|TRiw|-(hw~2k_{#Jui=Rm39m)MRvx8-j8&Z_MYu|d8Dhf_iWG0BVDDPXZsGb
z`;pbIy=MnrLb&>%oKU#!czGae@8J%-d_TPm9cC{m;H%NoG-HyJ?ai2Km{a0ChNYKP
z5<pS9^Ca<3=?9bWq?B?cnxOLRGyN!;6*)X{)?CUJ-%3ByU$HCv_!V`}-`R6fyBGZ#
zI~w}2{26CzW#OZkaqb5bt4lwYKjV<NEPT9cBO3LCi3y@6F#0n=P9Kz{AG!8i7Czot
zAL$76XVQpP`oTon>0isAaSB7bW9Uat4a$c8yELMG6$&CRXgl_>4dd}iNAY6V+v@9~
z!|(--&{2?+*5pNyt>zut>0Z#99R@kR$XW#1YTlHf8|y;q07a9-APcAZI=Kk4RWhh=
z!-E9-+6RdeIO!+$8R1<TET#KE6sF``F(U+H+y^qs2q(?RU0PX$Eyed4;gO!<yR?aN
zM%Z2xGeT|~?Q=N~KJ!O=AIB}C@AGKy;wD|Hdr<pmh1Z+D59*K+@><b%dbZPf^ZC@}
zXeDQ)zj&9AkiHY{z)DcQM{x&U9*Kl<nvk0|=IhRjfZvBEe&*=D)}v{gC_4HcGQvrJ
z<sQ}XGe`1uq<5l;=OuS9zR$BmMmXu9+(Q#`IaW^aD?Ja&cgP6Wwi_<V33)Jw`~CEi
z+?RXy`{`xK2#+i??dXo5Il51}ANR;f$OtD5jJuxgd3j`+X^$qJmq$7yJJ0qRL0rVX
zQm)SJw~vwUYn?(%y5omO%qH{)b)K%-tnM7?IqcEf@sjceP|Vdxc%I!eN2aFRUVgQZ
zm9u+JqGhcAt}{=R1Ix%$$?iGS<m_JOc}jNAksRgmlsI$XCD}bG9=C6mzmjXflHE(|
zG-vmeN0(nH***Js`jOtnE?KgB_Mnp8^XhQAZl$-ef8uE``FfmW_iX*?U+HbygiXY_
zOT!sw_qs^7WcRvAwq*CZNVa76x=6NU_u5ZPP~<xbbW2NrCW~at_xD7m>0isANqvAG
zFYDw#QnkZM5^)=ftb4ePDcPh?busg4w{>({Bkt5Tcd$F!fP{l4`nU#?fpCc__7U)W
zpGx>qN=`aw7eVqpebJP7{f^Vmiy+TtHJsT;oY3(XC#S=*N>cJ~emj#d$RVfc`>1!j
ze|Y%{Sv=`g?NiTSY;~U~hA<_!NIV{G@@)Z*pt}T9_J<M;sVz}9_S4VBKFai{*hiy2
zX5(nWv9|9?b`QHplMrd|iF@ccG?axzcUcH(!ImeAc{NX@6C5m9jmbOdb96#+mzElf
zn919USU$L)G-+<+tt*s}b3_d7+%d#3+eb5=@wT!ad9^LbJdwz|RBE#ouFS7n>7BGp
z2J&jb5^2EX6*o*a%asVt2F8pMb)A-M!i>_ZU*I*wFk3UThmOh1XRtm>SkaGfe%-N(
zMH#r{_arPQ7p>nBHh_tHpl^F@58B5`3##K)k5de{*cn&rBaH79Ia&#uG;%uBvRBNB
z0ZUkmA6;9L*+iBJ!zN++2ozpopti^vhTU;_UG`9sFjyYjjCnB$91B?qBl3cy*dqdC
z`#9+d_2iY#zr;Q=<RTV6S(!AnZuU|73+<x|dD$UbV%#Skxaxj7<kjv)!!R1iI2dG3
z$O~3Ck%K^9bu%bpMS3O8Ddcs1w{f+D&5wb+i9#3hN|IoRVfK6^s3+u=?8-cmP5}2^
z?<l>X6A92j-b90$ye(vQ>F|Bh6A9#1yNH}C<V{rhKIsIVkeAP3^?}F>H+AnuUNg);
zCvRH|fHYw8whLd%$&Fl?bq2{B8hzVN1bj9b8`)9n9}23RJ#=Jz^$_-nMBieC_T?w@
z*x!uTCqSL}>Wsd%kWAk#XK_hOTqDpi53&=%`OQM#M48S0gar0bemjc>@LKF0<+tcc
zKPn6KO>~&)tEQ9sblv!X8TQXeQG*BF6<~Q+=$mMB++*OFHkMyLgq7brd%`{;2H~lW
z1&GI`@Kl=o>3`)ls+UhHKlHzeKOyxgVl-7B2v*H(XhK+j&;J68ROM|X%gH@I*ZZbG
zY!+k|shX+G1elYl&FNZ%E#GkpOQb4<-HEW|X@+>^wS9IkVpMI2i&S5@K03u{5KT1k
z```cgi3;uC{`C3Fr_W#hPI~erV;EwREb&-p3VU5HPQ-(FATuMs{QTn&pFe%|_5b?e
zk6-@$bUIy#a9{u8(+~gt=Py(wzI=E^GSXx&IFf(;`gaB7S6_eo(~tCxsLxMMEP!p9
zSo~a$q<kkY21oj?M0gS?=sQ1>{+3u;TgQygq+eNzrI7rSepe?DFVd#Q#tLBSi&?Q;
znoj@eZ~#&^0sYgTzI^%*;)j!C>@>`XN}rJ>q51t!fBbKuF4Hi9-Qtgsv*MNVTwq?_
zE>v?I2@ELSOkhA%v$M?vMlTzP@@!*NU}U7^Nt+?97ocC=Z-$G&4lGGgPtsJ55)#7e
zzZXeXf1w?aUZUYO85_R&@uxrh1$EQ(;AP~?42pDACNP^dcC`Vb7^rmyY-CW*rxQY^
zhk+5CNC);oX2%ohkZw_bpkhw+dP(0|&58Drdg6m5W@k)@5A4d&Ilbgo#Ke%xZ5JCl
zFR6IV-p6G9bg&-4y9ZFpMO;DYa_`#<UfAzJDY$z^52WM~*u9*VU{7qd6>4krf>7h-
z|4gXC{A4Ga3AJ2)l63Psn^3d%lF3sGBMs0&pp0ey_4oh%)BpZLit{5mpTAPX@pU5P
zK&1@r*!1bQJ&O|;vqJ#c8U|oMl)en1Gsm083|MCR>dmDMJcyFbLi^O5{u^j{hRlkI
z4W`cb(}%mYe%Q4z5fr@e%}%I-lDhk1{p!v4i|%ZZV2bHhqy~sdzYFS?oiYjr-c@Gk
zob{`>o`Li&jP*^T1PV+tzXCSdNgD#3!Q7lBfa)f@c1MUvD5s^_Zh2v#4c<rhX*0IM
zd@(tQAQq`5%XNwsrW{;O%*`B*o46lp58|Ok#;dc0zCL>HF}z+g(-A@(io2&W+*a3|
zNshXP>!xP9HZgNEUDN$Ww-?!NMCw&+p0wQ)qa-+$+s7zh`;D?!3|kuc-PkD0)+GU0
zQoD}?kaGiX6tI;bV@F~XCcsjotQG+EvDBMnBNWSe2uN|EQ-;h6iZ#lYH*>W{FM<eZ
zCMIAeGaV2y;cLne=@pZ#-v-rpR^P3STwaOcUD+8U_3?HgL+6Z4y-o>)-%PT*#v<In
z;6+g2*)vd?NJy8OkLdO7L|C#NAqvG6R2ecW66f3H!@1?Km%De<*v~ML2`t)X2Nao*
z9z1`fA``mGgnr;yRZWL>=Q)|cK91~=A`?S1j+M0xt``!`3cZj>!v?d$-4@Y7Cf5X(
z6}0l5Do(YWkg&p-$6@&i>zdiwrmT=#Ryu(gY_a0n66sk1a@}VI1}J!YlA#l;Eq$9_
zPzX|sQC~zoo?fJF(_3w9a99I|1-=Yes-ndZ1RF;%RbHrG>TbE{zZpXtvkxm5Qx!G#
zaV!^LwXy@MT&Uf%qRuKRNfn)de??VPLeM~dcvqkNLlwm;Vg}c#sI=iG5~D04R)qRG
z_LF2NEh}a!ij4>pYl&6c>})eu)KyF`x`;_sRNIf8iel46cF4qof=p%T#wuFdLMZan
zLbepCL&S&eCTqa3W|;xYR8&f$Q7)vHq?m51oOzNNWBaIz;ukk&ase;S4k&UV<z9cJ
zqM~{uM?bKgtSVanAF#vpE0dId!HZ%=G=u9^wBtpk?}S+qZgH?bA`_CGDhiT4V+D{W
zJKK~M)mn1fNDXqe7VG70$yx&UUhu9WLpM>;W)tg;!HbR~SYWSfpTR(2Sgg%}r7Eg$
ztjnS8cAS^7T=+Yt*V(r(tXxdI=qv6Po5=<6Dm$RcMbC>0a2m>xcUHNO!m_hNueez(
z6aEDi#rkdr*QuzCmw3}cU|U;>pCG0G21YAGX<0GxqOZ8_Y{CjGxo2mavO?lpIzcs%
zrCgzvWv>Zf4zfc=FN!xj8M>j0zDn;zk^L7P1d<yD??qp6(b^iY$*3F0kpBL?mav10
zvXx^M_2r3I+|!mJvvOfol*(9drZ)SEtJ!990Rov(UgSb94!o$77Zu>FqHLJdi%NOi
zt0<Mq+ofoB$Q2cZgdl_KRW$dauZ)C*iUJy6uz1D&a2ZO=3ag@#6}$$gwR{Y74!k$W
z&NgEO123%LcQ$J&zSXHHE|bd+8C4YTt1@(B6_pi0tfD$}S1%hpFp$SJU|4L=fMs4(
zw$FQcCd#puW4Z9<qF27GZ=8HE(0#?tbu$%R@}ja^-yf-{sB{^WA6OeyMde~3s3_=H
zpZvpI6if0MKb(rz>b|#@()hrv@a3XcZtq!Ug;mi|E_&tGiuSajisCg%b~aVfZa|}b
zNyG}YmU<Q7Gy!{$`m8YVBt+~Py0MB%3yi3!pnDPCcp1U&qBUT6Esz1rRJ7hXc)8%W
zv+1VWPERtplgW@-(`~(Ilnd-7nW*UGQzE|;xzO)elo>>54=XAv4JqXZsV7Q}Lhdud
zA(t%VSVck0Gk$m#?RZgXizyQ0*MiVNN|@M`YGy5GDvDpJp0NUg&+KedR!DqHCotAB
z^`hK5F*s!OqIkiWp_`~EqhJ-)524iiA+HEv2{J{9!0<981D2{Nn+fl7h;nNGNG{Gn
zdcm1x$VMu9zS%xUTG?(Q%CYH&7iR}lx#*g1{W`6_vqo2X730W{ohI2K6Y_)Q%FsED
zl#8E8d1=*Pjl4Yl>}Ox|qki-4M>aV!*7fxDZ@&HI&!3*jad^~#Awz9hV^ua`jk(ep
zvIeitvcu0<qj%B78nm9-fH3{alJ!KdI{74lUY&O?VdQ=6uH+_^uFl)79lV8rO$=s~
z87x+3WXn_*h6Uwvg`m;ZxxAfW`ojM!c5%$bV&+usK<-d1@QxrmpNNH&_eB-z;Nm|$
z6{pI;OFksG>tu;ag&>_`eBCpH+vz`?e96OiyVRO`2?jRY1hyH^U^{1%tRn@D;f)>K
z9CHG6`4A^0o}}+;NcV_xf|D)pAh0DN6SqVUzzJmNqEAJ7%l;b?4Y^LIE+Ou5apv*x
zsGtl@&`scWWqo@6V0xU*9Ab8cqRS-Xbc4$jjF!LJpK_BV@MYSB?2UH3OB*%)|JnsA
z9enivYXj1Yu9tYp2D6EEAOjg+tnk@RE8jr#iX9M>cn-xhql{RAZUc?rE>=MAz(w|i
z>qO41jp=p&*cF<!45i3mr{7=R$JSSt0T5G~rWhxI?Ftza66KhL`l*wEc;Bds{(BrC
zdc_`*449P;+g^3PJ^Q%M4oZz}(^9-IcYK+b&|VFa4>r8jOQiAsY)mR4|0L>kah=?M
zd6<Na4QMe^;c^FCF*3>vCP@ds`Shos{^OI(3yl&)bC;Eg^CE2NcPOxZ<K`>g>SwU6
zz*uvV2n;qrObp6oG+lG`zQ9QH1R0dpLcn2#xH!Fs^G*$~AhXjZf&<}T#(`*1P*dxz
zcZqi-jeTiXtHz+<`pzX_=AJDBmKYShzKddA`weK|KTr(Lp8>P-VGYXlVq556aoOis
zI?U~6c06`BdNJt_RDw?3T1P(!-Pzsfm0&m{*yikvK`P9JUxv==rQ9|aNpUfz+^loV
z6EGDkI4x;Ja{^K&_i_4+M^Ls%IMm{CQ)!=a6O=&xM^HA?9Lm&qzke7d@Z$lL+b~v`
zS9!&&;XN?N9%Pr}>q=_9W2gSzkeK3ieTLhb2<t+EiNNcvnTdcBLdKGriKydPuNsJ}
ziIBRZUS>bZT{Z3H)J+F+r(4QSplS3;Lco&IATc2@1f8KDJC=I4O+$UULPS{?fKBXo
z1co=I8L-T;$dzX_a4?<~vS_?!%}8d&#(I{^%he`s!~rlP6T!io<?MtaIQ4GY8tvj+
z>UfsCQ%jKBZLbv!up8Ma6Z(TFW$2u5sW-Y7CV^~Ln|{MfD;R}7sIl3`YuHC%HnUB4
zz78hdC?AG7NlO-~3FBKKgvQIrJuruMd-ByYSH*hmNkP5UCA%F$JG>yya9ahmb~{l(
zyi%DdAk;82*_kO|o!NTTl8IPu{iad9XRp`nuR6N#g$vXyJAI;<OZ6?REnq58?@`HO
zYlDa~ElB-ti;Xwb897snt$OFp2Fz}Sj+{qkw_a|(Icj})%X9{02UK}ci)W8i40avf
zdevo>A}?~$9>~AjVDqK%dYD}=&Miy=xf$$Ne`i$hqq}!TINik*f`MC^VFa)Aiua`n
zJ?p@&UcItgR|F+jITwnu_;}jk<z-)|#(o8_m=kQ?@BuX&#Bz}$7lH-u=}FE@E6f94
zh{5*Y9a?T&K>x@AxCmYj5d7k7mTY9WqaNCsuThQf6+2F{qs{bCuL6lXwX#pgt4$a6
zqF=AA1F!bmYtZBj?Kr}gL9#;s+9V{$51~J<5Z)z3av$;b3>$f#pHFrvxcR($c8Frz
zNkQpLf!R>kE6kp0*O`1rk1E@GkuIxw>HpX9i`wk1y_rwa<P}ft<EqWzJj+YL;K*!Q
z-$Yh}(?;crZLAy7e*OLDfB(Neeg4P)@3;SV;RfB$lKj-74!nf^)uaHi*F{|V*TsbV
z^79{QYsS+*o?mUrTM+b-{_{^iefj*;7r6tfB7$hy_7of>T?F<@mx_XwZb3~1B9n^!
zH~mX{3+syHR+T1HPZT2iXO07_pa1Zm9a$+4WD&9tB$|Q}^`#rw@QR;g$RyTA+?(85
z^WB_b2)B8=u+puM$T*pcYgjS;DhbA4&{j26DGRM-ERLhM*V$~I3Lvdt`@^St2VmB)
zy<*2o0?c{84)N+$JTcX?6YugDi8tQ^YI-K-s9P@v>5ZXmZHge1YjK-yk>mw!&8l{u
zu(GsA)8n|Q!`U$T-M#|K8qinRhGCwVYD;JZ*{tG8nqp8>u#X@+)eoQlQsl6;A|Sme
zu6ZUyn0HaEO(_}`S>ZC6f&{LUP3`uutSHv8HeCGbyEi(T#F4(JD1SWQP2EeX%_a6N
zh2d;JycBt#WtVSE7|urBK9LSn!~k(3!}(4d8IE`N2?eVge639cj^VWEMqcP7nf`St
zXWYwh?6gSWdWP2y4n)li=Zb1^hg4dueE`1N^NRf@$;&nsht3OB$gG1v`dpAbdpNGW
z3C3#^sX>U|&w^q@L2~*)Y9(nPHOCrEYUejiFGcbOpl{+;NTafq1*U%_dnj-E?U~SY
zQO4_RcsBE))9-x9#eH880(~|72=r}{oiC?J+d}^hKwo_ZKD*F2$*4^`$A0=IHjv~O
ztoZxMFW&nnKs|k7@j=sJHWf;DG8Ha#F^vkz8#emZW(P;#)+K-j8Jjk;hYsae8xXvG
zD11~oct`qzflq)2`X)Ne^lh=LU&Hf?9SF%AfWBKk(s)Pms~7Hu8n4)Ikv()w-z>y>
zTO04*>*{8MuQq9UtrzzwV?<v8$C)1u7CBNBwO_Fh(y$OB8b;_GziFu0Pv0b>5nDZg
zSpw2TxJt++HJ#e-TYF4vzn|DLx=0oMr2p05Zw(rtm_*5gr8#)WD|RO&)KR7R%coC&
z>zs;N+UjsrFE%VCkdsdRW4;Qn!27W4*63Hc#<udpz&ZRZu>h6r3~>3A0h3#FU9bI7
z&WY9S!W^lM?F$KPjjn40gnwez|M|9Omq5*@=dl1@JSRZCEv<Lhh?wcCb}%kud7VtF
zZ??2v<KwdneWhgNm{!zoz%;R?J^FIMXvKi!7asY3zA7yLv_W^EZysw2IJTuUjOR!J
zF-*cipl=>)$=I=f=)^#e>C1<(PbB(+*M2|x;=OHhdQaba1&lJr@~b%n$*;R%c*Ps-
z<P95r>$NyOo8&heq<zKP{OqAa`pO{!eg8*tvDuWYiv{Y%F4BPM+j23#e&lsBrV8}U
zW36l;Rqn!%+6NtDbZR!f@OEEa!C+AQ#*?%~k<ZsX#v%js|F?U4a3G{Epn-jLfj^OJ
z$o`p~DnQ&KH^Mw~C9h>e6CFGlnm(c!Y$8Uy6iwuQ5u+N(a-C_IL{!_KaD;mJWb!Z6
z!wvabPI30oxP=PY1JyCfo(!Riu;XuAztO5=b%AA3xC*4)lHT5=Wh<aK5K7vrJYKjS
zW?}7-D^nZw0@M|0=mh&C%E(Oc>IvFkTwSzVX;_SwtSl)(qrcpE;}#=j&#EpsGJ-oy
zfURjl?R1Kl8*khIv=gEG=z`oV_JvR}COLzlqFNeqg+UmB27M}`THvKpMzyTFN4~%*
zIe`Jze7;LhiSrX*YMTmNJEq&h`-*pT8D?n|ke!?f%H}!cM$KitgmuYLh*{33MCIaS
z%IB73)vGDAIjk=lVDfd0GtB$8qqzP$Pf@(MJ3!IqKJpu*H@kbKcXf_pi5J5eAaba5
zbyYjy0^OR^5Luy^KuGNM1$)~T^#wF61D5HF?4XR2C@o@KPY-?<n_)6!BZcw%sp377
z^?fo7)vnGwHER<T*&FTRaH5DUY8h56RP+=EbS@*Si;C-h%mB4jCCJryln?-9C@n>;
z!bFOKJ<ITl396To0cK0?<w7EuAl|t$^);w4cqy9!8Y|4U<E35!%1u-R2I8L)5m{|&
zCRsbuTiNgZ%{M>&7u9z^oSv@N=MU6=b9w!6f4aWiK3ok0P5(`H!q}_S;<sW;<@+*4
z*`({F*aT)nkP~2S|A>b65XWc8tnha71X)DG#=sRM2s>y;ACgHFLfppR+U>ifVcf>=
z=N!ggtP(aj{35oK3EWK0{W$rW526-nBRB+ce-7h6wr48FeUOvLO`77E#~}c=OKui?
zq^bX8kP=ta%3j_g@!N&N?rQAzhFwD$hppip$8PjAlY@*JLQMfNJ0KfbDdQIN1_>Ll
z1`*)26hPitY#C|4kS!QCzF(MH+)>bH3Je)sYX;uxK2wXEz&7XLZ_((#LGm?ch4o=!
zH^`e^Ml)sw7{%;tQ&zCmE3Dugp|XPGTd%IORW#ybzyO;{euj>npWLSeK_N&jAyD;r
zQr-k$OJ*2>g%X7eyiyg_;5Env6N`;UNUvs#ZH6lP>eiGHMU2553kLjZMtT(twa)fT
zG(7R9tyKEXs-t<S1($?m(jNr_3mzFdr;@dZVqxCiYEuvuvqKRNJB#|DjBgIk1&be#
zz}zkqLq37sR)=AN^?3wl3(~`P2HvoT?J!J;Q6GWX>@eLBxh-pw(SGc1S$ngqZ+hN5
zO2yE@V4k(_V2W2N(y}6l4T-mKvz0j3jyV4k?FjarjfeK$SoQkhsidfHGA5n*dTsY2
zU1e*o4n_)&Pf}g{NdGHt=uO7xp5B<EAr_dexrufL7kg)%89N|ZP9wny8-D`IsvOvJ
zAlBv^>zIAH(RkBrkey(XUCCM<If7(W%Bye$@D~FGFO|^V6vZ2sz7niBMIpt!#OZIl
zcKrRMssAO9ucH%E({zuf_>$2%nKJdy<e6b~qNT3ofoYV4&1HQ;VlaZ6ZW9dM0=Y3B
zwf~J=p=T}Mxh#gzS{v|L>Khh55{y1ewa}XT3kftf5cY{>&9O~Vano%AY>{})^SL|m
z+Z*<>ts-={3vX+~jWI{HRBUc9<k8r~*T;w=he>TlwJiRvNiqdt78u*^Vq!w>j9)>@
zfLXUS&QMLYAj2#XZQXtwP;!35hEQ_qpe2w=WmvI-mKRG+3Y{TzQEgop8=$tlC#3xN
z8KVrOC8&!7+~tC)A7pSR1Z`>0md1mKk>)HpMfej_vdRF7x2{F6K(<zC5>cVBLMR+K
zz2@r7yjIU!ztDWUluB>+4=+zQS}j@r@AC&5m%g4qyqJoYsTXDkjLzI@8V4aP!y@MX
zWNRyrkmOii$q-qQRZaJluia<K#V580W&(>^)$=`ATuCqveNSy=EMrH87q_?B0;2?)
zE0AKHCIPnQduk(Rc9)1fp^MZDIV@If`XDFHM_NCN<WT_Z=?K|pA0!GL)(bL7nfH;A
zG0rfIPSjpXLKXraY{<-zS!+3QKUjOoK#R4k`-6juZ0<*j7J-V7yB{niWC*P;zro;^
zrD$_MRQ~Y1o>bZ_MJN6TD>ND22}L*mlMR89e(&}_Sgp$diT{CRx0Y_3|IztIC2=6)
z|D6B1p0367u>ZNzh27ck?`^gxcjABQcYDZ~YI)E+{`Q8=o|(eM1Rd*28Og28cKlE6
zM<p8&;&*In?L#sdMo50JXq12)I-uHzOV~o(jxD{5*qjH#x=?~_%>zl_E*tj{!Q1st
z>-92Y?!mP6K~6l7^o}yf5EWx%ZJ&+^36t~;Qs#kbWx|{G+6hb?4t-zPRGcBR_HyEZ
z7{Ig?S1UdN=H`KP7RM_uuqnfe@lYoL!gM|(tJUT=m<KeLwDztMMMKnP_eVv6v=p6q
zAgqjJc*O&CDY|)}Y|N0%;cgGauNtseJW#Dm1{QA~NasqG#NGqp-l#sSjlxW7_nE@f
z{lWoeOJm}#4Yo~Z$SixU!uV#OH>`{F*;}_YdzjlUskdy(@%D!8(;3zkg@Je~L+BMo
zL$d(2RoMK{7ojxw`uh|nQWR`NhF27(OVL(ldrQAA{AQO@MXWJ?!17!MXsj@@kcty(
z5!R=-d@hl<<V;Jbs4$p{XTVa0QN;-CZ56h7F*n;oHBy+@mk+j>Ivbr-_Nti)FgFh)
z6#;K{cqh`7io>fmOxiQDI)$m}e}JlrMAh<;<IMI+S&CW@6DW%Hj|}gGqML`2GC`o|
zZV!W1xeU-mVKxt=-}-$M5(i-Km*bq?XjK|_BXWuDd_I4msSi$ZF6ZYDZzha+!#l$4
ze3KNXw$M|GBW|B8g5H~Dqu94M?9=Z%0b?1;^9DZNif||8*_J)|YchgVyuqTHVK1lw
z2}PZZjB6k_w-j<8+?mv;+c+=7`c49Jn3u^4rDFQ&cE*Sh5fC`Eh|T3?`-Y8sJZ?8W
zRPy!^fj@nS$WhGA6Jlwqm}Frx#V0KawPXHQ--UjgwPi#G5u71Il)1>71{Q;EfHmI}
z>XWn8J=UJvkka?&y<t9_VHSH{GwOh{xt+Ic^pYeG;=w*!haQrXr)Bf<RyY3!sLl0+
zvg&M?j3uabkddI1#9~6w%^yk981!Vx4;iV1csb*+ILKPo31n-zjfe_eLS<vS_vf{R
zCI%QBB?FeK3xsN$y6D^KB;i|9^q(f)!*bWEOUM^61I{ojcU9IbF%=4<e9JZu(=Pz8
z4yp?#aT!AE=-z5l7@)S)##JB*<iwj;f?9P61jYO~gF7K;^C*(Mx^5W43MRQvP$QLK
zu`)m-b<y`Jhgnpgl)_ez=@-FF^nsahL3SI)4y)6%n{T<_ZZz2<^DQqFSKf@TeZvZJ
zcETj0G^*A-)0-|xcx(H}fsk}W$gTTFgg-H<eTK}+E<_myU-L;WMk7SP+dd*g^iVs;
zls>^2Vl)G-`5+gf5ws#LJ7Zj%>tafu0PB~|4Z`MsT!cml!CWsAFWlW?a^J@|jM)?j
z>zFG~-=DD!zK_v}9GogclsO?7_=T8F-!97U)g8M|Gho(cS|=1jjM>bp*i4vNwJ2K>
z^Crn*!1}lo!i+7Ws#RpkIg4R6K`;@tIU!=KF=F)J9`HheqL}n%cqbIyyihj%OIUY%
zA*|VCfC{n5wWz5JbW_tvNx#VIlae?PamfpzzJyJ&3xg&wooXeqc@p1*K_r_vk6j9b
z`EN!|VQ<Z#12vmNd6RT8P;rM_>0C5nPM0C{3Zs+@P@9AC%_Bt7iHETiwP9OS7!aHc
z?}Vbw%e={eb)YC%<;+~hx;d6#GC&iBDen`@t+Tps*#!Fid2Np0L=e5O?e+TMhEvJ6
z3$@p2)OLGuF&kEzv*S%-wrv5xo45rs2y9zD;b+?b62gP<XUMGNc4D?|^53`U5XpDA
zqh7}yX7~xnVbCU{8+=h8QX%Yg@5`wb2OG6brlr@SHip6C>w7YYd`rH^LUjG!CzISK
z^joR5DH1^$!e8uq?-LRn5n+OZWtfu4js8eowKtsG(7xZ;OSs?B6)A#2Ig2eP{hEe8
z0cdkZN`a8_?wR4wy%9Ybj-1ifDmDFn#~;<!=GaO?WPL|}qzE1$Yx78Y_(;~hE{Prl
zmMfzo`y~1`4aftln^U6SVYz*xADGhKY~%RDs`|irGH|*2D49G|nCf>8F8Ak0ruu!k
zh|UjElfka)qk&KW+L9l76w^155}4K}rP#}!`e3$~f%NJlQ^+y@sUPi#<G@7L2lAgt
zR!p2T#51zC4CwUChY#w5J@0+8S_40cEGFv1ZxnYUQuC42M<^Y54$*8MT=bD&FBIc0
zFQ*T0b=l1M{^8Z+u_T31p3W#giR@&}0Y@k5Gm4R5=?|v_quxKIVF4%L1FLEUxf9%N
zYY%)g4@oibxQ{7P-l7Cm$Vj+`QY{AQ+Br}TjLvbClXztfW%E<M&x2?Q7JU(=uWpip
zfGQ-k97f7@q=85nB4r$rSOjOUpa~ktZvt&CRE7-;p*)QJ`>Pm3sEkYf`Y0zQ&N|8v
zFZ1uuI2F-HX%qyrx(rk5>ub*FU8oEvaHBz}5o7mzhRxO(#%0cvNwzcC>XdltUvUPm
zddOhZ0Z4-B^&0!&Gr04HM*_La_|Wfn0{d-Q0tLp#M-a<FDKngwtmD#+A{ZF;8Cf|3
z6^|o{XMhWen!yc41k!D=T^Xy@*UQLz!s_zI%IdQ2x%hgabO5*Hajg2lc`|Uh`Y4%#
zRBnDIgv!`0oe|FR*{aX!bf$We#SLPU;Z{a-g&@<P=4*(SOyEFE;97=vNq@k%W+1Iw
zBqU0|Kv$0Di&#=J;`9fnBQl(pu2z3Cx`GI0kSBEAHXG1sn8pDw#Dp2%M1io(lVO@D
zP@P<$MEzN6Aw_|h)B)U%1PQzGvS9iC{DIauZ<`rUrC6%L^6Bm5Zm!8pOoU|;EX!1b
zm@e@e<&+$@hEsxBUt|F;oXc2XC3y>$34+S*KRw-_Yp;3eNTdG*5o90JBv{70@d1<y
zpX4P_4y?{`lyKAsP&QW;LV9kCS0}iLG6u_&d1)UkJ4QF3<vO;B(O_T}!TDf$ZA!W>
zhVBZZ8r$&oZo&wvxQH<!ARIJd^MrtGJBv1lNFMwC7r_Mr!ub+t-E6}#xp}2f^2ULR
zMT`jn!2>5K#{}Hg9E3m~+x!>7c>-d_mq1%2U>$e}s~GOjI6AS4F{Epl^Yu~2bj`AP
z+j$UTy0w)DCT_!UKf{#9n>Bx+xX59H+MKu5ylh}#1#Mtt1I}1P#B?gdt#MJ!%OcXv
zsYuEbs)*PiKVx~XI6E7tux|SFEPLKK=Wv8=-X*p#V846@)DqT4oC#qk3CNVN&DGFx
z(x8rezy^YlM4XuGXWZ6^vz7}Yx0`PvP|SG}+_qE?6oNDzY;i_S%rhn-=gWmg#9;d7
z@^+<-;B~>kvs-XOfFRn<P8lOkCnU{D(X&_+gARfT?;j56K@S3YWT31F_niB-{UA1r
z;BZAB)FjlL&3CWCgk=aJP{LN$MVQftVs@BNbL>NF-#i7vq2`I}5ct9H-5}ZIWVkvR
zHm@HJIz889&8QRsxKsL|Ex9fM#wm|QI(c_K8!caC=H`rUr0zOq9`D@OHXuyoZ#GLS
zkY~QVzYc+@y_D-%E{{WA-huoN=jU&K`uye7=P!RJzf<U>2HbGGWQ%p$g}5Ig4;-Ay
zm~MU0%(-L2lxT_UO(mr26eCjbLD{f0odqb9;YBOobM6@UXDF?d5?nRU5pMHNex{#*
zg89vWTEfnpJ0?;YWOeR+!h(m<8CI|T`#lUUI?O<+bBB!x*6qo7i&R>40=*L3`#+oj
z$*75J-|5`XmrE%p@o4S&{^mw&2~cs3gG%_!x!2(t(moaZaJc=IJj@F-(pwSkId>id
zA}-MlQmD|(HYg+%k6sfq#02KpYu0byWtXiuV6iF>rl;;?GQ$MhV(PgqQ;2u1IBc;B
zGUT3^8unq%{1ZbFPKO8t=Pmj$jeo*SAOn>qpYo;OBu8QZ0xlG3u%|TxXU*u?Ki!|P
zV}85>oaAFIpW<w@SUQ_he@A{-I`7L5>?cU=Nz>@T_5TBs((g?C1?pSRvF-aBF(K(W
zwmQ6$T`lAH?&cgBJGT2X4pmG!0wl_$PMzS0BV1`Cj>sl~#u52v=Mix}B|E5a1eiz!
zg-|a;SmcBvwYt91$qd1Q&NES$^4rWM?=-NNeGwf7q8YkWYinf7SZkV9qRKi6k=#Mx
zC`E>CpVHzq$xK8rCCHAbA_4>Tr|0cZMQOFQpMH>XgDP!4&%8GNFBwQrX)&VBAX`^X
za52o^uoK{|)D(mTY}uS4Q=K(2_~?Tyigpk^Eii=7TR2ngCR@>boD_Tbvx6o&i)n90
z|4e5M+0}>^(=N(FI-AYq(+QSh?3l17x1wC4vbN{JIF-S%7gjq~+9O0!oH$YM;1&|E
zQh8##t(0TH3bd9NGe&<`N7ue9m<(-WyoxL05?P4xssY!Gw=Y3a+Or#+FRfq(lt3GV
zs|KSs7R9@|(`;fN0}xEHj1aCZ7RaJigR&KXd^|{H%@s;oOcSS^y1g1Od$%V5SOooL
z9i?|;Y$Lblhv!bum_1|+SIb!wkO*{h2hS2=2Q{8}1>|_odtpSKp|pBUr|NhwvN=RN
zrmMeaBrCLsuGV`cbcIuAh^KUAHzc8a3+zGQ?sUj8-oy!EKAV9e!j!<Vro@ri;DkhU
z%WpGD1J{?F5FChBM}WQ0(B&G$LA54EM!WSt#M{~vP8ej4Wu!szMhr8R40h$T(k>9S
zPFxhv-Vz2N%$+)sRyaM5|1glxP<jojIYNZn{Ex5lQhVAMr=_daph#Ctj55Six;7_7
zbmgDDjLzovGYtZz%RtREh+oO}hZKh;lr%_a9ndZLAQNiz=6mTC_Ort``Jx7Yc9`Vr
z!`&pMY5@lEbWz1(D|!)>d~-~#ms~Z{Ls<jDF(>XUVFD(885685cQJzJ3ZTGxXBGl|
zmPRQt%)^W_fjJKIc)~yg#TQLa*w?>^&c}I}QYP3I<2(i;AVZ{#{gJC6Ls@cd7r`vh
ztF78(VMEM}-QIneV2;Uq9Pv{%?}_%b`KfSgdzy{-TZ3xLk})K~yfEXr8dOehiybSa
zM)at43WLa~DUw$k9Pa27bLgl{5|g2{%1ubrA4Ry$QH4qL6Zhi}dQ2=~t)~ivHA!Ix
zc}m#LQ_1mtv(X7BJNkr0DSgHoMFy&HxcDB8Gb8z0c0|9Vo=S-w*#3T=>biaO>Gek4
zFxT6;^u(~Ey1v{$oSdV=rH<JtXO5~49B}ZJ`ltQt08EaXfwCgp^G~n`Amo6vJpj>Z
zn)D_C^^3Ff=Pd=LD(p#SE{Z?*0}ZD=GyXN9w|8U|8EkQ50<G_iEXFNk3IYl*=&Mf*
zrBI<r3*H4K3t6FL@R;0sAB@sB-~av7k3W3=^xHrG@TV_NG_-35YfNsC(2hQ|_L&u3
zk{&hdmTt`f`8&H)KFdEt1X;i_MB4~|5d7H$e-fB+P;5Af`Co!?QQo9&s&Ml1L~LMh
z^F*CQk_LTz3Izrn$~Y{An6o^9y?Goz;CI5IjN>T5BRqhzxuB40?w{d5VL+N;%E}88
zYG+!5BmLgo;4DT)LK|J!u+3N8?<X9em|RSm%pg0XL?Wk}Tok7dwtz0CPBO$_eyC-g
zat|WJ3t`FH$h^@#3~4ij);H3N)jBz-gl{wVAwj~Ajb#kzS&4CEiqY+3(3=kk-L9wE
z<h+#~8<|Gg!NG^A>`eUIg6uG_NOokhoz#M5NAd=ev~=?MgkukVW*H%xjo(Xbd*THG
zneuKk?Id6<N5yOldJ|yMQNWumqMOY>riMnwmnG{0l~e$9h%9-<zV{5A6&7n~E;OWT
z;xKv@SnZj#U`CQDgGvjGn0rg3E$I5%Vp~L7I3D&U73Wa0lO_Q##>g2$Z)s}09V`vM
zTR0FRBpwn7G26fW`28O~{grxVzwTKYBhDB?KZcZTHq$X&Y2mC%pMo(4p4dc)tRI8E
zne!0z;fz5B-HN%jiJ6##p___1R423ZEr>ZA`(hNUeGxGi_ew^w+Mjg(`h*h!+1WF}
z2a}ayo>@m23YWqIUD2O(65Clv?8IM0hY@^+F13y|BM7=#=MTs_hIku?7&35HY^-%W
zzuxKV)1amI6SnZr#0C?m?2uJ#SR{hcFL9WTBj{_Jb(EyTTSsgj&Q6*L35NL@LT?@G
z{;$XZtzQraLN0-=+kITo<^bJ^E#Q?NL%J3GLq35c1$&T=ts^D^k3nySoq{Q^gT;Uh
zT#yxWYaKH&2a7%x^NFQd5OcA9B<5l!H3(qoEM`a2tnvdhFPz<&@`aDuks*UW$#^og
zj;gaID-yF*&~ZNP(P8_1U#P6G1NAd>xph?E8FX`-st%p^Cv2L}z*(`OBYwDi_4O}4
z{qXO9{z7HrlaC$k1oW_5Pf|CP*zAxhHg#E>J65rdGKyV(sDx*ynteH$ey5ZXf`Uw{
zSeTV07`M7w-Qwj?>T5Y{3_bfN9CqfX<2W8K4Kh-JNk{^wjpJ$J<s1r?8gGSEX<&`L
z#F-c*t^<?G1dS`7k>uoFju172OliVN62Xs8ls?hV!dHsnfA+Jl`6a*k_9I_OoiuOw
z`ZwSH^5;*_L?>qtv7^3!qKVVNxPJE;1!4KB7oD+L?og$`@rL6-!TLW2RE<bdn8ulB
zeg{aa?2EC|I<~MNt!(pES}V~?&mfVlx&wGJ{VP2AIK?I=Hbg!sz7-|2R{w((fHk}i
zc^BWH2J17=5XX@PrUehNy<YJC>bsD3%_f?yhp>S~;vsMZc^X&%qqF19J%kKHlO(k%
zWcCnRnIZ#I^DkXOK>s2lM^z&>z}}f-19xBcKwQc2m3IvM+$_|n^8*}eNT5`$X+Q@-
zavxnZdRfmmeGR~0GEK7J5|xk|V>^(kVb$r5auBIKlZn@zcp8y$uqQlm_B_m!fc23q
z$q*g0zC?63>r+!lcHC93OSd4&Od4#?hL{sqiTQB?#<@z(qzs^9XzDD+ufBUBx@l$@
zQW%`@*dqd#dJrr10VfSN>Xyan$<zebp+dScn^+bqMoG0WLEQT=la*2yruv^EmO-Jw
z0_~yZ*T4Pp{eOJ<<>x<A_3!EYN<p&)KG7s`K7aV>uYddg4_~}WRUu`WXwE0zAz%~#
zD)tYjuV&CE)@&I%j4FqAEbQ!mN9apI(gM}DQRdjJbzqeFv_SRcXoWU4{J>&25}VrE
zO(Gv673>aQrM>UiJFRU!m>G~dZa^?YSb`G^dtgq)8<X|ENm-E*HRFUmlqA=Npsn$n
z%Lu0Ok3nw<S*+#FMx-;ly#ReuL0UH|96PYf37!$BM^+_f0s4}wEIw#WGq?OJ_{=?1
z+qK6kXlAH6xX+~tsi&IRd}b^u;UvT=oeRvFX1<rtl!p5vBNThOC=-WIR<SS0$b0!r
z84O|Q!Dr&2#5+QNFP~W_Nr>v<`V^;9-Vyry`pj(vo$6>_Y`_Q%4p0JpjS2rT28Ebt
zC-(cFfBNam=byfChDGfPoSnL&Nr?z$q?|>>`Aq$zekS@a?df$9o5?{+e60DjIX>lb
z5G5zbfBwUN_JR?9W}0Z@*hHVCCaMl8qBU*5AQNMgQz;5avLX}sg>J#_;*>-mignkf
zr-JCVWC5~F#bDeVbC5uI!79eg=w5B2f;mLOS(mxeIW-?)!7<RAV~#f0n;6LK<u=@K
z83XJD(w5oRDBWO@x?-E|hbNQjc!PmJ*e}DcQ!gAS{ShFv98X?Zu65zb^sk^#@5#*4
zoZ46a9n5T5XX$yBWP*EMC14LduV<W<dCvpw%K!V)Dfsx3#$8_P-}H(0>u)HsD|Ur`
zQ)410Z$uz5aP)(82h$In99XvN0|u}9rM^c)#PA+bKKs=B8Fv-1n4(m(R)XviG_M5K
zh=O``U_3wRJH1$+k1Qrwu~FWBSj0iBaVlKv!t4SBA4|bo5o=~A{a^`7{{c*GruUmf
z)Lm17Q`smtJ$M}9{(8p$bOif+bk%|n$DL=ua5JGopn45m4J{~O5qwN_U&5kZ%%V91
zjQ~<-j;BNy*;Fl&8Z2yreoAUNjg<^K3fQA}G;<gVC14||i(@Lc3Z<_boUq^%QoHnl
z=rr+W8>wp`Y#z^~POTaS_X+wrsrfXP)O4(|(*L>_>T$qXHCs1Ts5q3n2RWO48Sxbq
zbCIuM4)}yoWI~5wbSemhb3S`I<EK#<(YZO`)7pUT@72{Yn=|ohF<z)Do@Z+{vbs^I
zUChS(q;@fdsg8?8!DUFqY4Colw4A%B=!3^Ds>LHl#n@P~=$0%cR29!Snf9L8muhpB
z=rpX1nW?cpEo$^-Mg5~CLyr^G&A1UcgvO-9>c*`OlV-13d>nhWkI%ByGtQ8`C(Xg&
zB(}m^{ASpLyuelwR}UpRfwxLtvPHJdMVrSn%{d`;q&5*p_F#=;`lL?$$o-7#Pxz@A
z$1)C#V~sXsAb$A#7Y?UI<-ND0D%FW%6CLNX>DhU<;G}2E#u1gVJqhB-^eg}`MuPFN
zv!FIn;xp^rlP`ACf0+2t=JLhGL>kc}#FZKX(Z5b2<f#Dg$*fq>v3!Jr0>C0;1R(sn
zwYe>kY2<R!O=U`bXGmmtuZdc#chq{6s}%td=}a8)ws(bk4r$&>A}C+Br2jB32!I8s
zcEr($9#K0lE$t_9`%C~jdgrYo3ILzcf|!VRvjEbI;^;^g;H3yaV&UjtLBQWr0N}Ap
z0>I!LaJB#~5~J2hVv^_+71Mkh<(bD}KR$KZDCti<&7Br)Hlhk$6cGkvwV56~@jg=#
zNf<+39^$uzg2S|+uD4KkS1hL>C$QrD6?L=+AZd%@5b}dFk45%FppYLZ>!frc9Ok&t
z5}IVylLWPfwby9PWTI~~o6@)?!q>2rCP;l{q!L76i&S!X%9-EUr;&4!>=PV7){Yj4
zQor$;5B!mu){GOopK(Na5pKfNv6P49PmPcTr%cQiruqvfBP@&H0xidyy+})zT8=eB
zE``im#pqMM^S<%T9>=S!mex7XW{4_|qXYwxm>s2Ma;a|l%|5K~+f|`S6hMypD2*Z?
znXo(Kgq_8vr2W-*E{`B=AV?WD+aPR5NWvB+K`>Bp>G?g^50n;fV}Y_?U`u#T$K;Gi
zWq2`s?`$Ha&v*<AlTLYPev%DsVvAV5S%1jKc+mu@%79wJ+Rp2Qu#-G~N>~mel&~zR
z0WWx(46hK@2<h4w)>*CrGxBl%p`fahPRFoBVx~d6K{xB%&c?9LGNP7YZElCcTgPgg
z6wOFyS#5PF?93Dha~-P7OM(tnD^ODWwg3bua~I8;5>u|kyE+8o(l?r0VX3bAh;aE@
zO@ts27NmYoSgS(`VL>A^$f`qq!m1fy!m{WFykJ-|yonCYCSyz9Ug8{8l}Ntkc8J>&
zRnrfw?E&3>H#C``OTR95#%VfZ-795@fbIr^Wby$&MAL!P#swmN5)2DUq*@)x3XVuN
zjRa~!y4UCRSc$k9e1OuH#OYK$M^wiwiLxOSo-O#X*2yYSMp@9wkrs6+3!X@t;R9vC
zwDc)!*o_-^GEh@3QuQjTUB`=*+5ufT*rM^oKF(xH=lpV}1qJZE`U`zv?A|sdKKo6H
zVg&~BlFaZ}1>BsN#$aSxL@Ub={9pZfaZ+@V8@Pie<AxRMUf5sF2=OFjP-vI>plnlD
z$WCw{%>ytu{}qxbocUdZ8MDyI80$C-trmlb7?LNnK8xsl8j1^P9w6c7!$R(ava|{^
zavCg3ALcB>ldlSMq!Q97l%+mQW3whhZn<y8fj6Vt+k&I8UE+)ql!3Dzz{aOO6}g|0
z=aU)G^K5obL$125#<^kI5+K+=mLF<NQ?5_XIzZ<F@!680mE;iju=HhR3v79%Oz|&1
zmz7!6A}*oJ{*0e8o^!<d<j4^mB%X2vLe%Vd3mg$QaX+^iTj2=Xaqm4)0J4K75iy=7
zL#V!7X0;Q#R~2C~(Vo4ta4DdJSY{R7B#B6~O8nlg(OMB>mXUJ+2b{{ljkNZBvqOu-
zEED_>cYB<1kxs^eDkB;rJIOCvtK`<#mSVEVNY!C5g!DU;&_9zA2*NUiHo_ot(MzA|
zXK+bLFY$gwcCYmAR|xqe2e2%%YMihLL~E+X6OXpQBDo%+LsX^+i_#zvKPsHbV#Xri
zYR00e8be4f`a>aV+c0DW2&AEpE=Ge%Nbc8fQaS(+&(1N6x#b(mD*v^}C1U3_9>*8^
z=YXTrPH!+089J*77;4wOLglWa{!At_V1irbKBh=pixP~_11MXh9c-oDT-4hkWl+XI
z8`tP0C}W^q$;KpX#i3BzKpw4<&`zM7aUV_s%~h<sY;JLOC=%dc;VQ-uX5%uP2T&^f
z<l+oDw1_fc^VoF8t6Ib6Ru>A%9`a}roKL4FqgbnKX3JhIPDuHXLw$@!cX4M*#?&<6
zshxuy8W{Sqvnkj@riUAfGHlkFj<Xcn$O)lc23sAZjKpaaX@G+JNk45#AAnyk1of)u
zlc6`qa5`02wb^YKx`xzrw!FyF)dnd(*H8q564Z>Yb@Z`B=jn=;Gfq-wa*)It_$L{&
zHP)!_4pLdAfI+b#r&vS3(CSi5l&e*AV}p|?`gQ$E#M&H9ymLfd&A?e!TNR4;C6g}w
z-&Iztxrs=dyCGt-I{Dy&NxWD~?WxetA;&WgIkv#3c<`!QBm^M}LOq=m*6L6~Sg;(K
zxK0V%oY3j4<7r+>Cy7a>L+~dVsHqM$uS49Hl!AU>vlQ5F5}jVOX1vg3Tr=09x+o<|
zX7fVS0qIEx+B#?TOot}(u2qL{+SLjrxFMa-^msv-GQ7fS34OadG|AO$7C}PSb3;|R
zNQXigjEb58wZ>_tL%2aE6Ia!tE@4G)BrVfPB1c&M)2VT?QVPjZ25P256>afDI+$CD
z?Zp%YE2Czj;gjLejt;4+1Rbi%MOZ^Nf!dmZv#g%#5SWXMs+H9}KO}mitWNz93R8x6
zMTaKSjv<t*i%cS6TmBR8y>Q4h18NC7)gdq)hX@OPD4(gsY1<5MCZ!Mhp*kSUI>f?D
zv78V)=nx22ADyWh^uEqYJ!K#6dX>xHWxd>=KU|(}r{@pnr|Zj0xXQ(-JfnS9R>J&5
zhLA<5C44O*E2}^`Z>@XhQ^mm&U{^8!sWEG_A<))~U)RJKnI=Y*UVNR%_C^*&u+IXE
zW@2Qmv+8-Os(ys7G}-IusGn`SpHZzhfOhe;-w=47%>1^+)91SH#Sp9nqoPiQz41B^
zhqu=uja~c-Bo+*Y6oMv{kab97O<#f3a-p!6NJu+%-%+`(ti4NlwQ`wcjdl}=bkL6M
zQ~8-q=o3%+@EkAwd+2sRaoVUmUq5V*0>&;gIBRONE!v^pSEtK3BfSVSR_7)&Ambve
zP?JS8l)i9EdJ&y3&rPOKor~{T9$_<s3^g#EkzNEDNO-}0EeWS5BxIM#=t3n4d9#Sl
zk?<1snb?V>RT8$Wh?-r!6z=vY7u*oALa+<(LZM)uEp>Sx{Tx?M8AcqX*Vsn(>4g{t
z2xIh>4a1N{jETgJZA*|i3vTl(j+gRlJ8ihVIl16YfP}ZJ1Z<ARr?r;@8(I<qg3u-?
zCj@MDHlK)Ha7uiUyIx~?dQN$eKwBkXOKQA#GupR^F%obx3_BrU%VWGxyWlYNBDg@n
zB0G;0kVE@oX1r&+;3W7eMt^sAnG9U7vblK=@7jzaE}~4>T*RnP%L$vC*YKY0a%B64
zGc=P~+f@QKZxX8e7u3Y#6dXI0F$Ecc_>tg9Py-jy1x*>dkwp?R5CQ4)6#9_hCO?ZH
z6Co^ebW{js<i6-}sE`^RTtpX0ICdnfBy1if)b=ho`n?J=SQ{MAJ?>N(if}r36;#JX
zn32=7sqSkT&Ve}J#5IgS&;_@0WCek<H#ngC012C03H{+09!pm_UnF7pPWxptk-jRB
z&98(C%>_r~H<;rJ&4uTw`a0Zd4;T5gr!)v$c#xM^N^!ruR@m#qR{jd{lyI1x%WL|0
z24pgrn)jg9F>*$#CwO?Md>g@r<%C2v#)c;P5yZ&|n06tYMwMFx=WQU4WA4)ogR!M0
zA*x2z+b~Wfj^|qY9Nr{O=AILY+vebdJwYwo5Di%xRdqIV-mMTBy<jNJ+Z)NCPV<JC
zl_@<{5mTLuGB}yzp2%R!NJ6MOn~BHkpgQ8^tn+NFbCH%UF$obXu2xv&ctXH&QFubY
z&2{)9j4@}6=z<oH1Jy-~Sj{(uTOndaAFv8CL^3#C`GB!$sYz%^xZsri26JX@#^xEU
zjlQ|uKv+F)z9hzgXkj-<d(F)_j9z3gOuN&ztc%VthMUt18n;ErQD1NtGGX>uU#eZ_
z8z)<|6f?Qc9D04hk;nwwDmh!BE5?IpZjX}?GOz^ZgoImO5{x!l+(mSOghy|CjN-tQ
zd$8KGDfi5?1e1d!kqHS`Io*6qxM95D>Wo!dMwnygvI?_#nJ`6nLEF2*oLEL2UreaC
zSw{J~WD<wTb_Kp73E?Y$y?Cc0N6Nj6>yr;DGfdi)b<z1r3cS4S0avk6acImF%Q!aX
z6SZ!xCft2q(Bv+n3u+AqOgO$Mh}$@NxcR)G?d^j!2_H|$_0xe!usS1Ka!=VvQCJ%y
zuLC3Jo?bXAxQ|{2<K{`c#2pwsj}nJdg9*wB0h=QU*)dwzJ}*sX5(s!$e+>a!f)cFE
z+O)aBm=JJWZJiLXd5>UEX4B@Gk8{}*jvFSt9cZi}U~?UzI*3kSk;w@G$982xz*f-;
z$^4!v_D=fAonn3KvP!^~m4y5qry>s%aPrN=2?3ka2%#Vg!A>XaBoGG*k4s>c#yFL8
zSsRR>s4z|zCMd@QggN=(MQ}I8B740N#EHTL+oA|=1M)F{M;E#ZGQ?UqQuqMO=1*e&
zj_!03X0$apT$sR|aJqStc;|#}bP-+P^w^QCa=LkxSZ|ok*=H^#a(W!1uEK0iCDs^t
zl764vNjUw8SCLtMzFiD%1)b_aPS2W_`&G?q2}|@UL;MUf_?7VKVdzYjr4lBJ#<{FS
zE!w{0OC9dwG8c^d6*%lje2j`7v`;Myrl{E=r&|FP>eMFh65F3HIwBdORCJwvcoX+A
z`L1C!Dh6k}9|_?pI?qLL-loiE5Brj4Ft!{dM5*XH7coX%<*CL#$0r1AJ|l#u=sOp|
z1p<!E$iUhe0yfVP%n3TqMU0VvI1`rW?}UKOV+1pT?s5^FCm@c0CD2w0*xW^kQrBkj
zjS9y*I~)Uh0A))?Ld9}6mA~YAaUSdelr0^Jy;1ov{-hL$(^LtptrUp!ju)dJEeVNn
zUvQS_%2=<A_rOu91kC2jQZRI>Kwmt$$b`H1WsG=VT#`uIyLh)sJid=RUFtX7%GHgI
zD#fsBZRFl4N@8ioLF(Aj)O8lw)eX+vGv9#C(&u2=JhscgW|ejyvAh;Gv+D?K1`ZuH
zdWU1=%GeUZ)L@Iq^->rs0Ty+|xXLp|Z>xYqSdRl*iQX*QX^FGASRRsL43mz-Ea6f=
zR9J=C+)2C*!I0@V%<=WyD$M3jsAt799YpLn%%T8~Q?oe~YFhCyK~Imv1dV(^Hk*^7
z%Nzd<psRebue+n}f+5!6AceEtuiIa6E-5*P`MUk34mcUhRqVnxbMNnYPVz^6j<&Dc
zU+RpPc{*7d!T8bh5yQCS#|L4UA3rnPeEgO%`5Pnx4_cADVdeN@WsMlqbH|skKmXxB
zeG6+f<V;dFH)O&YUZgD;ivevZj{3tVEmQ}`e8u^h<mACItH4VWCM+Qcj0Y332+pMd
zSDc<np!JQR#n|$^U<>!`9jKLl?*Olp>9tjq9FZ0W7)&9C$*YtsDE$``FJ?vm6-R5v
z)cuF^^ADf@`04W(C##msEgKBEK8DtN4uFB%6{l>*aEB<H0}n|*PxL<+rC$$^yIEQ`
z{~gkPTph4T%S7kL_H?52&1;9WpCiqkB(xVlR~)i=fX&TihqNE#)kOk^WbBH=HpfwJ
zO9nz{p6?jg*A#N)S(m;~AG5jck{~}6B63_ez{iK2i<|F18r9`Fkv@)=b6t4|j(V3%
zY|#{g0Gug!(G3yCztX=x?qv>7-Zg|JxPTo4v{&HDN2c#72V?#oy9BO0+R`WJqRZKK
z3B(&8j9ZRtNinvM!)%TvmL`rY6$lO-=WHHO=H^*wxX4Q>6hDqra~z_sGQGK$*kFo5
z@FL9UTX6U$q2|QsG~W{EjBxwIB03*X;^a+&ZIy)0xzJfdKF9+!-EYF)#b~HftR5qX
zERJvNJBYyJ=)Ku5van8Kuec}TILdMIGa$D?xutCZ<$EMRILVRFG778#*KWAHr8kMy
zDhXXM#M2Xp45-1_5+EO$n+$6eV-&{2hRL9836PJ>O@_6IGTJ2^<JiyU=7YR#k7*Rd
zLb7Jw#6ma+k-*qup*mQ>u}~#cS=&q|M9Koz$(RIbkxJe^;#^4rZdGBMi=pcCRmLu!
ze1vN<rA4@rsgt3;iSBOB#z(l<#}^V@aa`j8Vs6eR7-`Iv7D*UW8JycV4wIqCG_J3*
zm}F@YX2R*QFBx+hRuTj=jY-lXx}Y|P<J_v(ltD<gCL|1Y8grCIkO>JP3QagYAz^bO
zAqtmdXJ<&`JRQz$B-j=$k7QkG`<2O=1|%$R>ek_}IB1Z-G<EoEomemyoH^aRiI2fg
z@<)A_-wM%JnY7bfxylhma)Qy-ipdO*OFpp>eKpUN52rYfv$jRSxIgTiPY4)guzo;~
z>DE%LV6QQU8*mp(;a-ceZ$5!G5J7{nIlpMGAx>Jw7=kVAoPPjibA8cTgP<&;jHU)#
z=o6F^HaC|Sj5Q{3i{JvA;d}|SMK()kL9sN!R<qvhw1$Dr*h2pR%9c8Xm^$B~u(QC3
zP4o%MF`N7A6s||sDL99M9rOvbRW>)T=WE?pOu-jLG3p7n&?hLvw{Wg#Y8U|r48F*H
zeSCw$72D<$XsZNlt}Y}1n0Fs1;NGy%5U}}^P~yH~>b;20TN><|e}ICULkS*bZG(bw
zz}Q!vfyzE7bgkb|<4DF(u=$bDe|N=%JENf8m2Q{Nhwt79gnnG4A9A?X-u8&JIhE5@
zTD*NR36tLpFLqjXKICx4&g+c2wr!e_sDTb}YxYk8U2uX}Ldbwx!rCSDk+9gwo<WxF
z{(Zv2S_L`23q9{wOwu#FLRcfEI4hBXDtAOwTd3m}k$kNzN590Jr{5N02evQWAQ^Pn
zdYz$5b%=Y)3+{5ag*wD_f==Ft$$3UP%WA7b;k!3iY-`VOE33IRKSkO~bVN)x?17kI
zjx)SVIy6pGo#P=SYQ-aAo9~G!>uke<C9Kt<gs_tWz?86?Bf4^1dek8xN}sS+N<pwQ
zZclY+b37tBbe*Zh4s1V|*(4tTJw3mDc-0R%yxu;Xo-UW`huhQb^7`TaM6IkJt|kdp
z8!&JT$%h=Q`fV;uja)e<$9>_LkUFd~0VtC(!8!!huPDiz^9uFn0}C2r9E$Dx3CwXI
zU+Wy?t3s5F1(QC>Oz*f4qe375>dJD%=51v|xLK6nn`UfAx$w(r3Bl5D`CO%KJaGZl
z9S{XWm^@q7U@et(0nyusZh1#cwN$m?K1d>?QD-G>=3Ytm>~H9WQP}aFQP*nC=~}zT
zBi!b(C}B5-<9@|bR3@61u+{}6gayx+L7ozJb5>XVjEu(%PA0>fgi$!Tk%3YdP+LwT
z`M@vf%tIx1pyrZ;vWi}+9*GOMzI=E?4{#=Xbyp8?zP)|88^REv5=1}X0c0}|SB<YC
z_~CG1#aBrW^vFnWMYw19xsJx_MpY$qY?9w4Z)7MQ4gcN=N^4V_TMA<aS1e%lNoLRm
z!w&~MPQp6*%wL#yB*gkvAEYt-Yom03`Sj^;B}GBL*6#aK$=-H91ha&Nt5r-BSxfT~
z8TV3WWUy_ylNUKGS7q3&$+W&GM$On3obgvprp%~iKwEL{bd}F>1-ym+Q^zhs*z-l$
z)0&~QicCl}o@8Tc=(_o$fD@d@oUYatC3FRAl_8$e6<m?dj(NS=?~1UAJp-k#2!|`L
zhI-(N>ZGF5I#3hTA){vEC__W53yV?>svWYC(**!q?NGbH!bXN|q(QGQA6$_eyM!~M
zDyM6oaRjQeTCNS#{#sLZ%kZuw^w{#6q4XM5TWKTQ=5NBK3zjuAoR+RugA%$<Qs)_6
zw;d8hS5|v3qgZvz@Mbbv?qCOD&P;=9t&y3{bw^5ch1LPx{=PbHEJ=d76Mct~*7Se#
z%}@XJ9e<ede%U_E_(Gp&ycyd<_7iM&CM{V$kA{Lvu&jLaEVg9jnCboX+71fi{;@AQ
zLuX}KEq)N>T4DRuci~<RYjl0VFmY3i>aZ<3K^fC|L%`;zLahM{pNrspP&b)mbk)5s
z0h@~o6^A3MC&KkBc0wlvTt(S@R=A)$uzVt6^Eg1Bu(>&@P;xl3bHaM2+vFQ~s|4Kq
zQ;3tXWVI@bp3gUIbAEu&%`b%|X;-XXEy4_pzVY|&`lf%(XxT}@>1}BCz|?sWom1%B
zWPWs!)3pRa&MCx9SjAWc896<1D{F?k*2Rhs^-dE@YkipLO>VPk!7S{&@gQVz_T?f8
z4R<Xs61d=2uwI#gv+<G5+(NNSAoS%?FJo`gr<@^eF6JaO2=^U(R#S8`H~RMTIAF3Y
zCnT!Ik+99%gwY<U)eTZiOIRCtCWIYZ^f_Uh$2rOIBVl(ZN5aMdw<Ykr@f>t2m(9}<
zjrr%NO6;IRkh*4Kis=RpWG8_qR1xKa;Ll_e^n>7+^X<dM#+?FxaLQTS$(1yTJ5}(*
z;efgQ!x;l{e9qJuhRr{PaEX6!AioL4qkqC4>cowX{ZmCsW-EkAi`ydxZJjr4oldYV
z`X~9IJ3G-3F5wQaRlb52W}s5T&+WFEf^AzE;w=Z(D>HD`K3T&b65|_o{ARc%F}{)i
z;Q~moq>M(Dgj;rleZurF!;A9RHT<Ax8A@;X`3q(#VVj?d<##M-Wk4-qt>I4y3x+R)
zJSFVrqHZ#Q?X3@1TQj_|;vj4sn8ZRdGUc`FK5`qq5&v9%n`8Qb4isV$9d@v0BujOu
zHnm5r%}K?(jM>fw%WA7b(Z^$daE4o1T|0~;(k&^vNe^uxCdhxEn8UL74cl8YlwODG
zXU8Jk=6u4ECn?JeoR1}})uDv2OI5pDm$0==TH<Hvt@VV(dTXDs#)I?Q9?+p$WM)uW
zwYv$i1G;yt+L4bxVb$(*d;RdL(bM^S_gy$*0|v*OMNd+FX8)?*gG_~RDjXBoyvl@P
z9S7*FF!zd1wJuFJi6QyJ8uuzF(9%T1LeO;MhH0|7<pOcr-4F^RSfcDhF%?9g(_<@a
z0<9l2S&W-c3Op>{V4(PkGs0HL3{z_EYj0(-N)}slO`#@&70Qf$)+kwPA07K_3RJDV
ze5X-TWec?VrPEEmY!zq;p+kmuC1S#M$c(sFK?n&1couGRPN9r5+uva6YK?tD*NI9`
z>Dt^9okn64lMvob3A0aEW9+fhIU}P6Otod&OQpP$eyJFH5nU2np|#_>sa&q28ylRo
zXN~$Uw@@BAEdUs+H-@HMnPIb>wi*=O`fN0`a#|H75_RimxasE!J*SsE$~a!aM#qfx
zUW01WWQ1G5FkO8S?}q#E=5)0h6zPhMqZ#5UU0ZT=x=D9skWtXl3~y%TArHtvO*Lrq
zIV!rOK|<?*ZpjB(KUvDkNv-Jw;Sx73-_MuUvUYzveK;G5Bc0ygvSyX9xi5Ma%Xcvp
ztO4PeK+#1ea69UeaLHm+h5Xfb{vOfPz5AF9>0{9e8)Fku8OBdqbuO0HSHz?YJdI5Z
zI3GV@4{QQ$Eq-eC=(6;~$j{xBw)+G$zG*U&n_K_d8X2tAw(r50!){o!%&_gV{<C>!
zwNm)8NF#-?`r#(sl!2Bz(xzU;3A-KV3@3}E(MP1~=B#{RZz`E{!cNWqBpR3!w)v^k
zO?oT?VT*&9Dv}jau*n%6)%<hocKO+b^{o_D0w|H)V*Z)f0o{J*gzb+Rx-<o;U(kwJ
zH&^9*drh5n&T1P$#aJ0zN;BNb>e`eVk%G68j{pT?E;*TT1chJ1%24_UiU*WaA!v>#
z45do-aUhe{I9VM^2n!OPL7oz}WlN+(EDnLNprx50Bq0<wHD{ovI;6I#=#U66>5vfH
zqr>7>ADwlTt0C0&^+eNOGWSK6`@@TIfuz--zu7U9ij#2+wG7Cnf(5)BQz~rcRrecK
zZ2QMFhV1a{x5dbCI3M)sw3L1al8kA8Z~6BPznGQ~aU4TQ@tM(u6!7s44mWI-O|UHn
zQME2z*c`+c)VI&qD881{prL)3$v}YR^p;G8XnAd!g8_w|jTxxaQ`OGNVE-8anGK?0
zh?Zwt9IQdLo+{>~v-x>7sI`?fA_Y&C&T!uL>~-ixd)Nk<QP+Da9R0Rj-#k?a@n^do
zEMcvuN(c+0o<W`x7Ccot`hA<Ndq_MLHbG~g)Kk@N>d0;IR3f}&!iCsg)v=<zN7a*L
z9~w(!K>6j~29#-~s&8n%VQYGJ%9*2rRS-83{BSs^CiD+y4a6kSwj!*?DKMZGGRZK6
zG!Sc{eNe`@#vC8pWE0wr{Zp-}(|t|IrLZi&h|VYZ*d?1_Tl7!$hJrwbEC8=ORzZfw
zN9>dB!<_jixq2urAY6}2fqEK=81chi$qZELpK9}E6vLKDg)3&M?GM0NGdlB6*ovCr
zRx?_=StC;LPdZTRVofgM4e(-E*Yi)<Jei@i%6+=k?}bIU%|C@3PpPgBfLg-N{1f)4
zW{{_Z1^*<|;K4{joYq$+E2UspGf?WEYJ+toANVH`Uh+@r)V!3a2h>EiuQxuje>z|9
zA71MC^viQdq_9IhJLSwj)tihGVT<5<(&OF8D(T<FKW$4N{0Fb@H!O1ZK~4M<e)BD%
z-Pk{ETOTNhc4h#J+l%PDf0~STFZ!o#;R8j^9wY>nt004adI7ymNT@Jp{)sE@oT5<N
z>|sKspbyh%K6XuJpi=)-+c1M2sO3s>o*_)at)m$@Yer}O30qM!+-gQ^H)})+{z-Z@
z12NyB(ub{+8A|V;a46X1PxX3&KAIIGJiPCi6L#jGuq`!%JS8mnC!I?4QVM#I;Z5=<
z?2gVrseh^s){)!bpG0`cKMAot+wp><kIq=j-bAR+pHAnumOs%YX2_qgLp?j?%s*`l
zAn0&ueGe<9{li%U@h<+UR@_N`L-3D9`$bUPz^Fk)LaFGDWNQL<lxeBAMEF6K@ZO^j
z#WLT`17hc70&U=o494xwDG2C$_@dbw05MFNFES`KT_$rMQ0{j{lUd&U-j;g+i~5%f
zGJ~z9N}-^PCF_jK`#ceLA!ZC$gIW6+BT(=}@<G!;%XjcZ`{sO4H|`Bg>Dn@-PzuL7
z_MEOWM}*yphv*89DE+GFjrV0vQxRhgvHLXxrH-gJ&_-s1BNEXiu@zc-u46SVqvo+h
zNj4MEEz_I!INx8+AKr|ICP2_8mYp(lM5ueUj#&~Vk^68sNI3h4v!sWxAp>P&DJ<j}
zXzUk@@eh|ISd#B!GR8mD@$Qpx@UdsA_Yz4X5#Dnwf^%uo{qP95v8&rghma*5*ys?x
z(sG|nfDf`H!{+9hLXw1c8huKl=-p=@kj;{$J5GsO3O3Iaa-`Wxhh3gY5cH!Yow2=h
zvt?%L>%Li1V<CZ`VY^|~x=%|{nNAJwJ{t|UdQC{w0R`JC`(*j@E(CU1!p?wN!cJV1
zKzM|(n`@HeN5X=!%kah=N!U05C9dhtTMSZeZ>~vY_o))wTW>6+_0btixsW5VYodwb
z4_9?fH(H?Mmf#Bf!6|31sg^KVrrAh@!|irWcl?Idao1F9=>#q0NLY?vq<HjAlQjWj
z-&F4;2we#F@seW^op(;yOZfl^x3nol{aAQk1?g*e_sRVCqIas-5JbxmMB|l4AEt3n
zvsvZTJ>lfCaZhroz-BarNVu*x182?Xq=t8A2m@V~%;}C(w-)J^Io)MsJm~V{nbV!e
zcn2uGf0AkMBqQY#I$7RgdIHem5%eW<!p{5?Ll{7w5*GYZI>mg$T6Tsv@lVXg0VwrP
zyu~2%Py9+Hp9nAcr*yRbhK006blCZp*`HL0YG+*tMQS0ESRJBdtYv24MmiK$VBWDY
zF~eP1t<F6nZTZmY&NK+22v*uNyqJgfVmxe;%TRh9sttD$?$$LP0(-p5$beeHS{+IV
z3(fKw<SAh{S41;1Wzxy(JXYE>yqOL`SeSvD=}^62C?-gRmvkr{t-s;bMIYT#jE7%3
zkPS67V|~^j?|Qm?INAEceYVMD7UapjgIHSe9>r9!3IrxVdAom1<8JpY4Coai>Q-W6
zMMwiVlO1>iRJmTq>m8dZ6ImHYdo`D)%5KP|W=kRxbUxa{Udja9Vv)QqASRF@V8&&}
zeZEHVwVa0Vp$~IbC6~>@MH*vA5ng2UVH!{?6LtS^e*X5S&tE=${_=MUL`e8+Yh5s?
z+bW3IQG{0+88~ZDXVD%uCT7G`gUa2Nng56V5O-<E^SX?e8W~;`%$}#hcDW3t_f)m@
zE)uqRs@PG4_0<fhC9L&Sq2u+A{f8OkDPh4==`6Of$9JjWPVJGAQf!jVK&hwV-rtnl
zt$<gBw@5M5G_ZZ?swt}axZ{-_)tUNgXatd*)%ot$_ujE>IXmIZN!6Px_Qk1h!V9rX
zOp*Wr8!0nTR(yNDNv@&TVuchCuVwn647Fn=f+zj^xxm;r)vGD8ry-BRYpz9f-Z$;r
z5YZ)JOQB*n(QH2i+9_;-GYW?7lYLIld=o<<{UciXc-mZL^l528VgFkOD$Sy5Tb(zd
z0zkm|5XoF-WZ<j`o%yD<4FPxj5;ayL1PvoS(dW&RVBcJ8WO$M1J>P__av624auX7D
zL6NY{H-&B@Q((=2TEfnJ6ZRfvkkvQ!2@AeS8uXm?H)Zb(Z)POdvM93<qz1&alBivn
z6w9p}7b>v>y8k)fbfV1*bx{?48tB8TaoXf8p`?_Ne&V0n{Z%<-x=qAfi!GA=_`U$c
zfL8dUK=5Zj`<jpUn{PjI7YKcGh86JZ-+cSapFcg5eKLe0_CZwNhduFN*mRdrH+V2b
z#T`iP3X4b^1jcjiU%&Z(KYsnMzyJR!4v|uvF}T>RmcaP+51;=c2>{OFH!ReRRm7QH
zRR97?vPdQGN%6Z)3Alci*8sA%acsmcib6mg!1rbIJKk-q!VT4ZY>(>$PJF5Xylsr|
z!P6aYIr=Cqhrxnmm{OOD6XO<JEBE=($y{w@*sS57dDPiQwbk&;ki8VkEzstoi07iv
zPK~ihl;K_RsFSH+C!vHy4Nvi?7H;!XzTPX>7lY)<(skxgv3D&Khbdhluab`nd&S3F
znLb^ujF!{)!};Hp1h42W#3Pn^%;2Kp^h*q|{5I1%pj)cf8RNZh^(?E5o^Pcqiod^l
zr&e9p6(#Tor%W8GJ!SJ+bU2omaJVJUWJ&M+h5Me9jR_%JvCztkIeraU0A7Ff#la9f
z=6l#_mq_i{TZ-E&(h;%%uIUEd`sVw;fBNx<&!2w#=O6y`<>{3+Ss9W|hH+`d_GgjT
z+Qt^Oy}6`tQ*SP07U|{vCU*WM)N)p-$J2T_MN0Kd>ZAj;;qqQ?eF6>t?Z@x`@aeBq
zK>Ql*Xg3?h-nl;Hndg)XD7FLs`d)4+rZ6p|!B%9TQr9Un--$=6cTz;p5PjhNR>pK|
z<7d7TJJd4VYU6R(-e|L2H;Flw9xiWa@CqZti#+dTqu5fFp|qBV1W;{E&?W{W$#V#p
z@Dd{fY6&}Yp4hIIL7oy8{1hMG-|5})Vk5(wWTV(MnSoO0S^F*{`M|B{!h%Zd!1n$A
zg`1KlPA}Xx)F!KlwfULQ0%7W@8R;ymtq#TOTWnFws9IUAmOLWmq)2oqo%N&$VGDXP
zyem3{jZ+y)uS2y7E5hA8QV2lt;w1xW32SvIA#4fa1_Ci7Y`uvpv0geDE|)tyEj{oe
zqvK46<UUEcEnm<hbR4dF9m3m|jGD-HbeG9(1Kx{s1WI4(-Znu!KbwSybb1nH&*IN|
zRaGdjyF=&)7MyTMcvb(9#@S+fUB&_{%DtdvTM|K0pE*Arzx>fuE+&yEw$~*v$C2o^
z8zS7<-|<SLPcnnf$9>pcmtb3r`|8GOD(U;H`#auktbz<xlF2Bz!koo=vWmK>T)4cy
z<K0FdrV&5vs>*1W#(K3)E0|MRFw5Y4v#Y7AX5g$jwSFpI-eRj-hFi^PZGMYL!B3?#
zpHjPBRGVI`hpkl^N~_$bI}V7O(6ko%iR&T4$4i(wVXdD^2)pK|x`eH_QpH-P1LAVg
zGbOB%Qf!;d==gtVdz&WNj^j#j&tFkyy_s3`doMGqDl^Tr8BiJ{8_>`U)L1WIvw%oQ
zVv7P~?5Anz-?xW*MBL-y=Z444O6>{{Rhj1=|Bi6?TjNxF!&Z>?w&p=VwK!D=ng?%*
zH!qCM1957cW4@fP{h;LXb_xe2**=CWP_=t2O%Z5(!ke)DhjY|pw;iM2tMFcYf+Z25
z2*kUMeNZj}#FG+iyCX2?@d<WAgh~pxNG_rq;}gDEiC|ldPp~5*oIz(hB8buw3Zcp&
zFcS)UH5Kmd-*H3pqZB^nxNh495pV6o#S~s3Y5C>M0vpf>S=$9t>tb_0N!L+GGO0mm
z%-8VxXO*syY+xTB!MCb&y*!et?euO<Z!ePd4^9)W(;kM5ZF7%9-j+E?-af)SKBAON
zsYjz|?<p!*aNG8VkWsEJZ*Wd;bSv2Abc`>Dv0g4n&<J!Lu4b;u7%$yL@ZOqf)I=OM
zJ?+<YGGI%Jnq%1{b`~)zYc^@)@b!$-0j+UQNHhw<0T=GB&Magno4l@#`2PJbfBX+U
zhrjCJa!HNKt($|}&*MTeiT7j-r{^_ECJjMN^&aB2M-}0f9xLEYB*SZw&%5p<megdj
zwaZ2J;4scq_eIdr?xk$ALqvDg@#hI;tRTDMD6*GyFLOfLg?CGgIWK8nkA>qcLok7D
z7IeiaS`V~G8sU=OTjT8x!;3l2t_96goFOU-lB$0}2ig@^T!&y6Mw9Z!^Xe^#@LCXj
zfLFV|(i6ICeYNrs6!8jbpI5XXli~zaW<lG&2BBD8XR#pVdi3*nc(;fSTUwaY;TBZ&
zFG{+{ppbRr4FtpHCG9OJ6yDct7`j<dwde>GVvx1c1TKqRO*C`Gg4PCkw-}_IJ1hpZ
z`@;Bso%dtg9J~cZUa@zGsYA*u#2|h85Zm#3jOhXM@*j*r?NU$^4lDIfSK~TJ9lmNG
zozFB&Il&IzWl`uWzVuU?9s4WO-><iEGut~hy)*9Fi3TPrc3G(2>%HzG5=WsHSv-cC
zLU`UnN2=w{pJ7WBgSmgk;lTC~7LMTYR_%xkJW5D;A4l2l7)e(M-dQf945tWJY=a^w
z=LHk2atIaE1FIZ{is_mS{IAKmT_%d{g^~#`Cif|HV%2_=Nie11%7!vYYHwGAYB8bw
z#j7R;?pVCS9wH*>x+Uk@x{yM=f@Ka@>$w>%8Sk7J-j#Tz-6s=vy~t13)=CrM_L@n&
z#gIbb1r!77iOm9*LYP3V0c)RF2v~GR`5kYf7+w;v^xGz&Eaki65(k&x!xD$9DX%zi
zBRjCU6tKJvL1x2rk=jt}pNXQ@xS}=`swTXNVAOe0XE`7C6EWOX)U7coBJCkZ$fQ*h
z-jgxBOEz?{YSLyNmh-iHL-Cy9oE<MB8BkAbYC~&f(=M@gC1_=nz7QrPeQWC-yq3aw
z8k2TrL+y63Bz>m5#fE6vgcpyDO%!|5ZE<`3^oBX#>)W+7Tj+G>>-|1%nlcwK@f2Ck
zXP1UXz4^HEl$P@iei!ei_Mg(r0GtbxfsY5ZqzZP2`yfX5g*Q?Apklu5VL}r70hn9N
z3f)b3DYXbQCVSW-MPSa8J=o+B66OasIgH7k_9jjAa8c6RVPEK?UR&tk<ci%cgfMzO
zer@eDQ4M>biY+U60mS6%{b?4cu!o4@u7RqxAw{GRsI1XuG#k87V|dYH?H%u7{|iIu
zMSi-rUYY<GwmXCrAFrtxP)}?YsIaq$LC%PU?G9J#z6r!aLkGi4lD%x1Lk(1|F)q@#
z-6>V&6&G$~2Xqh<7tvwA3!{uCd#!;cV%5k}!cEvR@{U`J88|QM)P@qD-b7uEIwFMw
zzB)cT#6!HSWO!F>2>V|cyQ2-Y)|v>n2cOuogjbggs3$hFp=^3SB^C-M>!Ar+3K=lN
z%WNn~G*TPd0?)OM5udJnM*flI4Lc`%W3qR?zxM;aOPTO;8Ye~#&V^}9mh80~)soWI
z9V+sJT0oEin9rgNu-%EF^SZp3?6vD@@epG<=<d7sK_$r^Hb6ZLv)((aBO8k=cMrP=
zGbVf32}NK|lf8ZyEhLWjDDhq!TW{1hT@HoqL<C1~y}9Bm-}_;N0Jy!p^V?*1v9-w4
zn08_-7C|>$G4AMGzb6&6SBah0xbz}TIL`j$G0F$jBzG0?*ei4mtxt3ok~Jp7@pr$2
zCa>CYm)iR<os_XbhVe+Fd~3KFgHgRwF2)g>m+azk!l4gFS(MLa;cGBzZAuX-1S1>#
z4KiN}M&@(&GUaT{+<V5;)y<nbsrN7y+O6z<W|`P5%Hum`m_nq)_F_pMN9`^UdpyEm
z;~N82qrBT9;pl_9$dp&Coenu)@mhP|hGM88_ju5ltn0c?dYEHJI;YF)r?c}i;(mY_
z_LNDKH|Rn|iSnlSBlUPmyZ><BK_m&5S7C6pSKEuAD@E#^X@NFgI9>6odmob{JO)kd
zvLV!kpy|PFbyOg1scv%M#z=(?H3Zszr1BWI`YB+1FgShw{nsD=^7Xer|53)MU(Vwk
z`ZbwD|C@jR@n8P+&p(wGxLu*w|55h1I8}dl*O!Yz5AWi*VoS{jnC%5rNIUT&a}i}!
zO>C_pC==D}VJak>xJ7#rTu@EW90F}sHG6CdDJNcMtzry$Q#NmI9*E>k-hg^s8qa9$
zqHGdCN!gjb%$cT5t<9n&BOY51PvZ%#UD-~s9m|@sq4*lyTiZ(jY8S{BVd!Y4-8D||
zuAGfvgG8>Dr)%rAh;aKlp^(wzg*DSm&uf-6VdDuyobtLwper5cwwsxhR~NalUy6aM
zNmF}`PGql#oYS?g6KGtI?i?>z8Jj5e<Q@!?CL21I<|bQu^L8E<abK~6jXfbrn4I0&
z?Os)9^<v?{N^m$vJ2ucTP-_X3T{A1RkTD(K;&8>*2?FXj=P{1A1{ayHsCS<<dDBbV
zl%HvSgk2H@+9U`$j6DdAHwo9U33og9_+mGV&TO#tfZ*BAJ#Y;2+OT~0<In&2fBf|G
zfBk=d|9=+3&V@d9&UQVrpTU{TJZnpa8+Wp{hF+!JgOOOf{`?Zsw{Ri3QF^kMUpPv!
z>0nA}>s(M@)IgQyZ`s9Q^Q1!_8EzjDh^C(&$ow32lkE<WYXQPW5Znpv5fA9$m1nHh
zM0i>>g?3-`?GLY#XVj_d_wu7gnU|1b;62pi*r8JT0QMepLd3?q(Z^9fobfhoEGE)!
zilxvF&Ka+s_hEXmCnYvbCfmYMXDSM=*E6AS(k=%l?%HQP{tPY-O<?x`6M4;gS_48v
z+KU^}P3k1WO*5FcE#PxR;+-)8w3&Cicy^FPnzC<{U+>yw$%Hw~aQ03E@$Q|#8_Zic
zsh-%OR1x=DMh;I-SG$~k346cnLTduri`yr;MBD|=#5<+phQMM17_%+Ba$dEaqC*o<
zHOXzSTnSXd9)+u!RB@CR_J&x4_n-Ude6F)||98E7l8oz{Z+`jrAM|AK^;H_YTC>+}
zy#2#gC#E+n%|&<B?vBg3pc!KzevFG?XWF&@y|=TuuLnD;b&aE4V7!Z+(JSC9-X-pn
z?9q(i>Agyum8oY^4pFhGZFPbqFk(|0h~$Sr6-1DIfKdxPWcUy!(fu01$+bR<5E^1S
z-XcB@6RMvNz}x~-2<mu^w+J(yuwk16f%zL5vhjzMj>H~>LUWhh2TuGaI{lWTpWQak
zYc`s*DCu6^gl$CbT5*xWc$A904TQoWH0|0@k4vG+$6anb4l@Zs`$vIJ<UJ6DmKnP@
zIVf^<@<Unn>eS$-!&H+n<<;PHvngyFJn6M%aZ~L=Q%cL%uv`9CN40i#%h!+Hhw<Gv
zZK(Z*L+u?vaWr)-%*96eS6KN#^yj<Z788_T(;{woEd5j~P28u-!@{Q?(V6jPV-Uu%
zIkeNw#t{v5rPyw@+C8{Dfe#b)Z<d(0al+x#3nvzM!v_N=i%fUS`l*EJDwqk}B0gsI
zDmyEP1+e`v3ULh2TW;~in$R&c-thGY?D^U&18z7p-ZgYQekq9tzuw1t?ul*{&sVR=
z{%g1+GYtE*{olX*^7ZFmzUn2Ja9rbHNIlxEzu2^-9>&1;FXMur`T_gj_Wx|(v@0qN
zcB4vRcMGBXumAM_PsOi~<v&wMFAyr$3B9t-`VT*~&^g}x+_HDFdanr&-8EiaX8j-K
zG;Y*QNN^TWhV<i>jbe`JhX>b_qj1QU?Fh-Uj~iZK63Om|b&s*9Na2QbZ7;|?8@}O9
z<_A#r94TCtuI&eLD2bTor!?Un*HhRtqi{!xtqY4fINamjvKi4uJLzdrD0;AmVHIPr
zX1zSzcVAT*$vv)Pa$5-!Y98!Z*hlH24PIO^)ni9*Hymg4*fao^bN^82V6Oth=8t0h
z$y->qU<f8u+EL8S#!`pWqPRrZ405weu+cMO*8;<f&S&Sm>xTDKj9jmlr(3)8Dgn~-
z+E0b!dF!$5ApVSt5DNi;K~9P7u|^(;1Y4mVzG0tOucTuJH5_o*8P^SGsy%%@#t5i-
zu2IPjVlSA}u<g+$H5oUd>JOu+d#s74*Lb1LsGHePIL^F<Yr%olCh8hiBGMjjgjIE&
zflP=P4DX5!g$u3$<!D1~e|d!4BaoCcLmGtLEDWe8*4t1dHe3!4kW*rN96H_jWgE6z
zFuX>r*U}=biO0-rsP&kXf~Q{S3OafxiR~+k=<sffxgBalI0fkJ9oBn<q!POm7&tF#
zABS#NIkk4I;>{t$T}9n)B!g1Ij*pvNs*S3t=Qb#}t$I9JUG4$R#oSM(Z#a|K$rIt0
zt7bbZ3P=uAG<y*-8$%4%Ts?OrZi_Q=$$P6KiIVOQmYwbP@Z$ECO~ehc>mhMNAfj`M
zu1|%jC$a2oHY&C3E#lnTY}Abo&t9=rWgnfZBlh0zb-G{c1(0?*T`rftv-<UN9;f{+
zwxbygK9yVnb*(N5AM6FGS)pi6-MAp?L(YWcZ<fNBH$V6jrXXIws}4uy-a=KVM6f&O
zhzLB)BxPBI32|z)yCeHR>hVXcIPp4^usN?dTL+8yv`~y-Kh7$NgXhP~P=amoWMSL?
z5ieiXHh)B8bCO;gv(0MGZ6ip$epy=q;z2=@&A6k{zU?Is*0L?~h?g$e<__=veY78o
zBUwBL?*Dh6b&0~SKL7fcKbKe1y^Q(+zssJnW(I8~{P0vih|99pyz+xa4Y9B?*mARJ
z!(eYfX{OP8!Fg>yuiYaHlD*2HHN41yW5~a-XNCdw67d0<NCf<CDv^0=R2PZeW)jf{
zE)r1(-6hig3zS@b2Yf7hP!h?r0o@wO+fDtTGxaOwmsCwmX_}NqeZf|oMRa(g%`}=?
zZ9CdmtZh841mxC%L<XX;i-}?LD&mcHtj6Sv;P4<*5xf&&k64Y?E>!BV()LirXlpA{
z{o1n4Nu|LD0ky{>J!~)!zh|^~NX{VpP=30#p|mKF?TjfXOOp9}fq0uG0s+sM3Iu+a
zJ>7ypG|4KGabDD#=fZ<7c~LNP;S<!0A!IhYsf@sa?Awe*5>xs{W!Fl<>;jKd@JeZK
zGSfW=_8qb3$P(<f#$0`mabC$8SDIb1*JA%U96G#aVd%V;V_xmJ?s;`M0m9Av`<Ps^
z74ucRW+5nJzUsjBY<i5D)-|x`Cz{}gbObM12((GM3K)C)Lg}pbg|=&eSR^oX;oR_=
z<pU`DEyQ>cW^E<Mn2ch^YZiiXD(2qU^6d}fS%vG7S*36gGv2ZgXscrGp<paOZ+KO{
ziZNV-;oZtUN>-FOWvpiY?GNKcm~|SYVs;(|&(;|xn%&^&*v(<nV8brLT+0Mw&<E3b
zc5}LA6JRw!wk_ym)bC9s#ckWvV=!z;n;Bk=I(tb9p06`<z55m<)lo;dwd4@E<KTfE
z_e_NDiJfOD6+-<q2010R#~S%8b?t%J;{^iVoiR`~*|4{VhWu1sN!MeHfYQW6l8rjr
zIQa9mH4x5(@MxW(qbAhO>Vv2ifE6=CbJ@E!S}lt@vmv~%V7RNO+YLxW+T+dXW(WGC
zsP&+Jf_KG+aH}>$IoeQb_>6G%uv6=jF%7boy9v-^HWcnIhC|zw*dB+3Sj#C#EiL~#
z!Apv4ygOq&W;UcfS*DjaQ(mzldSl`mqxM~=w;}Mh3>~+jT0=xp_b?>Alp}RXt>Z<V
z+7Nsi!`(z(0Y#+s5lS4gv-*G+nAs<DUM%C`IYSw2XfF=6{o?{RWWw3b2TyDkhwu`D
zK~9N<I8>)uM@2XuhwxU7fl6%%;*d^ee_w1!k&a@=rm0Nqt@hD=^#A^+KYsnEm-`pF
zX8O%ffBMIN`ueh6IqA&N<t`hi+sx7Z;#iTW2%d#KBCCfn1617AO<49-9?|a0<%f0{
z0md(H<t>5am^Z_F76#L6bj_H9^|j6!QRh%H;i3rr2E2gQ$Oq4Gy5X$_0kmB}x2q2a
zMgYi&al4^&B9VVB;UJ~Q)#$Or#H$~IZ?QsZ9dLqI28->Xiw+0v1ua_C-dJzq4GV!h
zuQy@E!*~s5El>vu9STmoU?JF6>FjYTT!XnLx<v|!)XNvtC*6mcRh-t)Rx+n>4Q6-A
zDVN?<!0|FrG}hbI1Ig{}GF!ogv<_Rn7>7P2Ww9Rjku%&iB;kOzD~_#wNE6T-oiw#}
zvXsnutjAjfhSGb+)2&@dIDaHJ6}7ibi492<wtD5nX0aYGWf<g)*w*_dUg=gZA_f<V
z-E<5u$(QlMj)AJNzTNo+`mBSkO4~wwBYX6g*vYbp4p(P0bkv4yww2gW>(deg4{05?
zdNFXvYzVJ@815?Sw!<;93Z;>9FrKnoJK0BVD9P%B4eh1(+rkLxaUOLNd~;50YD4g8
z4-s1*L2XEjl7JUTVR(rR;T<FcmD&(gM{O|s)-SXmsJvSz+@jdCd|6VF6He)$znnka
zYQ}uNehE!l>I3R`v&YPGX6xdsu0l`xB&9MF2tp{HBz;U^Mm`7%NQTZU^IocKOT#r9
zgadrtpPqtp32Myt@OF&AoM(IO^#kI-!qGi;Q|;@mLpRRZ;4K-!wwUd0D<>oq7@PsN
zRqcaBx!%`Ci%D*GZ_~IX%5OU&!of23P_1H0bd80jI}UVuY}<)l;47(#4n-wHFfm|@
zN_QOO^gy?$B!#zFXoyPK;<C@>G_$*BZ?N@-e7f6ExP^NUw;H)vOW+m42*c@lO@fjk
z_z16CP_n0wydDlpCdCOT3rcr;aWZ3X3rbaW<%EU4E7dy1Qpf158jsAGtDzQzqvT%F
zs*J^JhZG*W-f~I%+GuP@JKYt*gw$$5?Q)~!bsp$;Tz9wj{-BvqH8Q*lcM11nbH(yh
z)vhDlevlXPWn5X#aLz1<@Cts8sYAx=wl+eZM$LZYb#2#z*U@BMU1mYBKEV`6j*u$X
z0Ufj%F*Z@^Sz7ny{^^Fj_wR3SpWf?^QQ4tBzFpZoz(l7>TIY1SwaZCLT|-BCOg1`n
z!v?(l$Miw~Pt7#LM*~RfJjNcmLVbdLkNcQh-W0OBdoqX~vN{j0$ElEVYNuH0Ssl0`
zsk=WseeN;#5ET+nY*Ab!Fr47s@m6JD%vqLaZGR;Wgv=9L%=S?_)eA@C!~G_WQSGcf
z_)-NRE+Y<4->|WaVe`H;i&1#Zz^JUgwB2Atpb(>M!a8`XC&Z|1GTqzt>E4dyBitUN
z#ODm<1~#1K#QHQZ1}VItc!bz(v|k>F1}SVkV|e4)!yPZs7^oVg>}AO$&C{<`wG>c#
z-y`1J$PR2iFG!7Bu*(K)SrAxW4fgW(9_GXD*#?L#M!`Y=V=QFY*tE7v{Zm4dez6H4
zG{WF5<tiw!O`;EB6ZXB`dXy@;br!|0{Tucs?L(PHB0Nne(DsiPJjNc0B3)1==@-CV
zrnz6|-|;+};OTdn_jbmuzNhh3Y7JpbtE6Bla6Yg~*4RdA-#W?5yobchr$JPa_R>gJ
zsov`(WXR_6#R-oCPLlXVz&-qgR1NzKA4gf3`Z%pU>V%vPJCKf`oNslz>&fIYZV`1A
zyi?ku5v|ef+aHEhuKvybcWnFf?l@oG&9hVh?5&IPucKx9RI2XJyW3cDjZ#gE^;7j>
zMl-|Cz9%w`hm^!G41Vf#ZwH={>E1awq@(q3)|jrE=03e}Vn>>u6JdJp|5K*zVf?3x
z&O93Wr)wkccwD%|G#*qm{ZO6mN2o&=gwQniN}$uWv6pC{%?x@@<b#0|0zPM2AI5*G
zFb!~@snZaV2-v98_4LnaoibfTAR0KN+rmg<<$e9;9jASr`>3y|ba}jd@I2GXsisjH
zTW+67HJ*$uQOyiosqW_j<E|iKBr$WKy2eu{$>Klk%*^Ybd~o^oiDR-&r~97Tn&ie$
z#kU3!PQDYP!~L61CF&-P>e|W~ni*>OL36?KgFdAHR<R{en<D~tSt1@B66k~F?4@DW
z5m>5!IreqhEigy3fwa}m(L5mV5CqVcwzh-0QSz@P3E&n1UgB}W=6-RNu$sOIVHXi_
zo1F|fAvVxH4*4lLp>?>bjAK#=_WC$X&}Sm~Rc5Qd5oU)3@coAUrjNrM_1PzTi!foq
z$B;b<%)_0ucRUJW+|k249jh!SDCHgp^NrTsTKwo}&e$T$IGmm4$<C)wZ*B+GJsa(;
z$9Z~&NTK%B=wu{>qmR&l3jW7F*7+YiDIrX5{-+(fIQF!;QY1)|A8a>e)ZsPA&M?~j
z*o>rbQj>ItvV>n-&{51;&e-Jl3~^XOa`S6LzWeb%e)+erqB4J$&A<O5uO9vE<?Rm{
ziM;U)kkDKASlsvJtuax(kZ}>^4feUuvXeQUP%}_P@rswOPCIg`;l@CjQ58n*xN(Sv
z*pRr7&L1@GO$3}T{VL4fQ2h4g)2Vehord=l8~Xj!r!IuyiHa)B7P6{%f@^@}YVvHw
zL+&o+z9%!GZYlR2Cqumlt7)NV_i$$}f|<vezKHwY&I_Hqi%;aoVz@I!wP<rRUu*}F
zQ#w5EAxa01rap^<F|JCN&38NP$k><rxKu#21neM{Jv(V#$|4ondv~vsr4o6Zk;wlj
zAF!{gD-u%9!spHtp|~o&>y%1eT~EQS&*wk<-FlW0^d|n3jjlTJV|hjx-NcWhkoWC$
z>m&l_ZPM7Uxi4@JW}b9Ua+(IHc!<{TTh7;ITuF<CmrxIc=3(H;oTrBd?tIQujSOlg
z4OZFpAi!ui#_sEVo}w%E@aE2BmAP72l~Z?NPQ%GdC<e4=c1OeP_RT|^+bn1p+Uv$#
znPuW_y7<bT$C;ZO`6_cg^vWpHy-wkUj2gRV7XimEh-CgUyr`%ftJ+58nB0$to>?#m
zOCp?Du{xL<L@O}{gOJk}kt^|!@~;n+aek!gjwKdBw<^`Gh%2td>XDalwqQLR)gl(<
z8k;k)qS=ScnlqZMh=6-LiA0Ja<B<QiRM16FliZnP9qax^N@!#rQnA+}L9h>ZXZ4TJ
z>G*ON4wzd-G3wjhrfYn>ln<T<<96!V79_?`wQ%fG2ca5{XO3t@Mm1Q*zK-<mf_EHr
zLqA~n>^^+(@4`spu(wlBoKEW>Uvd;SktY8-ceOdy%v;3Pb?{r(N$dPpi2H*gwO0e(
zTN*J+T;h>^=UDQ&9=|6F9TTY)p<6mu&r_Ul=;6H#+}`^T%xDtH)F0Sd%cMt+DtY09
z=e?e(0<c6=)M}nJhGXwWi7KjPhgCPrv9~>vM=k<~{Ay9OF>+(3M+7;I+<ji4pbqFD
zIbB3IHZX>y&YQ(r!0gi(dYUu3#L@b}PVErO+v)i09?+IHw&j0=4$2Xdh)vU-Ko>Z;
zRk}js2qvFIn5%@TOVi`8Q&B#{J02FugMj0I95OujKIAmR=t)tS@3e;GG!X(hpTA(F
zWT42AvHTGpCpLR7DTLkRD4#=IlmC~bKmG{OH-MhsK3(v{SU$}~_}L!g3U@zwvC~HR
zHErh(j$2luw$AqYwI%ZCiK)Heanx^}G&m@Qc@{Kivq05SHb518^?!&57|v7V|G}3q
zCH4aFXShTF&Lt-Tn1_fJ0a&1rhiLhp3Bdk&aCO+I&K@*$m{!?ORHUB$YH8FiAe`d&
z0<@}|y!)?8DX0f{)<tw#|0^|8=!QLiG1~Nvm)0z=$>-4AAnbyRV%WTjcpDvGH6fqo
zyyjd*@OPOX(i<Roj_R-_+TcT}jq3j@#;P8&*{HREk3v93*@NbnFfvFCE{H+)g_r#P
z<~0%fdu`U$i-Umkkkj-w8wG-h=WB~A+KENv0;!$W@_c$b*9Fr43*wOc4!DSYfxw?s
zU6>$@HapP1`N}U<XPS_L7!ub>Jc_;uZGw*4taZ$*UmvilqtmDpusKJZUCm`Ss~5l(
zcB&%43NwJJBGzah9;(=^y)CZ%V27PGuGW7Z+`4Xu>CobXF4-(NUj{kYZ1wAdzY)Ni
zDi(o+bDm?HYEqj$;6zb)?CBN+(wu028=A&hd)iU+u-ARjX3@+U!pvs3^)O<p7X0Oh
zraa&t-d$_?K00#T7Pqd&F&R7~WzSKpTQuJFdttuNy6sD)W_f3cXGXp}kb0&-H^iIC
z1C?ZP?_yQHY;FK}g(ttfX}_GR*YvpL`LJYWXs@Y%wD0)ZwVnK;rgB3PtAwa+g~wlt
z5TBFB2Wuj78y<g4HipOFBFAvaAWv2P=wpxH@)xhp;A|h3KGtCA<F{hYRrV_VEf@`F
zA)>?cGo}UUE5>lR7n&=#<BKnLF#v1{3}A~qXgj`;U#y~Z4>??`i?NEzx55LyNB*@~
zNFI~sN{Iy{0qd30Ch7;PQK?j8m5B7EI1}@ZVyP~S%Krd2LcVQ9Lc~2)bKX~ca;@Gx
zirT#S@M=G$dNTDZKhT6xM?diEHibCZxf2LVT<YBLH-%`M-CV@~_6O;#sM98%Px)6c
z_<h6lVBk-P2!?XMTAKr;0<Z3=+-}zg{Qf0W{b5!Dc(Qgc2TcPL(#p^M&R<$2cCgA!
zvM@p&*dx1phGW0_t^4p6nQOx=WjaVcQ|q#q!Iiz+>`DEueZj^A!t*(|wpGBjbd=NQ
zP_yHR#v;t|Y+N{i;7T-dob4B*tiih|Vw))ubmO?9n@m|m=g-Ck+uWD0QrKg*_!H+6
z<pJOu7C{mUp$<DvVKs80Fw_$`7_x{iPzYg)U|XfI%3MGW7sNs#e8VD0Lg73)O|-Db
zzpw!Kt`j#0P1&_Hh!#G@XSesw35CH^<5bEbg<~6oz?{dqRY~{I658k8RL&yIC}|7^
zL?IJNYkbl3vLXF`w}GFJN&47m<X&{fZ9SvE!Eu|%DV#@^IfdKW9ytjeydl00Y!Th)
zZ<2Y$MJ;TzJ(3@WxU#lo#|3Aih2ZxOYoSf+=#g9qC=cx02^7x5$ts0CuE?3fC};SF
ziJZ$f?Vl&0(;^i5+NF6vmot_OqP@{iBt1ly^B45p<Qukn#oj79oHLf%f(_2eze2<!
zpBw6xE$7kCq-PXsYl2*Yh}K46L^FmB{r7DbP_$x*r4#AOdtd+XQ`@#Rggmq{0&Sv#
z4x=)q-a2R?#MD)cp(H?C`vA%w@uD$9NL@r3T@5a|A}A9v_kb6S7)QPq!Hu2<m6kwT
z6!W(DXRzRRn}InNlL>*K&jjV1z&8I>>iEG6;waUl1cDk9XsZP3F-NhJkQw4M+9F0m
zAgD1xnGo2kr{TO;qzgfG5!|SOsKf-?DuF%Lg{%;VeHJlB0+XS&guq@qg>wd+by@@$
z2%P7Fs|0QpR0t<HjI#)mFnIKo0pp0x+h`mK+2A9qeTHC%YWx8m>|rFHGT^A!;}k;D
zMqnmN*yBh%WzfUeV@^6~;XI>S)WYplIG!>*undQ2;YT8gy)I3)Focpv7RZcR_>@p$
zZ}3x)A(lL_dxcQ=kyz43+2jl)1QVQxTeOi;3sI4Yg{*2}4<>ReJERN`tlWqcqAC-Z
zb3=wr8zG$Frj17_d`dX60k)!r@r*&=kC%EIS193gEfLoAtQ45`KE8q_M7BqkYYbM4
zPeY(hRL)`CVn@(8u(w5-5{;YtmZ)(KTn`<gKEh$IMR37p;rSjXu#LKro*W#PTf`U%
z#0MoP=LFg%b<x03AK~cPBDj%2d_DqgQ3Gv0y<iNn4W~R-F@{ndAM^t#do2=z8%~ow
zj&h!*u5#G}NC<M-G7W5GYezGYODMZOz-2E>LX^X~!pFIsr>m=6_QE7YI~;0z9Oc7_
zE4s)wjwg9d2r@X-w+NH?pQDMZL$^hjP(I<#ibZt60nLNUs-Sz6iRIJc1`9mUBoxjA
z&D@2zaXS%kIEM>Ed(dWKZFDY~3BSJAX3@S=kIb7q1wiRXVe@$MuaLYwC`_dKao^G=
zI0bEKP^oC+y(f-@t^yA35TE)3kb7u}r3sD?J`VFKvBln&SK@RmPH>WN5oR<Kd{)9{
zVkSMNNLT$(I^o#fBD&Gj-~$qDi=L*9EwbX|fjtrNA|9Xg12FsLNxTA`ZH%zqT68%l
zTt7enZ5?nn1zGRWY(<2sTJbm<M1oMksjdn&8t^>0t%|h=5E(l8tH1iJ5Bj&i{=RIt
z6BlIgKmYBofBV-jUxb~rvGRTLt7rLDr^r`p+D;2tcmEu8<dh9x`e}rkP{Naxd9DgY
z=edTcB>yWJA6m&YPirryYg-R?QT7(Lq5ct+4@9g{e@^<2uPP9t-V^<4Dz01>D9Ytf
z0SQWQ-HTct9P0@O*$K+%SRJ??orc0kz(F;z2yXDJC(TkmPGFUPSiCM6p%z%h7{&as
zn{Z6_5H*xNf^w_{Fp<-T^IjEv9}#Hxswa4ZUvot2RlgJq*80Y~RryzV)W`XHI4^g6
z^)PgQ5ud3}_GN7L6vXgl4<k+{2v!YQUA;0q99RiVklEuf!L<^>ufpu{YAh+PZj|D2
znBZF<hiSd|%4YE1I8(9+Gx|k&`aVZNV9x!bO^hhI;I(yl;9#8gr@JSer1-F7R3I8z
z#tKLz4Nt#FVN52pBm3hpdyE+?Ac6TnkO>YPhx3V~7wtx&7@NU^BN30Y3C{NeFngRC
zOCezs0?i^!VmIJ%3CzT9H0%_+882uA9X$Ucx-p^9nd*-#WDh-K1tcKh=@&sp3UL*{
zaSD5wk$Ph&5%BpJ(Tx=92>r(?>_JAFK*yr!RHyT|qG)&w<Y)CUg4Ji!@Vk{xg=dwH
zLNTi!$wsCYQ4&=ElUz{+53UzDK@*hXD#k@{K@-3p3ABB;=`r^5CX|XenZ1fJiWv;@
z11Nh83dx4fd>>>oqJ;eK11Ni?6Os<p_C+qEGU9YSK^a`T7jzFip;W{r0gK>9WlV+y
zSCz4cpW%k=`sK)~hrJuJQ}XJ&Rg^vcghV4-^gvEmh?pVwJ1*uPeuk4)p%9e(Q87cl
zN1&||*rU&QEq1jb(vO;R7!CJ#DT^@MJgc0k5BFmN6KcIhE{UK&5?pLXm6x-q=Zolq
zK|dwBY+E5>F^dDHiy#Sw^YAiviHg9IhY(h9#B>o|pb+fsabr;+1~Nny)bmA<k;0>c
zcP^^f4g}T05LOm9A>j4wNa4eScOGO9E3tybr2&sqI6qQJw6KSh@#;?845;@ax<KJP
znymW59#&%6iUX$mAl(^hGQkxIvv(0%&Tq>Eip~v971uAQ%llCL9n5gHlZ>xT_(F`^
zK7kNAP^T9$5~H2_mN|j;3Qeu@$D-+h)d8cz9eWXAO_|FT*2xjLUzgx0>B9u#z%6mk
z34#0N$ODT50)caHvZ{gm#mEEe1EK~dqksv4`^5+jVJ=EH5cqJG>NK!NjZloB`&z_E
z2rL}zpX4M2_Mj1J5OiRR-~xg3#B@~yd&~%>h)(ew%kl|<^At59a8iSy2YZx32;9WI
zEHVfi140-<2et^3Q23EBvTY0)Tl218aE5si-Kc~Qj{v$jvTY2A6$rYpMUaugqceaW
zT@NI3eKDM};uP~Dx<KJmB8dXosX%auc@ZR`aGs*h4S8D>5O2|Nj(J1(&5!@{r$7Jc
z=bwK6Pk;J{uP-;hNBn%k$xvdtQm*_goluglz-!=q?y}9`$BbUz6?n|^1*twIytS7W
z%ISuzyt1b*uUiOe2%c=?aC^_=(vcPpv=UAe3HLY>FQxD`p^NAOo%1lV>Z*G@iI-C7
z$@W3I0_o^1*h%MI#Yjub(l&S>3MBMa`%tC@63#RdSx)$J82jBwh-{C{--i=@ZH(T}
zu2xa@DkR+CJYxd?gu{)5%V-yl!X7-r)eVj=KPu*Vdb&zruR=n6LqEHUF^c)&Ow}>j
z%aL%zhMsE?Wejl1G+-j;UWbGewg*P=NAHKTjzj}j#oWu0P%A0V#{wQ9@Mxauq}$_1
zsFfZVz#j=rMgUg{?BOE>V4PlF)WFyZ^zbyG3oI~*A0i7ztVNhn&dE67+)!W;Kg1La
zT8rp{pyyfYqM%_AKZF#FS&JYEh4bt%p|FRPSS?|!T0|Epd`e8Q7s%?JLkKF*7{ou}
zoFnmx357kDj7ul4UvOakQ3@Z<R?#JHgZQy%!eF%sl4v1R4aX_$(Inp2V7yvH7qoC5
zOjZrKN0nIQ;TvK1LArz=N8XkQYh!>V;n(le3O%@G3{U$|rU`#C`ZeJTF>a&y!8v1a
zTErMNE*S!gM(e=!Y9u)25R#z#-%bF$9Ow4Ab^o_<Grjp}SjsAZYkevFScpF|Z$I2^
zJv@PSY5<G2wKuPpr3z<x4MLfZ8DB~*zXfq<QK&I((TRhHsyGL@7a<{oeqivPsNUS6
zB&yfrMM#}74y{t?B`(YJr<V+?w%bdPkU>9V+Ftf(J_ThD8zF~&#<0CC)SseE#Jq)z
z=%Yb@9+mUM$*D7xUWLStC;hz-)^W08^#c?(q;g^zymXkJ2QO`}Mno@t4kKN@L9Bb}
zGrW;TTwQ(NjQ}Wanho2_zk-%LD$Iw|<c6@gX&AN_KW&dJ2fX2g12d0Bz`+HcaWd_2
z`eN@r=1oMHd@Q0H^1U<8pb>0~J`g7CgQLdWV-@6hlqDm8Q`=aD*~3XpOELT}!i<tm
zhVkZJuq8cWLBU5qGGjkPI~+XwfTVjIiT4edkW45n!rI-CEtf@8NxKc%XPpF-+}`Dh
zYTrGgj5iKv`=kB5sc*<Ww;43|=`#Ie7{B*9sQfE9H$rgSkPSYwq8dI^{1oW@KBdlm
zi)tTgojB_NSiK!-Z)}b2V<*g(_Myy*B?%H!X!}--7!8OPbYrpPmNu+n488^@c!(TV
zQSMevZjZqt%IIovf`_0CuEtZ?uWrWM5x2fz5!@J4aDInCTP3g`w~Yr`Zh65XMnd2`
zD@+LNRnwR<xSa)y-~xejAGk_jk9K2a=av_&VvKh3XeQ=Wv6oL{=3wt7`)F2;^E*Tt
z6EXK_H`aExpx_v|Am;Mv`+;ax%steNS%YmJIEInf$p_*|-F=|h>sZ;HFj?A^aNdA&
zPR6`?1IpRn$ZDy9Q#csTA1kF3=13c)X+K90>QiEz0<jo(lKRA^ZC=8?!wGYaMZi(Q
zIInZqL|T%hb)WCjl9wlM3ciSLq!Xug2)0EVX?dc64E`Du&Q*}X7vj9m2VnN75^f$&
znx!4H<#1$p#=)Hr!0dq~TtS>37}F;(pAuOVirG-`-U7V4-hH9Fyc#Dt2zN1%=!lQy
z)hGQv#S-1%=wIP<M%zHXcQ9~5g232LXWEoSsb0<vi&QT!*OQhAW36$*?0lb-X@ZX<
zCIsBXS{pzq-VBHdPN3UB#!E<4F->2E8|)TGIvxkCP!w=TRWVI}93}YC51{N7N$`P~
zu`i;GVFaf;2+FyE*jj~>D1>D7kx~2M>;s272((4LR3Iwmkg7go(Eg0m9Unm1gGlgt
z&lt2n<9r7}nTWZEj*zTkqQ0nuW3qtL9R%8{n0rMMCa_P>n6y9RfX4@5_Sz)eN1PrQ
zwU1F4Cp|s@vzI55DGvGJ14H-G?cl5jftl!I$<{5@gaCu3#)ArplO6=yqC&!~eTXlZ
zyDx$y6wc$zoI;qj4{-&v_eFH0P2;4;2Po_ZUNN)A+<g^fNF;F9;{z~@AWR)Yh{4=_
z5hjsz@ooD@4vD0DWC_<Nrw69(gQOuR{{V$O!h~Ct(<4LoQPN|+?ypBzZMp}UaF23Y
z9J?>yw11C+!wiH?e~;3JB3!LdQgMZ%3K{QFaB_ou!*-9Nb13p5?$gUXieen<kn<VG
zR><eZdlam0&h{u{q*>b);0i5l!6z`Hspx2iJf`y2qh6@@u#Q}`<Iz&E@18)LsG!5R
z#lDd)tm9TO21CIH{KrwYGPYE%L;8TF@FL3S5wQiIpqz_&TNV(q2dpd?!38lte3Xb{
zRv>D^A$fSlvVb$T;2$Tj2fUCwU^)39f!KCWpe@=-n|mjvDb|&%7=xW)`~3${_P7@^
z2dpa>QARt#{(FKlv6CL{LQRV0<RZAyPO$l&KwA}auctz3igo2G#wg~84>g@N_rMa1
zQ>-f&VG=nX%@7^BEu@6I`A|;6Ij43H`g2a~WhX-2&N<t=>NLA(VC10xBI%3m2pHoA
zR*Z{01(ka^S8WJOmf)5IoX`5m(uEfMG?tO8fTR9BC7Qs>fZ(woSQ!vc9k3^#$bHe6
z6^aJESnpv)xyWWT6Ku;TFz4<NmIef8jfLbQx=}epSN?K^;*_%olvwTY-2wA^(x8yo
zvri~om2?j+vEF-RpFo89a5IKuvqzU$@4Z1qxhnDq^C{s)p{U)A^`3Yua3K3IT@8hA
zN+TkUR-#?~wT5bCBk4uM(sLim^r{M5wh6R}_94brI7_@4qYM_{s~Ce+L+kdkDLa(?
z<|oups-qvhR>rpO4{+Jf=t42|z&?Q(S+JM;11NjN62kNYiv?m}!Jck{a&9th>q>Yd
z>D6s+Syjj377aVO3A9y{>2W38^x?V2D#mCs^8|JkWe+PMLgTr{<0v0aAe~|Ns1oWb
zJl9x6Nt6*H6OnkLjJ;F|1=Yt_3!Jetnm}6>^H#8ggE~Cec$C2lc1;tQa|U6hKnO2*
zwy}tA$P+IQPnMlg2Vt{7h%R`vu?liD=u0wMwkT=XEfB&Bo^33`47PH?7oHuLbdM^r
z`orUmMRY;Z59hE>(%bz{sQn(;Ef6B~1z&kaC|s3v4=}Ozdtk``k@P&mBsSdxOKhHd
zV7ow&^i$$WJ5!OgHUt(tm|0cFXw&n+vMT8wVPfrfe9gcGn`w#q1-V}A&2Dz%v%hBG
zghv{yjQP~-f}OMk+CE<n<Nlg~6P{<RVhmEnR@x7s+^<&fWMdyCmY^5yb)4LIpUb|&
z>e$K=;swT`PWpXX4u|XjPcQbN%u3J;He4Q~%VFF?$5?_sW6i(?`z$|zvd4~)B&@9&
za6-j)JBI1UzyI@3|K<GU*T4My^{1b|{?8)f^QE=#MJe}y5i$b}f0Od~w?F?`mSz6x
z^MC)-AHV+7%lq}y{a2rV^V6UH@t?lFT;4yu|H`8-lG<0rzx(Tov(~{8XAd3nFv@2T
zIC%d|DgUp3`1;dd<gJv$iq8x7;W2LgyQc(6WiP_*#Yw1?vy}s$*4yR&=``cDAovKc
zJ&efHD93@<!$)5iY^h~5idRvktj;d7*DI5zxkZJQ>k%CuW$jDdt0FuQL&puM@)WSP
z$$E0^fCpF%o0oKEKuOln45%tz#JNS5i_HfGDvRw+>>U@n?imoa<S}kX18VJk5pF*a
z3nwLbmX*_*84z|lGQ=sbJp`RE)(#kWE$%Ai)vGA@G6pI$plv6C*o|tg7?5!t(18PC
zY?{;^I_$<{=%@j;cj`n*S05T*1AWT&5*#uhY;|O)tDxJPi6TyjK=$sPKqW|RpGr%M
zb`7X}%fz1t1FGyrxIF@eDkj@i;Au?_2o&fcULgY6BuwBH9QHo1UPZx|F;J-iK?E|*
zEe51q59r(`rB!tBKnxu>pq&V005nk_&l=tSB!<mPI*CBoN61h&1KNo|21aoTmCA3R
z5~Rl9u0$YgjAJNA18O~XqXF4gCxsijP0o1U#ejNVGYi6wLk2k|7D7;+81vnNZoLx2
z%bYwoGX^TLAp6QD?G}QJ>>zgVAdBd*L5`uL7NjkI1@}<u_GM0T<TIW%yNyr`oELRs
zLfCZ3U{^`Ew#5h(Vvx1w1uj8s4DON%9gIQR2}pVEF(}NxxaCU>sOL2`AyA=*h=m}e
zErZ_&V!>xKyu^gC4VHmQO$dUJ>8=DJBYQ-rgZ;;HOzfCr=(q{(1tA5X<}Sx|gZIfc
z3wTjyCR7ki5~OBAdr@fHE+AaeC=`xDp;=FFX<f741sl`|kG)y%(mLLpRg24cd%4zi
zOMy5zG}+g=c|wT|e+1redV0RJR|`3m(y-U}O$p*x(L-y7dkNPJZiy8G?WLU=cIccO
znm|%<Z)a~+0D)w19SkosY;dxS)6B5j5vKI@U$npW`$DKL5e(?S7w@C<N3G>ptDef;
zzg+v_k!;c^M|9tO^UJ^gaC`f7dU?HGKE1xYU2dP=U*2xFPj_dxQaP3*gNdmX4^d8X
zD#cM_AX?dsvpl9wk(TGRLaY3srYb*J*egHSzc@IefWZ1b6|M}xu1qE<pA7Ckhr-cC
zE@MN)8IRcaK{@%vOEv7uBrty?;+(MDLsz)3a!bb+(T$gC*po@H4gO=7!XC=PZIx`G
z+|+CpWH`CSuFS__Din=kp;J+|)I9?x=<o+%ZfAKRU&XW6BW!;D{nsD=(q`(;w@<JB
z{2n{{a^NzRR#&11r?4$Mke{4|*FV~KINyEq%OC&4j*eS@r2F{dPU%?P1=}|X`tN>Q
zKb2)S`l-}6KeC)beRD!}F`|7I28)wNuH~QOqD1U==~JE{Pz|XCV`QVcb@IB8S5nm2
z!v{kR&ptS%TAyb8RBRJwpStHD3r^D&2`ly_{-cE@pnK6^q6g0gCZ`_U?z2jKk)NDN
z2)d>0#Ko7<gJWkQ;cn2UJrCZlx&-9d03*Y!o5ns);oLRG4uqCPsj6?O#&};Kvn7Yo
z1qzd*V=a%c)JNqU@`%N)6-8LPbI%v-izAYDbI+I7VCU>wx$FsrfO6`1wm;hUO?~e9
zqFs(955}{WVvW`^H-0WQMH1w3?zy)r=x1{Ge7s`EPA&qYn#w=_^wYnN4yU!)DS<uN
z89OK33cr0zaXBnD^Ds=bPPcKYN<U(27j9C;c^O=#`(th=zHpNTccskOz3|6YDF(Y1
zZmru&^~3?)a-56x7X`c!Y4*9CSI5};!%%v|K3`fFQG{E-SmqdTLa1dpJ+IgM<<nNP
z#YPHjsA7myUTd~c>_(qHoOI#!9>YrtVr<@HplU(f-Yyi`t5HXdS>2C>YvVewxfBqc
z1z{@?Lq{#Bz04$HEdW%~LsBIcl*B<V>CA$#%ZkCSl5Txk5$F~ZFG@j_^nu8@cVUTL
zLJVcFph{naTfiu<Aqm2pC#I2}*VKYQgBaqJ*DXF?tVKBJ=<&#d-F*yHYC%2bh~ZcY
zEk7vNBRafpVr&xoPG;Huj$2UWDM-3qxy6<lTX<OW3x>^0I<=sJU_V=FO=tS5nnG~N
zRWJr^D=vgfB{*>TgcyWvLQM3d1+|W&2)D<ekOSkzQ_gE<LD+P~5H|~|79D{?45BYf
zIph5v!^?COoEZa^S<trXLWJF7kZ~QP4jyC?T{7CnEvUW!BobJiXzZDBixe5QnFYO{
z<bc?PPVBW}q*h6{SIR`75QD5KDR2p5V|Y!{^DGYggc!<TL6yD;x5uEN^0}U~Js6%>
zZ$X4t&>)65<rQL(y*nlFdOQYYqpYa~K@2k06@RLOlOglKYn@E$-~99szx?GV>((XL
z8mF6-A$qCt_WtSm@-7F=Z>KMx%C6rppWep$6*4r&JG;`rh|q4wG*MM$DT%83-SR{G
z7qf>^BzP6K|Ipt4z&aRSui1EZ<52fnDs%|p?d3iuf4&qB-?5?W11Nj=iVZj6A_wkd
zb(GKD$-X9&hufWOd*_Su1X3G|_MB~xMiAoh<HFcy{_p^&OHW{xhAhgrhn5v8p)A2G
zoJARj6VBIUU@{)hIR)(TDvbD@@#ba`-Echj`tX#br?bZ@IazdmLv#V`a24ceCa>5v
zwr?ic>5@VbS1ei@(mXsS--n4F<~4ai8%<1J^)-1cW8QXXgb6>l+mM0t5!C1QA%Yr&
zG`D}n_w;#bZ^6nq2r=r&qK%#E`1RPk+r)<VYNmFdCQ=Wn3Es`+#3reULHGc%b^~X(
z88#$18q?a|4X>q1zGSJ%tG-5(>1DgblDJ)!w>V78@&{92+qdD+g^r=2NrjciudNZu
zg`RSJ-0t&4)FE7FYc^&!6wVS2LN4mo+ZB;+$9AvEL9`)|8&l1N?EdxGWThM-)ao+A
z?NKP+?&BpH1L}$OHbjUm5I#a|4@L4gN^-EFrGVtM6#6V!_(^R@vs*K4Q(mzlBRilg
zmQ|mhu^G$vSM2U#=(r74o}#F?`Y7CU;9U~~=SA(~ki2y0)0-=iUnL6nXJx>xlzVNr
zl@TfgA|)Xh(UD~wdx7ZKysgM}FA%kBL-C~NQS5mCm^15*h%pOV^a!)tb`E(SWjO#|
zI==H(1Rjln%B-lR#U&D{>PRnKWjmk)FT&^~R)pO@3>~#1?QCLEQ+I>N|0vaN0GHH3
zGb@VO95z=m+|`I$e^xLe-4kL+U#-I^;03wulQ}(Sdc{@|hSFE#=hxPN6X9-=C|q`A
zYdSo!-iQdXphFCDN-RVo>r)BD9*;yS#z}ZgZ3rTfDX-X&ksZ*156Q%y95kJ8ub<9%
z)O3EkeR`{hO;UY-dUu(m<d<L~jQi}csa@i0(yAI$T!r;I$Pevb%qYTx7l(H&1Y@re
z!|T<%=6+GPw|ExHXuP~WA`Rz(vD@fznC&KC$PHyQb_FcLJo|ph*JP~tH!{=jT6$kw
zb5N-O>|Vb3-OxaS_k@ek%CV?VS+LXN5Q84&c3w9sA6{KAq6~**ulNF$51_2ofXF$Z
z1p9m(W#V9WjmC3Xt?AnzLZCgqBIFfcqCuGZjd(Gyd^XRl%Y4puY0Q-mQr%U;{4$?c
zyvirg_L~u39mXD&LUylb@EBY0q*#5Yb0&BhPVn@T;#ZqkwM*iTrHD(+Rl`xxt_LHJ
zgNHB7An;b{s>yt@0l8YW2oe$xyyV}Pu7iiyv<x0iH*pNJGpTN`M~)CU@Wz>8^GVU^
z^(6aedT*N4Y=ai!bvVOavm%_sbV%D3e2L6_4ihi+8DNsT<Esi7DDO$+i)#{DBCto-
zuX{pd!z;dhSo7<iSA1>3$AI<-68d5B;`s>Bc><4@xF18_qe?i9#hZSH+^g#K{Y^$K
zW~y4GjQ(smTTE58M;6f-b(_Tnn8%VI)H95(3zyxpM_|eel{90vru40&ChBZeX0<3K
zx4^U%*QM3hGv4;^ql-FB?v7<ImK^86?eVLK<5W}n_w)NW68D;I7a%FUH_aZn<mpuV
z1NTr)DUn<J`eL`0&I98`I^lhbUpDI+;+K>Y!YB=3c&oe5vqO{36nhs26@(|LhpW3N
zL7j_~6UR{xj#oIzpdG*LYVT8sI@{xw9DaLnZuc!C&wBwMuud|IIg}IO{+oM&_J)cP
zs=*N(Eaqj`#sP5B{cScscdvMrOO$cQRs_jT1hehD3OC$lyOp>(v);clX4m}dKC?ZB
z$@7?h9aRA;1O}LRQ|!uML{@K#6Xj?@wvV@oyLnS%JIMXPB8Yg?)BRpr*SB7r%jva@
z7Hc<-++&R0IIq|c!yYs7rk8fzr&`UtsoSc%%Khko2UA<}VfMwQ!DFI*(cAN5M>BZE
zyT{bH^zpUb8Aor>qfqE{xL`j3V{GQQ;_)Nip)=eyd%<x|ugDsi%x|&L&g(@laZ@tq
zehaUB8A>m5X|b#}ABpXeEA(dAGTI4HPptP_gxCThPYd^n?XgQ9$2`Q~w)CKJf|t21
zh{%k`=C&$JfxdRpT<qDDSK>dN+PvrmWQuMn36w1eXY^V!Fj&?isMk8bzdBmP#~1Ju
z;xnJsuKm?#sSrkwjNJsx0txZh7Ql%23cQnd*$!y)Sz|rsmN4&wihR5DFqx9wAFp#h
zq22G3Ru~C5n{@VJdQged(lZQw!$eW%q4qWa#^Kn!VIzwZo%J5T=Y+TGc!q&5xnMG{
zu2tXIL6JhmWz(8L5lfhu;9W@x@k*GX^qP5oZP&|@*dDV&^Tq{x2bk17vEH>tV)442
zK~9N<n8l`DuWm0l!^<o@$x4cZi?ggOMf!SVl3&uF<+qLOAa*c_eRR>(Nk({=3o>-A
zr?X5LRM&dCo<5xi=Zal8jQZ5Msza^mf{I~$IJ|n?e>mqLlA+*un%=JX<xJByh^s#s
zuX5aaoqZ^t=iwX^?}`~;-n!85JB<CjaICT2Cg**OjxN08W0<HvZEp}zy>-~O@+ycj
zsjIxzdw2T&rK~G=xU)IyYWD3?HX_w5%5;y8uG-#mOdarOM{Uvp!b>zl<aV@!6QHk+
zyl;PaE$XK-56nT$yDHTr-}IU$(=t`3B27K)T*L#_QN{7R-z{R_N9b)MU#;>QE{CSI
zoxnqP+L%?d?$KyCVy}OLQug1mEwOoRH*Joik{7ZICHYs78q){ctnzB3zBM&znDtW?
zbI=6{EKg(_FKh_da1><Yl>=&Jx<}I?Clx{<P?7IIrfc*IOtbku`QY;F6A`9NYZwYl
z!>2xzX>fytg}^k<>UD3SOjnY={b9J%IKSex5%~^a+QvBtITr1!17SnJ$7?e7!5PzZ
z(8~7Pqx?2Ud$N4kIa)pb#$O*S_D?_mvt?H{X%`-@oT2lb`nGeue)KbCUQBr(ag=#=
zx=#O#%(rzQ<*2>h1B^%Q@;?&S)3-&vw$1bIn^gY9`^X1Fz4nm&^})QQiTx&@YSN@3
zN*$$rX!Qf7KeG-gSG;3`uI>GQNXq~E;~#$7YuUy77s5>tGJPHu@|NF)dkSo_VG8P#
zC|^2}BuX(%6f;Yr+V*`FgQk8ZNw6eF*jEqbr7b!P4v;+psiv~!G_{(-<uuM!wwD<c
zm~}agz*L$8I?%;6bZ^P19lfP`(~-wk=eMx0(pUCMUK;OGbff)5alQ0?3T>zT=tvDi
zE`1!j^t4ttCA1m|(b7i8hn`)v!vg~Hi3#--`b|gkM)rg;+0A>QFD0<8r4#C+*4dX#
z=oxb8HyvvnL8(Z4P9*1DLY3J^JaWcnt9{*LS@gs&y&Zc~p}?ypoC^v17(L+#!-DpL
zfC;@`GreD8nwgX@)i3R9=60}9b*1o5g3tAW9cBBZqnf^E<G`6a+7_w^sM;S~X&>DY
zHZbg?BPwBU`NDm|x09?4uBSV?PxvfH=53#_jNymoiEK+0JKaG~)|yAu>sly~m_T!F
zT)jSd%o0O)*Xh0C)e`X@Zk^tn-kULFZB1nHxLSk-#TWU8zE1BA2X4E|R5wXOBKEgE
z{P=hQM8FM?UkxM}dF%F*#~%*F<?+iO?K{MU$G00JujKN%W0dd-ecUGKDOK-U?3=3=
z#FTw*(Z1jCR)R1YP7vSPB~kH`+g_S*f~fsb6DNrW^liAopCG>J6v4g-h9tA55=F=!
zV-MWn1QEL$SLvFo1<!wQV9jIG!b8vHyq*ZPV15jn4>Cjg6D9%Q6vBi{3o>su<Y!f+
zN7}=>u*-F?So@;Dcgl*lY}9JZLTtQ*!R_ID>{+)LD@<^DVu$D*iN!;EVn20{*MwLl
zQ&qqoKjf9zM#nUPWOI1w#6VflezO@rLLaP>G0l-e^UcT}^%VPL_R%c`?UQso-tbE1
z{mVAQ^nR59?oVh8|3s-t&~{4QdX!4AGR+T92f5k)(>aHljX8Q9-t$_mr>h*5yQjWh
zu-|SUQ)Jwugu;|*$Rf&quMkejv7K=rrN;y=k6~iBGjH}{P^QC`+HZdtj=_b&5)zhO
zfcLHE>)Y`DSc5Q8!|Gexmg*3pTB~7E!}<z}QRI*`tdf}oDlcI9;_5LYx*ns3LvG;_
z1hx+=YNGwiUJyve(}u7=L*8T7aA+*ZlVCLq0!#zo<Cx~A8qmX)JdQ<IS@C4m(x?g`
z*L}{tU4gnYbTt~-eH^nS3{k2LB^oH?(KlgF-6A?XB4g;N)wi>_pslU1@Y^4TjQ(n`
zUwF{!;|72?Je_2?tIX}atAth9Me|l)<2Z<VZ5K^qOo{AAH_#^8BC++PL~5mw>tl~1
zllsh>7_(5tJj85|N@7Hs{RcILZ(x8)N|nu}W=5oKaPmvV$(#0y5gFS79ms4IUE+Ya
z5mo;fWv!&?v23WBunmTR^Ro7_GxRgPCDWiSd$wavW<)(W37Om@9f(nT5ebjYm_i04
zstz*}+apq(%D|qvoLFC%5Mm)rFv!h2RsJGUh)8uPbM#K|4Gb@{q4I5$L@Bi)2t@78
zTyOMst?p$I`{+n&63-H))1pjlZleQd>726`Tsb}YbaA{$U<BX7n9qum)@7*Kpm{IR
zZM(mbA1wa5@4UK~Yb-wPuoU1e8J7)90p8k)XE_Jjw%LT(pogTBs7ua)!cu@YJWOJo
zdIPM9zv{F@xrMON<?1#W)XeSf=8N4tyNn7CX9%9{?#8AXtK(`|bTa#53v2=q(4Iv}
zhV2Azc&<g@4H@(<UG;y6B1)*LW0|2E#SX+pz+r*sTQd6^UNYyEuScs;goYl(O{^#D
zD|TYVlNQ1oh!q|DCe~{)1#X}RqR`H1=)?1io~#~$-bJW&ele6scn7^G)To7cGDO&1
z)xsW#LPC#Sk&mN<6P^#C?2##E$JliGILwF7Ynpl%KfNuM8T)AD|CJDvJL)2~{cEXY
z%F^G<v~!Q(s9U#))EYxmh^Q<i$3$M+y-eFc>^{8&RW=DJ{|b(md~Up#>1L&$X@PnO
z%WDg9oD0GNn!t#ju&vxx@%8{0!Z0@M?kk~(GG~Neb+iSc%DThWi?UEsU`rIk=1U5>
z=KUlairUMahSvg!9)p7X?z5u&)#qRT^5@_G>yJObTwGuE8y2pF?N)x^Ox@e|P(Kul
z(jZxWXd0juo>hBeaL4!2um>e6GoAr3gf(SuhY6APn&1~D<+F6ycf1M;q8S54t4$pL
z01}0{9+C!Qm;VK2EyLzDLvmPr?bm6Lby9rPib&_c3ajNFag%k$QVV!%)C}T1UJ>EG
z&vhniNQ@AB6biRq*z=q-dAgn4=8u6%kO~8xF$o)L-uQGEw%#(d#89$fE~=BQ)(T9v
zR$+4eg8jw}o7c%XlWXH#Z@W6#`lX9?^Kq`VT{YhCg9Bya&0LOkQ`<?G8NFCio9lYx
zb6wbL%SdGce<VD$t)Wri>c<P{P()yZF~jBs?w!!vI2!pDDox-2(Lzq^Es8)j&KSG4
zS#)$mYddJ1$U~hpfa1nekwl0+=7gI!Y-i88^u|NDOf<DRqJ1v6$n(bQHtcg|c$r=%
z-jQ=zkwh-5ua9q2x?pD>!{+re<uZxsDVII=h$~XigI>B9pD?_P%cM9<Tv2`PNHrEs
zK*bg5iA8B>uomh7bEyt;=7XgZ^O#iRtri<aZf`TuL}RSW-OEH6g<j-?D|(mY$iprd
zjCklZSbY<Dm23ps%MIB!%NoqxTSXXNB62KL*14=mBE(*GjHd@~11`hnxg5+Va+zpq
z%4Lr~!lh}dFDC76A!&W?1)TUtu9p=_<g!PeaK_=@c=7}?lhB@$*#nS}si=dIgSTUN
ziDKeu6I0C87eTP8Gq{3I6<2&wts_U7Lo8W@i6s+*$z{G1e)>CK<RoS++ui$P7&vc0
zsWSqJFx*w<IQ5F<nW0gyDP+?4qy4zY3<#?x28xrp=Pwn2LL85^uI_awIhm<9DiCtd
zzDs87@hx=)8$%Vm;O`h-VnA3pEtA;_vEYpqfRQ;CyY}LbiKM+|W@KV9%5Z0zx$T4z
zGR@uxGshn6MKbXyiGj+zk$z<}7q$N4gj93o2V;G7n%IxM2oq~329p{P&S^RuR{$pS
z@gB;(>V$#wGS9pb)}st}m3b?5qjo|BQVzzhUiVHJhL;&o;vzYj6-k6xeZIK%vE;RP
zemu{B3WVGn?UUJSAkj?I)zN^!->s4ff5Ifp$*f2snQA$u&<K-muh=2Zz<JF~y%D4Y
z40ooPtz}+ayV?6dCN|+Syi7Ao#yXL3=8fz{8CIv6^%p0knp=LL;XL$NZ+E+2>`yTl
zeotO-*zb1VaU`&NACc?r<;q{*VsH1DSW6_#zGOle)4q3mnP@zk?(cFDl-HNDJ*vEH
zGn72on!+UOH8Js#250gNrit%3{M-4I+bVlwjfJ2}`WSHVr5_A0Bldxk=e_Of3})S0
zw#8V+8?{$_)dvIT$xO`JAbf<(E#SP<*-v|=!$B>5AmF^?IG~qz4>)4(qt5}a_5?DQ
z0?tG;tD6_G%N_x7Z6SJVllDO}lhc;eNA?gSplUl<)!bt9<}3$Vv6Y_DN(>0ABo<$|
zXR6qO0c|@x#9fczl7lvHK&dw>5EcxmiZ&uuN;L$%TcH;49xi#_u}WGdvlU+vq81Md
zF_b*mMb9Md$;`ZwLih-o{n+hn90UW>&gWwWgjLcynH5PSb31SgwZy^I6YjE9niu^s
z>$}!}A0e}!y9t?!I%p>NJ0^T$=E?l{-(}vYb!4lHv@}xCHMe9XZ-5EmWD#aI$Vk1B
z8*79se0%qhWgMa8$@Wor1IoOSLda#_3fich5P|4qqP_FypaCT=l9RdXFssim8Zb&4
z8|Im$J(;ODDiA(ECaj>4)ekJ3YmeM9GO<cp_C~Gv3i57EdP3$nWoPf=n1DM*CRU>i
zcg@;&HFH}TaelY5EeIcqK_-0Sjr7|l63)EQw#Y%8kYz&hgKDniM#g%836~6uFtL7O
z+))F<7j3$Hcw3$zvvfmlgbnWuoR@j#jTFL!-YRo@IVq_x?OivP8`+d#z<WFbVg0mD
zW{ri>fK=)VF_gX7t)G*bc_S=J8Sa$KtqhX4_)u>I{*K`#2Bg!N6A5$8tVkl6)#uBg
zLMVH&4V{7WnwgRbDZxWzLJ*=8srHJViT7k=LZZ(=W!?z3C%o4;zlsyGdr0{~Ssx7u
zo8=j;2Gh?goqy$KKY#W4Z+`w`Yt8;rdSv4)lgyX<7Yayp>07U_U*5;ppuDZT+(SIZ
zOU<T(D&dNS`nCjV2CH1WS!a$M@wG*DZ+0bB4*fK7FO_Xw8YRmh)L6u^cPi;^3cjFb
zmCCZ8*BuvPfzNbcf8q!e&TWf>3~&uDer=6|1BFE%14XUejY>Oky-1T^8NnsN(OY@a
zl5Ou&>NYrS$$noOtA2N5)!S1^OLlvQl>A_N^8Z=jqBGX^TBHu`yC47Kmw)>z`uu0v
zefcjx{rvSaaSv;g!0+woBbvk(s_bb)ajegC5EKO9b=6RUNWgD|N&pBa4aZg|_|)X$
zd$QlL&}OJ>EOkTa4O=-vRxDP~z0=9aSAEIMK`J5qGEm&g_F`#!%Z*SO&KYpngLx`%
zWj>Y$D%T?EE|uHjg!4O{q<+Ovz|ay?!8&lA${N#y;j|$Kp)!>3I48lt9ip-Ts5-+?
zXIk0DMM`B%XQ%D0MhCSLJTe1iNy)y~X@fZhR9%W7KUgjzKhUxmU){q<WfF(tkHMtI
z(`w2n@tRhM#KRc_zOaXZ^Ah)dD6|s4<5EV3yUM)P=@Dslr7CkvU51dFElyx$mJgjM
zA}4b%6>9@HLS{H)(1DhTLV7a2Cn97fx|)(%ovD)9f;ePCS9?v&1TP~qagdzM8mptc
zw-PB7?>N+xYi3Gj64_HSp+u@f+=FJ~6bi%3$b`EaW-ggGYJ)c_VawvhSE}Yp%3t3F
zJi>(UT!fhnbkh;WcYGVIJFwZd9EiId!9mT)z<C22yivF^z#^N`+hksqFlc9+cqsJN
z8SfD<_-Tfh$Q<h`28tR`tN$XzUVTW29KnJAVBkENg8>CHv9xBmQ!=YVRWfPCxwZoV
z9GFN29+83KWLC~1nLYYQfEvjJ|M3JeL2nrDl+5Z-l}xku5ij^@hL>n&vOc0-X6@%j
zZI`}!Bg=$DLhUlk-mx5Lg(_hYCYE)KJ1+CR2-IHoBqNHUe8*mO2F@E$=8ck}{yMVu
z?#B7CO0&ZqtHSNyM>5w|BzOZ#l5|eyp2KXzI6`J9cyYQXCo}a%pf^kjssZhix$Q;}
z6{T7G@vQ^zSlTgAl+0E!25;2f`6XnAk{8E&K29bU&<uA<W)DJV;~*TxWV;E7H%c~C
zq~6FzL8`f^^-D@*Cmr&Gu^tQvDg{O>fr-T(<BrRGF9O+^O#v;JMT1AjUUdfUm^WJ6
z+3?<q@Ti>-f#{kB_a-)mmyuaM^k}8FH`ZO>v8H5(vKQxj7&uR6=8dq3W=c>EXrIjL
zP)p>jv)-fd!A~>1jLgJEa?PwYW0bc#NhLFsy*S^)z#SwLGM7ilguMvwbzXiT6Gu@P
zUPdMqCJa<oskH$dm9ScWaY9y<%MZ%>Xz)1cvk3E%^$oHTyxa(p^XqLdf~1BchmgTC
za9-wFZiKZnqqiAQRl=a1ZRnxUOE);U*N`#1MCRF!0ct?4W{ePf{Uc@RNM;guJeip{
zQV0_-nv&VeAR*Iqb;JvPdX-FgL?&TQX5}oB*`trt<s&%o9}L_<GLs53C9^tI)l9SZ
z5ij^@hL>n29*r?FQ*Q+E#;jkwQM*Ncr~5G68;tg0`m1$&Un{(6YUOfW_Ms1pLSNrL
z-Ri1P8F%>f?g*4q_oOAfsMhRqy}c5uh^TD{eYYDPp~cRs%MVJL{7^4M#cj7EH@beu
zy(?{>F;|XZ(ZK{ut)$g5#Y*070mrXC%e`KIVcfSrj7H*KK*z9oBS~(i?L}1m9C>~-
zjddV<#A;BjlpG#PZl>FN<K%~Sj8v9|z1JadryTM-Nt`0qg=I8DSgoto;{(F_mGVmp
z%8oxqP~cP;`wY}0{<GCU5n>NU<3X2u_Z!3JHNyw?@irC9KE`B|wFVhWK)eD&B%&J#
z+<TxHTE-;A2L_7USPeLl$sUQu<0JR#FNV!C>7#mJ5+W`GoiYhwh`oDSwDx!yO5V=Q
z?*(kD026i(O5@p)dyCkInS|$jh{;|EiObQShXh1+T5nY>L(6m$yc7eKxtwh$f`C%n
zmQc`|z~1R12YZE2ciKxmJ6Mr0nACJy=@U$+P3XvBN1zbOEk>a?9q)wVMJm>N40bi1
zRyanW8fVO*)71lSIGn=p5|L-K@tn&&Pq}SJ7|)H|tLYdv&!u-mgv&%zQ!abtIltE#
z<smp?7dyktxJ<kw=duQuDDED0#$zM*sw{?W#^vdB`SgbEkym?LRyV<#H+}!h|I#I^
z{xyE@*$#*~@g;AnE&cUt%NebvD0M)5lmfU(_M}V-;P;rBrB18|08x#0ZPXiB>HY_M
ziC$-L&50GKUH^o^<jPX9MP=#XU_2JHH@!`;d1V=#Sh#=19eNCQlYb5L0cabVDOo9f
zqpEvt;F`#<kG#kFilgi<-P`sTjK@uHxTb(%^IQ&2Y~<1qOjID{atjDX!Fb{EhO;6J
zFEgJcFU`!SO~|N#Rb5}smFqFQ;snkbx~mTNPbgznbH#UVdr9{wFrJ0I;a~{E<|Un2
zjUkx8Hc4M`TZISOV}WpKiPhjJaR7(mjgpoDf#V+NYU>C{-fYt^#g|JKID!M6V&FWP
zso4}VK0@YJgct|WYz{}AE7mQ{FLK4)^^!dXNp?Dt34!AYWP)fI?o=~-;1SI<b06^H
zxfsLCG!yb}1}gJGty^DwP&NMIgVct~56b#TD-HrI!psKismxoA6e43Af)E1=H9XEy
zFmT?0GH-;HA)~j+yoxp=g}76v#7CJ!dd~0?nPct3KyflFk_fR@C_-i^<Mm9n`VR)q
zlbLy=Y%4@cW{*MgCMrc8G!y(C!^_BoKUpWUB8g<G<)~{9C9)1`Jdex*VZpWUYUXwf
zcCCYDqh^A?TO>1id3<XD**%E0zI?56u4et>glyws`GJP>Y=HrjIRveBneRm)n;KD>
zhf-eW3zlV`dLxhs!(9ys_dvMZ$fg}Cy)**h;L4)Rv%z}qjrP>i=0=pvP|NGZ&N7*)
zH!2Wv1KK6CjYO2lNhj^!aJFKV%p{ysGFufEyiuDk(fw$Hb?fSYr;(X$g~&7$78zV^
z9Dj7}_@2H+GF5aF31_(xEGoFxWhCN+RCC1}(IpV>jeUzSv3_D!&1Jq9fwr9mvIk<6
zIg~LBoDb)jH^Q2f;jS`oRc_Qyh(L8pe8da>j^QP)U8l?^GUsGgBoSiu`C>q!?8WA5
z2F{b2c_S=JA0o4tL86(8ItU;99mC7Wgg;@RIGGhmBvUO%qfaP%abSgkJ4j{{-!sj$
z(GiQ2^|j=KX5wrG!^_BoM4yqFd80N_qVdKuArZA|Zt+Gmoa5-qB228G7)&bjR*(gm
zZ;JrLU5*?AAq<?CdFG9<C}p^-%v-%1k@hm^d{qv@Q3sB$FuX+OSU)jPoXm<OLaaVt
zG$53{*nG{vc``F^lr3CH$?Rp2kV&(4oULGZ8JQ5h*2%0$BAHwC31u%1tT1o~$xJHD
zl*}H4giN#d(UQR5F}#e-4_^Ji27;?uzc`_~YC?Wc)`P)AI9Y`Wf3hy~y$H1JB#_)?
z;1EYD7&tHU)Ej|B815$XD%zl(ZN{WHdpe`;7Su4jMCMpOF;LVSwSp`{)C)filA-L?
zKD(zC7g&@s+$ouG2v?f}N8u--h>;0@!a#8{_YUE3OF_`g;y|BAW>R6MWNty|YE@gn
z3;u3VGxgkOlC@{KQJW}HbFob5d^OD#w`65-fC=Gb5oY#&aW3<{2(;}b2)hs8j_oDL
zyb*5IW4c;p-s;_G>JWkGjJmz%aH6BkfD#wU$=r3A)#r-_gt8Z#ubHI1YtM2c+^Y8w
znOhljtsTmPH^SKphL@0u^%Dcd$*f3%yxV+<kQvHe99UuC4w9L~_e?Xl)dXj0h!j5=
zvUZ%UV0a0cc+|wm%)C*XC@J2^j$?`wQq3(tDC?s)!qJsQn7Bxd!K5;81zD7NuYaUO
z8Wr+T1j@V-7Nrb#m3gaoBT|S!bVl9Yba>1gVg1BFaWX5C2(kKnSveERUVP^$lk_nI
z!lIPnPRZQLplcnI7=>RH_aK?@CkzxPvm%LPR-Z3qhO$?e0ZhOhBok5shC3y53qn^q
z@NfGbCwPfB!lNbzD)mMXZ_N6|38~u1yFjm6hX<#L0~Jh12~4b?7)&nny$IBXNkrzM
zI>&hw2F}Yo^+szEsMWhcJKHQzarSgZ-QIP0Oy*cWEtA>S#6^g`{*kko!MdNim*AT1
zQ)mWM?Ia@YK}g6{)B$f2ikN1?pRAKvkwl0+`h;bC_Rh_Tq`hWliRRkC|8-w8dk_*b
z6?GsJ{2j9-LZ*IOeMClP=8bH`!H(AJ8V^BNdxx)91_ziBP8MNe{ls8WZ`2C1DDy1>
zg-hvUdkHdcq!1?bRs(AFZbS+Zh|Z|nyACHhN@R}p(>j^EHs0e=SjT7Y+?;?rXg~$R
z2gq#WCF<H0^{AORr?RM-SU)Y3*$T2C?>4F<aWa&>IQzrE9U~KqQieOz%xyKn`AP@=
zZS(a+_)Ih5sEL8fyb)|6xYjiu;*C^uB{wqGgUlhEFj@`f;SJ?-T=nVoSD(N6=9ho}
z;r90F^m2LA4ds{Hr}vlZ`SR)HBDc&9Cy7gOal;U`YX-7e9`(fUmTr{^G!1+5gXw<x
zL4BXFQD=AM2Qvj}h0u&${#RS}ezn^*`4?;Ck{|3$Nq(?$uKdvGt;;mrV_n~HYG$8a
zoWZ{08ako{zqt%FTw8%&My_p2rO*({UY)Z!rjRQ_`7h@$zy9Utud-$Pe->b(XW%M5
zwptQN`$5pcBqn;}&c?xURONS{r{my;HutJ+w_I^q@K9x}sj8IxV5(qaO;_s*3=axw
zzN!zv4bg|%g?Md)_X9$Kr3!92ipgdGWxM&0X~rXq0<NvN7$Npo_(^CA*h(@r!R9r?
zCnUoVvweRq>sGBrnA;uEl}`J+7lJN|H=9wXxt%#S8^!>2l#*>Ljsla#87?#F)A_(8
zd=}Hm8b0@#to2CAMe4k;cbx7`nyXAg{?9;hCgDEAGubPnvC6bJb3Tj7B<80~LRnM?
zu16+;mQ^N~uG4p2PJel*inmomEf`<vCIx##=Y&*}FFi8<f5rKKFYsO#jTgZ7&XNhX
znG*^l%!Z(T8q?Dz@`@+Ap&DS7UCUlZkspsTnENwO)OcD+5h3=NGgg@PR?cNEy&H;L
zDuNGi*@kiomv!cM;1Xwj7R^WV@Chi+W%b;FOB=K)@q3)`buT7m*t}k*Towcq*qL71
zWP>Fdb!>X%62b<<%WV8(*^j-pQwk?FmX@oxa^On0DcI{dCn`!{VsgE1K6|mpMnekd
zu?)7iCQYz;k^6ioywvoH<q3mbMc#_5sGAUd=p4Vj$8Um{aaqJP(L-)Nd)~55Jbe4Z
zc=`K|uO(&b=(!xsCk%CK9Wa5Na@pgLxT01{KxHWBia-p*8@asctosBM=dyb5C~k#S
z^iurhXxmB5IY=ga+Cz%j1JKzx7%zqFb&>}a6V6H)C_A6oPm5p$f>~a<vg#)ibSZ+p
zobwRO8?GE<FqzD6t#Al3Z{s*3^RaAyKeiPiaYhDVqN`>=H+yS3seNqHMqRye5M_Qi
z{@iqUcmj%(S!;(#X0Lm~sP8)tpfKw`WI(rUUqVV|FMq^<)XR?skApr8FY`u8Fy~~}
zW1~oB4?bbk*IvmvF`I*ALJ7qzDkZZ%f+Qg~I)rYolbqmXWWvb^1C@HCE#6e?e-U&l
z_VR;54l+L;fwGx%F7v$zWP>3ZfkIi1FMDJP>1CdJqooLRv(*R88$krB!@ons)Z^u2
zGS6ntDVeQ+2nN)qN5r*<k{1V1ax#<L=!QiU)754`HNS{Rx0AP99iSe`gyMzaB?hEf
z_EFbvllny7Hf5ul8ERe}Kw;p#W~O996nluw9)!*}I)rY^XOC%Swgx5hMmASdgSVQF
zI3d&A@`FMiy^+pkpa6gO&42s;^Y8xtf4s=XMhy;-KFf!I^CG-`_otu#S>#&2jnxuj
zB)1p2(x<U7TZX{2?~z#8ikWC2J;Dh1`l#Q(gfUNhRp3OjUK2APnT;e@v$ll{%w`}2
z)sf`UtU+eXatN`HOz_`q4w^x%E=fXnD0z;pLrBefE#T~v2?2*r@Y`D~C&FiBf?Fjv
zLszWcTFDT!v`ya#nW2`zaULdVubCN{3ISci@4x=#-~RCRZ~pw#zsT#hKi8KX-FC@@
zbqF^)!S7x*$?y^~_1h+(G9S4uKoASJ{7imm&eB*PePp&6fxyJXeqH8!B@gUE2$y@<
zn$9@%GS9pb7Ela#^+q_s?=Aq^z(~o`=>-2fPM$EljLb*ed|Rm&4XBqq@)U!s#Bm-5
z&XbuMP|>f6uBK%6fFxw9n-6$_8HSgUnYc)r{<e}KlDS2nP)j^@9l}i^e1yy`2;Jxe
zzrF3Ue#0u6NgA1YBaAn#Y-|(!_Q>G?1_yf<VLmd!f3q2063$^4LMVB#HJyR;29$Xt
zETAUdsMTOWJKMlW@kVrl{~ae!7+zvPk4*62Yz~@{S+A@FVkmiVoQHw)WM<w73#f<4
zgp!9&@Vhs8GQ5n;#6?nXWc33hb31Sg_k1|c!@wORvjmac8|`c67KCneg8%*aI)ob@
zhA;_d-pD3DtbR1>momsSxBNh>wrnv1lldbNsI63sHoirmaM6dY>AB2PZv=G|qqm0h
zwy`cEg$P6^`0Xv0$087>{0tN|pjJafh+8}gH+?wHlarZwqqPbC+b)@~4&g>8_}!a4
z8D659nCP#QSv`0lvrXSfCw3@%ah!*NJLZjWtsKLhX{HU<nBmh2{&$=_VR#9dD!Pe_
z%)AjSK)9LpixX-S{5Lwm|Bi3++=uC3aCMeq_TcNS-p<!g@@LwaEe!$Jm)BSA%szej
zbbgVw$e-R^T_N4B3t>*;*~?x5Xu~=xpsTgf%B^Q>(Z1G~!N@&mOCjxkPxz`^g{8zb
z?=6Ld9RrF#x8Z2{ftD89i=Fx+Pi1*mm^&`S;*=@oPyhZ^dY}LPmp}f;^yz!Bl&IvG
zl@@(qc3<KiRN}|E%dBB0T6r(h!Yr!26LP|#xALSV+g^m(KW*BQeOp^eaI@77A(N7p
z?DjrO`9Z^$@Lu|VZgfAvJI({GN&y7NRKwiEtt~H%yl<h(o;DOpIG?fz3d<J;imFDd
zhXTYlqeDhk?G2Y*nDM0-UNwAbGISE(up(rrtNXV#13}o=`nFAzZym}QtnB#8gc}ww
z3>2qwFP66X452cdGh~YrJe58%2~;L$wJDWQB+*R-_GZS3;7KIK(q)~>y;x$ehAh&S
zjDD1J@w5|gho~$7>Sr<3DV5#ppKo*zfz2*W&=M-u1}2~~uhS+(iYqj`mmu3_=x=p~
zek8Soj$<&faADkW<Jk*QZSY1U9?lq!txNEJD6|sauo`5ztIS)W89gSHNOdY~Bom6q
zMW>F13j@W;tl=d>>~Tl(rU9I0WD`lx%!iN(kIHaoWVXqXqN{Wd!F#qhffx`LE({bU
zvsFTY%r?y=ni-0B9FJm>K1Sx+9)jDhX4<Th#Ynn`zy>8J!Y5?n84n{f^G0oiNxhL}
z@#2kCLB%cA8TwI2!7Vdd2}~>n7)&nnz4&9ZN*aH{8H0|sOgQv1AH31nO?<;@km0Td
z)C$e0oe+WOXsW%Qae|kT3DJOo;$+q$BSP%ehg8O+q~V*Gq&=BFFA8n$H!QRm?v%_L
zozxqdu8w%2E@OBZnTd<!WY!=P$?VZbPLxJ)@J$TdK{DY{A0kt2ym}+E_W>^s^)S4Q
z%%#h${fewjGO2{s`im1%1uZ`)xg)JOGPMX3YZ1mBm3i9=7i7MzOOO+#kwYj37&tHU
z%o}BE9;yMgqA?<^wNath%AtT41jz6bnQJjn9oRaVwaAGOd-Wryh$ERv-0@^)-Uw?x
zhC3y*MkgiHbalj=ltPTm<Vb^SW(_it%pQH@6m0|t-^3(+kW6^ghsf+fNHo*zeZ-rD
zB1Y!Y{OrUVLA<HkMFgEHsCXk?5D`v{{L+JXD8pbvTwvUBneRm)n^`J;UCzBm4&j?}
znWx@pEdsUDF={77AiAc(y`YofC1hefvP@<xb4G~$9i>9%SoXS?o-%O93<&E!hP!#A
zs*({Yv}RjLGzi~TtsF}<wKzEH+FO|uA@=AaN6TI_-3vOOKqf@phsf+f=zOd5@+00P
z6cNo-JD8A}RBH9Tqn5DM1tNm3-N4XA81~M^gEEJ>z__E{$aV?DbK(BFQZb;hI(P3s
z&1If>Bdq%v?rK1-bd1^w5r}SZu=iFTBr|c5oXlMt@9{{^AV-CSZ_3HcawEMCoakyw
zW{plIH?mC+0dEqDhyh_e!X(VetU)HqyGI{6gdNDlVW}sO36IKfXJp#gk{Ny-nIG}O
z3>w2r$jtWLWZtMvGpU3%&6Jd=-6G#~CCHc?**h0g1B&;-hcDMJauWKEm+R-(w@<g1
zH@#ecJ->c>cLd6nWRkuX)tX!{*SATUi0UqT`B2p`p~X%FO99(+$L6-%P5h0n-?0~x
zri{6(>1_U;T8S+UF#mmP^{gy1t8YXt4;GCi34uQUNp7a?ZK3^1=Qq>YmWOIkZ3$a3
zeRwFjnQkxrlpjoW>&<i>0(Z(GzXK6*(YmsQ4%NDFp#vbSUn##-tcxymuvZ6mzE<jt
z`y)#TZf$MZK%zkG!Du|_y5fWvBg|`t5A5S@s(ycc&WZDERZoPuMIs|0dL?kr3~h9t
zcb(FofMPaw$ANh->>i26<0E?o=tRn%Ngve*ChhwtpqtfH!UB`9Ho*u8Oyac9DwE(u
zn0PspH9e0Idl59A9ohRopT%VP{*N%(3!(G9PI?b6M?0)0XroTv@Zf<lnYo-ckE1T9
zMy{%}F9Opd*9a4&w<_@BHYVJ0f!EwT3cLVNKRKRnU2%MhVe_Wrolv+)z3UwQ1hyH^
z-BvV^IBJ7T>d++;7SLnPsUsVQM1Id+jLo^+weMa4jps)8?#~G}&!u-mgv)~9BV6{#
zBYJ6?I_f2S1CxC;pL;eMPq}QFdDP2F^0z;PW20m15j>Zt)8*3}wntuVIc^tC&6~de
z<$p;(>d!A{{N3{%%Nph)=1N@hraJXhzqaUbNl}cvpwT#bvnYjZ%}eIQY~-Mtnd)=#
zT`COu!NfHh9!@qb!hB?9!5vo?xcF~lMFn&?7Q=xXhRqw^;KatuY(tP6URxj+w7N|o
zsmRsy1}={W1kA3PQgXx7w4M0bZGS;HZqnhCZYeQi_FQ_y3wPP~Y>2qp(mt2<36x9I
z)WL}zUuJO6_L8LL(?ft5ORZJyNuzN?9A}!zTr4Eo>yoaXG%90{0^ux7Tm6?Momve9
z69&6Uy5fmIdn^!AX}HQ37!WQo)n=fm)wB#gLR47A1Br_q)DWj^n4piDjY3#(L3?D{
z@P;{fI%$8!X(oo3k(uQ4oXncU2QqDxNXZP9F;3Yqa0kg;y5_jIN<AWlI;75YjKT+I
z7+ylAe%nOCnGb?R1$RA2knMc;x=2HQP{=_?kB1#hx7Q75FYIhP3&aJF9F{+Nnm59-
zhT*Q>NS81as{Ps5wZ1yA8W4>;*#ZM1^K7u58_=$e_b4PWXe6`z(K4A?5Z8?e6J1To
ztdCHFxa~Ixcp-Q!8c;TZ%gL-BJj%OAA4ytAG9e%{a0k5+eA+{r*@MveUI)ttyf~!7
z@G{K=&%i)s-pCsCtGTH47jL9uFFz>ckye}lT7-#tK7&bR-s*-R^KEB=WT_*E5HlD!
zFY_!n!rF=9t_IY~vWOHSP@NJV@g9#rnCLT5oJ_4}h{LoI91Z88mdE#G=458xDBB8=
zl35?2cq2M#Z|~xqcu!(L*$6HtvwH9-?_TvtnlMVb{LuuQ*UXem_%x;jDVaS837KZ^
zBi<wwF*4zvmVrvW5yTs_esMx|k%s)BkOQs9BM_$i3?`R(b>C6uTLcO<xegjE%RKc)
zYY_<dK)8b#8+$NkZ-vH4Ce8sdgC{b_lz*AbRzn0bx19xHsi1pLCIffOfUu5YxSIi0
z=|-geF6MlvllJy5&WZ3DnMpXOn%OFf2yu%(q3q4J6&xfJqS!-ZmcJM8P+Ys!8bLFG
z876!}CLWV8P?<M^jRN<&j6~3>*u^c;B@kDf16qWc&7pIdSN9!d-XoA49}FHH=TjIs
zFZ0YBVI9Tjtp<eC>CPM3*h7^$jX?N5QihkvJR4r+WbWGd7LP*NtHT-->-J=3;T#vi
zJw#>?LZX>8Yd^k!;Estt14YSf6-Cs{8bHOyL)n|{Avi`R)=><1rkQQNq<AAb>@VFR
z^IVQ;CLEJ6P?<Ms<2mXgEfW$^tJuXG8SA6L;~dbU0b$C|U~-vP_Z?)u?Ie%`o5365
zd<p~SWuAGXY?nfnxy_-IGRVdr%p1`ebvar(Ec0x5m6KULcqDVHe?r-dZ}ZH_%)C*y
zO(7+73qtqW95@QUXz;{)5(9c<;Qy}E_QkZub3)is5XxTcWPbvgP)9L~O3B=U(47wa
zyO)bHyo^jZCSjmbZv^qCF7Xg2q+&1Lh=y}~&Fdn}Y$Tl;P^%%L%(n;>s&kxAVc?E=
zBdntsy-ns7P(a!Sc8as7GwSXoqYN*RIi~y!6eqLR5E0^5|AeylLwgCrwSKlwAtiGw
zgYLCMdGJO!2ee9N63#i9)q_Veq5c`;BzCeha9%Sr*S<FJe{V+x5$P6$?sVYa-n)6w
zwHG_6f5J2~^G0nvN6n?Sp5N;V3Navs9B4frfiUG~FuBaD`;JW35>6I-gz6mUQ*xPS
zxe?Y;40ko4R**%c5P|57x_j3s!%Msoru+;PCv(?f_IMQb-(B(jtqj~j14?u?C9^(4
z(N!xnM$N=IAcmKbnS^snW~(TIytgd{atJ%P%4{3KF*31^VoH#a*+w~(Om*`CFEF!6
zCLWV8P?<Nfw|!bEp{7@E__h2lKN#x)CLEwG!o-xH!Q?XEi$L}!)dE`XsYaQXKbm-S
zFZ0YBVI9SASDCkhENUl2AUdP&UN^c*W^r+o2*k;(9y~(q^-oyEcg5iz2F{b2h4XA{
zYD#7gLZX>8YsYyjhL?Gx#6@y4s|Sx{_UIFq@!1PZmo+mbvp|?AK}u#1LPDmx`Cv)F
z%qp4S8JM}G-U#E3WkP~Z#a_ITLLOkc*SRjj#FU@Gq%v>2%|@Bmcd4p38mn`AG3T<(
zGjEjbQ>Zd;1zAM8l|gqpqwd}}x=JQE+;uW{4&nMcSH-oDWv_dQD+71T8(|&AaHnKK
z8AJz0-TOuvUgC{(*nMKvTr;Z&kMi!(C#>UhFL7ny4w9Kvm?@b(2%YbA;NM=pIk6;0
z=Gw}cy}{4=zE8`I>KYG0r(zdxWOZEdMi84Btp@Y(5cT!-%cs{mM16bvbb7hG>4x&l
z?bG|q^?dnsa%qqZsxDZioHXKwa=h@WuVmF{zuD|=ncFo7EK?jRE+N5M>dOxnkEIQ(
zxozt+lK*8_{PKg{uE`H=!D_AC<zK9vlONhfpL<=V;T}s?q(jup=>6uWfB5AuKM7OA
z7V|q6ti<wvbD0v;<EC7*j_8&mrk|-F#)5P~!^8pXZdmuy>v2?CCkBu>c(h32sVsv3
z{QIvz{^jd$fBxf7KYtZn5Ou^+_q!Gn%fQd~Rt*KGWrIOQ^W^&4VXuF*|0UmjQ#a4c
zZ|cd)aF$*wFDrP$2hUx_cfTzvAvRxmb)fZA?WWzqm1EDPn>ViyD^w@W*6WBoat#9x
zwJa2<?-Et2huXRR(Hhk(mMbadB^)X8!R6N{ADmKc4#s_|Jjzn(e4J|VH^f!^U7)(=
z|B-4f_?7CRWEDmrW{@vIt!71>Qf;2uks=>le*Gg<n^Sk6DpZ32pXNX=UvwmYAM8N2
z{64dA)#|E`;y{Lb-1<lRUxHL~Q?EF`4-N!eKa=5HtJ~A~PZg>mia(QT_*eoqQq3$}
zsji+ysD69-tH1iJANIGu{=Qsc$}^e$fBxHF|Mst6zDTriiX{IZ6p6s-!jRvr*5k~o
zoJF&V{rc+@DW}5F=MBODxBEn4U_2%)L}6@-DNm{t|LU^}qy8*|V;;KvTB4mTZpv@g
z^acc2oYv)wh2`+UbN@)<=7w42rw`*lwT9V={PyxQ^@QpcBv#uYVfmq*AK3boqL`{q
z<p<(6#p=LqE(-eWvLRt>ZehPU`A3jHsHM3IvU>Tr=f_^dU71;gR$gd?shWHjC~~fG
z)x=dH9LgH%g1QNTpcRWK$1Gh?f)ohK-$*%x<;y@}Rb$ZzuUrBSY+(`H={(PVFJH1z
zN}nePRy1PAYW*K#93FW6n~7CyMr@;c!cXzS?bD07)zQ7d52LsU(`Ll-L0fL)Ka~#B
z-jI@2p3~%49$_9dg1fXK#es`rWyXbOWFyo1H%m<0*z54=$}|Zf0v-y2N0_D)m-cS)
zV@@Hj=mhNC03*{i{y42urmJuJ_J^SrOul38iXa7mAxf`(3UkQE<b&r9IMr#}5#tp@
zbml*!$`G*Nl89PFrmJ_0O!q2dIEj|;0G~|01DW2lb2ecoA6$NYVl0|$O}q!4)wI{z
zJzuA@8M)C<!?4_@b*j^9-^F_j$JCcE`Zp6oHa~5XmBf40d7{BjC&Q?zPS+E;;Zu_t
z@$Up4oDyy<6fak2!bJ(x#3kC)<G-pF-^;(y@zERF=VEk-DMB)-IZqLqL;3cHu_esj
zbbnC!(i9;Z-V3T%v%qNNJ<lHwAcgC>%LXI2nM9^~YW?2v$p<HXx*B=g_~I}ZMWN$x
zH;gcgO0W{RvXQyK^j<P%p`{qPR6m2+;GU4VKZOxDZ#`_RO{hv7bxO59O@N!k!<m)W
z`PB+-2(=OvApk5&F`9BR;g*<kjaVY5q4X7WK<6SlN%!Gs`|>558ua?KS1(zdQ)LP@
z2_^umAQy7wZ0gAamj~U=;CfXuZh@$Ov=r{zVvgV)>XzQY!t~cCA6yLqCJG1h(x>r;
zaCI+Le<sxjQ#c!j8T@ZaELu(=x*Sd~lff%+?>eVfx-G^Ekj-0(48eq%GfSz~gfvhM
z)y@;C*4x8<y$IQI+rZ$sP^x=fGOlL0d`ZU1fNGc_^ZHkBIR~vy=Dk`Hx2x4`#!Cb^
zuZpKhT%BR9T2N9pI-qsK+<8%)(a$HNPjf$SX|cM{p}rBj0R|S)<;ObN`!7caYV$*b
z*{Q1aazWDVa8O<+Wp)qBlhG_xM&`jw0>-9X<X_j)I-4;Y9!oz}bJSq>W3KVLZ~oi&
zpMUrF|KsKDi`_-K@S1e_fA^=K|5?6T)Y9f5Dh%VS=z_eW{Z{ubI9ro{g~wafiG{G5
z&8Cc6Va@#mZq<q^t#X7akEfZ#OE~vSMoK{XHhnXEQIQjyB$0mw|2*;fPWl_|^7nR(
zK9UYK$TLZwhp6E7VL(9iT;r2nlUONI6eq;jq?sC-MmuYtu1sqx>McT;0!4g?X>Mmg
z$rG8*h8==>WBJs$Q1w<W3e(}-4+p#%A=?>=&2SK%X7dQbG^G3NgKH+UuhX=8(qG?C
zIi}&Y4jNW-E8(?{B2}=Vp27lfQLHh}Cc_Fb&N{(WbBP<1Z&>y&g3H5fHXSf(TzloY
zW^@jCuT#RQT++!8whhhvo98ID%^LXSUm@|BXk42vcbN54&Fv3f6wfeLd0q%z_<C>x
zHh58MvmdOl*tVTr6x$w7&x8<gOXNF{X?1JErz<C<o{$fQ$ihCj+V(!v#5c>6Kooo;
z(^;?fsMFB2y=k2?-K&&v+^2staZ8&QwGMy6bnR<(+9yoUtJzkh>@v-oH|0~|_Jqk#
z;JK6LX4$F{nm~*5tkVD$V{o2$R<kJ0=sc78fVuOu{Yu3$#zRBVHSiUS=*GjStZm)v
z6&^-4I#sE*dL*2f;knBy$OYGvblnEmV{PDr$}0ByP(tu<kaqc!^v{FuX=Av-AJ_M0
z4Hl8S(XLs94FU|Hi~jPac0F*b2K+>-aVV1*TBLd}gKGzZLUkxha8i|g2~u6ti9oeA
z>5j>A(gK}RO;R{9JqRApq#7)mun?$j^OlYa)#@4xh3Zh3B)!!@HFQ;PQKaZ!?S>k(
z8V6(v`jl$cOf9-z40IBfW`4d-Rmg`}3LwZe{&^)4aYB-@D9-5TlOc)3&-dzPJUtY2
z1^hv~PA?F%mkN2$FT_=VQPrwFimDCAX!VaKvfEM$YpWx!u1<-Jss{EqQ8jo^+@Qcb
zd4oh{Q4JPu5Kjktkx$TzyrEXBuAWt>9xD?2qcy6Te-^7YoI?&IG6Yf{pt?TIXmNOO
z{Y<Lo&SG?+CwuwTpmv4ob`CF8k0puy(F)Zk=rrCWsZ?v$;YkqzBq?nzN%pk5K8^oW
zd6fT@lH{cCy4q(UQe8t*a3JkQMW`NYl2h_>t}RxbTJN&^c%_<{x=_7#hPF?&K24w+
z1o%X)KG@WKvR7v@t=2QvQcXy|qIaqGNBi<bs&_K56Yc6g;gsD&4n+Oc0QZYZW&(GX
z7StZ@>f7WHtr}|iL62g~50)`FlEjuELE9HFUPzp>=Iycb_|#f#)eZH^YLJ&e0av#V
z#m^{ZS-~l3-VH{LUA!K+IykLc2g#kX7O|cboV01X-aGeCFE(8}#hh^DUzd`ClQyi=
zPbHp0cm_|g%5z@8o|5L>z;tUcF8-}^p(>&pt2R9{jZM?c@_=c`3HqlOrfVzS$n;W9
zu+OwTjE5^sgZ!S!G#CnDAu?TUE;3ysnDFAE3r*k`$ajGA#13-LG))PxN0@!Er34eE
z^<g|*VY+B~b)L^;8a|eQjZ9ZUBhzY$MW@H=^@Lr1<U5e*Y8dX*Ri}xaiwMEa*$1ag
z>%(}a#Zr?`9m15;2y=hM+${nMMvdR{FT9~#&*YAYHI%U@Y;hwzgfg~6R%g_U!Qqll
zbPjyRs?Pb=xf3?F5om*c)d=LouNbSZBll6bymA#|@%1j?CymvMDBCK}&=P*V;Z6Gy
zl+&5}%SpQ)_A{yhxBUK|pKOf-@ixc)X8$|DdRupn6JN1j)|?^#3Yj-ije7QU!Vdhd
zxcaHoPhzvgGnqc<CtH(&<D#f?>jnAthfp~!H*cS?dE0YB{Uo-*Jj68dlky}GK%dAo
zUVIX;QKzeKh)h>ymm+n@#6|bOvym@BrH0DMQB9k-Pk49FKDdUYeWli?@gYg5hJ5Im
zRD%Qw*g$o=*@{$G$1PM3w@H^1UdWLz0jlk76;=a#s)?n`2g4x=`{0afdzwHsME_?}
zT})`-i$<zhCZztO{tuygy!<-hZ4zT-D;}^D+fz+UU8n~AV;`JSt)K(dz{xYIp4)b$
znpwC~tz2k99I6LA;Ae~g)ip78MpNP!?ZiIey$1W>lxlhif=hLuNcF)^>{B~8bX+La
zl_b&XP(I*cC}U)!x}5;Kk1tfyPV5sNXtNK_sJ5r^S}ma^aZ9uE!7?Z*7TUy(#glT}
zWzMnupuV>JV6k4F&Nd#nf?r}rQG}0H7I=6@D4JImt#eO=8cGZ7|65hap|rr$G=gog
z^BSR?YN+Pb^g%!lcVX8XHbSm~TsTL<nlA?~@?{>RV7CrPbx`4Q3C|12mq6IXo^=-s
ztY2i*Z#?p0A6%`*x*ka|XN~CcC}1^Dq#Elk0(Q`m%c+%cK}~ECvQix`m#_pSUxHLu
zWpf{29F)~xf$DiAYZcNi)%G<0Q-x}%yPiq)JV%IB*Yw<Rp<3N<JjTl<!44Vg3_EP9
z3+qo#sB1)C0ckTcMQXjf)=AzPMZ=z!%L!cv`3}$t+qGQ{rG0wQ2~#;QJ<*gkooK$-
zVb)Kj!2+9OXT1LFkAL{7u2qcJ=!EHmI?)Jqs8uJb`xY-f5`ro*XBxW|PmXE*^zgx8
zC+vf(quXbiRxKEo*{7EDK%|Vufly6b<TvbLM$A}~vrpf0rFIVC%uijBks%mJCMo~A
z#>&1=BCLpA|L0U)Nhfl&^qTQU{p(d%D7vzy<c)G`A7_?snVd`DM8d!clO+qZs4BHl
zcKB4h8)KhZ^sgFQPz}ozMEUH6D@9M$R~L1p6&`Z4=vLzCcG9vQbI?YDI*wk$4JDlD
zTw(oKf;{x%o{~1{LBEhzhq2~&;p#*%9#7(<Umkb0UQWk)h~@WdNRD=)KBA;WLxx}f
zX8*(kBA~UP6T7IZmIn<^8tYqDg#Gl++w;ZeD9S}uU1A!}IEc9o8X~M!M-!Rub;?kt
z)W2C{nyFxM`m8%y{<Zx2<b$gR+Gm<N1sqy<Ce!o8C^B7DH!$5ECtTwQAz+R~nyAxQ
zvo&K^rd5t(+)jGqbDh?Q37=YWy@~urU+-|1f~*`o)YbO#1Bp`dE~VpzTXgYBzxv$8
zH}?_lt^^z;E32xOHryml!$Hy7%W9&cRj*2}g0daSTT+4j<j&36p!KK{StoflX>23+
zpGwm=j3=u+FC3I4dyym4d+D1660P3DRZzAg8K`Eyx!ANdS_i7juTQKmrCOgRd@9%*
zb3rqkuHE_qm^)^0_lr^_raX6%i7D6kBxT-E=ZP%?or~zw!P9fnzB_8zS^L6UBU*Ep
zCC_YeTab?xg8k7%5xRz*v5g$f&Tx)>-uCO04{jP(QwQgOL~rZU1Pz-9(s9<=<D{nx
zIFz+0x}aF+WLb2gSiKAw=a@uv57hzl&W!WHR_n8NO;g3{#X-0ku|Jx~9~5iHbs5g6
zSYT_+$(UlDZTWUg-0RbL#S)^yH7u&ZLW+Gp*lK;oR_m_3YQvgDX_OeN8T+F(s_Ul&
zYoo2!=e1Vr3Dqp0v|pdVokWRq>!&togKmfv!96TWF&eWrOz-1MjJf(Vc4dQ^<RZE}
zN+cbDAxdcfI5TFOcT^1<FKo_9)A?3gob~++<Hr|&Zf(-u?Brid%C^sStu4;_0uB19
z8kGH~%4<p?4_PHTPx;OVyV=jKn;ipk%V0%G#tR$!qX{FM-*oNl?c<edwQ^62P(82q
zbE;{Hg*p3-YPj?WM?PoVw@O@k&|z(luIg~MZdSYWXaz^S^f)iKRG+b>x_^4%wXTo#
zM?UuJ6M@xugevSml~gSvEvOC&CDTO5Z1AOuT<YZdNM0kvOu+bNvV)72=q-~z=in{-
zvzMsW%1<$b0Pc9gpF7KA9lydG#7hsn7Xu-qP8y!USL$xkQH@p6XxzkArc5QOqP4xS
zCB}Em`l-Y%hzKB^T2z9S#3yN>4JM6EhaI)5NX-uA3A~D2&RI9h<|^CX%D_o&Y8gyA
zX}NB$a+hg)7!OyN1_%61ra^#2Eh5uZbsZPVbgx6kHm7sa%MCh>UEE!cMf+;k(8x5n
zAOb#Tn#X^rn)Fj~$Dg`e?65y)4YzH_-x-%B!^6o-4sYz3MgFyzT#XIS6ghk>VJ(Wh
z)@f1X)xVW15)qNPosj({%fV6lRfXIasq~5OkuL;`AkUFYpQj{H1O(~pv8IzguDxL(
zy7aNb7^HtM(kBl4de;+^=Sx3nS`O03*5!^{4Bqfb{3(aim$NN(eF^>O=d71`bF*#l
zRuDgHXO?eFt^l%tR@)ApOOdDg&q@AqMGH}r$a;-ijtgbI;8WJeb3|ce?#sc_ut~ZL
zwOATmSAAY<l0NT7G~2Z^M6^4eP(IPUY4h=ZMjffHUMy1GFEQf5=W>(u*?L*+B*{}v
ztX>2#2A|)5{mZ}o;p^Z0`KN!87d3rOotgq0PBtVHO<d)0XyR~Mo>?5coq);@R&!Jj
zTq=Y*F(N-$M6J&;;1KJAfW0X4STiKe&C{B}5SaZ88KIyn;17D-bMpGE^RZsu%US!9
z1z=Rint4gJ6Edu%nHenK`o)KjFP5)32Z71ICWT~mve^CZl*gXNTfTfMI9cKi$MV#F
zqFSZ@L=hdhzQ+{{K7_zZ6svk{5zlbMD(Jxc7SRp;IOn7{dGKmgRiX~n3`;-`y%quz
zJkKh~aoqHr^k%QZtQn`k9MVaF3EArrn8~fi!FK91wo`Zg)BxR+;&?i@+)jPAHZ)?U
zw4K_1eLv>4sL|FWI=v{yPur>Q_-f5(QVnjFnAxBs0#3utz=cw+5me8d$B9$>qX{Eh
z+KKI=U6M+QT9NlOf@aYpvaCWs)q>}cc7~fCtT{F1b5%#u=iT?ppRvLFyq)r%B!6d@
zHuA6FnrAYfp2#LG;!(m?kgAsrWs$I=(P;fevW(g`9?s0N#&M7}N~L{Kk&5vYWDUNC
zXeu=;{M6dgJj#01Ae6P{SYFois06Y`ufM@~Ej-eoiPtAHS;GnL%HbV$+!NM<^szO*
z>!?b<8omgqNM8f&%Me`U-yx?YUkAAlcFFfIQt4Am$7vGw!7caM)hS}>lKUh&C4LUO
zl$}Rv&B^A3O5$BR*@XozVQ{sJ5{~&cwmK6YVp`O6Pi0t@GVZsy<K5#TxcrPBTQCXO
zsC>Jwr{{A+3L;#Wzgdbc+T`4l`9@38IP1h5{SEd+6Y$O7;O26#$NDhgQz5ZqpE_zB
z;<N|wpD6C+cs?7|3fn6QtVFGPB0F4x3OIP&b+vLX7n>^yv_XlO+f~)?S?rLV2u5%M
zs~AJBjjf3vKv~_F<k~|6p}+)1KLRt!wXrQJ2QJ1^g&os_YP^DdxB;wxv}B~M!OeZV
z8mS7<E5Cej5|3+Gz;)TqNLfSr^^V)oo=7z|jVw`J8FgF~Wo{eagzAugVc!h-5{SUI
z`M9R?=x3~bBv1`z!ag{qn)pL`l*JVHVA_NC;RNj9G%n}XZ4jx}d|%6&;fSjK(UMlT
zE)n<fMXT-Be54wiUI_XYdUmzCHsB7aE-s9FrdC7zAz&lbHI_RrRI4>>QmVt58eVOa
zF9EH#esreQ>bL^ckd(0x&a|4gINz~D<(X7N2q0i1)is<%s(Ug&o{x!2CU(9RaJcx}
zc~y3YCLavB070K?wLXm(pg0f^;Pa@K_exLG%8_b$BcojfMXGzwJ)ZJi?2lF)$OSvL
zk!r&^o)p`!Pd+%&>iRT+Y6!N^q#8b!=tZP@FUPahhw4DaGC^KCIhE(;K;-SiM3UmG
zWleYaAD$HX*QDZ2sn)0QpDJ1nPW72o&uu$WU9;w>)in#03}ndpg^|S0y91FIlkHJW
zOkF-0NFj=nIS>Oj3h<mwAI>T=%T}fIZ*P$}TcnqNsdG`)?aA>#wc+xEoki3K8UTsx
zfxkuBhk{NPSWoqRUeL8}Hj!?qmar#o5#4ZoA{(@)*aj`!wRY8!V(pR+kEsqk{VK@3
zYgl$69RYrk{Ypf?HPz8vSh1hNYg%RQz5LnB-fLRzV<+ByGcY@9jLDEa$)I_HcOLYr
zfyvfc@>s<~)^6277}$dML}6f&M!dnGMFOsJUVK@lSUZjHt)o!1-Rn{Pn>D7ZHo8wQ
zoLH?EK6vhk8PgrJGOZ8eKlOUYF3M*zJr8k#Y3#c0sEgXS&d~BMU8f{MQ=)pCPTSsb
z)9L={%Cx!F@q?kjBx;f}Z4cw&%98-xXEHsHaFJ>C6ayE^bit>0HDlE(hu-qPmUP;h
z<cCjJrZsMRPDF%r@0c@9@+)B)l<%2LLxdn|5t(N8txQ)RAGT@;A&HTLPD7sMb(+|@
zd@y7P1boi4K8%;2Fb(p1BGYIp1Z-fsISJ=UmFb!Z#3dl&s8@BmIeYi%MW<=|xTI+F
z54P;yMMNh*dl=8OpiSV4$+>GMIGnQ>UD8QCwk|)^7cs~WN>KS1RVVqup4NZ82pT-V
z5kcdzynObQnL(^obdGhEX?0-aMhZKM7g5GE7<HN`Ur2-hH*IgzGfT3Y2kzfraR6^T
z3%gHM)+eCNNE*PxTzibZ^2)20d@Kkf-M;8)8S=lMhe0xnK{7KKRVm;~T_@hE%y{_m
z1S5isSe4g0C)1N~LI*@>Jh0d~9|c=2BwectP?#g0O7XO3L|6M*2!aPG_O9QslTGH7
zKg4q>_&237swqM?^;YFIe@>ax>MaqvGN(OOy?<)XoMtdNP|}mx;fu`<UwhpQxyhm}
zjJT=N!apjB+NOlBk0(*5Dd9^kC4AWwb)FJ#pL(RI4J9Ua5scdAY_GB)QLB(JnFzCq
zQRen59^eH2B=X9Vx1oT2E*@I7Bno$tGobiU%B04$U8bMA0b!8py{5)2oE06wVe%;N
zbn{ZQ{@X;`gS_#mbm7`Cim?MU|2kvTl@qr^X7Dn~CpQKlLr?dr=4%N7;f?$AhOq%~
zz~BwQnAL&4Hb`R*Vz>Fsy|1mIci6>PMp?}-QQOnJ*T<8n)6=|{LBjh`)QrZ5WR@C^
z6!j#nao)Le%|>f$>>YP821)g1Y2BvN_o8lLU@sIXz}R0x%41P;JnXI7$mB>-lVfg=
zqtU82$)w4mkxAIa7-V!?QEw4QdfN6f$Y>vnIwufAO9zU2GCh2;>EWx{HLDgOWxE*V
z^zg-|hp&$(0!h=u`Rm(;G8A=|9*!v6h&uBXH>K?Q$uTqyTvAlT0R_!1r34MWsDF|o
z60|ho;X9HD>D`PhLSPnkAE$4F{O<kfn-+UzyBK!pFZRyQ-v(zOJBQzz0BbOm?PA!7
zs@loI1kPU4k(i3>I4n!Nq>DwG`>fLnEJ6ImU;NY__MiXi=T<JYNH*-|E=GIojvu^6
zXkGs3I?x;}VIB0>5PX799jsk;l+7F&Z$B8_pLX0oP#J@S>7WdoHZ3CNT?`Fll3k2Z
z?(|F2oYXJlKP!+1qGjQ<@Lncp^)rODK62?K-95FfQuj}Vq|H;0l=MDBMoG&!+^kM}
zO=hq0XtIkjI!oI~+7g03y-AvBwPRCAn!di{EV2%{E$Id(Nc!JqUNuO`j*^yzpeX6>
zU5rt7wvn_Av^q(rD@69V?kan9PfaFhuo)l9+PQQaTD!UQAe;C#m$oNnuXON-U;gwD
z|Nh6H{=<L!<Nrb4dnKD~Q>CDPV^s%w+FZsq7W>HIm5EiB&C|q5Xm15yV+^iVQhvVU
z8!uDPBbPfvBd23A_ToWnZSjB8=@?i4RH(uXPe%%UlHP2h^=dgy=)!wp)f)maUC(^O
zNP3IjvV?0q*cf8=;1Rt^9!^J^khBrWk&-s6y-8;Sz1ckLUeb-~$wfmBl|92Ud54+k
z@p0M7kj+bUz4bxTCM?e$Jd|`oZwR>t`rDg*aC8U%mWo0d>}dAEwKe4WI{V<1XKG18
zKWN;bo6&ejzH@2%nV~l~l3^$8ZlITDsi4@)I5isNh{vf>N31g9B3N`A0_dGF?_%%#
z)X1JBm>8M!kWC4$(+j_pet+88d9{;;sgXU`Yuxc=;p}hce58F{a)5wCs!KVSeX+Uh
zD|66z)%xj{$<aFSLh)@qsV|Izc`mzMZ8=iZ#>`5h7L)CI-9#<X14JEiUCO!ai_K;4
zMcu5>(`YT1ec2XuLZh&nf0KCpGMUSMvAOK4ESjj-cs%TF@Q*4{*v00uuaAdSb3eUR
z^VfGCJg{m(6BOtJayNDLBbKsf^S;Jd7=+kpzM<zlKDqeAt`Kc|jvae0gB0igbaMT=
zXtsJ&PYaMKo(QCF2k2^7%qW#O=->S5fBg8@e|P@=#~*+G<+opc|MfTO86+XY9=U1X
zIidNuK5-f31OL}w{^18+^k4qvpa1TMzD0(H?k!MFuVpxt30SMJ_jyTSH%08hU8891
z2r@!v+34My@o8r<gIpr*Z&^)iOzLZ}E-kxv+Yu8r+4SSp7?M;UyCPXs(;!t@VGq@`
zMrk-Tkr6sIq16~s;s_aT6Ve#mF3N`i7#FMJ-XG)3xMeh@NuD5#xJ@u!#4X0-+%m?P
z_K=V&aN{gVZ_2=hIVda#@TUHrHPE_G0hz)@oF4eOfAsxn4`ZnUH%9USa6Nnm{Cgtg
zO%8qckjP_}UXynv$h8#NBX{fp<mS;u<bw?Vs>*dyy9J1XF&Mk8*eoKKV8|nP>r+5p
zit0L2A7sOqk-y?KqBlNkz1KOqXCk4hVvZpp-c+D?#h)yOzV5qwW{EQ5dVPcnCcBot
z4cH%>uzd9z+8-2DL+3$M)cS&@Plx~qw=(KzoBIrq$s&uwuwUU)(x7|;<9%7|4-{ot
zhyvSIC}hz%wYOGmOz*GBX0i~*cXk11aN)W=T4!4py%p?_6pDNlh42-sWCd`1!RV|2
zsxne8c5jdtU+$h*6T0VU9ep+IQR7Wcw1;2V83G<1dDEEvHsFDu4yq4S1VcY<#@IAO
zOe%-2b_Rr2<4i?a<bfhgzk4*4Zw&2yS=4BIC<}2Y=!}BL^fdU(AkjMUQ=15Ef@V0p
zlZD-ud0!U$<4e^pbVmuYpm<U;X?%z0Lm!*FpO}(%Z$vD*vxcd$qyFV$GpUnTWE#qu
z6wcrQmm;2#=Ngkw`llioS*z}lLIlLElH$~L7_Fwm$-5F+*j#&St?op;`_pdazHO}`
z6}w-pD$8PBAVOV?pmyU7TK8EZlZ8CiF*=-~6EkFC9{s*7_D7tuEQESt7dMhc`)A)_
zwC=M+CJPB-yevW#YWGs#m&N{wQ<lXVd4YEXb+ijJ92b2gk3wP0-Y$%ow`I{qUV~J6
zMLr}*dUK1vK@32i#GEkOQsnj1AN?6seTQpwR$ZslZC|8DoO^LD7n?v;)08HUIje<J
zcug52C~C?k&LzDmYif<aQ0*cZgN=qXo1P~Vf3-)j8y<(_d*nucRpk4lN*TEfyHGX7
zo_Q*d-L$TD&#>_ais94ZC^Uvoc0xm6jbkUT$n=r(CsJX%N8g`z|9czoAjYt{I7$Ch
zL!%gj4}EDOApVrh=&r+PHLjDqE0aaepK$N)(U65Pv~5{*bYwFnlHMrt5r68rdB`#&
z{!EJtE_Sm%c~^#9Oy2PkOy46n!9W$capa^oW#nrt1qwl)e6j<GR->5YT?ulo83?mu
z7^+8Zytjzl?&K%EDI;GaCsh6jM#sc3NfVh=yJvLyN%z)Z27cHH4ShAeN?wuaL%@1V
z3^R0_I<gITz(;nQHtC;gXvjxvR0B5`)J{WaHBn9Su1ps4SSJgZekW!q-#mI-79Ahi
zz0jmLihRgNLYd$rnvXY(4mrAKn7G<K^OH}yw+1or#ZG9b4V_-u<P+@!S0L@6do%zW
z%G(A!vQ6`l9T5y|Q>Y!=z{H#BS^pQiWs<xru}$6N@wVxB^YOiUlUskMf?NH!n^{T!
z)LQptA$|Fo;s!WAWI>~avsQd*e)Y(1>FjiG-<jmi+`Yi0cH<y<MW&&gNwEjsSu0*^
z2F<sv)o$`6{VQvzsibL$m{hJk=sJv6LwCu$GFjwI3TNmZ4Oy5m@qJnBN8x2ztPu~0
zM^HO!Me9CGWU>%Wbe;=m@UkdHJOdUR)Qyy7vBp540zn;QF*sB|k%cZNds(=7IPAg%
zGH=_3T}V&twk(S^-~#X9bO++AC<|lA$-6RHi0gS-I4XiHjCsE=3qv|d|H`ru$3|Wa
z&DEu3r88u-8s#PL%4CsqCycp!G-P3@=zUojM@#xwmc<&2fglC7vkP?C1Xg<;-d$U3
zMJ3yrY1-l1+M4vKjeB6TPQXB6`kTlm)18RH*)iOtdo*5asB>EsUDRw>CX?PM@Zmte
z#$=!b!RR!FLrtdRQ?5V>@hP0bA-4&jRpdrkA0TgUZmPyUkzkC-_qid_xh@EKorh@D
zW^Wde+l8-BkT;s9$OgMIK;GCkD8?YKc5k2Pt0t+bqv)O^eDrmiKW!m}S>=T@drLIE
z-v&I0F$Q%QDuOdS1Crm!n0|cc({!7Lh(ELH473`;Ppl!c%{=ymdwW@!VPIPp9Us|6
zkfb+?e8flXoMrY(iZmt7zUv-Z_Zc8Vo=2K6{qE6_yfLsU^8In4jC_ry;O2tS^U>AL
z2oots<X2mAVeB7<>XDaXDXVjS_IU6e>U@oyP&9+%Mv^EJiZRw+Q_R)QCKF+m6|)92
z@WW1M=&Ny*<Q17dWGdyx2N-(yXaF{5wGDWmkFItSne<OZFytd~AEZuW$DC0|+cXB0
zyepH1n7o&T3%wu<<M8jx!nk(Qzp^aWhzW~{kVP}zUU_IW%1hpr$s&&xPw)n37&bTh
zePI}PN;+5-hUS1Hi4{a6xPxWbATN1YCJhm?vy2n$*-N9eMmBO2V_!)J%hFf_s}r~f
z2hn9aL)St5N+OLGDq>I!(r|qA_-?bu-?j}KnSLUT7FSXba{^658cCdq)@cUS;3!BV
zP^iu9e_t9VF8o9q!uuo*;!qBBdTU1OG>7ty5s7UC619i4zb}nrNR-d3X4@bZZMY+E
zOtUCg^+ajFq&;sKAn!}#AQqKz5VirzfHc~08+vSPW4p&)fM&<d9oroRXssfn1?49=
zaVJO|m1zh#c}GHLI%s$Y_Laq;Gb7(^$OCe><7LvpGP%nDO-iCLwc!pXYbhsrStbpk
z$si3k`Gqu$JG?IqGp|oNSe8aJ(dNKlAV{OpTd)n|WXa1iY0z+x40Ujc&h8)$GiJXp
zjs4N5ER8iLJb{5AjpopOkI`zZxhRbmTt+&BNjquS;+Sn|bmTCovr_CMa^Q;w*b*>h
zXOz(|jJAr{#lpN_AjI+54FgrN8&^uYQ^x)Z_&^81-t3_7AI`Eh{Yze!c!A0^U=Oo)
zTjWy2ZcQcWP8s_vyo2)#%Aoh@BBAR>k<iIk2|d2sXIHV;*l%d_uV4<Y4(tj0p?`*4
zs{J!R`9wFuq8O_{I-R?qvnGy6-jSK3#3#WVLyT$bptd0o25kF~q=RapqeTm@PHM!2
zkyCIx1BH@|G`4%(5$B-5N&7c6A|ZDu2`=fCG|iXxvJJD)cY;54&jw^O4sAmoDXGSw
zLnXbUD$pd9lrrd`2qrOEF7}BdCw$UN!vJ|(8iR@|HHo1#WXvOzAWr2{qrS&zCAQgK
zcFm-*5o5ymy)=y7y)TU#%MPW{Y@s<Yd|7Zi2S)33jL8K*iEV@!)2j7-Y1BA<Bn`D_
zvJHwc)B8ZKgW{OXHa22RywBN&^}_e1Vfgj~a%azA+n}hEPyFtCyj%zOO(fFL6Mku^
zyS`574$B9&Z18Pa461c@SYz$l|M~6l{dETkEgqzIS6l}-HDr>I7{^H>EWlbedS4Rz
zlvb96^cgj|B#9OU1)JD6z)TV*{8<GbuA+k;jHACViG4aNOJa=xY3VgBOSw*$rCeL-
z$j{82MiMT>gd_}z_a$M%lsTqYyVkrzv`2?eK@x3*^)@kGrgF76Kdi3{2Yx~l#@gPO
zgc+1Sk%TZk9Xg9U9Ma8+>9UopEn6{?h%2skXnI=|#X^>3FkSoBjN%n`5@$BlA+i{h
zWF$<{j{S@Nf%QT^lpYau+Cv6EF^gBwNvzpWM_Cv<PTrNtB4<sk7J6A2>we!Z4C5sI
zE7RsH<RsqA?t?(9QC{+{Ocr8pZY=d@A3eU?irM#NaSU;4WiSFxVop8=vsd17oi1Iu
z+R~NPC-IK3mSCf!_hn&>E74WeE;KAeKZ!fj(v|CU>B`lXt{7SP!<t|hW=8e4EZ#3&
zS^GxZ$pI#X-dKi)EZW>M*oBFO61gWnqDO)`AHmw9;|p8q{k|-Y2{^eTyUBvMlh5?(
zJB-$8?&M;V5NBbn(aXY!`F&X&!<`&%H(3yO^2t_xhtWFCoqQ5}ltl<SZAJI{vN(u4
z*Ps*2)`B{Wse>Yn%tvH+@;(x|)0o`*vN(u4*RZoK!*ZdEw~N8WA&D&XfFmahf7%iF
z%Bb{hSqut#%HxOx0yuhxxHG+c<Z92#sc|P4n*<-h8lvY5<9_eU;vnu^<4!uBiBU%%
zF@{`}MILuz1<}jGnD_g#IEXvNv0)d)o#|C6*XaV3s~#2OeI#(FodCZt3*%^suBtx5
z6H^*T=y)bZ9qeMdB;{&LQr36|?+Dy!r<m`{!Wh>lvRF5m>3F6qAGp#RGFnY=n7k|D
zPFtj6WPwFh=OcDG;B8qH%T`8ncAlh@U0`WiP)EBk0Z~yFvS#Rf1k0LU7KZlTmxXyq
z(!a8gNT=HwP>@Ai?dv;?)@knKLX$9#U^&mr!if2OSscTiykODng1EDxj&@-NzC`Ys
zkH}E%?ILogfw3)%ZU=c#x}#Q*>>#h+N;5IOKdB)nrfi2>c;q*G>Om2?3`QP#WJ+UT
zRpd2Z93o$1O6<|#mfvhG^ERmeh&sP<=}EAE%>KRoo1w0ToS(hDYg^X&8bQ*rON=q<
z+_+~+=Qq7f#Od50y9Apvj#Ncn<Gi8H*LV>t5I~-A9=d1jYrA{<2lm};iG3nIRn<;W
zaqp($PuMbY*#|&j3@Le4W}{;IUQ=N!-!9E<i^B5K&DPT=y;0yJP4V&=@e=0bf-%~t
z(NyxT47nJ9M;^BA?Lt=-xiRacH)Z5&yhg__-CA9DKt8CiNRVr-vO|tY+3}KHf-E8*
z6z7zYw`IVlbL_|88peoxp9wPL@>q}j9FUtwSCQ|>&1K|kEQXl_khg#K-9xJh5)%8$
zkT-q{V-cbquX988RpjO;NpH%?rHj~FMYa-Sj5?oYI4%Z>$RooUp;nQbkmVEP^k!`I
z0XZ=om!0&ALF+Wbap6Zq9vRNSs3Jdz;nv6tC#(s^p!4aPkejUuSqD!Xr4kv=m{SpX
zu>fQ^s;!Y19fEXA>pyPO^&huZvKRM^;~_|P>AZ^kAck8bFFNvwF-DymXG}aRVK^-U
zbKH(i6wh$Rk*dfKVz@PQqXUj^X<f%{x~}7<1yvq-U^u%)P(^O2A<;vX+j*Iu7><rJ
zVvJGeMls2|GM(o!Ts+RmF1S~bAH#6Eu>j=6aA{4)ZMvr8W@|bO!$Ho@+U-_I5&8Qi
z9cxc$J%P6)n$C&g8pfb=TXj*>xvl6}--jfmb3i^H!?kCBKC9LZ6!eN1F01E2>omi)
z3XsU{*x>OxH*{6ix%o+=hq9lqF&tzd7^BY3pqsoa@$*(zksyx@XM|cseh|a0F&s{1
z1M)V!_liO5G{f0C3~TKnhO<YPRgoXWaBB>Q4I;r9bZ)b~YdY5qbvLTT<Av<mWkuxe
z*$4Rf8pB~b2zS@F>AKgs&1fzn&u6Lecp<xmS4DnI4A<V=W-N5P(5+#NIycT(L@xB<
zbsibcI8qh)K@7LXaCE%TEv=il+2qtBa&aP$JTRQys;nYEhT(X-kj8Ut>;QSnaJXM#
zuA1nkWf2~EU^u(+S4Dmd!|4VmkQ2i-jKSJ%f?-YPniA=d)7dv}K(~9cMd&v7GwDus
zKyPnmM<<Ho%*DQYXf=^m@~&h+*Q~z){oFtM@f}{a8q_xQ{qn+_O?XT?sKPj7t;8Lq
zw~o0K(YC%cVbDQJf;$?*H0^1wTaZTJJ$oYH`_iZ};ZPcDtVahaK^iRr>h*`#>0pn`
zOTw}h9dzT}!btjkY1G(pD2;}m*ztr7AHf}MW11eh#3YeM<VOSKeQDGfb0`fN&PW<W
znOxw~>u<T)+?d2I6W-8l9`7mGcJQ`g?Cx!8*hHqJgJs@W<HQs8a0GX-jX?oMCXGB$
z49Dt#xr|!hmqsmi9NGr;<>%%p*w=wH(k+hZ8&+<bxe;t5vZ(RG_oZ<Vi>~oxI|%5;
zSs1-FLq^7$6GO~wLp(4@!?P%b8=sG`#cNjvw!wW7+aMOr?p;Bv(O*#-Vsk+no<(V3
zKR_DB-I5L#d4u~R(jXS)Vi#{4c7Hl~Sz;Tyqwb{<4g#Ws2Mf~ZcKvOlK++w>KG+}O
zHw$*+%!V>>=HP;o4EqLWhJ%18sF}uY#PtdG#)yp}=^&sR7qbMto9HKbS%zIAwxD;<
zkaWc2G<Nfoq&sE3OCJ$A&_O`A^rn>C^i3%@y&64Wk9=t4x;;AdHg7_&Pq4pYNID3J
zQAV4eX1})A2VV-<Bl{U3RqQpc8~XbzV#E#@u(xs1+q~V!Nd%qPyzV@C?Ea9P2L-CL
zHg7l7lJ1mk{uLk6?cX=vGYZ%ZA0;o#uy1f(IK<~<PZ%!h-EJ%;-6>;#MT2x?&yDv^
z0(Rq*$;&eA8(bHT?4gi+TJHyOU9<7V^K?MZt=;Dm{N1i^7qM@|e&K)~Iv{i!yP=4r
zJ5{}F5*m1(j^nv;aY@j-(M|HQOz#_!9yU_?8RE$%&Q)#x7_Q@VHr6|F9T$`I{abE!
zy|ad0S7<%gg~NAfhB&KtyYQTJr>uA3B+@%^9j~nh?9*JQ3zY%;xqtS9rdiY2jkrF+
z{)+3cR|M?s-+lkkI?Z)luo1_1f9*D~8{#V3yj^nq1p6zl!)}qF3|u!TWk~#;3p5h!
zA+EDYlU3{oaosDf!+sI4xA8vceVXgIL?gi-xy}HoVn2xMWGsTeW5)>C+nDFD-|ehB
zF|w%lI~Qq0?AZ74JU<=R@xwpfAEwiLb)^e?Mhm0#Hh;JC%p&%UxDMMK9=lOuP49O*
z<xjd(=6M;1p?7Q=0ei-E_d#t$ruU7w&KE;~>x@5Du^W2)1begbHojwP4A`6h_qsu=
zvCHIT8Fuj{KgRj{sUIhsq`HlLf7k3@tlv1p33qnQxG%htLj@d+J9>f9R#6&aVL=*!
z{cHm9`_eG3lyp%2VknKZrsG6K9rv`T<8EWq<YkF%Xguwu5vn>)N8IXhw-bk?gJo&F
zqCvW6n{fx*un}AGvP>Eq42h~=$B;I~`fb~=;dIi$vNT@tAr*hz)8dc2jboCRWzyK-
z%uxMts@>{g*S_vHq)fV_*hlL>n!b(kg33P_WweB8&fF;fIAO!WTY`zZw=JQ^Zo;Zh
zu)pF%Dge2s1t51jo+U5K^uEE6;i_yp4t;V?bZ^xqpT|g=yiR&2K5Qt1-YtXIuy2%r
zoI(u<ooPOc-43rwcgi;ZiVvv><enCR+$}>TFH7{kQ3P@dRUoI@B_N&6+u<YWP8s_v
zKBO`bMj7>Pd@^}ihJAzULLJDdcI8Kp{h0WWivU`DNQEHxv=HQO?Xrk{BR<65hvPb%
z;$P%COA$$Ts(RPL1^7Faf-uUc_vvV`S#q++5o$qBw%DSIy%zh8#yBp4V7(L9rNtn3
z+rLE6iOs7_ee4&iLFoAYS+29Dl60r6_gAEct(}EY2E9+0gWNaDK~A9_gwDX9#%{#*
z3HDc9M+G7Gv>@a@T@Z5LC<r-)ijY(LrVQ3ao3}st1iSDt{GCcd7-iJE8H1CTWj4RT
zb^ey;2W>A*>)nJyNq5RN|BCCVDCC|Nh1{o$Lhc(yA*XN+^{ExkOzQn0t`q%`-ihlP
z%Aoh@vXJ{mS;z_76Ml>{HdVCwW9mZaMg?8>qr#ATS{QPlE)2Qr(fpq0LuJURS;(B;
z?HvT4*!(N5!`2S4r|W+9NcZGriND)xHrAwU7#FrDyxvXhP}Tb}aUI)u8{ero<enCX
z+^35}?(Nw3B(}lchr@0SxQhK4u2a7xl@QmZ<stX!@{s#RdB_QSA0B%tbFYi%+rvMf
z!?J&~-ihnd0+IW4fyjNMK;#?>L{8Rui+Vq%K!o4StGn3RSr}#D`RNLg`$mPx8QT+H
z@AGk8u^wa;&oj4?-p^DIa&IUjb`yWpxNf5!<czF5kKGVgRqy5}Nq4HTjq)*JC$3AY
zKkn1jANP&wk8`O0IN33ziv1w2TjRPj)p{_>sCP3CC4x@IxQ$wmGqSV1-VKl{_G98Y
z9g9fs#C2(9$9=l8<GxYZamGf2$37p|73(;L{=UX_XR701ltJ%<RQN>iob%6n+4tAM
zr2d@1lO3*#S|5~A?0Eay5mdhMn;XmHn815_k;UDf<yW(J&h8Jm{aL9e8#PpM8zV_N
zQ^rj`+;HQNKt>q!JxF-Z^es=NIDQp#yaMWEhv+KqebTAo*2n`V!lH{@FVOoTTK5-6
z65O1_AN1|dK&6C%*%|ww2%?O8-JQh|sEjb`dw&4UaLf9S)3-kX^<=}6qP_<O5M|u!
z>KqP0y{8vX+@~*|xZ8^-jGbe1+flj=539iUqpC9S*U}s@TYAmJ-JX?|kV&R-87Z8`
zv7zgc8)K>>KZe>g$i#$=xQ%NB`tB|FL4tdRJm<D>QPZgfjB`sAttQ~D>Dp?2G?;Oy
z+NNv7Zd@S{kWaH4XYB`e3)eE8T8KM`d{FmLw)WSe9Pt~U&=imxldM_0o_FM}JrbNT
z-J-R(XCI(*aY$N@B;<rKFuOfNr-)o;0uDJga=o9M=(~#iAck8P<gjZE<jn;7?xEFm
zuZTQnIBZsX<R&7iA~$A|^rmd>LPeOW5X14AHGTJ%`yj17VK{sB!^$gohd<W-WM>^!
z<VIK@AlJzhdPNM!bpZkSG{fmRDBjvb0B5IvMdX8OhpNuon>k=7hU2P$fP9+a^yCkZ
zJTP4Cii>U$vOW8AhI`E$>0+ci*8~LQX5ApMuf*EzB@V{gu}SUx+#X+0)%h_D#|H?|
zc#gelAWs?2o`6t9o--UaZ#{BjPF3W`Fq|HF0OZ7QTo2H9Z+Y1I{vz@`hQmgxM{X2Y
zMSc*&$-oQbU^vF;$MeS^l|5SfqtzjRKAfLpL(d~Oj#NX=&pyD<n|U{D2g5POh}@WD
zN#_sF&yUC>!x_`9A~!4aNpH&BE)EHugW+%+auUPg&W6|8LGrFl=VD4u=h)QoIyXU5
z6}fScq&H>cYYc~NHXzR!4hODIBhMKQ+ZrCZaoQ?!V<w*<7b@bbi5O$B_CYdwrt_TP
zu%+OT+r_;qawDt{kn^G&`8l>)7L=!F);>r)PmpWvskipPaCSwlh<s4BP_=elCIoU~
zxP~$6e461nn?5ic7MH!wO<-I_ehkC4CDj(aVyPd<Q-*69?c3u>rt_TPu*~X_8yHpO
z$1ofpaYELPrDq^d8E%kro*~Z}4(p8`xiP0I@?#i|7h4;0#BdM3w4v|b@)#tXXUKDg
z!`hceZWLHWeh|ZnS+<*u1Y_{?LArT@oU`bIpJOZ9BR8Q!5&57Fq0Dg2yqnI6;W%Hv
z?;cu>Nhae+hFli29k*kP)+0BjTSacDA?ZySxi}<rP7KFYKYjPmY7~>aD?^?$999E7
zauXy~ksAj|dQ(Qe#&B4j5scB=P4|*_Wyo`e!<^V7H%?ncZp<X<O&PgR5w5o(hT}~A
zzI)4KkY=7C&lwIo-VV9l#Hb=S!ukL?Z!M6YW2P<`gU)SEe)6saxz-UlKgV{uM?Srg
z`WRFnRCTVKAwW(H$65M)_s}}caGW_GxE<9~9{GF>XX^tJJ(Q8tn_CQrgb2YHbw15-
zEsH&_OdwYF$PG~!t=(qGe}Y_wpLWp_kheju?;cvG8BVjQowXxk^vI1lRgoXVaJ-#F
zevSxUFb195+}uRUnV;tjhi!F_+ze4w<Oea_8p9!uT^^hT+;<PH#u;nKHKW$+JTjbd
zq$2Y6?Ctqe+0UDKH=Ps1ac+J<ZcMU>Jdfe9_3d?TOt*^MP(#w2GI9wyVC}?koC(@@
z53NQq$-5G3=WO}F?HEZsazi0i<i<gg-jtEAF&svA!5IDAbT4^VhFk>dtQ}k59=UPa
zDsp2cNpH%?g^JomOF-TP(RXio*nG9*T^aJ6;ZQB*klStADsm&Nq&HRMym?A~4we^;
zLFYDeD|uIfyydvX@f@{M9{GF>XY=Qh-jtEA$#6&-0P+^t^xZ@2G{bS0eDw3caBcHe
zh`OkAn@IKv@->D-(tu!$I-h1ZO+0dbj;(L6b3@cs<i{|aZgk_S6Jj{d#_zj_)@g=o
zbpX-Y@ivd#m{S$`F$|}N=m9y!aGZ<ZcW-&vl#ax{GC$854%_M;xlv#h`9Tb~#&D2<
zU<}r76B}yCH5J2Kdt^A{NJZo}!6fNTnc>zL4oL$*o-$n9WZ#Y#6P;^9f=3=1&X{f$
zxuJ$nkW0t`YbS=|M1tNV(P|WvyemU4rsR;*N%r2{4Tn^r8xKjkQ&xJ5U1&h3>jng6
zw0G0L<YgIl5oy34NzV9f6}z#Nq&sEo!bXIhSgzG<1nhRxGkIBtJ!d((3a8gQ)h<rv
z_CE&KJruF?o7=(+9dExp(yE5XbXCJcw=09*J<(B-;4F5#3!A8-jC~E|=o%$pPnoW5
zMNKiCZrcUyp6aM>a~k_0RL5@?y%X1^)eVp7>W0T=b%W<RDv+GUehAm`n;AP22!Oo}
zc)d@eb(-ti{R=UkqqCL0zt0DBgUcPtHcxLB?8J3xg~P*c4kQkia2?-F5autZP~t$v
zq0@RdLqpP?GIkk<!ShHWSQusC`N0wX33gr9_x>J=9H?G*7W*+p4*X`(J8@lF<?v`r
zwo_cURpo#a>%7gI!MZrUA5-Q)CAq836W6764v*<NhX>zG5N$pbI#8|hwBC)Id}8yj
zxQ;3v7-h71)4$|pnayv+b)nROih`%H8&gTTQ}*{)Tt~GIkF?g|VHeSomu1*D;<`}m
zKy}*F*p0Z7?o_dJW?YNssoH^22EE(Gq~v7@_Kj)>Ixo`syUlwm`uj2E4rk5g1J5IA
z0@%~It}Sg$ah)y$d7j6KbsqbCTz5>t!<q8}S?|PkX~n~%RRhdnm$B1h4<!%hmQg6r
zuIl|5uG3sb=$&dF7-h8iX|Cg&2_nyjqKC6R_IDfm{t4rc!F3PH0B3Z_oiM(ZqM)FY
z`@$nW)j>ScI*6y8c@`O9gZ)Aw#Mz$7{Ju15d^nWGEB2$>2*&Mg<7ww(C22f2Y9r{h
zGtUXru^&Ht+fCIHk`p?5OK9_(#tBG20QQUzpZ0dUB6ga=!NLM3L_RbF`nDz50<fo@
z9wyx>V}HedR3E`8quz~fl9$DC@X5CqMC_qJ;%xJCx3TYY0>5r-2}3V<MT1l`@l0zb
zo;F%7N@F7$3`G-XdtUdpG<r)g#*=iXYze|!7#)z70PIZ`y_YUe8?hxX%Pe7o4@23+
z+2$*6V;@<<F?`ti!lMIKQZVk|7t@s#PmR4iC*b5e$A>m+_-$#}ATv>y+Q!H)G&`DX
zgBUWcu6WwfJ$YGT8yb-WX#|F}8Qt$o!z`&K9V|<ujSp?Spo$B|9c^QpGg~~6j2EHg
z;%rZM-<C$l5;oY_!9E%*+nd=hsOI9C)?7R-rzbDVEMbEoL(#?AX1G_eAH$HGci!}l
zv<6^L8Pc*?5&H&1hO&!uJM(>N?(nn&O41#*`Jvul@gb5omM8OL&sk_S^Sb0^iQbi2
zJOhNni?hw|FY4V=XwscB_E&s})CNHr{N37R^0Ey3Mtm4bFV6N<|0?zx*A4Y9ehKEM
z+KVUqK+yX%*YWKIF+L2%7w7rgCZ5(!5>=G-{)z^v`r_FvFzTJYwH<n9df(u>P=0Zq
zzir}aP305puV|3!FP>@r#dEs;;;FY-cz+KC7-#$Js?FD8zmd(iH}e=r6&Q>%=zY2Z
z<GE3RL08zg*w5Be6tUZ%e4uyjBmA9eFrH}*#&fy`<GE3TaSBBkXDioj?1NcAu`FX0
z_cHo6;!|A)<Bpav&3+qo8K+Q~akfC-mqu;<a3~EKuV5QUgMc*JxY*k+TBrGNqgLY-
ziZ#yG?%tP1EgBq3<F!*v^&5;k*v54I##7IO_Y4^dIL@{LXImQGEMRbLM0I3T`z1>t
zhD<9sp3@Z^&y5O>6E^ofLmHneVn3#Y<IGmyI01<fz@Dxaw)%#ts6fvJ4|)%C;pQ)M
zvw-&S?e3KI{)z^visPA9aXhE1IG!6-9H&smaklJI)q9QohEc&Q8l*Z7Mj8Emn*I3B
zgBS^iLXNX_-YWJQ*A211qCq4^0DF@~?~}`Ox{~9`cOE3zLk6Jb(JJ<1qCw`i=I>O?
z!6<{?r)xQ$8?_vC@r~m;OI$_l#}sp%m5;&mRL${Bt2v(2)f~@_YK{|5N%Yvwib56p
zF*9H0b=Es^9Upz$_YbXR97@9OWcIgF&v6O`9cN40RqV%bosLD&J5_Wr%4qY`T(?ot
zaSA0JXFGmwV;{@{+Uv%n-YC-JQLb46Re3zqDv#%MmB*8BL5S=Z$~?|(d>oGWBWcw5
za43z}N+4B!Fz#R*)0H33jmnP`w);IN7@vFFHj2d{Lus@*5ZeYZWLgdKoUR6WZd8Mu
za9xg<h8g0wrP0j-+QY|wF^UQ_av_!=hD_^0p40Up&yAZcC==deHw;w8eh@>p2#EAf
zB?7?S?4a)-T223Iqr=AS7L=3iu^V@;VmGFebf-EC(5Q{D6CbAaAkXP~kY_8|_&M+)
zWkfsdHqxwOH{$vLdwVnbNZ5(}(t42RbUny(qaK8Eb3OLydJum2=l-q{D`6+DOY1?N
z)Ab<Fjd~EujP=;(qrvv@1F*MQKI@&hF0BW7PS=AxH|jwsN7G|BVQtao+rtmQzOMUG
z!Y;6<TsK`0^4zEgp$tineYzfmAASJ#b(N1&M}fWZe&4_4Ib9F(+^7ekoIsD=3|LjY
zAH;QQq({k;f-*#UEz5sf(8&yl>kF9YpIRJ(AR-_y#d%$1Gbqs58R6EBP;Mw!u#>lw
zy>lHy-#fJK52hJzi4|#uZ+#ukCGMY$x0@#yH9jcLDC4F#^XNuhZ2#(eht_@L%5Y1p
z<ZwqzH_=iRxB1E3sJ<$o>05f(Zmwd4!OjQC_X%!21jONvBf61j5%-`dqpWXwbJI7C
z=Ults^*u<u&v46F>2Qb9+|HP{aSvv-gAxsu#2IwsvcWqGXnkptpwXQx8G<AX6DP)&
zNkT>sCy6+?+u7**qA;Um(!a7OOxZ8VqKyJU7KWpecV)83*)I<EcIn`KS(vdS>0enE
zYuMLDf39>0vM~OeyepGM&WLgFw=?zkWl<x^p^L0xV2cK@5&`b$WpVj#tJN#Az%SYv
z<uMuvG-(%6-js#BZ97^i+r=6dA^}oRM_HJNy(o*EIb*S?y`l4cS<u@Kki{A%A|Vp8
zXl4@ZVv;-YoSZw6)8_(YyTJ6mEDqvMAvu~NlPnVMMC&AX;ukr0#$wX8d?YG;Uls>(
z=PQ^zlPr>G60MWmiC^U08H-Ep;@kVOIEXu?)3A#R$s*;>L9%`rM=syBiq*vzvDnm}
zhVr&72DKk$?rh-OQVMZrLmjxYRR(NxQzna?J7e*wU6_1d7RPWWFCR8p5O;DtL{D&N
zo#xI~iGgU=*#(mO9CzB2V&0d<G2E$3pqLR8cQ(|~E~dGYD-@zE!nE5i+P*J~W4M!-
zR>>}qf(Tip+&M_?&wM23&RCjiS54oS#WCEe%fpZbac4sv>|&7WpU6Thyu6QuxYI6Z
zZ_C0gLtVZPYCx1JlMS|RQp$_W%?gMqxmKcgVYE(1nS66Z^oTG)x9i7M<TYL#B41-l
zBzy_RsPk!F)CwM_bELU=UNml8MP6gUA#w@zuoOis$aNBZ_s}}cf?T^0bdE$1kK8=E
zirfe*ndg+Py^$PQJ5p~1W7PR{yvUUc5qVgCv>O;z<TZvH>U@n3k!k|uX>>S9@J|>{
z>lnPXM}{*(Eh4wo8K3BUjRlc3dil=P2faz6b(-NcZ{H&i3}-iPs>qLFxc26@;D}^O
z!5FOFW_Tx3&UBv7nqvv6JvXb0{1}FN?f76b9mvx;vdwWWA{XLxI*$dU_5iag@?#i|
z4;3SZLn0-Rr%|2F@+~6Iqq<l=YR?O+B0q-V^cb{uYZs8G3}^FPYsfV>*XukmoZS~J
zBDWdGNpGs7nr?OiIWZh()Ov=qnV!kJ5<l1MRF6C|oC%Vu$PZ$;HHJgNB#@`;f;O|U
zh&*SwSU76;M61XTVz@Pi!?qHTrwrG!=cZOTT3tn))yJ|?yER=!eh|a0F&uVrfIMZm
zmOnO!JZHFAG}?}^8?JwLbG25>u-%)opRX|-_9=ioWw=3Fe&XkvZ|3|wmW<kM`J&Ek
z7G2_dW#nrNhn4utcg_;?3^%xAAwy0qlvsOUIJ*~KMScv!=>|XUD<g*Es)m5v5O5;p
z40+CQu{hMGBvg?f!*HA`K#>eqFo8T}IGe{(M4rcRSOIdgRJ-e6MScv!@nMM#IWZhp
zH1yp=E4jorr(`<M87>xm+H{O6@?&B+PKs#AiQ%|<!6Ubc3^ko==7nRpSn_EPq%0!0
z874_@stm`6L^kBaa1CRatJ$sk<Xwr*xmF;oOoUsz&MgIFZd9{L6iIK&$k!MSt0O?3
z#&C8sI(b)yJZHFA?r9I=tm^zAhFfDe%+!HAWjMRtT11{RTrBpqr(9N%AH;BL42StD
zkf$-6-B2td&lxV<+I4ORaZXzMK@2BdY`1m+c^bpnEwdVO-Q;r&7YjXGO3fT{yP28v
zrtIfy42N0M<vVZ1d2Y9xLdm-lKi6$6kKD&_i#=wwXzg~pF6m7XIlsBB!(r|K<SE11
zjgaJB8S<Rr5I6Oa%wiL!s>lyvIDT_OjyM*`Q-&K{tB@hj84l5dM{a`fD)K`ZZs7x7
zX*@?X2jnTkwG92K7>;WL!gwCaITw3&YZdt+499O~ol^|QRS3OeF5m6aaLw9vG28ih
zDBWD_A-YB6c8NaeP1(=IA)#|(I9`Mf$ftK2bV=7Ej|@ldHOK9Cq52c#YYc~x706SD
zo2}x&b8?1@w{|Vlw|dCKx1F!7bm1Ztmtcg!V^fZ^%Vmk26OL<3i*aq@6sj~Ao9kCK
z_=8Ap4ddw6E?`et&Mq4jvFCAIytQkw=OkCLA4GF&AV;@$0ec$B+2xZOc3tps-hK*I
znv2bAEMm9oSV?!vHot~)bZgh;J1^CErnAck$;%R(*M*OOJy4y^6Rcu4u|U$DDt66>
zB!4Ha<0XrL-B5AzvJCqM*M&lk#pZBUu^$u8aULZFH7AGx*i){v)5;?DJf4fUb}jZa
z>?-zSxQ@@GX6(duS)B%2$uqVGl}zs&To(#87MrhH#eNLean2}XC$3BDGH6tu!%hQc
zw*Gz!w{|V|-0vE8e)zU3%Kp9vbtkIBV3dAkjz;BK?D^iqDHLKXHaEA5{UEMe!@3jI
zT`<aseU|HJz)bZX3NMzHSvwWd^1~0%`zx-aItz+DVl5Jl%Cmak;JQ#~v9yfbN$dx4
z-7Bs`A}6qCaox$rA0?ir0W;UTPn28i>F!mVKZxt3j~L^qj)GAJo3~?d4ZFq-KDG&k
z6pPKdE@HRgP|}?;*S+F8By(O)Jl?z5hDPN{o7b^3U=MMf&1$Y<KZffxSDW-sT$j~J
zJQkY+UhUs8u@`4%w=o!rk=;5MI=k=pG3=mAK~q;mT4VQYKsNH-hP+!sjSlXQ5o(}k
ztZeO+P;+0}+R_PmoPs+#=ROl;(h$P)28wC`FAZb-+tRSv9~8~(`HNy7WbiKLS`1{X
z0(&E>zJHgKb)bX^GVJ2?0sF0gHY~wdauxf2JY2^93c`@fDJX;9t)<qmt5XH+kAU46
za1p!ZiljSb?Bb~)CS-F0dkY-<{-M?ACV5$+ceN*v9Z8Aa<_)`4u^Tr@x>Lq3!4hGA
z682^XegDvE`j@;c!@j|ONO|<wjq_Hq8&gTTQ^qcw1nkJ@6qM2Cr@5{bb|edns0;Ae
z&9kf6jkrF+-ngv|cF5@j_LS=e1p=AgH@FUIj~=@rt}1r(lTWZqA4%`TbzEZ6_YbXR
zR8C%&VCTYzuyu4oa-zd-<yyo(s2r)<JY!|O6W4K(Mc+TPPIFx=??`MO>4_e@S;VMf
zKZfg6Kcsi!x`s0NdpjC_dv=@YeS_;zAK<YYo2p_zhU>JL2H26?3G9vc`~IQT@KMp`
zg+u)qhl7?qcB8~9_G7qCZIiGQ*EN(u?}Ji-Oz#_9hZ+Ho-S|@#`!QU{Hs1Ul`JI;&
z7hClGL#wgNn%=ntB61z71Uz<Qz(wqX8j>>CiC>c5iR-xBqVFGCjc$tA$&wSUL!zR`
zZsMjYcH<^VcgombaUF6z1!c5()4$|piOq8vMASP{6+L$2yjASRRFdwLu?r_b@5u55
z_LS=eB?B4u4X#72fX8llw2Iw`>l5s+xDI)qz@El+gQ9^9`v%vcTEJsB#8t&^e)0)+
z=_Bc#xQ@#%`u?GHn(Me2BC+|vb#@FXVjonKRBfJlz41J9Jq2a(_t{Gx@SF{<L&~Dl
zyCv-^_G7qC$0E`@ab0%F16rrK&R+7c9_fIWAZgKKH#Swpehk-X2_bchxQ-7!?fZvT
z!$*mOCH~GO5z*#xnuW)1lvu@n4A*fnVzYT<d<x27^Mmq%4EqMx;mBl<-NX)6?8k7O
zxy}MPpO+ICVD$Y%tFg<P-nlFy(R<`NW57l1gSwJ3*S+F8WPJ+CsCT2ABK8fgL-L~6
zyWx^5cH<^VcgomXEW<WWT$f$ffL7DL<YkG?b7@4>JJJ_DcH_KN?8a1*?v$}h`~|K<
z=BJ>HdY|SxE{;gBN3Ju^u3|Uh`UHE6<C@-)`w8sr-@R@wbfe?mMo6aj4X#6Sq}RJ4
zt}1r(lTWZqA4%`TbzF+k_YbYpT*n0xiQWU(*?75#eNbUiwRw(VS?|PkT#OO0PjelY
zNJQ+&Uvzr60csWdF<hr{H|d?YF1xM)t<zk`MG^`2z;$-6u#J7NGdrj|QA;?ZLwh^3
ztuI)0fHaT|D!2pt+4GMQmrEFc3nvn31opG#-|tJK#)m^`$XHF%AU@=>jox-Ir$O04
zCXEd~M7@Fc3*&R|OQXh+LupW7#5RZ_xs;>tF<Pe?k_#*n+lUNlhWNLoF{oK7d&(<5
zL=LIo4xVC9lc{-%o`2)ky6NsHZySb_wx!YKFtmqnZ#yXVQ4Ryo|Cl9+Gr7Q{?;l!C
z|BBc}rU858Oyl6&*aw_BsAN%T4E<t_80p?I!5uBZM0G`J$a8}<B4?Uszb_3V(xiiB
zX{<3M-9!dyq%q{6f+68dF3bolLHA2}zc6&SEsfqU%ujZ(5B)-TozC<ohU6lUzJF+)
zW=Jl~NU#TnwCfN>?1S1C)%yrLuMH3<&`o55GI)VKnIRE$qIWLLh}e-U>GW<V{#ES9
z#E`n4LD-28`4ou0e`uZNLoUonum?W0YcN&pW-v`uQPw+IbBhY-CNe=8^==p{d0D3S
z4faC`f!DiHVikLh>xMSJ#)oth8L($uM>IG$U#7bfb?*-kT}dTWgdcIw1;1<@6U0&Q
z)iqp<wD1}c`9IR^8MC(nBE?xrNX&^b@b$WQ5!PZ47TLCe{dj<`Y253cdc;r?Yh;L|
zd&V3kv2TFUA84G*Y$BxG+f}*uC9zLcWl2b%>9Q<HqIq=hy=dJZdNWB#gyC$$pX9jM
zBUj#+#6EGAB_V8v^S?+E&8590ri&5ij>XI-LOT8t_gnDG4&VvV9!^eyB+}9ZBGWxb
zOl-oGCRm=p<NaV^%x&8!Y;Z`oIqvmFO&|^yubwo5eDOFjWLB7f)@g<`7dX7$hXspp
zh=yIZts<`x;s`k}rMBrJF(TJ2^ol|2G$Wep8am{G674E!6?u&Shsa+Sq!9x)jA1OW
zg+is+=*%?(EiUYk2MV;y)m7v*!W$xA!$K;zJf~MNoCm4(iJxnEkK_JWZD~&+Dk2}$
zTvYvB7rkjg8OXUd!CU+ERSajY7YI7X;~m4zUqZpp9#i{J=j#F?L<!_AI_|rN)@g?0
zYJrG6GMssIRp$pW+$-cGhD)zvI8R^2a5h&lSU(RJSS@yYqKf<=hFe2Cs0ql^7_VJZ
zux($NpXV`Ntg^JHPF0Z~#Bgg!M@5$B^eTq)AfY}%uDSD$;lkxqi`|4NBDWO*$w*UX
zxHW{M5=+JyMz!gy7|xnK?vO)-p5f+WxIvvo8TlH+L6ktAGTii43}?-s_Q(Un*{!Ck
z&W~X@-t3_m4x$9|MtHqq&^jH%afLwOc0Atc-0s>`ksrfwx;@30N-@T0?ZzY%&&vEf
zXE=z^BRA8JD)M6(PERZYa$>mjDu%Po$gCmPEK+anVcKeUtBS~NZfw$<s-Np79FP;k
zaqefY7_?5$QZ<j#A;;sr&W+PnksCAl1o;}nL6m|qSo`!<3}?+G^vEN_&Bt(q+KRHy
z*BB0J0`ipMrmtc+o2wXX42Q>iog2EU>fHR~6P>Ry97GA^X$&`g6~mdU0s^<=@gBJu
zHmb-EVz@PigPMT64ex#TE@zvYlt?+@cFm{q)*czoz$hZOSz<|V%GNH!50++$;W!H_
zAfIM9%^z~e@p!LuGhkMcAH;BL3<psHc^bpDto*4N3)ce#Yscdqa=Z0iMQ(<J4|LAk
z(G<f$O+cP9-1JopXUzujIu8tIcbconk6}37K<7)P&goSQ=jp2$&aL7Bd!HV8U^u(w
zUqx=H;S-&&>u^vLbe=Mt-8oO*l`x#{_Iu=k;q2*=MdUVzA?Zz(;WTjoIwywXJ^J1m
z(K^j=ZKplz9FO;YZk)D?{1}FNT|xm-3dRt_*&WkF%9+k3G;}(L2tD%o7|!lwC%q}_
ze2w9tCLm84&h85)@5+!%faH-!hBI_k)w%ge(wj1J=^{25DTd=}gI+OcHG^*Qt_-<^
z2_AW5xcL~)?n)-TDI;HFIJ#7dF$Qb5TR_RX66CsR<&j5*Gelj~x!sCOdQ(Qe#&C40
z)R`*{yw2@LNb;@>xeOT&IUeu*+?Z1p`9Tb~#&8fNkf$-+ASFISo--UC-y^@wUqW%V
z+cJqBiaO^vWB9>!TEuW%WzcsIt;QLXcV)<PhQs4M^67(B&USMm=}j5=x|a%33dZQ?
z#w3$>Wyo`eg9trxW4cvqH`I{yri@%15;`Y_ORr)$+Xd3(T?uks()E7s84j1Qz7imc
z$n8RP(wj2!=Ge{JiQ#xDwpR>VP4|*_Wyo`e!{fcq=VQ1*{X-eKP!ZB(h~aoavhN;R
zO`ugoo--UC?~$8FS9NZLmGq{Je2w8CO2HWXeEK4Wv$=@DuERlu9=Qp~s>sbxK0&_5
za44t%@)p?i-9zg%!*K?Fn5E+J9=RDds>lywxHX1@ngnCexm`X;q@4J<E_gVGg9trx
z1EYxCF5@J<DO<Y?Kk##6I9{meyNA|khBH?%SZl}QJ#u4CRpe$M`~>+L!$FjSG3wmV
zQ1Y%!=Q+bcgbukqY`Kd37>3idO}<o$?`(|7jWZUJ=P_KkR0?O#PLJn<+J&mMbGj#u
z=UAhF&Qpe)zI=i20gP)hc)ZuSG2N=p4K*ZsC?j8EIJ#8ooL;@q-SC#YD_Z+{C!J$B
zJl-QW6jDRp-L#kVri^@z;pkE+xl69^9$HQJl6Pgu^B68(Duv^zX3d?iecN9CFGCkD
zLMk9#DkXQS1?;mN$9JPedykh&;kcT4>_%LPD$3Z`Fs@xHwWJp>beCQwFU$0vvs}DX
z3ddK>V>drZx>Lq3eI&hu=NP4D`0nDT<YgIl2^O5U$4jM9sy>hXAfj7Cxpt`(qYT*X
z5LCmigJ!@Usm=f?Qk{(jlJ1oCF8U$86W8%@=ly-Ux`D4tO8gzq_cT8p&UJS&eS&=r
z=h~%Ge9ckRyWykcWr@vi)i;C!2b9%J+q@kblI~RXu372OJBmf1_r`s_ZqRCcGI?2s
zeS_=pe5ZGtNnf@3W4Mm<+bN_wL7IXx>fP975&H($L5d#xbWqpbOOte`toJpjYnMv#
zl`jFi)lKrUMDJ=(p6f!H1CsKlZQi;`(w#E)HLPowO7WE{5xePM^0Ey3MqC#P9gwaw
zkKLF`(w#E)S6l~aUgS=X-Y(HP&2<}<4ku{Y+q`*p(ci7OKEd9&t@%4jQUqnx`!v^W
z)H<9(u>-dF=JjrV@(Fg~V{jc+J1l9n!!lj%u<*SIVTJA#${n!yKabsnL!V%O#dTEg
zz$k;>r|TV-je3VuD0slK;57DQ3Lf~)ZPTq?Dz)$#|GiIMmg$OzWuxMOE=BVGZpP1|
zzaLZbfTapZov~BR1EY+3H++;BS;F%hH4i69(P6hrtYSAqL(-ip&#P_1->K?hNvj@~
z>8giiqw3)l${r9-&D;DjT*o%vcpj<(_U8Y+ZqRD%G7)s9_l>wN6h44r=CK=!NV-$j
z`zx-a$_GXnY<{}(VcDpBpi7aw&6~KXX!FOEJ^<{?-)Rn;);=uLwGYci?E_tk<gpv)
ztztK(@`>JGaUE4ZFv_U+X|CI-emFsj9=myV6}u7FC)i(c9o0W9Y5l`8UH`Cb)IZRr
zNFKW(t}1r(lTWa};yS8;V3bks(_FVv0dWc?5Ena!RIwk#b+5RNY9N-h24b16fmk+b
zAm~yguXh8ai2ax%hzsA*)5bWef?$+E@AgE}#K@8{Zlel<E=BU#jZIatAH;R9xQ^-|
zmb4CHnXZFaHtHbgjt7U`4p>#}$8epF!-(ss5`s}iy_>mKQSZVde%%IA^w{U)x>jcK
z`JNPy=gsD!Dqv6Jy6IYoWuq2?E=BU#jR9BnZYUyAMK!L|7=-jrT$ffuEYsBx%SJWC
z3D5V~=i|C#${{Z19t*06V3fh;r|Th>jd}>W6v<;Z&Rf*GJ=X9Oy}#l*s)$$`%81>>
zUdhW6p4T()yuXK%h)av6#CfaOjkuETlx_YM*HKLbpOhD|Pjg*6XD->3Ld}KOy9v^&
z*v(Hq!TyTts49X_gp1hC7@WK;(>u{ohCOnfk!uzEL0s2(z41KNMJ%oMBVeDdi&!@5
zBIr^iuXh8ai2azth>OPE;CZTySklUfWx6tA;d>F{I&CP8xY%mxDt0q0CT3Xn_g7p;
zwGoUm>V2B)_+Eqrdx-07a9+iJ4A<$L1A3?Gh$XF#Sf;BZ_;{tn-(z`%ohMbXAH#L+
z&Ad)a^%0CR>V2B)_|Ahw?}6*utY<jJ?VrKgoock>1!r`qzsKU0=8D4>FFFGwOCa`3
zYbKWInu%qjX5xhBJNC1)#%)U&NTXOrF_gw@O%LkCw6~Sg^gTwaiA@vHC*z<V5aZ*Y
zSV+-kg+tr0$8IhM6;kMY6qZ1h6pS+X#dIab!gn4-zlfz2b`HI52|f0M`0y3`Q7y&N
zP)6(~Mk(rD;;Nwc5c}ClYZd!JeE5p}sG4F)t0|W0YKmo}n&K48DeOrKRqQ5YN>ove
z0eDW|Vn3><V3a}c)Aba~Mm+^xoaEWh04ZWWsGvgEA;{l}>(YvfWxAqb*{G<XYmz*6
zGsaf29~1lWdPdVb)l@LbsQ2mEPY)FE{vL}e>|#X~`!QUnYcS9|R0Zsf`+D7=b(-s1
z<wFwt#j*;!ZdAp74A-?cbL>ZT6^t_K-PmP9F3I@L_Zh@7E*4hUg_<gMLlH@Ls$8e*
zPo#I^y0o(5f{S_f&hU=d*Fx)H^MUK^npq8dS3mv<_E%g-wH1ug>%A-AO<tB^CpwBY
zPuCkcuCwQMRIwk!b-MOOcdmfz7-hsh%XOD_2}FiH%yaDtDpl+Uaorl%(d`|;o^jo!
z-M6s4VUX!PkL&0T3$J%WTvhDmCy5!B{ayM<dI#4r%Bc5QuDc*%KezcX&$Z{rRIwk#
zb?cfQT?Yc}gfd{CuC2Ii)K<_v6<+TKND=!%wH58Om^Q|pskVZP7$f%CIqYTQ<_Nl(
z!eci!RmFY~*EKy;Tt~NX0DI&8zJF+)=DLmA3c8!ZVYdsjRqV%bovt?%cH+9UwxX+d
zO2{SQx{cc-=ynQ^-NX)6?8k5&uUoU;iR;q)BXIQiY;2=78x-5%hCU`f1W*CFd2$i?
zpx9xD<=2kT`kk({x7(x`Ves`qLVKcfzL9|A+4Xfe<2T?oEK<d7ev%kq8F%ySrg5l-
z>jC=Sp>^N5GTag`IDJP;H!fSny-zx2-1O$g?qug&3lMOdu_qC6hFiu<hdYeuZJ%Ij
zb+SvuPdZb^Et+ZfLP?&v$8GbUlUHT9WxQ~>!)R_#W~%Dj41!5#%DC4kj>dA%vktfo
z`y{VQaBI%8!ySimy9HDPZZoly-jso_AzT~DxdI>{H-4DBD?={4;gLsbGfq@Reh{_2
z#u*yNIsZQ(pXN5s$q$^K4CBUftH=)`w>5mD3Q26mXHk30MVy+gaYlYb9_Y>PB2|&^
zuai}+UAM~+ThM%k^DTRwKQ49`uG&4L%fvy--D~?`ZN1dpq<cYJG#gcER-yAjR0z6&
z((Y_+1K!^n#N=<ce=34A?89x8u8|J~TDpZt%V*F~n(Yt8?Y=AFBh9q)vN#7>m`88R
z!fuWsJlO4xB2R9s>X8d&(!_$0w||E2878iF&-~;Q+gu|eU;T-`PO~Iu^9Qbo#g%p=
zbQ|!<Hfy{&w9Pd*qH0S<9cBS7*Jp}1`F?{ai^!Ws%<s#h#-u}8v_Ydy42VfN!>PAc
zBpL2=LguG3G<iP_p<>%U9frswyQtCjP!?+pMfXoJ>R=Z(8zphWL>8Js<79!r&-3?u
z3}y3zlHQa#YmK20G6Oj=p+gQzH&Wg<+m2FgvdSmj6Kleh+7Uhay3YxjK7;|iKKupX
z7rS%34R~OiHbZ4c1S8wjEpmteH-a;2ry;cNb3!Hyaept1o3~B7slP3YUipURc94(8
zQ{HGNhC)a#7$b6Ho5{N}<YMw3xeM4Hm)ac*BP%ejo%B!rbZ7<5F`F#zB#Y)3K~<&D
z=chmZ`Io={@s~gT=dZv0_;xz|$K|V2p51WY>F^(a{P~yPe);{^-v;4e%ZvEAb=(aB
z7=HKTu0(gbFYR;}OFmnI!Ekixf$zuXs;QyXu3;7eYQgBN7N%vmtLRjAQ+P)&!|tsi
z5Tf307(!o7uaZ|}`p6j-HILn+0oYK&HsFCT*}dVUf2yIOFRhUeLUcjxG=$b^Mz!?|
z>%0KBAw@<tkKUF=Z<|JZJIII1U*jBv?}E`GhpG%?Rl8??@=5oEnISY6I$th!zbJV{
zW}6Z_c&>0X1i)qp*#<naP4keXe`VX0PV+5VjM`}kvY6&g-S=^_KoHsc>2>}df=he$
z_Iyc^4{Vd)+y)A&9+mx?zI$jTzS(|PVg-DYLztU|;?b*3=-IY{&MOD?9%ba~q7lMx
z!5DSE&j1;6VS2A~ze#gN#>XnuD)Rl2qKtfvYN&Gb(smCV^2gPl<XY{XVb~pK9Gc|1
zpo6UA&QZ|UeSgpNA?)V$;p5J0OBfo)E(1QYmpSi<U@%s4U)U=t?o6v5y7kuNU5PAo
z8P~}Iv1cb{DBl>`w(<wEu*=m+|I}KCvJi*D{a>`Qnbtg9rfVM71ye7JbC89hfcIr#
zoc$A7tT7Zqa>ycC>qM(jUh=NYF7kL1fuFYv<Kf$~=-9f|S8R_RY6U}5SYs$e<bu(0
z7FtdBipWKv-U=M?z#~kowT*n_5yq5~{;4d69<c^&m^ujRD2r*Pv=tF1l19Row*vF%
z_hn%O`iU&o$PH5m$fEtT?=Xru_ve_2N9gj8vkQd7P8K#R?rmAvg|81}(fZOx4HWST
z>R=bs6%)K5gU5PV1g5kJi|@<g7^ZA}X|h0|3|XX1Y1ac1xo38fGbI9KZx;r}`?A=N
zyQ_SmsgbyMinueasJKj5RPf?LVi$os?Lpb^%i<XB<djQV7(=oUWYLC|UU_IW1Xr|+
zJjz5k=<UL&^nF<z!=0Ko3Rw_$rWF_61g#{CbxP^@0^y*Sg$Y#Nl|?soPWo5&ku}Oh
zu#K&#HaYA&j8?PKo4hOX1yAy#k6^dn%fguV`?4^klk~4F3kiyFml3#=QTuVEn<6Cd
z%4CsqCjvw-3lqk@FAL*nN&m{SSmRCv+mJ;wlfJ`fH62dgmB~Ux?0qD1r*ZZ7Wnqjf
z>0enELUOPRa3`aVb}`GH99kzn61men`h8g#fqo*37HHBqf=LHt(f;Y}!UjaiyAr$5
z5YE{J0z~H{_Vo9+WnqKYq<>YrXnkq17Q*k#l|!$-!)Tr6P7PbUECP4hT=n;5aSV5A
zN<MDJBJSjHBgn!Ge2LsMyU4i{`)%GX42<_>aSV61f`(=n2)`kVlsl(y)41A-4>M22
zUYD1JF}e3;aSV5A$pY+xxHGK)xgvFMT@o(Zg;28hk-(j{$l`rj9K)Sl4nf?B@Efv7
zxzjpzO%_T+P8M`!mp2UKe{T!JGH}wtGI=(yXu=@!Wd7(oj8<dG$-5H5P~Qu}i0o+$
zd|McHP47CWR8r`pH9am5A?S45o1hE<#q{+XSGBKzJ+h?<+^X1X+&IL(#+7v28?dM3
zXs?MV>OBuE=?*XN1jd=G*o~<q-6`u`NQ?ANWSCvQ@wnRSH>&+JkUr_(8ry{%*)G@V
zDjo(B<J(iH%I%)L4S9c&xs%(D5YGD<MBJA)c(*&y<lns!K^i99NM4o@(`Ic?*c7*w
zI&VwEJ|yX&n(R;->t=Dg6^(HRs%o_`+j||EG>F&}+d$mt+|^3@eQE5EBV}oj*4Z|w
zmiL<009{*s%$zi2EcC=3ih!>6j+XbOVZwk<Y(sPiI-|NE#vN^ApPMq<kRc*S!)56_
zSpFYwU0?0d^`A&XW-25NWVm0mTA|BzQ1y~YLr6JD!zUJ9TP4}Y(%28h%bv1EckOmH
z#vN>9PzjSrLr?$q(m?p=dBcp^Z+pt1h^j0N2~J=eh@N2ujYs+(qjf*R%A~QuqQ2q=
zo>B_<1|#gCjH)b+R|trJT5w0(F#1c}GLyyzi-sa0_RXQEbfLdJ06Xc9VjqRS=Eer9
z3A*y_BE2O*TgC~uZMW~AQSc}Idxe0QrF1TZ&YEr|@5odl5pQtUFi*F{xD9z^p!;Ku
zDrpq-w7&2#j}TpOI|F@OEjR4-crX3^I;eQk9v9Q!xlht_H$I@0V>)Kts3?l}yD_89
zdDJl_MZ%?RGEFr_j4~?A1c2Mh>OAV0nxZS$Wpe+{-lL|AimrMbtoJB{qMf(GKFx5l
z4SC>E$5a(@U)V0GtmxWsJ0+oYpTiP<X~(nTxj`C^yC4k{^S&>Q{V_?s^*oqjYB4Lq
z0V*|O+)*0SY^z6y25CgLH9)qd(Yr&9TSo&R4|wbj#I0#*(bZnlRqS7}kZ9PyS8(EQ
zwYyxWD~PTe6-4pYxT~!L-iADI*Y-N0;bep^8>kH1Fi@&0V%*L^;Znvxw|m?f(J@s;
z{AQ+;P*!xEE-Sj~QH<ViLS0ceTyH}jDajD?2TC%R1yErT<913y>olis6c(LAWzp4+
z;O|SrP|+vScr8>>u@U2r(l92Qyet`E^w_>&8-Y`8c=f(CYAib%VYslmu`H+*(jeSH
z8iP`rL>hXSotFk|(M2CNdU{(LgDR{lowdFQUC>?=mnZc-Mym-CYqp_>yaj2T`)5Bm
zY8!^f1Kt?aVU?xvTBw2p3+`weCSEE^L!KL?5h7C?^}cT#2eIgDp$cXKX|#X$`a|n9
zi*j*Mj7)uL4{XB_;I=fnVbq>`mMBLpVHE3V^o(I1DiM^<63{<`eY=1AW!~3feNc6t
zYc2@D$Bud~*FpVFMr(~86J@zMG=yRJd0QC0vi8TEva((=8Qp)!D5J8>%eMPBP?kN=
zYRA0F$`a|q%zVWaU`(^Fp7`W>2Eln}2#>3s5^M{jQ<gp2Y6tqrv)Y?^#G!&EM(LD=
z)@hElm$sM`pi`_^vNM5g?1K@fSi>}mMsyNH20$F!a7Sqvo=HTXxGnAmNjDJ@!Fo$D
zOJDCx!w_}SL3QMzG+vvCRK|2|#amGt#*vekWzrCW2!0VFRXYoNUmAu9lMa@pAzK(^
z8x*Ogg-qA!LZ<6RA=4>VGTCDu-j>Eel}tJlC23Hk%4gE_){NF^&a{`mSl&QL={?18
z()-dd?)HgoykavdW@6mIQ>KfVuJ$^ZP8uOnZFAvI<92&E%qP+iwu5a@Iny;QXSz<8
zGhOWkF`YCbiyDT0-!=|nQR)kiuvE~*xT9@Mv#7l?rjtfwQA2?5OT#?m6Wb8(C)*$v
zO-q_?_RNXoWpPZowevY3Wk06Gnx?kG@S&&h>pow;<kgP0`awlajN9ABZMvxG)=sX-
zq!C!uE?m588~nP@rJ-v!unj6}V%$+0hWCrMu`%C|bxn4i>3wM&GvDX6pJp3W*mTPZ
zn;uuY)Uw@UJ9D_TN|>>>b|y_X<f=AK!@0KHgT`-eY3*{GuCBS+>YDW}I5*Z0{&oqh
z2)kHHlT4V_jx@NhFc3;fD`{@il{7b7NwdBVXB`FH#<r@sYaz}Mw>S}9;sD%D3VrX;
zI_;WT;7YV@aEAeX{@#FFd-T}Mhq%|!4udx%43sooA#<}8G6r`Ty6yT|Ro}I+Wr%wX
z;xJ6#(rTF7bT!OPuRwA7hHtv)-mYU-f!89GA@DU`qY*hReYs7SzT9l-i%~fI-UBx%
ziolC?E<@n2(2Pdkw9e%=UFUMMbuJcp<TeumSCJpYZLf7dA~&uC^NO*Hwbkw!woXD7
zU3nNOroEYG5blgJ^mX6clSrBCSU6I)`f#h$kE>l=-3GkBFn1f&2B`?n=#M)*f9)HM
zx~(rP0;DW6>OjLdqk675@5Xg4Q5In}-LAI2FAFm(-7$xuEMCiUSYE$1)Ik>0MKHHk
z%>xlTYL5BJb|HLQ7G20`D}{ED4;^8Ry(l^P)-XEcFcsr;+uhsWShy97QmQesu7)F$
zb%YNTvuk8GzRD(QDln>Dw%-;-rzu;+@`<L_s0m~$7@eljIvp-@8B0VS;>EV$F2P?F
zxv`s1kgstQs829P<oisJur^<16Oo6A(VnnYMZQ0VC`S*ya}As*7x~7Q=7dqyaCEhM
z<|m&hW({w^MqSW#x!IiV<Q17dBxG=G3Et=)4LT}CHG@&qrr9U`Qw<GAjy2Aq1Y|}X
zY;(HQ<z`D=)=|41%kN}i_a3&DKahpZX8%AIy6u8~qO{|d7P{PQW^(eb#4a?6+S`Q-
z+#cOV(fhL4A3Lgc!J9X<)C7WsEZS7RH)OQ#vqUBf83ep6LZo@bg#tI5H=XFJEQ>X|
z0_6(o=p*}-l*vNK(aXY75$wXKblWbvG27-K?;s!XH=n@QtbpRm^x~V_pbR8Ko--xf
z*t3HffUC$2xqgDY89X7UBx1(sbPmOsXr<Uan|At1_ts!4<PhI%_G0piL?4=Q=`1m(
z5Fc?h!OiBHCjBdW<r-B{1~H>{8bYhlQ1Y%!7NU4Bix5xR&B|@%4@R!{OH|fTmFB{H
zB4V>viZIg(m7C3lE6PGd>}3%m%-TH&BU$W^CS|)=gF4C{X4KIx_E{pc3wf-QMNA&H
z=TN?H7yF}0Sr%(_hk6IdqW!Zc*~`slTh;7BGsL_s&i$hw-Ja;%vap$ON&kwnShs_5
zBsr~Ra$Z;8VYHf|HhEWK7p<%&u93j8`?0Lsz<ysAwbji*)GwRL#21t|%&3EpOxL2^
zGy}-nh3C$0cldo-nBXAMRoO1q=#KJ;Zw+;n#q{jlR-&w24S9R+?6&f^Wzj`<HnV33
z`5?NJ&Gcpk#FVYtCL*6^N?Ubeki(6=M;HZGk=J-}h<uIi=z4-%T48dtJO7E46E4tf
z1!w;uxtBNY=hmWZRz}hrwe}(MHE;w0;^wC8$lROVN>AREAr~j|$Ri7yLB6PSo6nH+
zri^@z7b%aIF*<9<fMxuAyL*F`;=#>3+Tr3#G4}~046dnnO9nt;#F@w@)07y1*OZ@u
z-)fg9bi8D@<dfbg@S%;a5gdq4Fgi`4b)N|`<oSFX&hL52P~Nr?^vI3fe1d$9*Fd6z
zF(9|Qj>)?+<nmajb2z_4ZWCgv$c?a)-c)t2Sw1+{oaWoSzu9*Wt^3hWf?PKVJ#v3i
zSC^MmL~b`jKS910e}d=)W7N4BDwB6*$SIPIaVcEX>)Z&nihMsxF6(@ayug@1-Uj8q
zduW|zIIhqL`yxmm@yHE~D)RmHgfenb4y>IRj%z{s?xA&>;kX(jA`c8_6QQcek6}2?
z?gDaRIKIBdBe$CZMQhI)4le3-ZWLHWeh|a0kr&AAa^ua0&^=@A#qJHtOUfp>hDTu8
zPH5<>ag>@qY|Vz51BCQi&LSH|!h@9~yIGL*Pem}A6>~-#1zIh;mKVQ+EQ|pq?@E~1
zR%}>VgjsRRgd57Di#v+t8Ka0xbMW|*fLmIfakC4aMdV^rZuEuIcLw(8vIeVWZ#*UG
zjp}@eT!@3O1YnF|^tDTR$-6S0O9<<b!|5Gzo2a*qd}ROoBZbOhWdE9w2wBjqIIY9D
zPuF4GZ5@WOe>km|1w}$b``?!ZzfB&J=&CG>H7WzY;%?b&o_wFK!noTi3@eK;PqwFZ
zziSu#wgY6b#%Z8L$f5-=z4FjH%ZvARcV~=H!<7JCg6aFR*pHygcCkioAW1>(`QmO@
z5fU4Wd~w(63C|aSDUY}kfZuk2U978U7#bjpHop#bu^&BUvdFnJUJ1};lD=;k2a)F*
z-hnqEj5e-#VN6%Q+;v{;4C4eM@$6{^#J7cE7XT8=EqlotOtwn`?rBZTeYz&*zEKl%
z0+o1anCZ&<(lArwPo&WtgW}3|Z2;pAq%mD7bJw|4u#FH|+BE3*rEw60ihGkZh(gmF
zX71DVGxv@989E5x+lHZ}_oZRn?GxKr<4?M_0MbZFbh@hMt`WVr4LG=yhD{59UmC}d
zD5r0;rx1&#r8f8JQk%O*wm}+!MQxV%+tRQ>{Rg(u`hoxno&o~BFz&z`)8#k!t@0c2
ziMI_yfZNirGg5x|IJOwg%QT^#uv5^P72u$CI_R|5%$NY2j=lHT&7wyYdyOH7*w+~I
z1acIVQSWAiON=ZDtn})h;01vpTT;C!v5LLMhePaZOnCwo0(-)TkFHE$yMO!Jbay)_
zCIZx0r@BqoN*Bai!-A{5R%5%vy(5`XYNvZcfxbd9&{AjPm%C-V<Q<6(DMNc3@<lAr
zk+IKh$b;Fu9h{O5s*Xl08(etMm=uGD;0_)&U3PO<mI~5{Olk(m_oZRz_!DWoA}}h&
zxi{QV8q?gmQHpc&hw;NUjBUR!jT+kyZQ~VzQF+dt{Wy4vvF1ednWu>31=|R0YfDYG
zrO}at<&&g4>K7w&Xm4iDq5_?JR-l7cqpjp+8FsNSj~(vZG0=kxMTR5Ih$W13B^^|0
zj4VNmRuFTb9!PKpzZevoB+^hR2WgyxG>n69Tf#sZ)|@_(2K9w)1H;7S&eG|7j8+pR
zB`?dQA<qrc2%Kr3{k}AeNRtkhZQ~V_(Io(kJKDxHXL4ap*s?vr!M&##x_e(5<{_U*
z;}xaRB>;E66rk@hTBkWv57-a35joRHdRrPDXAY{B)DniANpBXvAkJ(kqa{ppCKuO4
zOMp9jOE95!6?=^#huB}iBnAawZ)0cQzsr44<C1WK9tZFB?u%P6UKpDyVjt8emGw?<
zX1#+71!d6tbn(r7qxj|&s&BabYB*MQHeal@8S4ENF;cP3y`hZQjZY@zlIdM|B<MY|
zpYf-v-fLVp#NKSY%^m1){(D+nbDu7*x$6Pe0ej#&Yrs|Ph9VMGRBc}U5)ly<(=bY>
z_s7lp`*!~ZvvGSk^-hngv+>p^@m4n*zuX5EC7Gd$5qM?cHIAIE$88IvcT!{9JJ3gl
zszd^1L2rW6DGROp@lb+YPe2aXLlUJWzasWQ@ln}OU*Q?VASfMn7^-1}?fwl6bx<Ot
zJuVySE0ppzLx3^Os2e3Xr*L$CR~or3jLuN)X~Ulw>MMexk{d?pl!aC^(kCy=40U71
z9cylC*A@)sS;Z=xGeWwZbBt~}4v^at$EIaCcY8!>Q5qX_@K}dq$F8a+91~BrH#199
zAr7N-mH@XkFDv%%plX@+X6_$|s$=@geNdN@7^t4#>6sLi(mflH&5*DSd0?P}0w!gu
zp@F^vAPgRY+bIdHhFfa}+Nz8o+#rpRqHf3Q_ocDFQc;yg>x-BKvep@Ql*WGimDz@n
zVvt5iTem~zwlq58KBzE9BLPqqRp#7V^-;ub+_h*4GPMfWUF7z-+2~~(`^Yc$N0zcB
zycWo)TIb#>l7cj*t99-;_BpHEIK^@u8;ZOy4MR1Fy2{dcMPO9Hb5ARH?$Z@K_l*i3
zI!4}crj1VCmPWCtXT+HrhQU*)s)un$+nDCecF<nJnX#<LhK}z`;~>s_1$<QLb5ARM
z?$eb%_l-&)I!4~xhT-G)rLiB4mpw(oRI&|X(X{&KK3)BD->CjMfls_N3;}LSqZ>i&
z8FD);F`A=taN8DBsQ!mh2EUlD|GD$cD>0Uc1wgGjeQpuWp4avXb_vL#cd7uoXB9wb
zot~fTQC)uY1Xp;y8>%nr{h;b1bE^S{06`h`KFx=EKvlpVVn{n9sA8|N-^k|Mn>k_x
z@d10A@q69aV7=PE8Xpb&x0X7bKt-L&ptFW565CG#S$idm&9I79KXwAO4S5jE*(0fv
z4pvFI^+l9Kvv599$w}kU$~S~Ol9xqkJh*U#iRrHQvw#8mCqKF)7v7ZxzihjEJF-~2
zhSQ|vXapi@&=h0#uKH-j8{4nSBq0GJx$62lx;mh<IK17E!26P@xo#51tzB!9Xs$|<
z0BJGiC<zl<6m7yx_14$nXqX@g<KNqou*39YP=%uwkWj+fk%n7(NY_mOcMDkh-l27N
zn)l!Wk>Cp<ShI&(RB`XqR2lagnjtV_ghAhf5{b<6&4g|h^Z)(dLs&L{!NH?=am!HO
zB)-Oe2+AH@bJFV@erfc*t(E=7^T(h7M)kC_c)kj-+372!a=YX}u}=Yso@{l=`WkTc
zIf!C9j(W6bZ}X)BA1X>r3BAG|G-HewYIvi@NVby1A`dA!b~R(q2!8+Nx8DiVpML*#
ze*DMft0SrQwy`Wm<jgA!Z7zX5=|@^e@|dn8dDuD<D+?DIJ#KcXU|SYF^8K-*Y6ZF`
z0xQ7&31f6tfbN-z#CG>a{%V{)F(vJA)n8kmILdOYe|ZdwCNh7`c@;$?E~J>hp5QU4
zxKZFEf7SIGXo{GX>rndcq19+A5psf@FJcKJX}Fky&r}gt+ctvEMhDe3W#q5WiK0lZ
zISI&3tXD*yN0G>5_BuBtSVg`+Vw91u!4p6Oc@sq6J+$sKL8fzgtc#zKv+R+ZM^}*>
zVI_JfBVWTOfEJ97m(aRTDH(E!PCRl)A)q`H1y+%ppL~LR4WOV{!5EMaiWxHGIm7we
z3V_@QwTj#XF`pn`Log`z^5FWAV3Out#qJGCQ_3bO62wF^M2OS%9uHgZVPXR`J0G+w
znA?E&mp1rqpT|kO&PZ_*<#9jKYLCbC#VZe6?O|mRVn(}!_`WRmM+!BEQOu}orH}>1
zjA^aM!&WXOo{{)zE5|@w;}|L?aog41ZCP~V@%yD7t5#^L)ZW}eFUr_vjFF*?pB9me
z`+MXeiP4@RRYh({E$NNwd=!J}8ZmT^mAyx+W^u?N9%Em{?iK4ShTUuNL32+RxLzL9
z7q2|DhQ;Xv&7PsmkiQLhz)<aN2QbtcF+rw++Gz-_Mnj1;BwpF-N1|7v*~_97F^yzV
ziynszwZ>3TzMzh>FdZ(+B99)C(d=bm0-|lZ=oqSa&C1Xb)))$^2J$9|zI$lh=Y-4(
z<gwl(LiAX>#GprRgq7%_%us6#1<-;q=-g(3C-2ITOYGy3JDLIc8QQPv-25czO&Pg#
z5ev-}J#xNzuk%NDq*t+fHYNT2?yX0cVR1f0k2cvkc}1cRP0)7wKy&Yd-5G1!fCqfk
z-u5v!%gJXnJVB<=P@8}E9Y(7eOp3CQQP0c5M~~eZX79^lf9z0e9dPq{dK+Xx(PLT(
zg4@rrmcA|b%r1oTy)68SV|U)%`?A;{JIb<<g&4?!;z`cr4R*255}7RWcrv7L^XYLS
z=J#c>Kbn+fv4(IE17y)i&C9~3ZPt85Q%#*+gaq#H?7g>TVUui={*`61#&VR=jiWtj
zXQ`J37~R<5UWfnu%isU_%OC&q*WZ48JDvPCg3Sfp>2PsvdOd;<$Lzac87TJoBeCO_
zni*rykm=o>6}T;mF6yvppF6+@@s^y|N6b!X-Hb76%6Le%d;5cd8q%<PYfuE~cLOB)
zI?b`ISR>I#<XA&l+kgjS@B5`8cFrz`2sRB7$EKAbh~8$$8+$>^`aW2JpR@DfgP(G&
zO}N{!*3sC@o6=1d#Ic-E=Iz2JQ6=w6{8W>(9LJ)$Gr0#JVfd*mY!X`1KXr|vEY^%I
zh~a|1MUF-5{(Ll(g(S3lS%mo1Zf0-$NXJ<=*J}s)h!k{-9>>R1G|D9;y{gc<Pe2*+
zJQ_tRlD7gQ)GG4*u|st}M83vb04*3DTcdTF7rBHZtX!hmBR4Rr$jvDKiOxki&^fVS
z!x)iIvmlpiMC6eLjX713n^E%<<ZCPi&_JHVm2iF|<zn}27RM*uqc>wrg<{;2!sTJJ
z50Y0TKB!3zj(tJ~cXu@CHsHYsZId^W{;5|EnV1}|iGWhN8FjGDR_-u0Bh<73FAKkN
z$;W(tIx5-ph)-m(25gk#{m6<uV6Dbax0Tlo9j(e^TYRdjA%QmUA!|j?I&wo_r+Jf$
zHUfM21nLJLJ^HbRjE{eyAx=MOA|NK^f{`E#qoL$ondge)y|o4=wW%fB${%@djax^a
zt0^>m@xy})NW3iU)@4l=y4mVvf#%NSU>7Fo=WSWoZRVtZ>Ka2?NZ`j8KRkGoG<0}A
z^s&30JKY<3E}#8MW{aM6V!S-;zFqQ)#9DPb&}%4g>k&uoKkT+=(!a8X)))vf71Uvz
z8I(d~vXB77%fjypbqDRfZ>=Vf`a~9MR0QQi7A*=1cCpVAnJi=|_p<Q&M0cCIwJnQo
z2pd$<s1*zyVGXzd8ps>(_Q*jjW-P0AZ=dqZ-CKhp^sM*O=k&EPPkU{QS*3{AKy(NB
zZX@0wR`_+}C}T*aG8TfXFg0h`-cg^^_r^T!y)m6I&b^?aexu9xg<%G#Pds%Ex!N@l
zj5|tWpBAF4KJCphoitovhxLK)uf?%#X;@$7hmQ?m<g1(rM}t<o^x@emb0T)*tcjpA
z?7{(#rcPK=?_3VpX<29(dG^?Aapn;Fx<1veczC8a!#oGID;aiiu7KUq4X_&n-q!nw
z686UsrNt2?Xwo2A0;chdJ6OV?GA5CRu84YRpxs+SDRdi1qrGnI7ei^R>sTikz~$L+
zM`@TI*Ze|P27@%tK^mo%tdTT~fh8R*+r}E#wJRQ;t!ODqW11ni3VOm74}9G9kR?Xa
zFe3d#8f#?NE`4~WB|XpSlAh;QNl&=+;ck;H-{uXwBKL_j)@ZL?1HrhXZJ6;sd0ECA
z8!U<n70(-Hbb4PJ2eIfHT(*lLp6S&vPrJfUlZLK|c-}y}mxclIwlv!74q#EyA;uI4
z;=;ItZM2E=_RA96;4+=CtaU=Wmxi&s_oZ<Vi@xGa7yzWv#+bgxXq{$Jds&Q)Gtus(
zVRM1sm&P$H+WPWyi##C+!5wYG_;%4#HX_e(y#pT=KO9rK$kR@$lkVtvI*L3s{TY5i
zmpMGs>tpUVt$JHqegBN}f6_lPc+rhpShzgxWF>h==B{G+fxO&)%%eM}e;e{(n74Dw
zq=TxYQ3$Ac*`y?7eKKxmpy;vjhV34AO0qMao&F7t=oOTOqM_$>(a=-lf3KuaHN?m0
z5B+AKBs=xl5yDVOuUL%Ah8VX~5?ZG@b)#(Pgm%xVW-?ke0An*d*oOx2ioB>yh*3uD
z(+s*%CKNAw=&nwvVmIRY1p6z_qC%l(b|nm))6ikHf95Bj^zRk<plhAUT%L9qPTr9)
zC|3i;fCuf}vjO>tfTz7~J0dGH=qun^h(USC?|Y2a{pc!@h7O;eszUkD-Bu$M4WL*o
zG;&U^5oqBJU<=CNoObl6S%QvA0ejdOvc&~e?EC8(s`nxG*TNcA2R$3gh<%?4GQA7g
z2kc=Z$W|3pvG0!&W$dreiRy!%X?@Vs5>rv{LU;kYV;7{A86|FG9}Lg-0+XbJDvi<b
z%yk&-1=tH>+`$s8mnJXEEMX&}1p7HYtR1G`#b=g6lkO<?p%=X3GpZVTG9&c;L+dpA
zHNQr1?kxfB9=kE=ZA<8|ThjOhyLc*MXTTPeQSbY4P@;FWr+_`OpJA6OcH=moV1I>W
zP%f}HJLq+TR@1-aWf}Gj_CsNd*SiV%s@RRGB;6_7{3|R2Y(W|Iz8_;{*f-b@g)APs
zd3F`M5!WZ!Um+iq3+(ORp?}5rY_F!|Y0ur?>2bBDge!p>OZy6@%X7LQ=($l4bcz*0
zwwR}=Ec=rk=p%C0J`zFE%4Ajmgw}mVNDQ@A`y}Lyc4w$ou2t;&V@1_T8EaEFJ_^d<
zr1oU)M9>*_8Sp$g`@)z<ce_s&`~Fx_#{LS=pj=>Yq}uBSt^16SVHeU5*u#FewW%uh
z{js8qovazQ37ZFOK^gUK2&$-eA-;e;?9|u-wJLVQ=Sg?U*u^#pJMC_#g*ngZ!kp(u
zVa_R5=2(B)#y$wk530;zt7l6f_Df51p3|i{Pd%R4TLRiW`x%qomPQwv9#os7C3dg`
zD$Ze)!3(B~bDr%$;Dq^Ob&h41D)xie?-ia=dCs$;jM%5yZ=*biE)MW|H}1TRedGnk
zcy>79j5(6K(rVov!&yUjEifcYAU;e>cAl-AWqU0w84ET_c1~#b(lA{6zBG(TKaqw^
zsYx2dkXaee<vA!wNu;6YpL$L}yOV|`x3{HHEE*cwhVnW|gBX&_e)=Axbvi!OqeX)>
z0z=xd=zVF_BF3RKUJH5<gy0UmF{psaY-1y0^rbJTrZYg^mqv|6hthb(kT3v9BZ(o=
zV`CfJJ?=)h;td`<)4Hb?{1Csj9{fzBymPh7bGl;WX)8w7x6py}-ieKji?EC3A<2|(
z?MQ<w#srszQnKn0v>K%(T$z}t9!N(HyS|PNocFlR0!kIPvFW5UJE85`k%qgOAE}v)
zk?Tf6@63o<?VVBNC%vOLHzRb*ROqVdRPu&Q83NTQBP;^7k^Ivg>Zj3Y(mhpA!WO-H
z)|iVHh0-#Rr#;gvc~vF}d8(5{SpKdahrf3c`m<OUGL(eO6H&iKl4$?x4fXoHl~YVb
zTkTXZ7?_g;5_Y|ZmV&L0knM?MiC)wMhRpN|t-gN~jBfON@J)0>n>F3TgG}oD2i?;M
z4aDi_9Iu!pO#DJdN3V~-m^PH$=A_-JfV^$nUQ|OP)8z23O^6rL5TTA5GJL();hm*h
zJi11!)iGY<N$Ae;D_%9pulPmIuSjKfzGMU6ZBg{bTBFmEFSR$r-2wPUnrg#K-#xVM
zPl*Db;ukreB5TznH~On0-=9ybjSi8&;+qE{PxuooVx+v?z1`~+@My!7JG@f1QL!pS
zi!KnoexI!;!7r#*D)N0y{cWM}9HADAM~0eOV;<!B3dYDL#wy;{ls)3+2u+C>KvQl*
z6)241C$CC;imODz$Q-T$=q{1m7DdM<gKKljKDCA<NR}3iQB%eps@*egm<UU|SN5Pa
zfQVVlcJ@^5-TuI!y&IXiP6=TxZh(L!ry01_%Orjs7}(BTw*e30hCy|XieMBs@GO%?
zBcuomYG*&!?}K8B%yUHFE`~yes~e5%(FO0z!r1qYu?}UiE{h-?Sx`q=m>4Q~S0W2N
z0mI9}5fqLcGNJ0*vKUn6l<lGgkZn$WCRsGm^vXl)G^29GNMKZCz<RqdkA7bkMxcqV
z%CcDF79>v#>S!1Hl$6<pL>1mH92LPX3>UvI3-gdqWFei#S`9_7t(+vvVwyX-ek9sO
z<W3{zZCP|9tv#q=2l;TYSYslj0t0yxy<Wf1mX_c-Ia9_=V7rD<MPB2@A@Vh-LL#tW
zbUKHT8l7)<ZxFW^3rng|2d~f&i6M)(BN(9A=Z3^zZGFkQK!!($bpgBRvMq|vMvKKH
zLrsY>p;xpD&@ehpp>>}LGUP&lj;W9t+zIvZu!~<+<c8?q_fCE@f-fMy67oh<p?hYz
zX}fzP8#N5H)8V3xt``@h<Bs@&!uVA3s!UVjs$Nr`N4p!Aw?)z0sG092z0uKhV54%+
zanls>Xv64ibh)(EjKQiHMvHGR!^Cf1A<IS97SPx{0-NY^{sBI4D1#5}$MmPh?DT;-
zeYv!N_h+<7+=CDL<yPI={?tTG-_chz_M$&AQ_u(QA3o?S1TI?iS6mB%FLPl8ePH9o
z2Yp3L=%y!23N}6{3Q5jIi~dTEh)0XQLUIF_OH1AQ`3oNu4kwe~$(&0-AM{s}Q?p!n
z8xDWs3=#UEa5z%{ExZIvAGBj~E+Ja<%W@7LTJ#k%`&dx^)YdEUK|3b<3}_LhU{!~|
zgE3P-$gi$)=*x1I6HxF$UU5~uU**V$<tnEg;Dd<wDmCuQmG%CG5Bdt#`&A+x{7L)M
z#(F5_s_MS7x~WBUah0krwCJy-glM_8sv-Kh6qn$G2<plS^7xZvi{pbnP?dXC<z7{}
zS5_{5B`JaUpa4~;SJmlNb$XQyn&m3VBlw`Alaztw%1f4bGH(<^KB~&As`4t^mCIFC
zd2L}U0hBx5@j;$^<J;Q5EjL-G#s>i?H`&vlL}E8yFGGuZ?oB=S#-96yKk1j%b8o7_
zn`-c;8oa3nZ>qtYYVf8Sys5+9RB<;|+)WjCQ^nm>ako|#1OK|IpWf6@Z|bMFmNyTv
z+$6nvxp68lS~&NXK8P3G)ID$No;S|xz;`%RjXvm?)hqc5X?lfhjNpUVGhbBN{v^i6
zR~k|auZGYE{jxgaO`Y+k&L}swd|TwM4*DS7kOTgyMU=wlo8uLC*5DUD=$Dmy`Gi&a
zj%tukZfq_3Wz`^`L`Hv74e~)mtwq1A8oa9p@2WwrOQ$ch2GJkYAQxQHpHzc))!<z<
zcvlVHRfBic;9XtsuC8}i*So9hNmc`1p{{pV*SoXpp+D++cXd5p7pIP?>)qA$?&^BH
zfI#0-*So9h-PQFZ-uSjW)b;o-d;Ci7ji(Rdr+ke#>{&0s#s~3Jy$l&G`ek0{z|ZAa
z2z<~l%kcnc(J$**sn;YfdPg8W2y5vLa*JHHh9^tyAU^1mb%=cE5cyE@)GKrry*~yY
z^vOz|dTqw?Q1X1J2K5#I{7L()8r0*^7d`=<<f9tYv!j=XYVe^Nd`OlJ{-oVd4eCjt
z3m;=ix=;;1RD%!Ipq_QN=rM2jAkvTnz`oETeb!^27CrF@AN0#Q{OJ)di=J+R4>GXw
zSsv(*9`Jw<`efChR;({tzKst8@F`Wl%Tt4#rv^Ds)!<V#_*4x(RfA6+{_u7k{+_Bq
zE+C<f>F~#;4y{E2st;<e^df1(kdF?3nm~#c?XwPlPYqyXu7`KE+h6GwN|jHg%BNDL
z=11T=%zhWn2>AIMJ}|H119KEUG!p*82mP`Pc9-um*x`eIS*Q{%`emWYi!RUMgML}4
z5-s{=p-P0w+6@`((86N@KC~~RKSGuGpkJ234lVj+9_)Zis1hIa%R-fC(Ju>CUcL)e
z;)8x!20OIqmu0ZSEP%Jl@Ik*UgB@D*%MyYj<mdPhAN0$jLA2<XMT3|Y=$A!<Xi?G0
zV22hF9UX;9yXlvcqz2%Fe3^~|lt1a0Rf8wh;7K(|$4l{-#q}^LVQ<2uq$Mcg72<mM
zpkEg9M2mh|T<>z?3H}#8=$FOy(4t=!*TZy&of;qX%i?-y(JzbZT~6Y9_@G}F*F%eb
zSzHhECw;P{<)ekY2_N*!LY|kCxE?;}lg0JWqF)yB#Dq+rEaZt6eX@|}<s`!&KIoT)
zJkip={Dt|Pn8aBXcUHxn)%DJ*xU(wmtcp9U>z&p0&gyz+i8C=%6q7is>z&p0&gyz+
zc0Ke*UGJ=}ca|sx6HPI;v%20{UGJ=}cUIRstLvTB_0H;gXLY@^y53n`@2swOX4gZ1
z)b-BldS{6<FK2bVv%20{UGJ=}cUIRstLvTB_0H;gXLY@^y53n`@2swOX4gZ1)b$p1
zy+t*+s0J6+;G!B_RD+9Za8V5|s=-AyxTppf)!?EUTvUS#Yw+u`s0J4$&qX!3s0J6+
zAQm0i&9O9~AH+5=yVe$=3(QodMKy?dptk6jRfCum(Vx&C)!?G!i8+J(N;Qc1TUu0u
z2y?YXzpNTW%qM?R4I;+U7X7kn5aEUVi8YA+s0J|}>z@Q5#x`!jP^2H^$zXhK(J!k8
zL3Z*d)u67@TrNtL@FMw+QYDO)TE6fdVUmkdB~&P1R;s)xRq9gA<)Vti@8!$tdb%cq
z?+E`~lrt~NnHS~Ei)!$~K8XIP1~2M^7bQ<wllgYhH5q(Rv8XC_O$INQVM5nr&>}2)
zQ5L<ZPIXP@qH8kv&?Jxks8`~00zs-e#aUk3qH0o|>QW3=p+u*;6oVG|@>O+uRj<6N
zPOqxdtLpU1Uik$PN;hN$<{Q?xq#IZDN?n1$pVlvnmanSit7=(SV4xGx*Hs6^s}6`)
z9T2ZNAYNIy=#LWYRozq9WU$O8hICaeUzKUEs^zO{Sr=zu2>L5^*sE&!s#?CP!(P>4
zuk5hsk5cYcm8+{Xuq-i&t9tHLJ@=|wzN(h5s^zO{`Kq3KRV`nYdvB`cn|khzwfqGu
z7Rl@449r>drHeCY5i{1snafQnR~Ki{B4%?_7rtq<b5j?-sd9Cd1|FloV(vwMlzVTg
z<(q2xrdqzKmT&69H+A8gy09+STy(hx9~6ZuSC?zxrV3egD$6zKkLpyHYc9H6gAdwy
z_1v3!?oH#Lo9gtY@y|`;pPR-%H;sR88vp3J4cJ0oq2sBp+gx<r1|OvJx^9COL8|LE
zARBRWS-1Iy7I`w?hJ=t<*KIDkZi5f{WK}Mo<WFDL@sv+brxqPpbpZ!0`U)LbbpZ#<
z&)Og5XIa3(b97+U1sw3Aepv@rUBJPg6e;WU3oT;LcctaKI_zDQdsl~*vOBy~9ah(N
z&?0WGYddHW{*kpE{7RLpYddHW4wtnZ^hcGeYdaTR+rbC@vO26T>45L$?Yg9c7J0ia
z>0D$<2e%ri!#-4}4|Ujwvazh~d|?0)lF_vtv`9A|>ae=Db9t!4J~UW*s7@cM(}z0j
zLv^Z)JQ$-Cg*xm*9aa{3&>wZ!hbs4>Z2VB=KGb0!%Ek|MSY7SGFsLY0xexVRT%O9~
zAddRi4`P`pywsL95}`jDKIyU#S`>vU_n~b3P&R%j8$Xndb^QlBB-$}q|3QnGs9e~9
z0t9toIj5gmTF1WdL59euy6{ug{Zw_!Y0dbRs{5(@{8SfystZ3gB!24Ps|!Kcx)Ixu
z0~ql@Rrgc*`Kjub6(M{_`B_(l&?1m^MF=elS=Fs8LO7d5zpT?zT@gZMyeRIe>VB#V
zKUvF=k7`-U-_ak{vXntni)i_&WA0P6{M4aV*N6}qX;)RJx-^735iy&m>Xge-z<y8G
z=@;TDmLWc{vEc*%3Lh9LKCmz21HTK|dW;kw^jEUUg%<slI5k@I=d$L2*iBz5fizm$
zuh1WHYJAXliI%ZptM3vmqlE>95B!QQDS%*XZ{+^<uYdn9|NP@mztdhW!m!q%mIWlA
zaO-t*HGTs>o=uzkCA)iqR*;Dq>r%l<{7n}MPU3C4UT_k<oMg0=RfBIQ34~7KdAd??
z7Wtp$<!2F=&i8e4f0mhs&hgI@IiAIKb%uTx6F&3U^QBX7onD`XN_0+rmURxDHlL;c
zGJF1Z)+J-z3>7n3bSqS>MQ5&ys7)rY*u7$DV`r(!9=k{KUzWK}EU}Bj?czGv(2#%2
z_jM&z+y+|(?eDrLk5x4OxAaTqd|1sA$6Hs)gv@lYOleAo4y6)}3Utz@5rDFXjumSJ
zFOI2P!XpPoZ`?0k#8R@*wXAhyP>Pr5tW3|p*BOw`dvpg{r$4$8EwdolKO4QyOLSvc
zrzg5UtaB2bl3WFs&P;T(SZ5(R3AqX%UWE>IpI9dsvIG33a}1pk=>Dxv40Jl6o3}D6
z_@)uNZmVkGu5r8WsouoiG-%gg`Ns17(wJEz<(mY`HzDMk45S(gYjk=S^3x#oF07z&
zmIf#fi8(b+(J)2slmF6qLHBZWaM!V2Z=ckg7j<Jt2YB7z(R-tG<ko>(H*j?P)`3`d
zUA}bC)y)?jdvy;+H(Yd>)qNKkZNKUEi;k>%dZiAqdZMF_v$}I4!{nD9DI}xiHytDO
zkQE*M`0#+Azv&>TW#qbFqQji-gve<34a@25`1rt#fLn`rP{D`hQ(ySNPK6IV0^kF?
z6+SS}-~$r_F8<M<%lscL`g0*+wCK;p{Lr%gTm}=}_Q3MKc8oa%{gD*`e9$ioz2NE{
z{jv}XTJ-G_i(s2TzavhF7G@88&@W4zf!k~J6~dgS??RpU(2$}(G6>*<{#=K#?=msK
zpF~iA+8FIb7vs<l1U?9Mx*UdEgpF}OihfyDp!*j1ub|NF0kpKYf8m3u=_K(tTJ&8K
zh@(Z{rD8d$SWYSy-Ag!~R4jDV6ZcSf8Gq6z3p1ldpUhl={s>v%gML}%BjY@Tu*yeA
z`m=;YxQ9V3N|*J~BHhsSeYD7vb>KhgN<BX4mw8_Lg%<s?8q!$}>8zF@%kke%XN9cm
z@@UbYE9A36)^GvaL!uoG5YVE(S^-MLdD4Y-e2`x)5@@1DJY`X9(G_<5N#v|c?I#T?
z@IfTDsQu{TJN_in&{cS}NXKM3{tGSoWR2by)rBt5pB9Nz@j-ts;VCx4gi;oXQ_&)3
ztSj|s(QYUeXyk)Gi95*JJ^G^zpo{ou(FaO=ffjwBtUjP+eU8FWPS9n2Y}M(n)Kidh
z#TJgdD*d28XHP+Y)KhfnA1&G+^%SHO$<NhOG=#&K^~q{B8pWM-R{$SW@9Hv0HjxJ^
zBgsAi`lF15oDTVpgsJ$GFcQ)t^iTR6nH^zwQmsydabyk1mzB`4?awWe+4=2+&1Y>{
z|J3^Yg+Ix=H1!iLB14TcPnrXY57K9Blgb0tL^b%tcl3ce%3wQDzN{vyS)r$kk^^?q
z=sW0-n&?F)%xKY{tF3CDD0XJG8#-)V)K)cf6yMSQsIBV0#Ys0O@If@FyA)_?l1G1(
zZ8U`xyTGCX%_T*Pc0<Q6O)ABo^vP<gnlO6O&509M5Jf&RF+hv<Sq%xxS0W#^7TJ@4
za#wZh_=PFBJW%NiGiGkVBv?NP3QSeCMNsIT1P<^OYtdv-jAQy`jW;wXKV4OoSJl^5
z^`+Yk81(e#$_W~)<4^i7mDp7!rrQG;Diwu}gSr`j!LvdB!Uu7gt2(T14`5ssU1-WC
zTJ+26r&o;}bPoVyuS!f^Pxk=uCzY6rSC{^A;%O7_7d{ANjr!3dD0B}1gSqHJHv`Zj
zPu7KgjPoKNO~*uwXj$_z5dw&t-_#3q>VQ9qe01`FFhRep+^fs_2pqIOGDAX(2<oOP
z(AE5tuIA%|_E}cy5pHOoRr0!Ik3WfjX=3F`SL*RW)THwiwCLMqwFqI0_E3#qQ!Vi)
z5sOZ1aM+(9)rk#S<P~=%D_vnf=?Xj2Eky5pPbFeMU1~q^Wi`~IGUS_4T8lnerONj*
z(4SO>x@eA2OJAXb6rYbuUuI!`;e&Qw2Ps`oM}Q`#byxA~qB;H~663=~=z+=`cO7MP
z^&HtF`WziWbgdkJQaCJC^hYU0Gb2w@Lh=nCq^r6ze$uQ*e30j8`XgGThnfd@dg$n&
zi{?mT(eKFa)Ja#p@j?9Sp_HP_-zUvh#0UMk8m-PyPny4o4}x8nw$Y*}lnQkIiuEwD
zaGk-TMJ!zAuwN(5JH!WlyOM+E9iDXE84GLjbDhefMXXmBm(e10q0?F{!)c3}s4gXA
zWlnl1bKEbq=quEz`QUk&gq}~159@bCO`0!=kYA*snSY4=^~*X)>4AY*_Y-^8nJ!wi
zKWtj)k2<U-{GmkzrSsggF5M#gi2rov`oN#R;REXnANa}mz&*qV?ifBW3VdK;;=}qJ
z79G-=T35gDftds!^vN<dp+%o8V-s5R$wG|h?=tk`gML|riI(-t+6^&C{7JhZ41laE
zwr70MZU~*CMV~ATfEInS%x=)40A<uWO9~()CP4*0=#zym(4rj^x<HF|j8zHwNW6*<
z`g74KTC`*01!&QZNd$`)?U+zE7J=DF@IfD_>#{l}$DdS{!arzfUHw9`nfyxU=4g>_
z&|SVX;YEvdL#OR%k#1lDFW=EcXiYc7s<c>?<{hF%A1L&N7LnMA=?nc4_eAoWK3V2p
zXwjd`CJ<Wm=W5uRn|Q_)Q933QF|;UBHFZpr^gH@wHFZov=uha6nz|-3A{kGgtfr2T
zTArh(j)+rRR8SK4p6MC~mZ}g4TJ+~?{IZ$>$*b|pY6kivQ5-(#lhyd?Sa^Q241Y)$
z)F-R)>uLu6q&iibr$c=C=W5uRB6-HZtbbBLvCX4DYV&j`tNdJS9s`)PsLf+c(iXK1
zwRwy#`X}v}+Pv<YAn8$`tQLNf5%w&5C+Lq_xbB*uMScYy<X4<!sR7B8(jPFI{z;I6
zQ?x}?3E$HeeV`gYtXBRc@jTXV+LyoZLBFi_tZO@1+R?YmdIB2s?P}_}$b&y=H`LV6
zGHjjCYT=UB`3)@!M=f0TfY2Wq`td52hFb4gtyh<i@EsL`616TL;ZG_JHEhiR#R8Q|
zLk)Y~anh_%e5XAb{ZUq5cb_y*6n|3DDN*Y(6r`fkP@>jlD9A~1sXc4vDE_2kQF}hi
z;EO*st3!X(p3h3%npBF_HN~Z7yzYptTViK5<FneTrkO%r`g0{}T_3}rRPRdEnt_Tx
zDN-5M(IR5er8A`U%9AxY6)l2PvsBR{s?=3Aw8)cnRSk9|2B}MDXpxTT`WRaD?P|}u
zJ_Zxhm+IK9OHBBaIJGV@p+)RR7mKhvsozoM>S7W8q%T!{$r{lY%vn*Wd{FVg&WHj9
z{UEq>0SC4(xOBk;NzU^2iw+!`vI)1)pQ~Hx8VLR*C}a)f3$CLtRlm^n4LFl@RkJXW
zN3GpZ3)ekA_?hTSYh2MHKiAYo_?i4%cks|6C?sw13;Ech6wP0R3+k`byLCeke-b!X
z?Y!>o!CyrPy1R!KeU6Shy1|FMZc%}5!NFf!3-**1mrk<aI`SMXrh@B8%TtE{t$0B`
zHa{6A&)>lZ78E`(c6?w#!3h{UKIoT4J8+8z=L;Y7J7T?X6#cRg2pom6!%@}``YRc~
zupq6!5*NmTw6tj01NUO_;)9^jC<PAJ%;pPA)beDF0nj1<b%e#Dwf<a2SU4q<9zL-7
z;e)<Q+yQy!@??bF%`f1%@@1_wzzVm#OU9kAMOhsm^vl{GrEdI51g_MLb#c*!(kU|7
z_2()>B~ScG`lGA*SUVRux~h*w^w#+={8zs$(-XAFyL3ew4T4m&(ihDX#|P;K3dmRp
zy55TwcX^I3;dbdGk`xj%NdES>A3uKn^;gOq`Q<lckkG%sVXKz=`_s?A{?m{D{L7#J
z;xB$`=MwP$|N2SuP1X-zKmFk^fBhf-oBuyO>mPpnyYu(|@-P4VcRzlkgCPF&_0#|L
zufP2BpZ|%P|J0iQKWYEN-~9B4zxn#<Z~vda`kVIuzJB^oC;SipIpcr$&w~HqKNtM(
z>!-i^^?&{N?XQ3N{l`!L6~FoMufOAYe@Ab|KmYKLfBJvh|C6u%?LYqhPwjhu{g40a
zC;Z?4&)eHITXr00diUp7bc8RgxiI?cd@2+ZrU=QNu;gJ-9EUv&T!27}#0W$)fQCK#
z_kMC!zI*SL&uVm^E!m7<<Lq3us&ZvjW@Y79op7kezkdJ22fp_w-hVxQzZt*Z*6$wc
zoA-aFtmlV<{KLzC=z)Iq?YBR^`{}2PX8-c;-Cwq!U%vd^mp3o}9t!{PzLEa=4`B7X
z`gi;4`skZQSa3PjyV&0T?aSX$jAQ%eU;X^yPw#&$==SsP{`~cK-`B4qZc}pWlRolk
zr^f&E;p-1SZ|I$>OVqRc=<of@zyA2$AOG~BK6Jf#BGCW(?(1*A`{9oTy&yRwefPt+
z(6HeDdwpH~b3?I<Dj%{f&)pjARn=>dwei#MZ(hCl{fou3YxOQpT)cnsq;^-YY1`8B
ztD86VW66<h5sM?DgZ6H-x;;s*#Wc;H+Y4mjFJLofb5V<^g-If07GJi)*>Zm!m56rP
zdg&dgg-xH8dhcn$)AG4hidGVrI&srmQ44@R{`4-}YDKFVtvI%fZ>4bw`kUUPT1#wM
z)<U<BIW2kn?A|i11=-rQh~L=0s88%Icv?`m^y$5#_l`cgw7^~h91r^<cFyNHu;-Yb
zGkFf_Ihx}?--gc#z0c+4A#eDaFMQVhd(Bv%#Bu)ixN&x#JkkB$I*{N|?)Q6%^iK97
zTU(CZNe#@QyDmYl^J31`eb6os+Jg7SoWnJqqlT}AiNB|R_hRoQlk;_-s_|g-_x7?m
z#Rc@j$vHZw=dW(w7H9M-IXV4%@zixh8`klL^!mvOIY;Is751Kuowu>>Rg{x3cH7lo
zFQl(-Zfo?`dvfy4!T0n#K9m^pdvQ6UaHCmSE!QZ$-f~Dj1s+6qj>epG@#*)X{Z}`4
zV0StQx8ntC(AGOfrS;#arBOyBW@5;RglQioXRh^L&aqLmb9jv*GDp|5ioM>;;dCjj
z=)8-j$wfT>UQ{?8LUUf}6%u_W`H3A5ag%U}#7E>5`qj;SQ6q=SoGDMg`>S$l%%So0
zyRm68@zu>k^%l#<Nd;c3H!+nt^W}h-(_9X7Im`8L^xKxheb_r`R#E+;J-7QH$GfB_
zCOff19&Wz6c?8P@KqUU5^AmyhXxT3M<n-0eQ@wRk)D~qD?0{0X&Ex5JOMvt5=xnXh
zMtASSR{|o=?bm8O|LzUy)P6~h^YaZKbj$SL|2_R4`1P)IY9Gxw?bmj7?k_6+>G{Af
z3iavvz;CJ77yS+VT9Tdc=}qwbd(dxfi|77M>T>tn`{nulLBE!b3F_!$I`O(qr<Re9
z%Uvs;(kk10f5qNb%c4bNf;^}ivX(;*H#s@v;Bflg-JO0fVV8&y%4~E${rSyk=jXi)
zPw)5VpMGz6RMC;uPtI7U-|08c`$TbiKJZ&CebL{*uebm6cmuzj=uZ9b@k@eh-jDg?
z{CkgIj3MXed-_o{VMo8y`KZUwG3osNo_-zoLKyYh9uoDEpckgU6w(B`B+ezp&l2U5
z8fd3<+ty1`67BqaBX{N4Z)hhb=KOno&iVJ^vh(jn?(^^Mb1wQ@%kuQR?L_C_YZ;t>
zFLIxM5Bz#}J3k-zwX{4xANVb4amKHu=&5~l?%plWxx{N(o_{YoFdcOyNLWs+Rtd^U
zOwK8%xP?{%a$?*%|8DZNnw}zXr{^uC&cB;{Y2Uj0`FWG?^n3}?^YbR(>3L6YD{cuB
zN|aCs36bK~<F?QuH*hVV)9)tN>35HN`rYHM-}Kkxo}Tx#oqjJaNsv+pB9V@_mMzmz
z`X|Y23ynTfkZIPxdlmKpBEd>Yi6*^fYnPa#E<{Hr%^H^OOTkRs(I-;@+LRW%V)CQU
zzn2U;{ch$v|88_z6-+ku`T6?H^Y0~t&cD}ZpMNjvo_{auo`0{;JpUf}HPfD+x5|0`
zy=MRXd*HX2_U8P2;MYuhem?N)E&lv`;MYuhdfv>NK(FMCe<C#lH4VLvY0mjM$LZ5S
zx<4yN>DEwA85_++`Av7F>V7<tqq}RKRbodg45vho#gjMZ-#u$>1y88i>3Q?U`FF3X
zwC`j4`FZf^*=g1M{Ji0(_j^^fCemSSB%my2OITZi+0MTkkG2UU^Zoq1@mSAqk`RA>
z9{l?ITSGZN@6~hazuTSq8~C+`a(cgyh3DVBy3=1DHv0KZa`4aX2Y#)g%tRcPN1a^~
znwQADQ$9{B66fEG+~?oxGta-b&%~CqL~R26PQP2BIR9SLaQ?kM^Za|8hI4;?K0QBQ
zpLza0@M|G>em?N)^X=(*3&Hd6fnQrv&d&#aeLg-vANaM!<@|imZ=Jr*-`l6MIAdl$
z6w_CSy2LgrEvglZL^`Gb<@tAiUdy(wOL=pCzPRB0yQlTkzCZ8uyUBn0y?x$Ae~Syw
z{Vgsy{cfRm{yp&P<JtN7z^{ek`T4-Fh2#18z^^@<=jQ{zlZ~>!qoXxW?fZCk{yp%E
zIWzQWDRyo@=-1Nr{5<0}UT4jtPU+5e>t=oYN?d8eN>i@$zJ*BwNAH&z^Ckrz9$E^d
zssk42I{ke-X>MVeat;q|JbGy6NG*qlHXbG5G|{CGZA3~Lhle&IoqsPXJ@o2+=$$r^
zrw?tGPWgtE-+XAj_o01Wi8)QAX)14~@MdZ=ba3fS{GSOeO+e{GlQ&VM54{)UH{`0*
z(y3YNe-CXZN`cKpktT>Vr5I9);jx`uU6A4CvGu~#Wk@xKgq$YgGy$iHH%)NqW6Lto
ztJ6b%KDLNTQHJyHHLD*_fn2=Sk*YT-y_v|>M5iV=_56FyW~y(d979TOcIfI&r&hj5
zbn0VkCaJBN8Vg-ele+C#zxk|I1U{aDxmfg*8JTN?zDb>hR98rlYhqkKo~gOW)Aco9
zbXA3$6jexZ&D2&%JZyqr`JB@JPvD-sl-c}f!e?vEDXfsF*aXEUCiay0*;?#VJ9<8u
z0NN6}BWZ6EKbxr8R8mMGg^?)wVkV06nWg=n^F`N&lR^rKugz7|iLOm>t@B7X33!v6
za8pPj5x1X{U%D{Bm$TL>f2=;q9bLN<e=MzqKh|R6kGvI^O+p-aw6=VlL3urHn!XAJ
z+gcl8p++h1_>VF`i$)+BpoJrl;Fm0)g!=Mm?F0Co)=8B=wy_y0xhAiYT=;oes=+6o
zn*{$7c)GS!{>Y%cY2xL|2lrtENaz(G&8s#<^5vzM;vrjX!yh4AYrsG<KwBGepJjkP
zas$a*al3S=EngnTO2R*YWUN+}@xL{_PM$kxxgFBMuM{s@^Z;kyU7PK3;^pP6lM6`G
z?*h`4=+F}kY;D%Z`ImmOV8{gBkl<0zd7^27EGbO{Z_|Rr#BSUNU>@~%CP0=kGemEt
zmyn>^ZTRxiH7;8Oi7cVlN%%-nP#OoVmKV4(gI^zP11T?OFpl5v<On=@0250~<5SPQ
z9O4bcJDMR{Ed!FCTM+{iTEuI3kQv-|Cftjq_7M1-ciLdYRE2(7fhQ;7$xE0zq%;m%
zZ6E^DJacjqp1g<&3L>^TbDmXt@&uk-feDUf#q^|gC@l8DRu=f9$#jN9dJ!<aR!U-u
zs3_Z0ORR7nEeN#OLK4m`vN#hOOKx+z>%9s{e?wxGfMkHy1*u)TQ3s5(Zd3aNNKf^f
ztkQ(NemrX$UwBq!hrQBsR$RP^K=OGlwD`O&$Rcs9Fj_t)E9aRB)_Hxc9gv6^ON=U<
zn>LYNsdq}uS+B1Iq5{bb$A8@JM|#dmi9-@dFW3u6=pHGUU{xB2${ox=G{81G*3Gt1
zLY>Xgp1@Qdba(M(0_k4j#Y7(UHzY6&NPk0OR)K5_gpsmsel*>i;DbK96Qz)zvj&y!
z4aS>uK3-4W34U34aeyK((_KVpDz@^dS+`@_Kq5l*vogc8563-6Kt;yNlAgKZ&?3<j
zN4es?Zc`MN#`&%e1Lez0p+e^O>iRb&k<(9vYKQEBUsxj{dq8@<B`z395KT^MJdR{*
zEE0g|rt4hflBbup0X`?Y97H2#JG&f2!(bQL<ryNPm{R>q&|S0%>WSE(vVPiZ#HQ!)
zXJQnAWNnARQs0(G>984$FW+>XQ;WFw*p^#h#-RtK@rw%&NYD63lhyGXgwrmP)zfo?
zK1I3LSH-LM8R_d7tC7j9u6VBaBmH(bDv)3tPW#1l_GYjS<p%YrzE>u=H(!D1rnP)J
z&z+BH)*)lPxicO$AU&<|sR3z`b&%&C#g`hTP1-O9B|HPk>?JBG-X!vn(sR^|gpu<o
zZ?z6g?9ry0#P@{0l>xF?Q<N8-EK`(ifm(KrO_pYSQZ(MyIzEZ0!f{gp>93+_+j>2o
zD;_m|Dcp;;*ApA}6_D*MdX8?9JCq3jO3ztM$*AW$S0rTHMNt)digIxhkp7rd>m?dH
zWA~vJNHC6U?eO^uIZKBTnDM0WC_P7AI7-J)&zb7Z%ctke`B7ee-im7Zc?tTVU=)UA
z>O-bYefh<N{d`RJ`&_Mr{@f(U9ZNuZLi%c@%H{7Fj)fm(J8xyGFH-n>td#L3xvi(<
zK1yO|_tSF($3b>~w%_~chM!LJCme81KRsvGlkX3iR={9ZL0`U9@3e@|Elih?px)+0
zju6djvoruhMg-hv+q{5;ra5_}h#4o44AB8;K$>T}jsQJJD4gpEWW!6vUy23ftt^mO
zet8s}v#WJ6V0zAGmh!--5(Cg{)1vMpIASm+w6Z5ZCSxGIojl}(oKnCfEB2SqvIO{|
zvI(8b5=6O6O<>9rq~~lXxy$L}6$|J&hu(*nM^Xxy_|M>z1@eo<44QCVE|{L9a>dTf
z`Eb!4dTqMbHRTSf?m^F9?9xDbRd%sp#y-Vk5lG2CoXi~l2%52y9MwVSWfns=5wD>{
z4zyh>fswM7)<yMIMj`7Y1%@vn=_lIHM++;^b9SE?!hy7KiAkLEbqmNC!GZJ#1_H4+
zE$ZAfnoSJi9K3tw#3T+Ry~NsbRD)rg2Rv=jWMTs6NZ%Apbz&eb>T(6uC8WP9mhqHu
zpy%vRF^U68KfSv6yiL<ekz$f=(<0*M+9D4d2|yyNE0%PO5WNC(Hx-axfib6Ju?PvW
zb}k^jKONPGNIyBgCUJ~->3mm|k(kzbwBCXin=*G%MWUxMmsVjm=@l4zI*^|HUn(%M
z6c2)~qj;p!1mV-0g7u39Co*JKMU3sla5o`S#29N%ldUT&GGy!&Ptibfi4_Ub={Y*d
z1tdLZH+sstXwy4ANBxZP{Swl|PBmj5^~?mqmv1W9Mb(Q8nceB44o13*9+Nw<uu=8u
zzkqBbfnS78tooObe0k1g$s!~*JdYw{E+89*^qh?<_I@B)DOqNzxj~Bg>X1Ly2lB^i
z%pZ#=7}&OH!~faBg+J1`A<(OIFHCT2OXQFA+Zz{<^xIYlAQ|8UX~mY*zqL~MW9yKy
z`$)teODgh5kmy|w$eIcM$XIPX1Cp`Y_&`!&zN&XZAnCbPBOr@?_+w2Z-&x8N7RG#D
zFHRuArq?8pVAHY+$m)eZf=#PR6z~W(y>5X7o8A(E1e;c#faE)qRvuRZl{_*NORs{0
zr)?8d>l<2`;*a#w%N0oQ>s5-~G!xPi4@mIqO%lk4A0zd;<&X5-3Kx*{+#4yT+4Ovd
zgt)!PX|oZRo_lTcM~K^No0%!Kg9kk%KBw(~b_wZz<Ii|b=@8u6;fHuVNJniNCwB=*
zh6t<R1z2ccw9g-ndKVL+=iZ0;qp1`32S(}j6?|UlI;Y?Kk?wkf29hriJ7L!BA;VYL
z4+9CJi=99s>=aK4kRTd%itmI+={f9#;iP*GJN3P3m`hmyg?h_+{%AIcr-a%dA!Iv9
zfCRrVSn`W`lrLWl2I^t3_(gyOzc5(*BEMW?Bt0*dqvvp193*^9X(YG?^101bK$;(t
zS_LHCh0~H%#iNiQoYvkHh7700n*t;~htr-@d<2Y3Z=kM6dTCP#kl+_)ic^J0nflgB
zfiy+g7uH0#<Ap$q>>)_mJnBV{qzj}wynys_MJA+8hFE+>&wZ-qkJTY5Or??VJMV;J
za<Lqqn4X#VWcY8;Y6S;K&<gW(P8UOld8k{_XoYz$AQ>W?Qv5ayl`rp235-jVIILrm
zUcy7Uxek|6FwRc&(aI)Z9Ck`!T)r+-6n2XDhezo-`_-wc{wbZT9Yge-{i-YM6JEmZ
zR3DR_D5+)tP6bXFGCY%v{L2C-ne*&d&nS69&taaFJmF)uz5L&&@(D!A&eP5$h78Xn
z3+~^k@(Cgp0mVGTnZzGGtto&)i)}khUff|FlwPX2wvTc=z2xKaVOgh5_JU4+BhDxS
zKdu@e&EwoXzgUN>;`2v~^9x8Y&O+?sEA$-2>0ErJ4M})KgHKjqye&Lxd2+78a&loK
z#fw^5TglkMw;KGiIN}Q7QNAJiNjw#laLISB8Ly%)y)-Xsxikx2Kzgj)=SNYOCPCa9
zKzh(z>44L>KRD?|K++~EcH9q$j}~ijKd=h6t@kr(#L#rx*gje+<^`o<`kPWf7f7(n
z)Te+hkD4UySRj%sQYo$mAbCAAo~#@y&4gM}gO6&@Y?Pqq^F(i3-9asy=&`xd51|?2
zN1=`P05O{H%$C`{0!9jt$9n*zzcVfZgm3p8&%h<5Cn&xGQhm3v;Ar%9*62}*oSyHy
zY;5rqT-M6zwV&F%i2448zS)lmvz(IdawfX#`DE;Ei~7YvI~gDoeN=iULx%mk7!PAd
zo4Y8+vv`QHw;d&^8f-$nCgM2&5&}f$>g)ZWRurpb0I*~Ay185P%h+uO=8w!&<~N0W
z33$l7WPalpAh)_DSF!{GAxbUE&3%r{aR;zp=B@DWeH-0))SnY~0M&>3liT=D&rw1y
z3KR9BO4K{C8T~nlZzt_LZE|eQjeYFbYnky!5DV|ckk6wa7T&whT=e~XFWBxgXy)R6
zslDLb(v=zAw$=OaRRXZNBDWV&Z0yuP3pUY7V_fG^WAl)6Twl0X*Zj2nO=$L;hv<nh
zt^?^A%{_Y*RqN#$n>vuRStloY&IXuLza-1|+&p9hOaM05`u0*wIba|`EW)p&vFSN_
zSK_gOG&K^DjmFc|h!GsfsZFSH5_Om<krxTi=8v=p-DA8a=q6}oPmA#y1*(@!?9o8B
z879&%dVXxnK$>1LLsKKEX__!>AWg3rnSu0@X$U=MCK7!OBt7R08*4N1K~0ocn}PJ_
z#H5U7x6K4ShXXEZbY=9YB9EDg#9E^drcDlusS3;`%o}3#oSBHh_)QGP{E<(NG>XBP
zP^MlYsT>R>$S-L`&n=DMn@wX&Y&GFeP2Ajf1EfbvJT;J>^`~$^Ouqz8^+;Vnm<Yyf
zAc>y_k~R@IPuVwO#wB{H=O)+V5NZ{~)={6HqX)#E3nYkz?x{9RTvi4R-Jc?GVymTk
zMAJP6S(NJxnge$XusmumNuV?ecrTiSMgz&9O9+8;wu4wu(bn^&y{DtLuleJTMR_Kv
zRLRqCg2NVCJSa_z->V^itj_pjjZCe>)s#OL)A7gY(V`YrG8W>OrQo)YtHN)2z2#17
z!ZB#e9sWo^E#?VU%UCULK(zEc9xS2}#g-N=?Jpr|)5IszEd*(44`eY9v2TkB4~x#F
zpI+<4$7RqK{6M;&*zE|NYf^T&F~OH-VwawGS+OoJ_Y&t|l$Tqg06Dd3A`!2*olZDB
zrSUR!F;a-#Ml8k(jbpSTTCe9Sp}RoRPp@nO`I=t1(rYaAJT%clJ%o(42uKqtwxP?i
zc}*?cRgG~=a>4=g4Q(O?l72$b*k>*)>UEox!nrK1*XuSW7BDXDkm$nxxEN1>G$B*R
zl`<=Nxs?+jr#4Og7&*8#e)}qdPTOM0AN_f;WL#GB%jj+W<53!CCC5s^dG<u?QZ9*q
zY$Bl+Ec#tQ(r*?tyLj4UfId8^CLpNyDS|&j(M(9fPB~PkpH^vzwd|FXSW+NOosJwO
z*0k3;e=K~MhtjJ~zlqQ6uR2w?$w8h+P4xtE61v$-C?|RVJy$u=^CW1s{s<&!MX;P9
zS^cS*N`GmbMW1NN%L0dsOngkKFFa_ny>06$Hw!hja!4m^G-!p`7mzd#KXgzc^y_0g
zf8_PdLyqLcp{_?@Q(Nz4MaBM<9LO<tG_g|^1W5Or@IoNHauQVtWW$d*+}8g2BR%&q
z0HUYo$gWfh;ZaXoPWV82(sEx8kfvY)41x6I=hRQVp<echD+H3BBl>c24v&I!Tm69q
z=P+|D0hoT$bJosnt6)3|HL{xemK~_ko&f$x&skqF5)k&Ap0m&reaNHq99hssHRw6A
zASG*ogc_~fVWmpXt#1PfHL?YAefbgsUEh|Tvr<!-14w#~c!?e2ZHjX6M|zG_iEV;M
zp>qU(0vvgio+Ej<b-M8hGsJ!YLxviC&;^p7Bb2yRIj^VZh$(I{?nmJht|1O2J-1?n
zT`xUnlZp9*N8NK`Cf~*&!XM2kv5Wxeo^!(xknXt)fV=?GIN!C7i|MdAC2^HN(sSEC
zfu!f?UtOAli16@Wih=+M&f&q>Sl-6Q!XHhI)FTGcYvXRIZ}c1<yo-(zI}8En!8ts5
z7ZtB9Gkj@yFeVxxp+<NxMjIXl=cp)&^d!bT)Cdp8qQj%$ytY_yZXQJTZ5nL~CnL_&
zOH{`cPUca1$=;hgns}7i3cs~Qhmpc>xknX9Xc~S?r3)TyUk*{iZwVX)k}qHUM$g&K
z@A^ytBt3`U?y|4PRz#bYm@ygwNzaSl=sEnB5*a|!bNDTWB_0Lm@LNnxJW9`t-{?8~
z7UL6;^c-C{<|rPe=kQzZlI2nN+<~hk66CNFlNFHeIh7ZH^bB@P>kA-FjRdy>NzaSl
z=(!J<{LyP8_fr9Be!CC9-RHa$ix+KrZN&72Ua)ZmJ!j9mZ(}x);2eE3v9UaAYUJiC
zAn7@KUe}DE=kQx@(FKy8!*97Ji%01>{1)pPk3x;bZ}gl!uM0;&!|+>TY=MN%QE6j}
z<56(Vo)_aB86+)>W2FNUoU`ZMhX?P&gE8RII6a34JMI>o!-Ki43rKnn58h|bi?xq7
zSsQKk0}^V42NSl7CYQAl9!&f$k3x+ocZuKSQE(0q-iHV8!-KIT;@An!;lbDzd6XFp
z59ZP^9tG#{U~Ug19Va-42k*m!3HPN<dJYfX=U^2ZCD}Z^o@1;8(mg+f2itr}`M~gC
z?3h5B&M{~LX`DNLm}HsoU;>GOG&OR+8IY!P0*Qg7=kVY|_Pn--(sOt)hEX8tIXoCs
zDUX^Osbc}8XE4T7RQXUNJQ#B-kJ58^Fd@o3O3&fJhv=O#xsoN7p2LF)W9CtMj^3Hd
z7(7bP(K{2p%%jk`4dnO;n+Frv3?w~=2V=wKQF@NvnW$$TrRSx0Lg(f|cHGTWln7@Y
zq?hp9L-;Mh&(xgUzPyT02EXvzL-_4s?Rkt8eoJIDkgS97TkOSDu}sh5w**A<C||z#
zjh>@p#-<D;Jx9lU2)`v(nv+~`4!_0j%%g4ppy%kAu|xw&&*8U3Mst~J<NTOC?=k!q
zYc*}U=a{X5G@WC=2GVOc<wS4@r|0lnOxrwaYP5~J3S&0ECA1ny;~c9ukX{F|dUJSf
zYQ+2vBt0*Fqvz<D3BLxCp2Kf3k(1#UoWpN1n)4_<FMgxv9Q$KN2a=w{Z!xTs4w#<9
zZ;93BQF>ndM$g&v62=WAJ!j8Ly%TDkrswcmN}%v4JuiNv=j?e2{|1ttv*)E!3J(1A
zoINkrd>*CeHV^^H42B0|=;u+^M)thN@Ze*3Fg^e->`l+%!Bk}7QC3}e@G(3XKf&7s
zmh(r}M$UQh9PlXXIXoC&0*^wC@Ze*3Fx~~i8Paoj@G*N{N1;RK@L<Bxfu!f~V8YQc
zv^1Tc!h`Ws@TjTL4hzx{v*$g92jjxvQPVlT3@kV4IXsxab{?hYrFYVEcrgABAdPdX
z$N*^`e9Ad5t`Lkvy-&v{0;K7jD0m<}gHPeXr|@7R<GGY0IEM#Qe1=ECIXoDb3Xjrr
zcrdZ@JPOX?!9>p!hZ3B_gNdi-QLpEx?0NCX@F;Z7o|l+=?u+iVkqCPr!8tsb8aF%&
z&f&qQ@ZeMSycED8QYJme))E&Fk3#40;8S?;Df?i&KQs<C!h=uY!KdtliPb07I6Y?{
zOeGy2Wo?89<1-?JXU!nn^X4Fl>xc)TX>`n7^TVUiH2n4yyGn}hU~J56Eq-IkM#qf9
z2}o!feoKHpkJgt{EqUR`AB(2^v3ll@ZMH~<ZMzD8ES&jc^~@jZ%lTvB%pd8w`Hce1
z>ABB&K+<!c^MIu1KIZ{R&#hwuNzcu17+TYF^Ba)#+&U(Z^xXUgBt1930ZGrzZ^Tfg
z=eDZ=Nzbig0!h!!Z$Q#>?|DGdbMqT%=;^un4M=)!9TP};Zhixjo}1r*r03rA$ZJo}
zZEFFNo?FKRlAfF2fTZW<Hz4V`_dF8i({uA1ko4T=JRs@0`3*>V?mZ7kdTxFrL@hlx
zzX3_lZEFFNo_o&&lAfF2fTZW<H&Xf2bMJXT(sQ5lfTZW<K_Kb5c@Ri?ZXU#VpPris
zfu!f=K_Kb5c@Ri??mZ7k_ngv5cmulU)JOu-J;!Ycq<hXyCqTOAWDo#J&*8zO65wZO
z?(Ta@NdgZKCY1n4b9e3~1=8G|R07--EjN-%03<z!2jeZ}QE(0qCaZu)={Y<Y|0xcT
zP$N9p^_RdoJeaHkAi+62n5+UGg&N_(WEJ3A3C`ic+^@o;;2a)IrU8$Fb9gYB2DoT~
zb9k`bxZoTfOr`;l;2a)IrU8$Fb9gX5Uz|U|IXu{2;Hn`XoWp}jFyK*e4iDxI7o14J
zIXu`&2jCnYOws|6;2a)|W0^<6IXsx81Kd-=IXp;K=H?FIQE(0qreG6~f^&E<ercjr
zgL8PW6A{2UJeWiTAi+62m}}wKmCNOiv#jw;t^tt7FPQ~Ex)<`87V1ec;8A~h9N$#w
z-|(Y$K=>^cp@5|4?0G5t#G~{aej`Dm#|po7A_6^!-;#&`Bt3`UQWJ_t={fusH#^?I
z=H!%%0upMpjtL|^XU|I|DITTg?0Ip{<6cb9YtIAc@LN(5fTZW}Tio?LO3&f9IPmdT
zrsu_P^c;RmDgu!7oINkTeIBLf?0G3pg#$D_uRV{R!*8iu1tdL(-;%Jvqx2kp%Z;pf
zRMYd~H+l}g<?<XL={b8|5*B!rp0npAPXQNgdR}`TJ%`^CNdP20hu;W3>!p=FFEz4g
zoK=@SuZv~TbNDTR2td+v_Pm59@F+NE&r9wCPUOa!NTx!A@)6;|T<Qa)drm+Dkj6R1
zv4FIUNO3H@(&;%on0y8vZM*3U{z%W^!4${hQRAE(2Ov$2ght@+4$k4h1WWKJJ%<Mq
zKEb2(93D(S1%C73y!Je(5gts41(5U{9?VTbJW9{u!H&M*OT&Z22sE9;gLvTA0>ELO
zKUx;!g$^V=hX<2|foDHBhX?Uk_FH|<qfL4a58`i2oAewW#QD^Z!h`sD3Ia94gE&so
zCOwA-@gn3=dJYe!Ko(gD!8tsLp}F5`TMKQ{b9gYpBRopa;X%xa{d#y1(_BHoIXs9d
zEN#+rco1_?9;N5(dC3$ZD<U|rJ&&HlgB<7k_3$9)=s?nQcre){yxur-R$GlZTGbzv
zBnc04aLJ>_nPWj9-7`veAkBlQv<(RlqB$0Xp0f|4j-^d{4i9!*%L^K>p1Clq!rHi_
zW$UH>=-Fc1>0ZKb2=zdMU-%7qmPf&F@f&DG$4m?hkn|jWOAHH-(sTGNF)Tbv&x_ya
zIp@6d4Kv}l#IW$+;2eHS3=5Bfb9Bs(VWH>fn5m!zBshoPQbCJH!8v<gVpw<-oEN{*
zbIy6GvIQhPXU|Iv3y;!s_PoTf@F+bmexv8;n2BKllAgnFiDBVUdJexOhJ{DzdGQ-P
z=bV=u93bgAd*12Vn2up#A!W}?3=5F-y!eftqhqGr7m)NEemh+}lgu63ge$V=C5D9w
z-1v=3HaX`dh6PCXoER1$y*6^sHIVK(F)TnD=j8jaG@4Tq!vZ8dXV1$u**t1GCx!(`
zue!vru*8CMcrY<6JW9{u!NjoeC_RS<6T`xz;2a*j3lAoSh2@-{!-I)o;Zb@H4<?3%
zN9j2{m>3p9yIO9fS{aa*K8axglAfb?CK-uG>3QvW%wTvhaV<cCb9gXuEj&uk;laeU
z@F+cp2NTx<;|AyOV3L@4l(i8aOk4|(GK1m4yYOJ*T8L&#&*8zOKJh3$hX)ha!lU#Y
z9_))?phkEwaV<bXjqqUNT6h#{ga;GX!lO_lJear^WL0nu59XQ{9tG!|^Kvr_kAidd
zyu`KKCa#4)y642T0O_@nxEA)I3RdPp<Clyq1ZMMFVpxFmmnVh=NaL3n79h>Z9mB${
zztJ%}hJ~@hZ;4?6lAgnFiDBVU(=;(GK(;TZ=kQzZJwc=g=jfP;Vc}7}JUV7#Sa=ki
zmySu#;kTrUkxQAL!*7XU;Zb_do_8O9OAHHbf^+ySCF9t1(sOjo#IW!vJx9k(3=5Bf
z^U^WFIsBH|aqMF0IsBFw79OSN@LOV7c$A(OztMB}?LInYVpxdr%nA#?C5DAZSsUTE
z#IW!v)Cj+I3=3-`{FWFNAXyvXx5TjUC~G79)-f#L9DYlkIyUZ5Bm9;NO?VV)gx?aw
z!lO`Q@f$sd-%`zvQk>m$VpxDQ&WT|G($q){3y|))V^}Cm79LCuJXDMH933+;EIewQ
z6T<?esgW2KAWi4Qu%M!}UYr;fAU%VLVF8k!qjx5Tg-5|TJeU|3be{Aa9!v}ik3x;`
zU}9K!6r96@9m4`O!h@;6N2SwHBRrTG79IuX@L*zCcodw&gNb25D+|uy!NjoeC^&})
z6T`xz;2a+87#4624<<zseJ?nN2OqNMC25g1SsU5&lE%oR%wTvhaV=DNP0!)M#I^7!
z)CdnIu7yXTMtCrBEhwU)MtCrBEj$V}!h?xx;Zdj&9_-S8P$N8;xE560;2a)ITnmqa
zb9gXuEj(H{vsYDi%57p;_@mcuVpxE5FNt9R()cBY1;|Fz>ZkX-j$xs8Uid9BEI|6p
zlcx!!XDcx*K$@nBVF8k!qhlt91yw#cXU}^Kza@r+Ho-ak_Ly^CVpuo{Y_kQ<;kU%F
z013|Fx5TjUC_RVYa`6t2f^&4t)EgvVJ~-!`mvm7cg&NuO62roy&^dcv$FP8N_$@Ik
zK!S7lEio)S3eMrT<e%~=I7i2P48J9Yg>zAQ&YqVT79OSN?0Jb{;Zb^yj+q!1&R3yE
z_Pivt@+j2Eo|l@4JPI|k=XDGV)Cj-jb|E0aIsEn*yGmkMXp>bJyGmkMIPYa`gx_)>
z5s%Vy_$@IkJPI|k=cS|~kD3}C!$M`n?0Jb{0n$Au=@v*+BQY#M8t25Y07=iwu0qe@
z!NjltNzd8y62roy#yK%8K$^~pVd03|)JO~qke<QBumEYfkr);r={Y=@7#1D{=kVZD
zcrY<69H)bGcrY<6JW9{u!NjoeC_RS<6T?C|?%*6AOb#)RLg(;cVpw<-YJ>+nh6Or@
z2NS~rBshl$6T`xz;2a)I3=5Bfb9gW@EEo=gb9k_0SYGfbIEM!l!@{HB93JdcW^m4)
zmlzfx!8v<gvYdGooU`Ypx+IT+b8IasDoJ`ya1IY9u7yVnXZE2=EaZ23S^Neh{FWFN
zAi*#EmKYWu1;6lH$FT67&2N}h)}G8CYv<&Tg&%*cp7~>~UH(}3@yF_!KNi37$3|1i
zlQzF$r%BJvZ$Q#>^Ba)#+<P97^xS(Mko4Sp9)_Rv+~+(X>ACkjAnCbvOd#pG`3*>V
zZhpg(l%AX4fTZW<Hz4V`&v`)7bMqUJ)iV=$%jHpJLFGy^>K(1W?x_;7{(2zqc>VQA
zg3bEt>BVAF?uL4W6Ji5abi-0J>sBr<UvB7IF6iw)Z(l4vp}`$DaW?dx+Zg-L2X0F2
zKObMLeWb3Rda;%&_Z_`@u~uYV`ox8Gt1WZ3)*R5cFP7@WpSLg83gXYZx)`h*-`7=H
z{r3Y`6!m~iVMj>N{)xZ0b<G_yuecbe-(@a4vH|!TF3#w8dESu<z@cV{!@Q=RVckE~
z5eBqj+|Y*!?uY^4j2j9u&0R;3OEVa^w_vVg;qPsFfirHauoW`VZg}8~yZDm78Mn7W
zZUy1*y!%*%R~H??w_V%ZBJqj}ISuEm(Qa1YZz$x_?=s`<f&_j`S%9^aDyAZ-$d&ot
zo;BLAhSvJ!Z&uNgSN#2iskUj$F{I6Sb<Y87rpE%8Hn0JI`=U=x{C&$kj6IJmuvWqA
z?f{lZ&mD5QBaVSTzG#htzoBy%W2J~Ygzi8Qen9EY)#nGK?tFcIK<g8MAp}1fbEG&w
zngmGlTpYza(7OWz_`yVX1OPw4pdI^^^{yqh4g>rE1M&dY#Gqvn=d!UbPimEAT3G^w
zxipPv&N}PGh{PvQWHEG=2S}BAIsk**_*u~$JZ(a;1Msvv;J^InCBT1ankTj1mN2hM
z+$^$i61xKQ=;;7q=#dU;%`FMVJ7CZ|EI+`Y13Rfd3<e#q$qz6{JSGLE>qpao!THg&
zF2U7%7Vm&TZ#4X<MZb0wemt<!Ln<s7Ec^a!<O2~Q>*K0IC4nCK!OHJ&E$YXz^gHH?
zAFTcAvgBn&kx)W%;Z~6(glMD#1ZZDeMKdsH?<qgPpj~tP0E5npridpPVDw*IBbQQc
zj3;2ghTTuVp#2Cu0fWxU<Odk^tsMLSgSL6{0}T3P#t&HVRr7L1prqacwFh7EqdBr7
zQSfQ^_aN^0v6f{mT-?=*h!vGWw*BITum0nIym|M-x9|V(-)^Xdy@{;)`)~f{<?sIW
zFYjLd=IcMc`|0N8Z{Pj&{^uXRdH2%`+z;!;m;d<g+wZ>q+xP$d_k1IgfZ43W@K-l4
z|F`eH{fTn@_33cQ`p??S5;B!oqlEG#NF&u1awS-N_i?$OJi$?|V<c%CK)YXVlJuIi
z)g)2ItQtdLOjk*6NrFaV`J;?S$zzw?NLc&PHtC3wR%4Js8(n~`gBE*3>-20S-8c~y
zYzdnjKsvN72LaLqiw_t97f9>S2;%N1-W){aw!-R8k8Pq$bTq|d_(5c})QbfH>i1V9
zwjYk|2|AVEN&GJivl_z^>jU9{jhkVrR*+cI>vLGadDOZkOL8H`3S2`F0kz}|l{y=e
zND<<lx^aR42v1rc$P(`%u;y(`iV}K@J}^`MXf2=R)IH}43F2o~8=_p+5Jb5I(xzz2
z%rqoXdqkD2Zzp1;-wK9AdaN%coMVxN$cl!fz8C)e)gke2s~=p@s|}8eg&|g=hNN;4
z4D{>wKmYInt>}_9SKRU?YyRqoAKrg>`A<Lp;X^U%KYaJYzr6h0_dkC7?#JKPDtYx4
zO#97;-{XY)qI89)7r5oVK&HHT`s(Gc!rs67=EHaIe|Y&%FaOJL|5N?{um1e?ci(?_
z|JQ&1=WqV!pa12H@BZ-TFTQ#I=l=jAFaPPok3WC&;WuCZ_^xof-Ql(!`<{;*8$Y?V
zp!azD#qA3+Ucb2i>gAX3e){nHQ1#{i`G5V_7ms&eyr$u+FPQkR_IRK}?GY)0Ux!F3
z2=}*NJfhm(fAJ7JdX;<{kGFd~YK=Z0kB6Ee`~-X{+D_r}^za4qwb3MN_>2psSiWHK
zi6(FMxYYW*78k~^?e`un|J4_F!KB%0!{iQXy}$~8I6JTRm=p_NiODuT>-hEyaH-LP
zOUw9A<ML{cOEL8GaY6927&$|I!N&dio@L7c<^q`|iq2C+gv!wry?NRrQ^Mf+$ZTv=
z<CoI^hG`(I`-{gDVJ0pgVWBsVdt6H3J|CB-yBh!PEnkaH!oM6LPM9pgx}PFAbuQdD
z4|_~XGG2?x?LBe@)tBYM;o&4$2w~l}kMj)GVmiX*eveBD@N03Y@oTrN)$;J>i?^Xm
z?`fZ=%YG-=REFo{vQ`V@*ZF|?;rB_j^fr5@%E#8qUfgac;^$-1O!V}&2*PO*`SQi<
z5T$q6Gb)s5W-7f{_7ZnH0AGtr2{?4A;-lAy;E$q0$lZ~cd$Sj~n?3URsB9dxjbEp<
zD*FA!?ME^B*s9$N-0ejEd`#B-6ap-hnxESs!ZB)7LC>>;*2E6s+1X3m&7O2MB50RA
zJGI#~O^gc02o{u3dA*mln@RZjsI1vxd{zolg)`j!(}|O#KYx;wU+-n@rmsF9m!6+O
zV9n2Cc0(4<rcR#chtL^NHc|GXc2j|`M&$8z$=by~PYjnC>XXNrDjaAJXJ{{LH+$Oi
zky$fT<CjT`MM+5dd4`0`M>y#9Ue<0Wx98)sW~dNA*m4TMu67c(9G1oww8cKo&G7YJ
z)NT&Ks}ZT;(GiNFiDN&{P@hcCGep4P(Qf#9FKo9H+||f{0Ll}`CW^M5RHvMlFIMhT
z9Syv4_ri9wNnedhA+WI!wV}=v)F=2eRq&l13AxvMX}j5Hu0{m}%C20S5JB-LT|4H4
zGcud@dq9`H#N7_8&qrosqHX+5LBNFccvf#??AYUSpgg_Wi`>mu_IzBLi9i62n{9|t
z`jd9s7MhFIQWllTL$CJYc5_->jYo~%6GRT`X@c5jbfyWRo2bIZWiN3z^TG3R+2*H)
zXG_F_hmGi@IkhqCjL1hM+^fB`-Mp30M`Y6`x8X~`!O(>1pJu1+YZtR~e0qPi7q+rK
zex8YA(S*&PB~s3<yR%~32ER|!WG`$tTio+$vJk1^am8WGATIFXBx~CSd8Wz7re`l|
zx8usSs4zT|mZgT}@FZyu56nkQyce{a_3v6lYIxL0RtVl^#CmH8ZLj_G^y~%g=1jX5
zl}(g$3<Mz}`cG_3A_FJ9-+mgEy_ntX>sO+(4bQIpmR*@R|I-9@Le8gF%F|xRZYIxb
zF=2GhK5xsmK_$x*AGf{zQ$%^%i`gx1;aW^;bSwyO5uv08oTjHe0H37EUdV24r{`m`
z$+j9DA<IH3*XG3mby>F0m>eIKpY~FAbK6~u31&%79URBN<l#c6T~St_#AGjIHy^^)
zm~57e`#U5YnFXa?f83P(rw<?g^4Bk4{`8l3-@kkR;m7y?_q(zszx?*yH{bpF>+fw-
z#x1ooxopPs=Oc>3gwT7cBU<@X@B-Fyz81}w|HIcme)r)|e}4DjyKjs#XV5*$*O`4E
zpGpf|XO{a{n;mZx*H<I`<!`=RRQ}>mAO3tmYJ9hQystA6|NoEo<5(hB8kB1{A`OFe
zLXZRWCUK%9&DHc~P5<G$4?lg3+7Ek4y~Sfae_?ObUh5ha17qvIab<(_wzfZp_1%yg
zSK6pA*7j|=H;A>Uo$miDTHo%qmd!u<d|EFd(kzL`@ZXB`f#`U<-!!*ql;<Og>7evX
zj6Cd@cqItvLjIl2b<3~&sSO<O^IjfYXYJ-pUs4yhNEuRVli<FDlQIz(?im>}s$j%<
zQeyMpA+znb&!-F}C7QFb)p4MP<I%KYC^ItL8wT=5X1|^`H}dn5A+sNvke&ld)X-+i
zIIW$g$;f<+GJ8FEbM;?=46B7OF07c?$ZEBqlfONkQ;bX<H*JW)%d?-R>-G>LjY_R~
zb6Y1B^znNXP;~Q;nh=jqP58I>$XvHEkbw;v<arfMu!)j<bvj-r6ya0q78d+HD%Uw0
z8Lnt?Tc%Yago;K;{g_ri*B49_(H@!Wg!sP~GJBnPi;jB!@-4Fv%a^Ia=*(t9h-%rm
zvtl}w<t$}Bwqo|G#1@9}d}JsyfMg+Gwot;piZ1c$^%<Ft4mu-45G1EPNtt0u+`>hk
zj|?1*9p+7)SP%_`+Q}I#w<pQ4N3!?zj;U82wC5v2eTU+sEu5mtE|5ZbI>{v-=}eQ4
zOwitlxI+7$j|z3znUoT66~($v{r6{NI@;>Y)Bu=DP0-$wxT?Wjfeg_AY>NELHhH@p
zQTR8m&(Abg;jFym=@lmZd|VbAQAUWFT5LphpR?fYc(n5@QQ#I5nlL*yTI>D!$W*Bq
zl3!W46q>F@jKS!%cI6TN*n-(@)vGMu6{xT=zggifs4vCQHC#5Ngs7bt%*T+~ZPlwZ
z;1$Sh3x*<8&}1zbLL^VfeD;DFOnqI1$0l94LIa8*T}b~w=`S4~d8P?T5Fk9)3X#A2
zg?n9m$EM(J2RAlpj&Cp&d*w5kh~VQrF4t+inCe)wD`Ja!H|*HEh%E(p9P4#NPw$Y~
zayy>CScugwxq`BQ#=D6zf)r1L`CR++<9?F1(4FVwLgjAO3B{ox32~5c6g8X9-dMS*
zw+brLee<{%bXzR(6{w)p6<Id_K)LzqB9D^^`oQnF#h7XFKJFLH7J+;PGT0W`jtH87
zp$V>In@06LNte%EFps+<QYFq@6P-jN1=Qd!9nc^o2r5w%<V2azUNB?vUZ?L;=n5<-
z4^q;f89<SONFmH;2UtArMctP7_54}dL>(?ia6!}&4tz$W1Fg@pj;fC!tL5@A*yuW$
zONGOV@gS_O4zZg9vJBGEbvxMmyh#@_2ZHxucM4dwW1mkI0=5amEnX%Yf?=rGaat@8
ztBw}Sf3gMaZYB99M?VaXzE0|L9D$$j3lY?57zr^Kmr?@h&ont!Tu7_g$=ogb?;4ua
zq^#q81*#F$fc%Z>LTc6smpWE2VZJ>wxZ|#fHl(UvA;1bj=;D+GF{UWthDka&Q-<Yp
zpwf{9vPb4Rqc+j~wKd*u-cZ<@tr6jSI;MSI5X}AVSiiFRu9&2<wQO93T?&<sb0guQ
znWQ8Voaw@5bi~s4dzRi(IIcs6ID-4lNCvyY-l)7m=5wP7?)MzMrK4Vf%O)<kPqoAg
zDTt+LM!0-#IKlm%r8hBf1t#o^h<{E)F!g38qwLn1sl8g5MqBHU)cd7-ozx|bkZGZS
z6v!Ya;E{Va=}4H*4k5lD66QK}mrA51YcYz|5dgIAHv9RO65xQGWBUTBkbAmZCwG|z
zXi=5TwipXE2Mz<h7k#FKmJF~RCR=Ls^Op-nhl+8qH*;>p5eY+Kb&jO-3>{lL(0}&G
zTq|~K?NY0ke@n|n?=9`S31fTeM-BmZds(+7U_PHRRFy^S))@&s7lSwSVF5+#8ku9W
z_v^d8eA&{}pN~vQma>Zx%?ulHT!XQ)U=G3{k9qoTFJQJju;-&fVZY+zO|vUY1B}G(
z7yZ(7DW&fqZuV}^(_41^^O2#(KGfi*O4bTGLMh>R_u{qrT*dotZ|~Uh>#oIxDtE<D
z8!ng?qF{ce{gU+WJtJKwcggyKAe65zMk;3wjD*4L*~kp8zE19LK_ImgJicH*s$7zb
zV4;<Nx@ioXvU_X<B4Kk+mg~fBWhYRdlI2+00e7q$;&?wQU5>pq#Ifv9xiVvq+62rB
z8SmS|-Q2lFr;j4@5m9%$XX!0b>DrY`Wo&4&RxSmr&n(?(q320D4%DFp!k#kMsk;<1
zEbApl`l_k1oU&*8`)8kDZ};+L%PD?7Wi~1I27A<-7ii(=b!ZP^qt31VG+Fj6y=C}5
z9}~)-ZY#Eo3)IvEA*zj@bj;2J-*6$aft6Lk0X|H>9aD6jiGeI!c!<KaMG<V>MBUYC
zHsa+Xnrh)v@f8QSjJ12MN3ASCRIfy`aK8c{U0c&>n_fxE8(q+JmY?g0E_;<>3t_xs
zj<(}b<z_6?3x}i<!C`9Qa!i-oz0}>3p|8M&G*jjUiA$s?+2GW5JyT^Bo%!Tyx!o(f
zTmJeLnBcN6OGh072o9}z!q^Zlx{T5MrImZTpP?&L_bB5IJxaQv&S4zmByf>OczIG=
ztL1ox?)G%~Hze;dL(4FQNfs@pSIT8f{x5OR-F{cRGINjHAea-f@A;Q<7#n5C&I&ho
zIfjeHa!i!_y%Ke0?p~R7Zrf>88!!%}3#ZY}Cbed$baKm<hrP_bGJUVsEYg->3QqN`
zIEoIOCGMqP@0Uc&!=TG`BDbP|%EVpEw`!2o2{KvaDRA*gDfh6K{#PdOaa~Jo&08o1
zcdyjiAv`{Imz`Jom+101=yIK=TS4#`#NL#ctFSGqAFL3>b*#UPVOYp)sarBKKkk*f
zE3^34UPwu+Qob>I5H!mHDN5Z=b@@fg3{iKbvI`wJn{hy@jj^VT8rEmFzRW*eG6toB
zIhcm#r~NctnZ~!}v>@Ti!cQCnQ&tX=Gi5H4VHYx`$qJRd*u655k3)2E5*stD%|vte
zz?rE{m1Fs`FWXVovaT^RbN>O;LOmGvAucnhiCQt8y?8~HW68UZkgsZ8*C5k=E6yb>
zTU3}bBA(5uRFNvdwcHYG@qPrE{o=hgl@EI=tc)oNRhB8JDC4thf*`fCH{cgGNWv(0
zCz2~u`RYW1jNxBYsm;4rfo+k#smJrF4U(9=Ju=tnyEqk!htP4ErWN8r<VmFOE~?@e
zDYF-NS0?mv^$lonDdYBUMG$a}%^8`?SgC~!Q)#anqH<4}>+B5Ng;kql>2v5Yr53z-
zJWY~OIb6O}tlOh<o$P(fi4jjZoQO4-#Y<7UlesQcmOi;&b_vuJ3!bj&Uw{4K>+j$H
zaa9&Wek^Hmv;F?Z_usyI`Coo|_n&|M@cnl`RN=Az{Fiq>tRh9fFXQZQUu@(5@bmZI
zzu5kHMY*K^<GXkN&$}Og^W(dJen)X4ij+~^=*#bZ`pfrU|Ld3UzxmyFAHIM0g5pK*
zZlKZ2bX|qa3bo&+veEB;eE06R@85qwesrP7m;dnf4}bitcR&13|I6S0hntuG`1Ozf
z@}GYA=l678f4=*6>ys`oD9`6!>Pa>7-~9dG{r%rlbP5fT+XA?gl}f0TN5vMg{mmT^
zuWtX2f~UamzvTZstTt4<-`ZikUG0AjoN`_Dyq<9`+Wt#w!OhEG{ruri?|<x(*eEEJ
zxc+}zBlGv$UsVC8pa1aRs0bB=xOXE1Q3QW=PV;+^;SDa=<-h!m2a&p?y#DJS-+lez
zGzxc^EIh!8O84Cr&3^Oa`)_~#=G_S!x}@p)R=O*U@EfoH*Z0)WMH8OgSKInFUf7}V
zI>S?|>dUV`y!)#!{~EzgZCT_7|Gv8aum58O*r$x$e`h7!P<E6W>NgDC|Eu~^m}~#}
z#RlVot*ttAJ$&)Qg4N$u@T>lJ0o$%wxqy)yfO(y@a{+rrz}j|~?tpEVDGu0H18l(V
zszl>}Z55>lY`dIb4<ku|U1bM@dS%SGgz@)w^~!*4HL5RR)PUcvMclzCgj+0e3FGgl
zvc&IU)EgZ1qrdGEvCDQ<vbPF?T*9jMeDULeJydDf0psW?*milyz8&6p1oD6#;Kyz|
zz72=cb_woycPp1ZVA~xC1Ge4fG+^6hG<z6Pp!yC3uwh#b<?-%zQ}KXpMd=6Zp-N2*
z7{$v4+b;asw<8oubm5XW!7zDh&ewg=qra{6|A1{5dkh%fnTa1(MAVLbJ1(ixxX3!e
zsPxVGV7$BCx;<c9Oxl3mS6KLfahaN6+vQdJcI207Ty7T<4A$2grwFLl0m_^BgG+A=
zBcN>JcfVZ`w#Sc4Q8Wg3u?R*EgytLpEjn{oht?YGVHmr`#E+{@L}#v*(6}W`^zL?l
z!1%T&(;4>FxLmSe7!k;G3@(SzoKuZoG=Nlsar1%ZoI49N=M;(8xKH<0&S(E^EEnT~
zKYq01f`h8`yL*@Y)@zbF@y6w;91r8&?Q)?3+pZ29u<csZ0oyKf+{1`M6Mn>`&u`<(
zg{tMffA`gPC&C_v%|bN5jXmd=9j~G#$Gcly<~<Bwo5sZxH|Lj&8_F5Df0uw>!6?Hp
zd4XFSB<r}_q2gTk{ZXS>Fzla`7oKpJil*50)sCot!3d%gtypTBkGI=(zI*)GD)cTo
zl4x~{t~bB!?RKBd=x@7UV-H)`Zw=UX0pEaawao_%o9rBylZR-9Wkd6ZW~X-RMv(m&
zgvE$f)D6(QQD4FBAk4&%E9ry_*WZbz-1#S(-fef7?D1o-5H6_1q6;F??Y3)Z_x*8Q
zm(~#1g^5-yE4AY!BN&%QX$?`sSahkw%A{4DKqidqjSTa?|3pP~(UhB?{O$q$xa>#Y
z%T-6}@6q_ZA|htUq3zH$=mKoJW@S%%u8kS(xO?M(_8fuKj$3vFBZ0%PgKtB?xZQSF
z@g;s7=Y$`y1N@#2@Z&?q7`!X|fN5<26Mn!B@LNT-_BfL-H0F|bg&(l(>Y&SaVUDd1
z{w1vDt&Gll7}uDM^;}nz%(EZaGeooP->nNvDzx&lKVTYzcf}vTxXE$8%RTmk&uO=n
zrQVOhweq41_4PDIoLz(;i8*S=zMyg6!XOhruAC6g>_>tj+J_9|qLl4gfy?i}Px!j(
zE?mN}Hi-AB_q<(^e%X%nQtipWwkt<RJLzGV>9>0~_U))tDV#Cwi+-q`f^l!}*cYfH
z^m^`Z>}15W?Z20H+r54Rm+h|DJ&bErg&zrD>JNFZc0_p#XPjGxNk;<b?Ha{BE{I9Z
zId`-P7tRY>r|_HFaoM5PBr1~DB)4Xa^+H(qc6aL@zsKzgz#R<ko#!JeU2S*Q?%Kgc
zRY89bd))5M+QV2H;t%finsgyr&;7v)V?P3y?dr$f7^JjLeTY@HW!>)EaiPhi3u?P~
zzr?B9an;WJ4nmlx&7)THJf~3Xf4h!t;IiE~xrbr<nl!C@Tju)XQU=ox`R8}HyST>~
zRP-P7Mvl%rzu_BW#mshZ*z^S3u5#RufeBvoyRQAXY=>Oa{#G(<&gCm^9-8N^J7Ofn
zTik>+&jx&l_nwMrFb(dsPVw?<pWzfg@dFn&+esJP<f0!JG>R_k2GdKr(4TA%z_{FV
zj)8<$e}oQdT&_UZ+Tg<V(I4}H^1UAe+UtB&FzJb}sJAx8pdCi7*&jBUDc5k{Yj5QE
z>p8;Ir*|n5JY^>u+_b%NJ3Wbudt88VIfh`ejnK~e21zhp2lv}0=KHziLSf;|t;K`(
zjIrHlINseZ-X5^G(rK{hPaPP>*V!J}cA3$xKTOElr?DPP8y+?OxF2ZJii=st{N5qz
zrVWpG555iimFDe{AbX9m-L1OAxo%z(O`o>QSVuc5wCww1jXzaT-DSH?jUDR%l@*rT
zx8vIm))4n1YOmlD$GO(H)=4rON6_RW7-lQbaETukl8|D1TnfKQKU^JkU)%26=ubQd
z0A*#iW6I}uV1=7D9^Tz<fW5>I*mlL`9>#_)8o&y|j}30pna_|6<Ms^ci9~44v+f<R
zDlIf{@qS5l8R>eM&HTLw=M+LlrfnD_^>&fae%yn-8<2P(3QRdke|OUBxPEB*nP?~5
zCa~>7=z$9d>PZ*O{G!#mt84!*RV)U7uzPHGO^<d@)0RtdB-xdL9q<CG^59F_k^3}p
zrg)BF4^w}JXK?84-!1-_zPne%2Iw3>;GyYKGqUfGdgC~Y1gjjgBFo7S%c+Nh?Sx^T
z6zx$v#g}*18Q$3MLJBiV@En6QbkUTw2Jt0!GmXo+N8d{ZwZ|ZnPUG6<QTJMTjP1th
zJ+1Dyn{@ZE2c-5K<Du@UtY#N<et^3K+e)yEb_er@AID?(yoKpOItZr^oflw1uLE4d
z8Uqukz5_8N+H)PX))3|<wZo`C+QAFkZGM+DsC7SW@R)*brB7l)@w(!U<1xk^W+dsh
zbzB(x7M{=TPR&bPcz3(Wdcx}N&>alxkm!QdOmZA6u;e%^T>3plgCxh_67J%0?{x;_
zegw&Jj!cr{Wp0{$UXdRfgII_uW4WJ1_93h}qWxPAG#<ltGdMwVoKgomH@;<4nS5R*
zGQ)H>xT7ek&hhMcQ-7h|!?f|RPVc9DsWmyz(>RzdCyDvd-ovR!@)<Qpx-y!NbRR+-
zBo8=-N`}2fBu@T)i|Ew4=j$f#bF`980kflYBvPlPBXRnbj>Mf5<~PhQlUGSQlaBNj
zbwl{UnOdjpmu`o_Zu08=y=h7`vT(tKr?ty5RQ-`zD*nL5EIJdXpfT<VQ51eu(h-bc
zjXjK6dz`vOt-mRAkS=xa@Q_z5XTct<7sI{N4|Ydr${ZJk|8Dwlfnijb<6?^RxKF12
z!=vX2v!iIr)yG=n-0wPQ#U+gxza}o&9YuSeU3ho9n07DkF{RD@oX9B8Id)9p$G#=H
zU<MX`sFT7EpVHh{Vd-fbVUDQHH@}z5<_C;y7U^cSUZ#%^Z;x$#Sjfb`w3}m~iDH-<
zxG?bC<FVd9X>Y`XJJ)k*wvzXpz$Dj5?~+_&SJ2syV}Q==L<UHw=BVrMKupegBf(C-
zHei|$q@;9)GU16<EN74LR2dJuHOWcMwCC(M*9+F{c|M2s+r8wYKl_=e#wME)rbx*M
zU~_L|44=zxvBL?!bqnks7cS4y_p;|rK8I7Kd$S!)`ONa$ZXmxLqt^J`KWgPl4slbv
zX^*-l{LmTnZG>bE9z?0z?r*=ug`JFGk~zPSe)Pw8Xs<1tCoiB)`b>gXP5T17jCq>t
zkcBhie&BM)c0TncZj9bC2KV1~FPjnX+O~O%4Rr38XpY*GF-dDr1~%uMG43UwEBwV{
zJZeuyEzzFLiNv_DHHv=^<UKA()0C}SG=0z>4^0o`8W{mvFPK?1Z;uCZ?eRda;X0Pg
z;h5(!4&>Uw84*>~bRmY%V;smeVlea_?2V!od*j?MVYg{l;a+&ms(apoj}&uPJTvun
zR4%N|`*-P2@tweIC%hvB-0#|Mi$nRKo#~8YSNav^A?XL@V4Z6cXXTW27>0e`$3ZBb
zMjfAWh<AM!$4V_54<wb12M2>}Jmqwl^IMJseFx!=a}8k(mrhuQ<++B+AgeJjcxsF{
zoSNpG69zDOft^e?9*hbHFp3(@{x~2BKen0Cj&&-ZFl$meIumK10}8q13yR_#gM;{k
zWF1PE_I<V<$z5QcH*Bhd-zd5+Un(%9?4%1DlIV<Z7p)M+noGhNG?(~3H3saaF<7P=
zgGHn<*rzoHCkBrpo7Nrw(;fivJx9#B$9R-(dw1s;2exzV0Z>#r7ZH`xZOI7H9)LGg
zdjK%$ws-g&MXLwLDR8TwY0Br0J())GS=Sn${EHY@EGJZcFb!}+4Bmo#9DU~cBmPA)
z`w_3J+L4bX*nwQbcc*b5t!GoXYVJMkP~I<5&9vu1D(P?>=_alCUi-FLLYAk5N{R+g
zPqOcl2_;{`9mnL!N4Nu|w^QC<=Rq`4?QcZVX`OQVkX@=&(YgMJ9+G@1GtE4U-@n2@
zKIRgYRWbrL(t5$IAsYpW%i{BUt|Xo705i=z$8-FZ?X}kUoDWXZ);sTUF^l#%N%d{0
zgmdkZ5+b=v0W<m8skLCbV9L-K#0kzdgy~CbjYu&0p6)pu=sPe>Y2MyiKgIGdIeCwv
zM!1wUZO*y#vXIX9uWpH!dRKP15{ZhFxi95szFVgu!7w5VMo{2@p&jVV#Dx*s^YHMg
zzXwj8qG=(mF&t}(RZ70kd(KRAUnMlfJi`%N>jfX0VA$bA1565{72%x|XR<`}9fZ)k
z9bvg1SGh7Im?-a)6ER-;L92VxVJ8fip=|$HOHBJGl#9_HRuHe}C+jp1$R>|#djuw5
zt-l8X1?QT4Kx_#11|@ysM<vopKc-T)49v<p2ax*UcIA+oW8fg1^GjVI*>WFn5zMtg
zdY;?C`|6K!&!V66NKxRFCkM<vIaG9=g~-j-9#zN7NmJB~c~)azcr*2E_5j&#s+sgt
z+{s$wgab>S5;bSq*8zCW2X2>%Gv*EHn1l$M7fLys{gFT8{v79l*IwtcavNy9u%M?L
z!d341h0uOiHbF4P3OaE<h<`5EyVe!98{u-`i{_-Ob$}^I=i~>rOYs}3t;WTMGG+S%
z?oi`meH<^C&VyudNRJ@uU-F&^+^N$Lh^Y8j)-#8?Jx!~K!Q9IzaDY*8-;Vw;;t57j
zj9~VMl9R3&2c*4pTS5%wn|MSUnCp~n#`xh+p7TNEuhuEigqm}Dlg}S>o%TkghG~!5
zu5ld;d-sUEnmqW3Jwi0au&nPbC(EQWc_MR7k_{_+3ER1HGaiYZ_PCC%C3RS`1eoL%
z+548U7@;Pg!&*A$ak>;A0h4X+u{>Op2D~boa#R!jP;Cv9-LXWwbfibNg~`9bX3it;
zIzEw;r0jZSwiWHM1&LOC#^6=HmSBxZ1LBLtgP4}ICQE76yNVG(M(7+>@?f58If$dQ
zs=r6miufjd2LeI!!Q#+*W}gwx5KuH=>1rLI6HXeCk1f6Kk$pkq;!99}*uo9Fw>%&=
zYJM--AL@_LEyaF-vi4*mAtZM(p@=`8P~j$iWJ5@v5`8b3&8LY6(duO1eR3{0%;9+8
zCrtH|SJ?)&H)29@JJ;X9)MA~r^3O$Q^hC{h1rUvON;JCkXQo^}L#o6`hLO%>`XP5G
zFFYZ4$9%wBiXSRInl_nNRLb%E5~i<jBX>k}CO%fU;INo7jAM^vcBwgf_rTvsc)Qj;
zQ4jMwFnz&YllH^_4Z7e&R1E`Qvvv_SM?{mpgTvqCU#hxDKOk3H=Ru;MrH@mNaLya%
zHOo#+Zqm&VCFWI>8h!60(LIwcC^|#dVXjln8nk<oOZ6^^(SmKIb$32tj<AYZtlVpj
z%P~s*K^Wo8A{w;kaD+>5;_@V$D&Iy5>%JZD67nrrT^v%Maf<UTlci}@%r)C_Cf2*S
zqsE#97p=)Ml}=wOl1X;{;?;RhA#z6hH0D_4#bCIW{z5zHw!n1W0;c#OV2YmvraS`1
zm3{z>1Ms9D0lb2Niq;D{wdRsQ55p)fGRJTp9}-7#jF_a~&U0Rwq^F&lchRaf#{HC&
zyes<}?@FgGQ@HzM>(O^$E*U(-7*Eqj1x$Haj3Iw5FvVm6lkFcEO2hnKwn43N^1(D8
zEMD=9V@WX8>kI~rjYi{=ARri-d=o|<n&t@oPxONowAN65^t~t&!sY4h+%K{6lL$F+
zAskLPv+O5+lwFu-2$JYMM_56`Gl)9z3}FCM7So^k{58j@p}*k%Kw^#Wz?`UW!%Z^x
zY2KBO0J(-Dw(qZG*zE5W=?l{jMt|CWaoM2o?)w9#y{B9|^IQvzi?sCa!?YF9?os?k
z&hk97!@ZU{MC@oylD##3(YT6KM~VJWI3|8f+gy`q_mUfUt>#&XF}&{+Nj%T6v^$`4
zWm`^MFkgxGcLcM~cK9nM?_*Y;x)d%n#nS+je-(qY?7QWDoBAZ}lv`h}yJ<rPCf%_j
zX0=B#yXMs@XgR;PjIV+bxG9+Otr%DSH+V+*QN<sVey_02O*=3FC-OT3ll>kTS<4eY
zLUHsR_$9RtIOM1ue&;FcnDNQytOC^*fdH11#pXk9;PHYBC(cjG>7t!-jeucb8}C+V
z?UZ%on~E-Edd%|&IIEr(Fyn_uY1+s*<S7;hn0zt72&A1jV=@<A(60o;ML+qH6N&Z@
zvIn(Jk*3-QQ4{AHXPqi<hczjG50Tx<31M<c*4MWk(28)Cxz@0#YE5E3(7wRwXy&Yt
zOd{J7Fb+}!m&&aY{RplQorx)$Yw`{L8R3lA!LYZ+nJ6laiz`Os!de=aU0yWhXytba
zq8i`JaxpH1CkhuPQ~hBR6fVTp3Kvqf{O+Ul7fdpy74-lnE_h+5J%XYJ$`=QQadUhx
z-uUU8z}2R+GqCLz>D?KTG_<+b!V5T%_G7T_DI7XsxO%6YtdNPh#}kz%{RLL_T0{Q%
z+Z5AwUtx@M&T-9(2dM%noe*z|_8Cq`(*ID0q@xpcBUyq4RJu2A648Ydgw_kDH1U4r
z=S?}zv2prc;27n?1LN4VpCe%22NAo|cY-03N*(iE0{`dy;w=+@V0k!@r>a{<(vxUK
zg=xzJ^6tc!cw)pKl@B&~@GaK=v3Bc3EFMG^6|b@_cw9nB+@E4d8AI{jINq(R0Q0zL
z5>w_dmD(#fsY!>!+$mk}?Y&~@C?dkiY|gLitAI0BWVMsclKxaz0~kiZ@h;{K^8&6w
ztu>C_T5H5biuTwJg&*c(x5GI$aH-rmwL>qKEWr_>b#)+%F-v(}Jsr#k=Rtih26Bx-
zy|2l?&`;~2)Cj+;I0}d&za-8#wAMXciU%i6DIcaf+iZ;1xoWc*{m~8;bw36$>+<ZX
zlFwwZ%$$L;dTU<*GHvyo)D+9fyPhNR-?XlXdKG^VK0f^w_e9!@e=Fx~u3aKnq=ymt
zCfx`3k!(D-9QQ>(1h3Wxn~K}X2L#TTALe{;?~!oEo~SWMN}BvpIbwd-_BHaYB%cY-
z(K!IOkjFsoN|sc#%lr-k*Y$1Go}K(r`CIx9EM4l4Gq(Fv?l63$xccImc}6Vjz0M?<
zEu?R7%9Gr!l4tr3NFdrX<@yeCjI}lhCYkeF#jeyJzK$s;;e6=_n2@E@V1Ajt_o{{>
zeGLss_E^eeO6NzrH(z2Fo${0`0A$C+oj3hpL?kHRv_fXZmvF+2%cUL0s<HkE-|)ED
zGSrUP?n%?iNt(2;d?vL+HqEtLc|~)6$>|cEtH_b&9NDD)@DqDn#RQV<V);kJyL?4=
zsDv69<!tcQmMT49#WPbjRi?D|3dDxajks5}hY}Ja8G!{rwy(+q5?#=N=l+J8D88gj
zjQA1_M0{B$LCqWHcG1eQJp`BdypNa8bjF`DXo^ONWpu7xPEr~dmzUoqN`3z>^QPJ&
zHAj|zh*PaA$S3|FY)<XaSw$;kr*L+jE7sGxTDFe5XMZT$hxBKvGI?F0W9r=s#GCzL
ziyU;R2zB!+ZW4VP;z0dX5X&3``8Q=dyMlQi)xz&uAIB+dnd7`vQVXOf0;2%T9zWIr
z282Bf>8F?uCer#Yr&Z}v<>Z^+fp#T*m#tgp1+*OL3^+h$JTSpXithwwofU(&eB~U~
zq#s}`m5&~Sr}X<O*F4uV){?1@W4sb?0aINP4#{xgp7s@yI_-L>-VkfwuI6LD3-vUY
z^ryIgU<lcLf531$2=*vFhl7CRDN4HbT9j7Ft9$g*vHnOWv27TIL-LeLvGaR*mw=0j
zGaK-r6$d)|16ZZnD>fmk{+_h=u-L?dOtAJX5Y*X}<G$o68oKF>Nm_G6;)&KDi4LME
zcGkhutRdxz)Owk6ttxTNck$4Zyfo>8%ocv=wo}$|WxCE9M1px85X3xXEGA#C1H$k`
z15nmFK(0+)pmJ)|4qaK_f$eqBk40+#C3!aTUve9jd^<!EOO{}|nd^W#Qf<DPk17AE
zRJLf(PNB6?rQhfG*3y`CA%aTskE5T~RpkNAIl^PDeU%&?o%2|xI%8uomw&5Ff^%QR
zVy=CfqndO9Tobab!&<U$pmj=)Gn3N>3R}uY${fj8RFz%lK8Sl?HESxWPr45ot)4eT
zr{)c#pyrK2R8!XBuJyd3*J<7`W=vj%du5N{q$WL#3<T+?gvm&MsS=W!OH64Rw~AQ|
z`NCzJrU6Ru<V!R{*&_(!k#7PIf%Z3!=aLa%CwY%sTzkbsG5W+AX3)Gb>6$l^B=j!f
zQi2sS8bi6XEO4S5)lPRxp`kmT0S!s}7G~S2BeCuk)5{u{FN<&$`|~&%2tUjlvh!of
zkgi-Iu3AF`cTbs3?vi;67trJnqTr>Mkbg9NXlz^d`%xBW%3^}_jbCkV8kb<9xrZ|4
z+Iw&<%I-*bgz1Mbf3A(n3!H0>6a>*3ZCv{*r_d?G;9lj<0aIR4rNbWd=h#7{fzHlE
z`pITQr48*Bn5v|gP*zCt1@&N_XHX-Qi&CnE<PfXg_~G84d|CNNliw<?V9GV}g(Qav
z|C0_vw3O$PSf(jU$lICrI;<*+6NCpz1mDX8!o!r8Kp?UGuyDC~=D^=mZtTgIR0fjH
zN)D0N21gC8Q^IaUKNwDHoYE6|mn2!u5khCspsG|Fze*C@(+W(yf0SB0aly@`^FCHl
zuOSk0gbShUk_Uuzh^8#(`MsDK=KNM_xc0ItD>>yP*A~d$$xUiH4}!9M33Ut=E|@ko
z24{BB3VluQ;u;f-bG-Y*X+7qMh#2WPT)8G5gnW`ORDV&t9;Xz^UBV+|<H5wO{R1zP
z))f{q_g4W8^E+Vkxpv9Nk-W!hF>L^qbtf72#F0~DxZW_w8K2eaItS62ZNdGaz|8MJ
zUTMxzH{6aWg8jS5Fx4+Ec{R^C7$=oaOjQUDKKuTvQiN$$-u&4P8{^!k>xx&wm?F{T
zAeJ4AzWEI)EBbL<6<tVO*LR?Z2^ZK>-+{|UJaZ5mPe~og*r!q&CS9B_j<#!mJR(Q7
zK0<)J?hj-l>eZB;l%v3sw8w>`GYeHP`^KmSFy%e(%7+1rsJq!8ew;B!v?IH3w&O@V
z<_Mf+y8)(}I=~cb3Jj%nj$xUIsenkb*{%YJ1XI2r?_$ZE?JzNp^+G$c&eV<tIAO>p
z%@M5ccGBhRc7u6t#6%&U!IYtT`oMH2Ffhfq0#khpV5;NKxZ-mb0l`-L?=6`#Z9J82
zFm)RGlT8(va(IEMt{*Vf<wQf$9bdqdLkUc^^MS!N`|kjzx>mqsL%}@6+w)!W2enQy
zBWcdj!?cE+kBCC88XqY9cpT@r=zqoqO<V1B-yQwQKghW9yU^}&#`XYHj4<!2z6CJt
zJ-}3_0~i^_184O1sV8D`Q@zN#Rcpp%l~+wNkvyA&{!}}QF?2pEQ=eoa#^JfoFs^(o
zz*L(Gm|~ML9YTdk1MFs^3&u3VC@Zml7hcu(7GKV|hsuncIyJahj-$oSy|%15+863h
zy(#~yoZI9DrcE*esWHzzm`b%L6L6yQATZ^x@~-ktE2~ZWAeG;ZAMQrY$1NwHJ)P+f
zu{~jku*sLCZ%zFk`YE;y*umO>%)*5n?J2{^6VX0{S$W2f6X>jZTELWh4eSUP*(a-%
zlw=)u(MevBX*pvSc~^Dmfa!dR)~Oo5z;J|3+E-By!BpD;GrI2e;I=?KfAd{zX`(%c
zSkWF^n)ni*(rib*%RJ98E<#b`D$cD;|MRQ?4CQRRTX(a~eWtE=nfPI$kgkF^e%d>+
zWGJr}7~Z=%E@oiiLaex8^}+L97Vo4zejMp=m3uSVA?xI;EV(x42oa(B^6cD-QO9+n
z{6Sy`w5khe=64W6pl@Sa9XQjUY;IMt)pJCUm+0(R9NyLU0#j}?Ft7VJoQX9@1Xc~4
zp)=Ji_TO7H)t*8W@;o<IR?M`G08{J{F!|Jh=^ioMR$NfG#|0QC3&C_B3+-_1svS;|
z3B&lW`K1t=<`<F<S~13>WHzO#bY6gE%nP-1O<c<GE!e^LVu03M;&X6+@(19~!y2wJ
zo{Tdw<&!RDrWSs#d0TEo^9%-^N&CwAnYf_oNj}4>bDiS8RLv<uu~qYyU>e1`ApKN3
z0i0D28JOx_*Gy_{uu8?hgtZ)eui}gGjFE{u=7Vx%Gk$}11T3qa{5V`jFW(7@-tDv#
z(x38YfZ;)!V_+Vie1xhuZPK`KRoj|zS<vc_fV~N0+t=EF_-a?d=XzH@7H}cpd$vRM
z(YF!e;QkJ1fIKxWmhDw8L;Z2a*1H_@Ca)4L;B{5mbMrg!H+l@+o5m?rF+gmL9M<;z
z!858c!%CBWPf<U`k--RxLuT9qUZ7~O=ELzhyvqT2j~`=DT1YVEy3x+Is=A{}JcEf_
zv@a*x9HX3B14dql_5gGc?K4ExPoEb~2vpwD-&>Bv`ZgRYbDg3x=&Vs84zpb?=lQ+2
zoUyh3a7C*fp#if$j$7K#p_KLt9OL@7(!(a5iv=g2qrPbW#j_)w8q@#OONhwAf-q=W
z`7@Kw<k?8Z62+)_s~i~jCqEP8;$hIZL|jZ5i$nd9Xy|tGZ<RFAyz!>z4V$3WDYib1
zLHWNi=kUJjs=?=Y?)TqO(M_I9>P60VRrdjncezAD@hZUN^TH7WBkjkf9X$%ByFM`7
zC?}40QB3r%YUA=QTFq>S>>RYB9gc(9uB_{V$^L?opX7qsj_x!r+ofQzhrXkFRDX&g
zs1PN82M+l`XV!sqnws-zr@@qgG|{-K6<ZpxbU2O+UiUa>#jDh^(6{*x1*)ST$RQjw
znm1Ak-5;U8<2%^8r{9n8D*^`8&U-v&AK6dIvym;W%>46vsraLHPuQ2%K^+mtycG>3
z4`40PkBU>$+sXNnjt=i@O;+iwIp=s+=XnrIxb5SZ$h2SLBAvcA0>yo9<kTn~xGv$I
z^NU4aX9FTrq+?d-wBB{D47lhHJYYoe&2`{=%?ZQ9BBplYOZZK)sd#JZ*=$;>SHKv$
zs|Ogfu5s<lBEM()NGp;=`wT8{$&Cun5e-;Ea}OYu(Q^(+YlzdccmY`~eyeIU^V^6$
zcRR&1;9=H%<-imNkF&x$I#qULQ>}1T@gQ5CXu$3*oGZ|Beh2Y6q5)f!V1&5N{>ofD
zVW{_#&s-@lotktj%Qa-S<`*-~q%+}C(#LTHiY`^OYtn`M6xoXzL9{A&-lQ|UAbkT|
zX6$cOZxT(b*wElhRC(21Eq<G4cFgFuui?4V8G<D)n<@o!%`>F@c-~a&0PDDY`Q$EX
zUoCUk?2m$drZdjox&Cl3NCzgDN9(0jq`5XYnrc7dWG@<EZP%WR%hml=VTi#WgyBh!
zQxHIQF5DV34ju=FVp4(GHb?G_&J|cy<ln-aD0#)&Fr87armU+{7E|9K5mL4Xa&)Fm
zpLMFUX|2i0`;=AlnymaD%^M3<xR8h@emn3z;SG>3fQ3=(xl91!eZqIAT)W55t~FWK
z`ne7`N(yIoF3}l3yLf?%AM`FIj`Y3Ml+e3`^a?-XO8xG^+9j0J?`rKbztY2ME~l=7
zCZPKl2*0=8o3vEvgmAg^7XrkjH?h50?jq}k?1ak7X$7WwD8N*QuVzTRk10rc6Wg!W
zP&w}B8p4q+9~HEc+%4zvTrXH;wAbRO)0qwpc;*x1j3Oz0tW(TklBcLSQ(iIWx^KJY
zciJbpVa|F9)<2yW%HTfN8pd4H8MCtHlA0W%3x>iei=mWkDD0N9-H>}D9j;W{$%7pD
zr=5XCfWVqGrKp5(CNxwybESaZ<p830>*CEh21)5t=AaZ#oq^12<vSDjp?qiNSNE<n
zm%1Meiz-!qCoWa}PB8oJ%PcVEP+ftnc|-2%dtpM+suuJd7r853kh`KOTrFIXyHlR>
zy<P{%UA;?at>3l$tGpe*tDF#m5A3%pbMg2#BIytkdm7XnO})LM7`1PaqazzATk@3S
z;G#MNz<7H<E->8>0V+f!jdpBhI<ps<=Q?1iX&qFFfJx{2+_?^_uIZo^#!1_*iFWiD
z*ckn;d5h?A>GySYh`yHqiAgJRd9=sZHKSu~RAq;$1J_(m{e?ts)xE@$W;<8q{1}%f
zt>+4B(R?`Pk*l_Bw}lm?gOurT@^4);AY70{qP=q-AIR{OY=;6`&)f&3_!mwAlV>W$
z&iHYCfbb)4aqt`ON}puj6n9f|H1j11w8z*y`GeczM0@18#>M3zUf{SY`Vm*JF_<Ea
zLA<=%9jq&qDe)VMiN-Cj=KQv@Pzpw6V!<5GK<1%zfk(n~L>Df?(puv)gbRsOe)nKa
za+jL$qlEn!gE?1DX3g(>x3o2n>s$a7+k^Fo+B9SY?X3G?rO{b~TqD_~&`P8y;%SqP
z3C{92qBTip<-{Z%gin*+S*cZX?LJju_OTAi1V7hWl@6RV;LCItq7uX8U*<?LXf+>G
zU!ww@a$kui^tyk-o-@}~m5v!}gLifJH!$U)Rm7rf;p8)EKPs1l#wDI%uIIWVXs%r<
z!D+uF#9Dd@G?0AZgd^T(Ny?VS2~0AKBc0B9s2kD=DW@RWL`B}I(;zfdn-7?3=L6II
zjVPxi1@G4y8@K94VVJ{czHdi=ieUz3nGIV?){*xlJr>Q(^MT5xaWS^c{Rj(>^jKDl
z>{6BEq_t6zrSscx(Q6D8cdch!JA-~mXXTfX8m@c4DqVc;gTQpx2Qb|!56tm!M1oEE
z!u%3txc|1A%c+-;=nK;Oc8sB#o~T@C+Or*uDZ046=%#v$R_M>-OZ4Y4M^I0>LBL3Q
z+~WcaL!n?;Uj^gfBbegIP}_0x&34!=^e$n(V+~bW{-h}|?MJ`}9GPQaw;1Cxmx%3s
zJLXOLWQ82hwaZaMyakMkx%>WriMJS6dv}d7b#FqaQ4rLhbg4S_OnV7s2(+i*@Y3B~
zv{SA=FvTGQQ(PJ_-8}_N_H2$|@<#z<;^w!pH;(zBootMCq?<fgw=GVY2u!wm-sSW%
z$3?bl-Q(*R`yj_g)k$Cs)y4p(oHO24?rR-G=h=Y8CmBXN-M0fwGK_a|+|O^LvVp#h
z*b31e1DoEhsKwbI5<&Fi1nmA4tHJuy{sv5WpTLw0&rzJOo4BAPO@1Q^YMy&|7Z04?
zRo)%#R7Vq-aut9nF9sOLwJ`?jspg|{3XL-ghu$TiX2M8vn*33&PmfFGh5ft89Od31
zU(k&A?MS7d=^lmyNI8X=H{{pA3}TsscY68==udZt0FzD)Oy?fPu&kpDmFePp;_9mD
zxvv5{zz?}5+T+g~G_4cj)X{;d{uQtT{E%y+Gr^6M2RT<vUo^B=ZauIA{G69iQB~SQ
zaXV|DDHqG+eWb=*SM-Oaf36qX6tHY6W`Z&{iUS3v7#3h;3ePbRFTxMqR_(CS3O_Pz
z)y}#t+NAOkfhk@9bDi!5sOtAq2L`5CV&0{A@BB8TyI`0iwf=DD>DyeJ6xz#X$+)T`
zS6;t)_5+4GwZ{(uLD924tmMXAr(}3yCEK^7KjpY@Ws2r^5Rss{L}1N*3vajb!D`%T
zdms=@_PWXlmL7|mIBgG@UcIL<$UJirNupdbV5+l2e_mIW=09Z)5Xl^_l-GJj)Xj5V
znTw~-3tW^p28@V?F-PQT&GR5;W$&Tnh)ugF{ZXJx{aJq|l|pg|m*G5%R~ag;p)z@l
z^#>Ozt`wNo1~3k`6TeE}nlQG7spsHs)HwiCi{}lysK&rW<^B|hf^v#xEL?Q&E9+i5
zI%^!&Y5y)u1Ep{eV+{Gr%A`N-Yn0-`;XU8Q_@M8o$_BF?@>Jv6#>fF%-vJCoV)lno
zP%xIW)&Y?%qCHW8f}ydgzd8ZWadDUl<~Xu)e@r_tF!|$wSzoJEbI}iwXpjD^b{GIB
z4TuEuI^}3J+hJvx{!8Xu`3Arg&st^LrvC$&>Z_EyN9PJWPujanl*~Dznz?if+>+CV
z2QMhsqt^XA=b?;a%oy{Fr*iHo;H*0jup%ku37GOu>gHDM=VUQ!PpK07b8jTOZ1Qhq
zH_8rzyG(W(#ItlbI7{mV&0BgW$9?SqoUo<;5t^)Z#obe0e~7iYpOc2>{xFYgK1km(
zOm)04TF561Om)C3YH7w^0#jZGFy-R0t|Sv{4b8P%Gd^u@NCOH(%(YfUs|8bBAMfgp
zmMVehwL#{mc%~{o%rQ7(YpqpOpxPbK1?^kyur$mwCsD6+4Cp6&JG4@c4hId}THfMo
zo3vtS$o9a=W%7Ahxg<MFr4bF#MfDvxfu@Y*RN?O>#8B;A|DbLZF#n=w&vDEBq3^}$
zrgmJ<Irk$%kEA1^VTuOircHke*?!9L#9%~m`mr|3fFS%_*RM)u&R8a36wICdp#;x$
zMP8fEWtjRTJIPJ+yM$oO{SCI%zFICNeVg-jSuM(Usn7uFNSu16pM-aHXCm*iaZMWF
z2NO+657nIWAyby{wbE%S^}+ArOqk;`m6{LdG@#`uMh=)_&w&wTJ;xwGaq<V`^LG%u
zuXib)KlgwNO`fujROIPD!Z@V7HmateQ3^lB7jsx;LsvT#K*4afO&FFWziXX~5RrLK
z20z800;6z`#*p8Xc0SYL=G57l6V8l9#0#c7+;C#c-$(+MZO!CwO}|x@vekK-%CnMn
zn4mPjge;0but-Zc!(FR6!UP~$T=`&g4YB*`T){E#;9XoQgZ5~mI&)I7!QaN=%I_-X
znB;EjlUNQ9-j$EODx=BPOx~Ek&2>n5*ESw<oMcDBYc*>`VOdga05H`Y0H&G)WtGx-
zp>nV$Z&49z`hTk&vfm}KP4A-DO<97;(%(j+jo-Chiaa#w2UP0xyLD;FTrY$=PkDg#
z)Za#Mvfia0%2-2{wLQPB^ropJu}W1J5i6l>6nIj#Cqq7eFX5PTk7Dcb_Y#mK+9Of*
zZCr2fb{IS-{TxF|DR1S?QcP9#OK4}E3#*0J0a2jxZIjO=8gL@kzDmT2d<iTo@eJFW
z^iHDwb?zo_Y}!=GIJ3`?R1}?$IQmKVA-_ztuY9nvt}0SZ=L)nJe=p(VQwPD^u00uR
z;=#N2k(MiUt}9Mp{x-<samfH4>!mLJn`?+%D8EbUgWh$W7%n1FjUHf%@d8Gm`NV~A
zQPJ7)LvW1l>Z!0z=^Nxn`P*248W*OXIs@2=e-UARmkH6kxZgz6gR^OsdDpv~SEnvY
zciNL#r3dfo-cq95F+xo`6Jnz^#7W-c>TX#ICE5;5q4$G#Rf~&vZEIoH{A~n?Y3-77
zHrF2oMrYn90loGG)|TRTRkM|MZA;_iEV+x>R{9#ISLr@@t^96XG%)6)^0MZ>S_LiV
z8e+M~he39?<X>%#bAItQ`d!kZ=lZLHWE$6ZTCg_~Ei}Kw_gB;rcCORfYv=l_s`k=L
zs+iBj1y+!4osdA;=5RquCnOa`GM2=A(}kiTQwOeeY|R^o2)EOnm<0dfft$3VScLjR
zu+8r!hsf&%v#r((F1g9Sc;rk2>bHv**a(Fm^2K8)Mi^^5MNQ_n5yz<Y2XhHOh(Gz9
zW0Y(%b&rndQjt{}*M8Fqfz-F*#nrbVokSOs5azd`dC%An!r+xJ4h)0S#E)QDjY~kV
zzRh<8(H~0i=#Kyi*}e#((zr#c`E6SO;Or0A#Kfh7sOJ7bfQfOz=QZb-)2etC4b$)9
z827uTb2<Izy28Oa>nK%qLd7zbad^_6-VWa7V!=rl$menG<6{ez&jv??&I@H&5uJ&3
z_PC0pg%e1&ocJMS^=)O)Q9Iis>QFrAmm`E^6D~CQ1JLTU2h@R8-+?Q2@&XF9_=rP^
z_yfgGHcKL&JV$KPq6=H&{5HN~?nihLb<Z9!`=T)!Ne3?Bu5Tk+Qu9HWo95iLXDhSC
z@0OQk&ShaOm~}#OR-^+HCMcZ{H?eds%=ZWHDu=Qv)kz2DxGJ5H=tSxFh)Mb1Dy?#^
zU7|7$-bM2qG^m`FDN8EfWv)rw6;lTxdC)o`CPC>3ko4ePpG_;wQsYuWT;ImEeRJ*N
z0h)U}T&|pz(wnADkZ=&)Hv#z+<G=+nXr7aP90TUMsyle*`ooQ*vv}R<<NkCv<s+tC
z+3M?F9?^iB>FV#`%t;Q1`#aFNi01b?;B)nD2Rb1h7VWE8m1R#P!b?2!go#$)fvJAV
zCboFlg0QMct`S<MJ(+3`(wmBXMN^c*DVwkiD>em>m%sNQZiL7q?a5dy{cc4#&9#Qe
z7VQy}q6=|&ewQq}eSe!6()Z%((7TmLwSSkOKE?C`qtx-f9b+hG8JObS5NkMh^ezc6
zf+^pWcNKTY7_iNJmoTj%UwBvXj!1jObkI)sq5xC9wAv}Az5$G2mx&8CNQPXaooctS
z1+XK{cL}`lySm?scUA8Jm||>do0&QTFx|n(mZ$iVN(J@1oF&H^qMhpX0izo0{5I-L
z_+8cCMQBKlgCCyf*&p&=Yp4ppshx5`8AEcCF_be8w^4v&_J<tOxD-;-`a}MSXB;EP
z7|I6&MiIn0E^5S(5wuebJ+QljcU2RgcFNlZVZ8YoSMk(Lq;eh$GHu~7)&VZAmBYIz
z-*a3x$Fcv?PQEr^XlHs?F$t(XTr@S>p$>_EUn8*Gj><TCS3cMBkWPIP8jxWz-(}#r
zuBb3G_fYg4)h9%f;3(erN7NS<u|14&Z>P=$48xDwDHe=zWgn_Bru`lPp|~K%P#r^H
z<^|N#xu3JqvQtm|7-g<|PGxhCXVcQY4~&#a^{2d4+EKJ?wsXE3_$eoyce&wD?;flJ
zV&vv}#{72x)4ipPtDH<=1TV~SE8<Kr`G2W&rJNODis1u>Q&|0BRuD`zS9n)vPL3Li
zQL2>rX>;S)bFg-u6UVz41t%^zlr@+5I)t-px6vO?&DkGLD$yAqv(_Xr+is^=Vl4mi
zTT$>^=cp<hV0p!LZ9`7NtGXKoj!`aSg{{x?5#!<*pWj>6o&{6w4&Ied1Q;Sv?_z}#
zO!wYE7sc2BgIe=lj&FwP>{6CU?Z1_?qVMHAsPDxCA{eR2`nICN#E+fTFx52xKO!#l
z?tzTJ-93344}so2$p7GYu6W=&vQJwTFx}?`jAWyMAL_1nze1DMj*VulQ%X<hOw1Un
zhetc*U|~K`+!yUInos<E#}e%b;F#^W$Z7I#l`s{Zad*2N#oE=M^+fV^rhTnWh|*6v
zrT9A>15`AaHUMA;-%*#j?C~R0TDHED2b1^9yEW~*jG=o5Dq}!rFmiq*V=?=9o#H;y
zd=T`h^@7Sjz5`rjTL%}_`U9reJYcH7QQsjMagZBCJK1+JOUXwMOg3&{vNcyJm1zT@
zoqS5blyeJA_G}iZY!AS64_isFX`cj!L1({S3O0SXz*LV6nBxC{VX0Ps%0+o1QgZrY
zfE|2C-L5$Mvrmq9559w1AX8=&!l!dBYT~rv(Vy&{%$w>)0rMDjU(wuW$k8!f5bcsL
zq+W}Dwk;8qdoaJ8?&r8fF;0InQRb>^N`IPP<c9nU$Oyg5vL^y?%n_~3TZB_<J}~yp
zcgcnjtjbYL-HZr6%M$XGrhKV<Ccmq=n~J`lz64xA91`cZ5zjDj=2op~W8_`ccLb)G
zKw!$p28If#apec2oo!W^f+WZ5O3}G*v85cqte0>~k?jkQtK>7VY4atSQ@)cjqtDna
zV2Z&2rd%0diU9&<{w1<v#(vO_Qjn9TgaL?WFt1G>tZS;>&SwpddDE_pXIpisfcdP!
zsaCRy?N>SjBrwjHBZM>I8(R0a>EnIVojJhppif%CmRgg(lcp-OOdc#5G38oqZ_*Ph
zy-agNkmi&d<Zl_q9yRp{EU(iqNtrR-F9gi{DqJbu8&{ER;dNc5aaQa;Zl;61f&d-K
zk_sxCv?t&~G~m3Yc2qWXJKL%_)%xAa+|js5K*1F6O^~nr&cIaD1Q-QnW`AgQbC1WO
zsy!4fTXr8<-}AwdSiFjzP~V0FNqYt7#@UV;lD<Z%4cP_C?WcDSWHF~Q=``5aw0D!2
zCA!pwCv!f4X}uuA<~o2c#c#!fQx>B-nvXW4;Fz~c(3|ulO-W}&ykO!%Le(@MbqAUI
zQ%*lFQq>D0Gn_1<i67So%(X^JtK>N1+4GB1J$V`n+4SXOr3UFaZY8=-7*jddWVwGQ
z|6=WwuENn}#(8jXR{dgNik${OjxQ4za>ORTVg8#j1oTH?SiP&5ZQ31t2WpP!f-hS0
zix?7qn6KQ9%!!H1-NAR%1w(459JZ<^GviBu;qaO7vJAx21icGC0`=Wa_tcR2pmR5d
zKGkKS{G@HUgaJsWK?9k4Equ=Qz5kBl=_w~U=GkvmQz;stmS`?H+8d_WD857al3Qs_
z(TX5B(G)h<+CVKaOf?58EJL~qSwIIc4j_A4@h%&eV7mXK%7IE(sVi~^?P+H_b=}D&
z`e9ZP4TvAo_qy%^AsxEkc?<KH-v(=m24n}wW?nAgiC>jcnQH^~mAt29we|(Vl@Iz;
zp4=06sVO#q{5;8aqB|vvS-CoM*0m4D+5R#-Hac?>3FdF(%rs?omE)dsgi7u2z%b=@
z90kT&BRW=lJYIY4TX;=pK3I8DwI7vPYOKlHLZ=RbJkZ+3oa6nx?sXFlI9pAg#wu?Z
zD&}0{2YG=U=y2Fhy14Eo?I<Rtc8cSnG_LOO0H)Y|`a4)d2;(UaIN8hhL<p7F2I{G3
zb>L^hl_lQC<8K&clte%077&u98pKGUd-=Br-I5%_#5iNh=}&c@%1R?&Ox^XSdGmem
zylcBHB#{5I$`_CMW$ns`!8%or6AbM=0DX7hj67uFk1@axquX3p1Z_)}RP|J~Q!F-#
z`ql;NJ~^!o+`p2$#N=ySmZ@NbMoHeI9tc0YPx@XkbUPAp=eLnV<aVk}MVO%ck{sBv
zUXT7LVJciIUvjP?OxLon5yqn!0!#&3<9PR{jzmRIpFb+sa?Uw=lk5zb*5}!Z{v0Dm
zKBx4xDzh`^h!Akm8F%u``5|(K)77M(>%-B`e!9xZ)VE=1ookIs8`^uIsK1x9&|C+2
zc66>FL|yjNx(Y(yfw4eq1OJiQu`i6htinnqbI9F1cvtyMyvw0!(iAnv<0>zokW|%!
zqCdj@W`76go)S53C);|3z0P<aVAdzO&O!PM8648larbE7LbS^-&M8!Uj+~TyChbZ3
z<UI{Fm$>6aQ$j=pL*9!nxZe!Z9T_O{2fRuMxYjAEieQ{Ij5EpHb1v}#&Hb0XM|vW9
zljJy2`j#)qcJUyxUEhmrcRR-p;*vA3qGI}8)jcO<TldMaSY$_{9UnaCg4Im2gj6@_
z<3#u?wt{1=<YeWRdJN388rMEFI7YT>%E?IgrqtEciwWjZ{R3c*S4OwcdakmAQ#PR@
z>HJo1PPHR|WAXygu{z@%+>1waw(=K%sdiCCaT`C1#)+mlFohpEU2f+ySlw->d2>A@
zinKWf5(}vI4<dSXh9DAAwmD|V^uwk#^{cvkUUcTruJ85zOq{yy7sAycyVSw`biB(>
zIM*&`2#w3#9By~8{!lp7j)D~Gj}6Z4wEijrW5xm0s+w}6qE&SM;I2IBC0xznwTs}G
za){NU_%Ot?ac2LRdK0E=?TuA_Xv$}zC}ht;YRE27cj}3L>>q-0{?Hh(mSK*KqKdG;
z7oC6V@(1_vRVs>NChC$U(FHGyaOOB;nBt2W!|^IqoiWacm&se?(&|itH%h!(WS%&4
zj8YsoWdeosb~(b}BO>@@Z>liCIUkrjjPrr-gsC*nuCG$p#TaMmRq5LZoSU@ADy2P&
z9A4v0pqsvfKpxQ^+mc}zK_{*7$IrFKaz5x!we&dou?funI2*XX1N=A=yPf%x)9<uP
z)rnK<88*^hQR!BqGy8((gMGp69BV}uxcjRhxk&>I#_Eq@)vk<|^Id8fxZMGM7%trI
z06z}dZg+qm2R*gpydeBI_PE^vez?!w?f^d&MYlV^52Z%!P|k!Oo2}a&;0JnccYq&)
z$n6gB!-cDMb$i2{UrJB7-2r~6K5ln_AID3#JHU?!Hnk&WO!yu6&&fFRdS+*Ef7WS8
z(33xf1VZUFgsMqSR^r{%RkmcUK~ucC(hoQ?>3b^_Tm4mHjQX>!h42IIwIqA!jChcv
zO$H?%fjI^N-x`<wL+uDeo^p~vY3Z1poVAx#K=9PPSq9QoDzJ3wVR%TjM-kj8n-SqO
zrV9afQ>W(0DO)L4IManx__?Rxy_CL2G>!H_mZ|I;bp_8{<D8szo-U`g=7aEieFsH7
zH6QpPG;h==)OQf$rTL&t!rad}vdad5BSJh_&Yfu&U{#rqa2Dx1C~Bwg;0UYlC?n%s
zyBJXQ9lk#bV+oOIdRH~SX~!lt+Yv)0x={YW?TB90yQ+<g@!7GQ96EJgAX3Qdr4A)?
z43tr=7yRs^GbSF<nUE9F854@=Oi>fj8Jm&5_rPX^i1m8GW~A?c3H2TL1N0sE1N0p*
zjlQFj+$XKdLbQWbFp_=3xCq92sdm$MQZSM;)E|aS!AJ%WY@V&EzZsJXOy_`VH|r}`
zyLrAW*o*-x*o;Xi*tGc;Y}N!U*gQ`IV~G8HRJ&PowA#&>?Sjqxo`Rw5O<IxYu;<@u
zH{;d|Ht&l8rn_9K-K@o5?Pi_Ig3a9Zg5edJ_z@txUsv39LfXXsJHQS(xnCQ=bQfoh
zF>U4rBlvQTTS0ddR>egojNq;Pxb(+<wC9<E;Th7q1pf*)?=-7-4`@#ihWMk3-Ov88
zRjD0rA-9`%^)Rmd-36QX$`owIwE)A}=5Y`3D`(NfncNoPhhxL-4%RNYC~kLv9|a2C
z?f^gXA=HlP5Pq0O-0lEBj6804fFFg%-0lEBihHRYDxB~me8cSy@FQo%?GEt6F6DLy
z_|*l^bAGW)2|wMp$Qr`6?RE$FVdb9fux=PXGz7OZenj;h^k@3vUO4E__)*ft{ZS-f
z(gkVn{;)x*o$mdruRXwzV~@TU;pzSk@FQQ+?GEr`?@>DvAvG?0kJ}yK$KK<12l%n~
zxZMGM>^*A7-Xr|jLf!5FKjNU=?f^gb54StOkNrdK*gu3H`-j^d;8zy|41Qx7xW9w_
zgDecMmxKL-qwYa}2lyTAAGpwr-@*P-wafJ#@?*2^*+2HWK*0|1WB-`@Z`B;o80;T&
zKc{Tt@G~(6`^VG|h!h&OjA}RQpcQQ9JQi%`YZQ!P_j4|}hC|<h14Q4USikCT*3$<@
zd0>4<-P||FMJ<`S8UCZ;XRrP^yy#s#e-kFVRJ}Xn{(*7e*L+|InR-**L#gk;uc7bY
zNUZNbWu1CmU9LU9gNT^nXRo3zv))(1W^Pr%X06zQ&G?*x%{cCY&3I~Hs;^wI>F+Ms
z^t%*n*0Lzr^br(n#@`nVqu`iJP8!1oMLTM<s2y>%qO<POt#@a=jDpSD1O=P-g8?I)
zM)O7@?p%N5){Bp-IP>JADl$0NAJ&}VPp)xio?*eJtrQrsOmqDabz`~^y07mb6inZ7
zOP1Z757pwTap(O#1;bH1-z5lK-+MdnrR81ay%&tIO7-V6dtGnuc0RM0$x`hI*c1J@
z*G=mRyOik1@ly1|E+zU=pkM2NfFIFCK5%G2(23SPK{omh<yqIeKC{2!T%qsaZZ>@f
z=L&rXPIY~U{1r8>&+O#5n=a&QXuT+Ro&In^x*b;Oxi(0-P`j!qGuz=f5dBD-&^o|)
zt#v>tB+;)T%{9h>+(pz)`jMrn{fNj=(S;m*?MH|v?MGyAXg?y%Qu`6<0osoU*%|v$
z*+wWfwEMQr4l;eXb<OC=1tky`m1fckH}Qzgt9H}xT(B7*Td-M^w_pd~#;|j3kmGJz
zq1FjMHsHC22yYU95WyneXA2m%SMWpV%r!*TljIP2@53(2yL2dAAgW<^!$w>0&N^)c
zoA=@sZ06VjBazfN&)kt}H|wnzY}%;{Mg;V34He9GRziA*&Ai%K<`6+3n{TDDOdg~H
zvGj<_Q`ff<Vm;*nQE9TdkuNT}ftzXAy}_9PZS}{U%Ax_O8E!Y@kgLA~{0RPae+T$c
zB3|tXDAc$FRl3~)ez>yS?f^e>Gu-X~Khzwxldl6B5b)!62l#Pkr`sLiM@XgH9pJ}p
z0cr;;h<@czo@*Qt>vjkDv8TA*0e*xixt;MN*IfNk!A1Cyp{@Q1ozeG_Lw?Yo@gpkt
zpuYqBIBU%BAmhyVab$A41N_(*-0lEB_64^)!0-Pp>~31UPmc4B@8?y_#%o!cnfn2R
zK%UV+Rsm-jvM@%*Cb0#w0wJ$HpSpMF`Zfgqi*t(ZUq4sZ!&TM9rj&c!3zy!u<sSXJ
zghsPBWU=mey<6XMkN$DdryK!c_aFA$?{O`*+@pV(XUp|o6@T9EVY@4HL9*w5yQh~|
z<`OR+zaNib<OtVC?f_wYgT1^>weg{7f;?9~_>rEH@tT5+Lttg*o?el0fUfR61HBd<
z0t_H>1Z^R*vZ#dU5Y(;c5a4FHYsHI4hY(sH9l|sZ9>iRU&B!?D6)QK9kRl`TMn#AC
zk!fjVU@!EI|6IGAZJB5K$46OIIr>NYw>jRf+~(Ii8o_SQr4;+=A5}8@Kpx2K7pAoA
zgUe#NZ2&lB{(w_54j`M1_acV!y?u+$*oZ?J2SCG)L-=a;z37j~^1_s|@4*;jD-}VR
zeeY<+Rtm0?eQy-8l`<=5--FP{R!T$6zK86dcqYmRlftft-o?g)MP%Pg*B2X)`0ng`
zp<2;RMHXb=v(`m7C3QyTC$dI2g)WYK%CZ#QRL#ipSlH-v=EYsH`-({>x+(L0Wb{i1
zm3<{?(w+}#HKLoIh@SO0!DRM0R-AKA>zVvv#({}t98`@x=VG*T&XvkJ7xSHS?&irk
z7t1}drTTIcz2g8W%Df1POF2QUEeG7Q--E$TIjVTeRi6<~()~hT$a;WBEFU^kTFWgS
z-5dx5U%n<BvFGR>XWOw|;7(|ZC%iWH9V|3htIP|m)$->Hqt7^8c^~JG9R$z**cWCg
z?C;~e9MYvW)r;FsUo7Rvy4Po~Htl%tCB>y(w(+GgsebIA@3~X<4iG^;Sg<Si;Msf~
zIn(ZxwjoMq`f?#eTh4aQ9Y7_{_n`V7-xI-_HhQOk7(TxD=$}Ug@;!G-#$hR2?$JL_
z7Ps7^e>PFeJ^IH{l5&X)^tSzF)ZcmG#K<_1TJF(5xvpC7(LYAFluOQF{X0X__Rn!k
z|1L>h%02o=gloA+|B}OAUns?Cmr|1N{rKn~F}CF%{S&v{a*zJ0nsO(I?Hn*Gx7?$D
z^4hoDqkrN8Tkg?6uI-ddT%b8MsV(>DpIGjed-TuM-Exoq2`WsvyosrQ+{7*S=$|H9
z?$JMK4O;HeKfzxqC$KH+%O}!ukN$DRwA`bAo?~gbNB;yDq@2Ks^bhF0<sSWWf3)1A
ze~<g)AP(E^E#-bs40-x@ao{c2{t;Ck-)sM9$&c?n`se;wnTDIL{iBoYeJ-v%_w>Cx
zy!W&%9vw#tgXlO!spvS=^T=ipJJE6O*`SPrPLlP|<%|O)A#+bB$vF7gSB|)}-7614
z%tkgNDM!v>J{Z{y8ZP;Fk5)gn%zV*tz-gl6fcQtp!Ahdze5R9R9CVVE*DhXs<u%dR
zk>#a!jgG@L8y)A;>t#JIvD(}pXM)dqP#m)!-h0nD*sn4UVr<4i(EcbZoBK;Vvwh(f
z&%R>6$~dHm$~bJlj6-aA#*tj|*B8Lo?Tf>ZabOY|hegUbY~GB+5zIIQ>t`HPtBm9G
z=9bfE;p|xt`b@^bWtef$XEF{D^^61jAmg}4N_VavnD<L-m2qI5Sr2&Ij6>{5#sP1e
zae!cC9LdRRu0;0kI9Pmh&Uv<T&bgFw&h6%$b5kFmwHWf8bC%r9ix~3QR1ZqG^J14~
zUM_}w=jF_uJ1=6$W8;xgr}M(yz3WTW?Yw{!?)uu2ofmegjKc#PyS~C)!~f{c;eR6W
z!vDN09sYOWQ5grb_ntR9Bm7S!RQTUP7BdbyNyhQ;VVqex>+$emh;R!3le#VZ?^6C`
z91kCcqaXe!eO+w1OxNLmUZn{CyHuwc$HRxgZ94q#Y$J=Y`DO<hdl(u&XZDr*V|kNj
zOT#-^Mka1nULZ#>XW#viwfyuLoBJbuk?<>P{%J8W+NIAduVbc(ujoSTvX=bkty_7Q
zE1}<e=rbagAK$CI%Z;783~Qe_Tw}x7(r25kG{}~@D=yR{{OVrePPzJVplIV8<6?>5
z@4^wYMoi(Q?VBLRCQdzb@BUa`^6i1x?K3Fx*1h=i(&}4m{5eb?&*aXj-4guTJvzDP
z^3pc$c%Aat`e+N`VfWZz>(<6-IkLwO_K>*(9L^kwQx6SzwKU4c%=0Z}%Wa&s`D1Bq
zxqZh(IUu>^FXGR0=dld8FF-)McZn~#k4Wv2xp?x!PfwlBTGC0f9@L7`fTDM<IE6C@
zeCnlbUIX(YA8qFTk|d`MiQ1NS$#z2{41`Ab4vohwG{)x8WF=Y}ylwjIUMOwj-i=oR
z%8bJ^N$E4z9vbx{eWucdCOKOAOyMtWb0F#;<uv0+T=|uA`Ru$%UerF@sVUdE-mg;k
zW*qo<`s@xUZQnxFzb~6h01YEb-AnSZ{c}Ll7e4TuU-qVqP1f)5Cg~KWoFKsZh3>ub
zmfQD=1b4$#wOp``$^p@T92?rc$$H<DiEqoXEsgx5T<$^ECg`KojXz$w==Nu++P#4$
z?P$Ii-TpM3$%kSb0!lIt0SvRg%57e&s|)?H?Iy>dazxga<ILK+jRRNr$L05TtFEkq
z#tE74@s2GGm~Qs7y8HH?KHtl#sT)7La$dnpImY_XHW$~m5q~#_o@4^4yKfz-o3|T|
z7Tp<5u-kr*>XQCpoh|oyZ3+zY;W=oGx!VT&P}Uc|spS$&=6k^spF?2fH3o!z7s?#4
z@njr~w8Mv#+x#0>_s5N8M0>2;=f}D+47A<Hx=}h)jtG)@u_asXv2KzzwcKOfBoRtE
zf^6D7;bPZP6D_yzftx>S%9g_byB@@nmfJk}_j0;Kt{?hx`f75}xwvhFkL92-JEsoZ
z%4XWI**?_0c7r*&!7UyWE%sfN_bt;S1rvkj<)Cf1^1X7A!_b1+L5qDH4G?eJfRFt+
zr;4#HwOsTg<s=cx_k!(FuKbjQK5L|1NA=^nU0)J^q@3m4c55F}Zr{4RHWIgk795`C
zz{%4FL1$@L#GVf!FsobL@;>Tr-f8{wv`OX^d?WJ$1Q{9=<KFvRPisT5T@r(JTWI5*
z(e|BI{rhR(u0C4tZZX<xAF{ZysiMVifEJq|TI}9v!R4ZD?l%2ns>)n3TV$>{4NFTL
zu49zAe6-DzuU)CGvR@dgL!%yL&BZ>Xoaf$KF7awOPVlD}5&Zbxr^ok#JvwVd&m{v#
z=88)x^NjJf+~(mkR}z=CTw)`Y1N5CU$Q_#giO0_O!2Z)etnTr>_795t@xAs>7<0dO
zoO1ij_MdUc-BH@UCFEmNu;oqI_~Uy7m~9sxDYV}vw*GoDcdd5ek#<ia<xY`tZ|yYd
zdNL+`2|m$dHjg==FJxW>iR~S5>2fnRs!M5`kJi}ugj+88pp@G;8LlpHz>W=^Ki?y6
zwA{V{f8XmJFMfJ+UMNRV-gbd{Ggnwx%Q2*<E<}H5`);m&7+Ur-nLpoa>;uHa;|yYx
z{T?Q}ePIeuIbf2O<Bi$6y1cv-qI`W0#FEF}Jy1fv$6Fa%b>e#hx#i+ZAR_I%Jm&eF
zf!hX0NzNcgQ_DT}6*KGVrf!+sdFQ6fez^pm+ZQ@S_6u`y#w(O3>+z8JiF)f}xya%0
z5+`u|)5?+Jrhj%-bfI%gZvUVZVgnFU9bPA<dTo|O*6J0squ2nrG$Rj*i;fN}E;>Bh
z>sFcPgWW8Dxm2vX9@24#Z@BStezD#5k11o<jpcRy#3zog9TSb9v+F?z%lDEimN+hL
zXv@`xch3v8Ty1#Nfb|DxqxWUs<vtbSv9Fji_I%ts-`Q6JpRyi83-<iF%GQ4_t0ZY<
z=MOIE<M&Sg-FO#4pBCw3-AgWz91z+_j-$(F8T+ZY=;(voDLsRZe$L=MYPRE$&gf(R
zP6dnI8|`ssh(nosX7tQ`{k6Uq{2z5N@e63d|Diq34E62fdKky&&1HME+Kg=7@*JR(
zjEzZQc{bEY_%pZF<9n5JNS%-GJ^IH9o_0Af(?54b%T-R~X<J_)5Q-@L-5b(q?p@~f
z#++Z8{pN-6z2Hlz@$nC$#W!~9e(pCezVIQLPqLrIN{8=CF`aWH+i+~$P^IfvyXd!m
z569ZMmy!JOz1lHBAj8{v-gAyHllFyRylW)-ZGAvI7!v-^S~@YgFTrU#e=tSMBkmpT
zJzGTY*pQ{@jyxn%I`=9!?E2)GWGcgf?8I+?wYRPgrq6r?rNsxyJfzn<SDwHtExvpk
zw|tV9IQ+mB)$h4evWGwe(ylGua>32rONh~D?n&0vy+;IhyyDtQtL>1s(7ER_%w7}k
zoVkbh3C)qoc!`~*CEm)Z42}$K-$`P^6B?PZ5miFV`=RRQy@{idrgr}13ok7(cIqZK
z6`IM~@8Rw3U+o*T?)V{CBNmg&LQy{sF(>|`i*3$+Ve(xWNk~on5Et9ra<%D;ZH|pw
zd~)_KsWX0vd#8H)=Owz>M!4y+@0ni1n?x!^7xxTIbPb#{exZZ)WxT}1-Ma@VZ@KDf
z;+SJAIG16*CzsyJYqaF>Y*7R)N1WWVda(6;k3hcrPt0=eWRU>5d+wR#jF<43?+JTf
zo$1`BEtk9t9Qlv^$5y}R=wSMpzlW_}h;eimyDw+@Vw;zTiAC=Du;`g*yglP>9t`dP
z287`U#QU7fpUCJLZ}VWBiy*dAVQslDFJ?LY%ez76a;Obd_ZHWpT=GnCVbqT(W;yx{
z%Tn$IYERFvN8z%*+$0%?t0(K`NVi;KBm^We0_=KV<5^!o<g5p^w&fDD!ezrfkv3|h
zB^^W_x2xh$xwzweFF96EUtOERH{Ep3KH5Eqw*5ogHpC)#u9&lTjl36~xhKBlPGQE(
z9pzo==pP4R-uu__h%Ds=)#$piA!ol3hr+Wj{Cw{oR@>YaLOdUJA>n8Km}8@#Lulsg
zQ_o{d1J?`Bmgyxjx}zT+3rU>&l8Y}gI*B3t?;zm2$Gt0^JuX5bvL0(}_J*vhv8%Ai
z#P*Lh#eOf!q4V6ltLM_}-k?}yzdY^*=J8;tc&EE=?uF$M#Nw`-d!gkX>&Dl+yh&Q2
zuA4*Ca*PGL*Z6<;UKL{;zAIXC?-ZFFV>?8PJ(g30;{CB*w8-~p9`Q&y4wcX%->VzE
z02&M1)`gp!Ip8i!PFbXV6Y1P)$(4;3n+F=eXxatZS(-DGu{m4mA9q=4$wPHrUYkBz
zY=UUXKW=DHi`&1(&nTB%W@yQ)ffgSST4Z^&=%Hv|m%ngT1}lE<%jFwrn8c1lqL|E|
zP{G;v>L%|NTJGBOuI^dAZP2}jv8CN(65BtaH#r}26=yvz_<HL~)tP-oEo<HAp|)x8
zW@zE}JPr=}wkst}_HN%XQTL~=hkRe@vpm8hhpD^o%%6LD-()>nVoT9-_n<w_FPmlB
z1^7<?=)YUeEweH|tt`2fPE$)8cU|rpai3@1&h4^1jDKt8@ym?6vJ_fkur59N#`U5(
zz_Y$0ZWpJZT=Yh?_$wR)&cOX1J7(Irot1J#&(LTzp+)b}uH+6W7rTIqCzww(Cw=P{
zm!=#IGvyetLMt!1FqX8zu$;PJ=4r!~+;Xu|aM%QYik5gfw6AT0u_gV}#PX{P^KZGx
zwyq<=eLFAIqt=aXFLFt+@75&*mlofwx`|yv^YD7U7woxmfVo@F8;8pe9{#AiYBz=)
zEqH3Q<fcNCJt6IWSsBySO&Qv9f|kQe;L`Fvrt6lAzIx(8*PIzCbI*L0Jt^)aYc6nX
z%W+|hz3z0$jlmazz-In&9N%cOhtPi7obE?kANbMot|f={`t2`OwoZSTXEfsY$FUu4
zbDg4zd)jig(BQfF#r!_5<<S;5g2pwub0AmA=#6q^z#V>Eqi?ja@f>aKIY-+(vuMGR
zkUx+=?xCYC&pz6|d2lqZ?tYw8Qs?FfP!0-m#(}nRURRDmG2g@NLd(0a>MqZ|@9q6@
z1KYQRj<(o+7~~5WnszTG<wss}<<@6&w6%dAZ82?V^r*CPD2#3QtVW@&-^%wilK#2j
z(guOI<u(@7_keL`KclU@apgSjzWoE$O&g#Z83*TV`iHHhUGDRi%Q-*S=fsTa-zC1>
z{xM{xjri5nW%SrR{yTS1`qDRYIfd45?|YXlXZwPM<$HOPP+dthQkUGGy7)o*EYvdN
zmFsHHmdNJu^=em4Vb(W!2(Fw!!x@|1lDaN|<@YQ+5)*IT3pWp~eK|RH$9DLuodYna
zu{HDI5EFL}$em+*RgM6i?~y0dKU+87JHW+`!|Bg>Ihpr-(0a1wEEzc;WVq2+_4ynE
z+pgj69=f*{(myOL<6t7&bL4^>eO0>>QDt7>b25L)1*fk4{82VL+Tt0G2H?441Mkdu
zFNi$l*52fM?tm?4r)9r@DU2-*faUMYiy@BFKajTZmt7##>K{j2T>}jee&_xe^sW(R
zH-6%)yK!D<l+Imqn|%BWS8j6{9BplLXl~oxyBZ$-?aFOz{n6I;dbGuUpfMe0yquMp
z7xtmu<IGp#Id`S(8T8D`_y@Jiys>+dS{B|UjC6E+btRnJvjDp=w!<s8Z*m=N<Hpb=
zIm)^Tv&r7ICDX3B@{Cu0kUcX*<&`lH>Jr(4SugX9gXNxKF?y6+TRlMvHembAx;FaT
z30zWF%$Yt>e#gP*pY^~=#$R^d+nj7@;x*D2+j;jNljY!Ft}dh2_Rsy1@15}><#=a9
z+ngraIO%)KVG@}ar?ur69#ePi2imwK>{|}I%J(>m^F1PK)`QrTdEvBaxlg(Cq}OY^
z!iCZ<`6}NFHq_YUjN5ZW^^45#ll!RUaL=6=Z*jKV#w2O?65ecGZqtl|o2lhISd_Ze
zEBIz3OF_qm-=EKQ`J`KV><kQ>j@yox-!$t+LmWG%x&jh+zYsTaFPx8b=kHALyZ=~s
z*M8uskIjFjU4m!Y4X)+NEspGH)g?*jV=q?jF7H_nS4GEr4~3*$bs<v8*lDyu+}Qo>
zYn{KJF!ybP13l}@meF#X$4k51DQOqm$a;|VT5j<<zQ-Mq^`+0`dtb`OxlRTj=6m8Q
zv%c7F#>?!pa*1nt{87I56*y(*k4<aWSJ+ebDG@lb<GFUWe>Bd>{8YrupHks3pPAdY
zf7oBn2TR}B>l|{b#-3kr%;*L}wZ<-gb=Qw`w8hh)ozr3F?=#cG&i#dS?O6c#iOkAN
z5;>dcHESfdYk1D*6C}1TY}{$rIodr*49gkhq3;@rk=VWF35DD}JaQ8wVXjO}`ge_N
zpXo>0LsWx|Lu^652S$<aQTOvbDcQ1aT%>!ZFGuLd@#0mgrd=WPJExbnd)vJnp}U_!
zx6;20<Lmci!<@N-M2yTuRL<TI9nk&>*55gWc*=eTjS4?Fx9RdQw|@8#5k0ccne=z=
zvA?##dY!p)j!Ij6gygKCYUv-vY}f5_VV1V<3;CWD2D`81!VE9w?auvs(CLqR$oB{m
zrB#NL$s%V^gly!$3!llHULxz=FY?Zmwy~S~_qd}x=bH1&oe~~qv^j%JZn?{7INkT2
zIm?;x_U+D<BfWkNhMSGO;dS9q*)wzIlHK=KJo9`{rKB$G+wK<<fAmn2V|1p2G47d$
z49Fg$hGu=StIh$l#jYh+N8}eCk(>qSh@4AWeAbdU9=RB-KKJE4`Lg>@s9^Y?lOMfS
zDu&z@Jj~H`58{ydb06(~kx?T21q?K2Q0nNM51{~&JHLvhSYC2lGJEn1B+s0;GZnPl
zqkmFzq#Uzy=JX-Mv1B~T<$E04`5s#44=vwA104A{HV0vIwmRdNm?Y&kN1k#VNOQK(
zz%aJ1oY1r8%EdN^w(mS%8=Ff2jeaz9iWZ+MTKt@7;U#FXgP<+mN4q^+Xq&J3%Ec~<
z#!I^M;s%-h0+34h-g0aismtY>xxWX;Qg`1g*MfMfe2<cyy42q}3#|7XX4?jPd&WTt
z>-RQSyS`9LG7ic?>JqevPpZ3Ey8GVdJ3Lzarc86OWuPr~OI=;gS%9n0c*(4p7YU3r
zj=U4BjpWKXTI>;MjKe$k$$xNlH#eyZl(T&2kB4vXE#<iQr;SSrxb0pty`2LtuaytZ
z+_^F^OF`s1Gyv^wSJc_=4Hnw$Q&L#=Gp%v;t;>oyITkKcVth}B?%X>WZS$zBOWoh~
zg^tL6KC!*!7WeOaMCHsqT=?#*gYK917@K=K^XGHv3#@78o=HFJE4X0!0V`(CB{;+C
zADHgurZQfNa@zged%<<|_+Io&sGG%OYU2{`@4l){<`6p*GoUVka%4=j&HZ%cFzsza
zEaT1}aWZ{zg=SCULTQ)DWBm}q?s^tj9&+B8{<G$=)9p)eeRuFTcKvAk-pSE6X9Jqs
zd-pSp!^(;GylKufDJORdYuM_NLJBu0k#^yC)2_tvyOwvPQ|<)!S<5pOEbpZLuCI;j
zWb=z&GMUYnh9<0XzXzq2@v?S?57`Efa{FeiHn>;Q20PcDeU^;%lc>9R;QQXjksfW|
z%|K(*+Ou#z|FkQ=)SgS4ZtlxV!Jcwl346BgS=wDU8RyqVOKQT6XMNA-pZ+Co+t@%?
zm;YT}jm+~s2C;2WVlxidl=Owjzje9G7E4F)i7gE+zDhJ#*Yt%?J?G>6=X)09KUlk?
zN2?g&_j~ri-ZMORtFJ;bZQO*!7?3yl9&dSRJ?EUvi?6##)!b#Av#Xb3YC>an9QNO?
z2S;Mg>N((AZgY-a0@!`C<Y=2?;b=Ozec@NjoC;^!z2=6G4smMy);-_$ju(5*zTy+k
zy+Eso+=+>;ujpnfd$+OIhlJ%3nDIJXYs34ACnh@1y&b&!RLpJ8H151M9^uLR_P4&|
z{jH-h7;pdB&C+M;+n#AA_{eZ#U!(tuea(HuT#|ES#l!2)&$&9uCqnwp%f*83IQTEu
zu6z-DSxd2-;SqeA(fvgE=RRWM$+|&vt*uYHiz#<r?6r(dpvayNT&Q!Ud&|c!b~AHO
zAL+NJurq(2WJq7cZtj{3QS8{*1zK+NI~p&KRLgM?&i*52M{Z*EUfb)pkon9NzLq(#
z%QIewCVgRQ-hI!UowEg28Xh48KYR@>XNL79=hsPnl#`@(=LNQ6c^%6`c;Y8c!;FLD
zZ+Rj~Dl!+Z-}+cMnKoX{S`vLS_guZ{vsnGiGsjET$Z*qV4{&9?<c+N5Jq)#Tb;kOo
zQKR-QyD3e(mmn^6gTVlGseEw$>9$)N1yj)a#xA2o&Jmw=<dTQaTHWB0&^8W86oycv
z-3MGTId4XheJUOzHVPtU<ZL%y*7BY)PP-K4-3R>QYae%bH|Mf(c#CQGpODO)bCGjd
zOI#>?(yNR))3|taHMHCTMC!;E5PXrJUEN(vBGT?ZZm{qJaH;j}T-L$xXIfeIxR(do
zKhUVG$3rK+FseOo*v6v`hKo5fQa^R>&qBH72vgYy%*uO?aO~I*padh^^3FtGg%{}h
zo*=P(aiOO#F1_U&r!uu}byE^+&pF>t#^wMouY<JDopRx7=?iyH)>6Zn=VE(^gslHN
z2ORQggA=^vs=Lq@qUWJ?KXcBujoMG8go%D6R5~)8G>|>h*jna=?<w=_O{859>hJnA
z4|W)vpeVG+8?rNG|1sA^ez`D_-9w(Y%6$$q5&8L^PuYEXn2DWJ*Kh89n2FdZgaF1a
za1j4|?-CZwe&I%p9AUde@A3Lz_z;OJb}43tw#!_y`wt3W{l9{z6aR)5tP2Jk{2JQk
z)j01FPwbA@wVyelzhyn{^4_||z2a8ES)y&OSbYJ7%|11$X``5ObpbfGFI1AOuh{?P
z8$3Ia87@UY+GRW3vnAtb^h*%~k-fp&!|PxsVpoBg$bEUw^6b1YK}FtxqsV#~TKEfY
z5MBpckv?C@?amc;mGKfWW8Z*Y%l!d4o%P@@iwz1cBm9a9C1=6yn=|Om$?%s8BiMDb
z3nJ%`s9Vla*n8h=e9@;xRy}CJja)jd=mr<ow)^z9+MY{Uq9cP`O2s{wAPM0^u8-I;
zWex3mkX5qRm}t`m?R3w_T}Q1O+z5_Sy_>2L9*e7mC)z=|w=M)Q>&vXNcO%s$e3zNO
zdmQE@Yfd1_8WAqCM#<mF267<2;Z3YkooCCId6otvXAq;z*lg#t;jm^s=zghd6J;%#
zd^0v;-SSu(@yhLIQCOJ^Ew*8_&ACj75Z^uHMT;K-ZS&`-D=cgJj3%r5$GJxf#s)3=
z5!&XJyf!x1Gg{uwJsKm~wkx60tdVk&o6zF(LW3mR?=i{DzGol{#_P<E>zhS$4D&r2
zO=yhLOS?qYp~?CaT4H|gm5}9E7yhwl3oZAw%pJj0q9x`GEwK-1)XD9iCw*q$D;I14
zfj{x=Xu;Z}?Ym!U7B7kxOahvlYx~D=k$I-@=X@MUJ#`Hvw8%riteY$GM!Wf1juxyM
zno$33gFu;ma1WrTT=<oP5Lw_te)gV5+q|{<hhJs9U=LZ}ubV3y!(o@&K1+MFx|MRV
zNuyDyXKeRK<jxDuw03U-tK808S3Zi=bzSb7(_mM=Is|j}vn<<tr%;%JgGY-^@X}Pa
zFZY1Y_F3H1?mrlt+zY%Z;Y0UONXEwYpLrqv?fTxs3RySs#PpBLKXb}gId|hpC2fQI
zyyYTqs2knh0-4pFD-O7P?~(zh+~!=iPw8*18~yD<-MSCh@6#7Kc{9(|^L$S<!1j-P
zm3fBsOB-h>+`5c-S#v5=>&EsaD*7=8j3YUNY&`ki1wU+GDCn7c(6{Utu)~Z4&M4!c
zOr~A&V3|MczO=+@L2V|64UI*1$05<qt_O_L>VDjVlA}#s5SB;X=$99Lly+J0)_;x>
zN3TUoEE!rb6KLFM+drz%uJ5IzO*swkx?Lj8U0-IO$WoV(ao2+g_o$ov3?za0<1b`1
z`-NuTHY63>wY;QVyHCNcS8v21D({{<Aaiv|5q3^pDQSZo*19zGty>$nOE7s!&e9xy
zN{R@NU|w52Mcw$A(O6}+FC@0i-|f_tgDwjViY2st55r!5$ZPjBR@!9`%bc=tr_X{9
zTQ^vCZuZLPr0m58C|90yIeL~4ku2ISJv4m=-$<Vy{Ljt3dN&wAat=@=%l|I7X82I^
zf~m_XvTJmKBB22V4((ubyS}_a*^_R@$gF1y+IH{R`rTJlu=GWCmGCAfVeLcGUB|bG
z7R)hP{4SR&du@lTwy{5>RZoFC%sxG}G2^9&W==shGN+f+bLXBfu;oB=Q*PgZ7M0*B
zh~2wpYJEzg7m^1JE&c$so|$9CyNC2RXI0cm&IgoW_l8Fl`n}lYS-Ci#cMg(Q(j35D
zFORr9kb5p!1ar^m-R6LhF*x}I(Go)h(XnqE>r3My&?K7JaZn|*z8CD4a*y?Zm0Ug~
zJI(s(T$a`2MeVG;Sh--Qfd!H`04;GMX!{oS0S%IG2`%v{XqyXN-4n284rtEVf3*1U
zY}a{YF57;6klKh(_|nzq41zbsMg}jsc3^eEL$}Yce!KrJ0anIl;g(Nc@~6_`cb2xI
z_958N$jY#xv6s-!!#8+vb5C>mM+T;Gu8sTB_(y(*7wvlRKJD2zjLsjqWY4suA&VEF
zU?;}{TJo11E%%m)@AmnCH@lVqCZ%y=q+E4G%aOb6pyHVW=Hk5r<c(VY3{ZXIcF+>1
zi5A;Gn#ZxW&m3zRhZLd9hgjRApF{SnZwy>7KBbG2%N@_flKTU4buo~HU6<qZ`CG7H
zXvzPg?&d!bC&QhW?+LEjxfkS=JB8RD9*eU63TTkp357D|TpkpA*TWSWz1y*DyG*&u
zb1o=k*9}KpJPp*L2%nw5;*pe#&+rh7(YJ8>$SR<hv4=4=hqvRLx#NM^BYRVYVt;`M
z%-QN2P}ck+?{>Uw;k)le8FsFOWwmZ?@K<c*KbcuNSB8-_as#(+@J*a*`_8wqf%aq%
z0R^VdfO8qI&$Vta`5r3@W(O^K7dYRN&jT&_zR-Y}cRdc65gO(m8YD_+!BBm=<;Xeb
zw9fa~$1^V+tgTy_5N<s_AWpB`mmE^jr(JoGH_oB5_lzwR`|cV4cYTS<>z8y3vaHNp
zLBwR98B1eNWISB_hVL=r?f1xQJAVvQZKIe3&)MKu`QE<2MUj*SE#tjM9=0wR&+egn
z|EP6?-^EOc`1xMqyp#(*)<v8Aj%fRir*VjLP5-dEtT~~f<sd1xe~xPE=B)tjiiX<r
zhABorcc>RXq;B~OD}VRBMNgkkL)t!TIDMA$B5MQ`o$tXrX8)<$y8B+>86%Qoi=e{W
zyZr;pNdM@0=?l>@V}otX9wP3hoM$}KXZ$K_MCMAnSWdrJzYADt>`mMdvHK8rBLiQa
z{OzBe5q@yt2HTg<9GyFVG|t>_@Z-_N;m6bGgQ4sio$F-h3b%@Ue^~M5f0tJ+b(#5h
z-MEfBFWe9r+Zh>W4>3JN7U0^+J`fVuIi*%)P8lxJE(~Pm<sRYQzEGYsHc*4C?<sYu
zTOIaN%%lxMdgkDS;Qb!qF>PE_T*@V{p97tonJmpN)~!o#%)DUjnNv(L`+(ajeUX|a
zZP?@~cN=E=0&JhTB09G2=g2v{8nGWROU3`odmecbt7{vL7snEV(?{F4rywxEG1F(5
z&&(+xUgp$w*}BDaFt5dTLYxdvh7^`_1gZO|TWke0e|$DjX_3v&9lCo6iY#YFSbo1J
z#mAm4kha(@<fY5}!Chy+kalxsE@W!w{@fM2*W3V$Z-@S?9KmB9U7U#CK8sJ;`^eSU
zHUx~foWRdHA8zFEVp>JlgFd*t#1@agf*B;|_ks7O%oLO5I*)!N<Sge%%DArEMFZ^E
znC8-F0(8sO=PyHEd<kdH$@(%aWu9I9ndjyeBB%t*i6+bWjsuo6?NYm!CthmT)CFtK
z95Bgb?;Zeu+a*h-4YE|e_po1m0jN%2fR58HxcBla$bj&xgNyF>E{EUF3$ZTtUEaox
zdHe*A9@!BdJ+du4di2#x&9Zalrih#f9u_%~7bj~8kN&6&sXyz%1sNL|?0M$zLIE-_
z{AD}OaOU9~;A_$CsqCFoPPyIp+@X)UwcVVHW$z<5Ui^}-vbMn$n0b-2VfPi2Le2-+
zaO~bh`QU9K?ppUUyX<;AumRvNxqDo{k2VB3?e`c4vTi)e+4n5zEtfc9L4k=aMca32
zAvv3u<g%BvU3y;To|>GwClIB7;%73B#?RoKyw*D}E|ujuB!=imTyl}K!Hl}*4pQ2{
zn=&>VA!9SC%M)eRT)C6x9NRh?G}y<np#{%{7T$yw9|l@%>*qOHy$9{L%kR;WTkh1*
z)rHW48AHn(BakEz%R4r_Y4(9~$;*CGS<Bnel3xlfzB_7i@@}C45o}-N0#0A(dBYRc
zP3#R?^neTbUb`|{unTAetnCXd)0}<f!i&-3^FI^7%718yzeEcj1TC?6Xn89IEwQ=G
z43Ue`A}68+3yYTgO=ypH?dYt>1*-4-k(-8>P#Q7(lw<q~O}6aNVxyp4ChrGYa`vC8
zrDu!qn7&*9;kN4-WgKi!*}ILey=={^m!X-~Z3Fw;@iGN1Ut=CBZ-V>?UlXCddWyQ?
ziD+Ner_S8u^iThIg>n{HZrTR9Y3KCJSG!+)E^`Vpv3dZb3RLR$MLx#NRb%$lEiXP8
z{PGu?)!un-+T=k)gP7XBNWHUr<HCv4M*V)i*L@{4a%Dnhz33lk$rW+tzm@sX@^%Q?
zW4uI$<$s_lYcq1ndCPYWU@A*{tS?)5<^}v<&l{8F$||%nUg2#QP9g1biDYl!(Akp=
zp4pSl5x`Vx61H7wUHUx+qAkZ}p1v?XltzF~-QGQp%-V9L{fKST$fEb4C07_)aMEar
z{YQ&U6|J%bZ@}6P52d;?HCp0-(Rfa04j?(hC!vhOCz*m)pE=X@`g_nG?SfJ4di;)S
zY}XtcT6>)!0-f1DQ!jTd;li`;4;Q}so@xEjM&ey0e@VQ{J$JG;fXimI_AoTC#qBe|
z-tOm1$DOeeky4KDZuh<6uAax@8+{8ceh9QjyTskB$0e8BanSRYN5FtD76QmOwp=uh
z?EM}WM!pAupYd{FX0Fbwp6@09J;qtt5e%<&?Y8At!q3+R>N%Ud9gLRTxM+{@3QJ9&
z@vF=|H938`gbzF3#^+rcpzd)t^VDT#$a-Ah_O!vZy>=f!y2KQsK@6ns=e5%)m-tXp
zY~m%+L=Eis?(z;zrohk=AL@H7Vq1<KY4;kHX>BdsWwGa+3oZPQnL2wHx+F5D2=dkA
zrC@rDmrrijjbxTPKn~dTANgM1pylFAPBt{$WakAt-93rbg~wi=*~~rul0LH|rH!A0
zNjQ&s=N@or_o+-nk(JL?nRdA$vR@h#e8{8dN7#7I8|!IgIHKs<s(df@H8c;h>^#$`
zvnNR$8HZKM{4vp%CKx$wB&US*T-AGs&pk)*o#~4hyYL7OftCw4O1pV`g}?>0xP4|o
z&0GoF$z0)A;SmgHJ1?@ZWDkj~%6Mh!%=v|eTl*hjEir{?$%}ZmNB9+ZPR=jsH2ND(
zm$4mgedqab>$}Gfx4!eoD;as{%rvc=oL!>SnImV7&Na5{20oc}JKXxN8;@bf#wC(<
z^Eh<I!EClX2fOOJ>2&(c29-VohG!1$f!!T1z;eDP<$U^V`cfAtwRICO>C#HvESfA#
z+ZR`D+Vzy*o_%h~uG@jF^1Z}kUn;%mRw7oyUoLfOzGugzFU)!w2e?Yc(Yyu>ugQCa
zM#|iAFtwx&;Z`jdOq=f|FQ-e@LEknwmC|Ppnyk6p^qChS{o6lqmGD!k+9MNQh|}&<
zCWYv4hXLO+BYJBwUOX6yA(E}HHbxfs$oC=(B0qyLFJ{O05@Ux}xtQ5Db1I!t^p8ty
zzh@teCw2yS@9e8f+nD(yZj=VdGi!b(<mF+^G&x&5n&BlRhS<Hqj3PJ5upimSNsaBx
zt<b&{dj#1NT-Bj{Ixn6f&v;LQ**UOsnJe%7?7nx(W79e;cD~o#N;Ipyi-*>`QN&(s
z00+t1^M;nYo2MhPGEK7m6Q-1NL@vob@VT@r?qqoc1W@cWEEKW5p2)iMY<Y8jZ^`#8
zF#qKoNl=shcS&n@-7YCi+NGZF9Qazl$1u9<3$vX&;1VFD+!>N)ufbx6uL<UkY{Bi4
zv&u~z8y<8{_J#o4_$yd$vc62E?F+yCuCL=3o&ACtGhU{QJ#UXUpEZ#D?P%RY0-ADv
z(Bi|_n0MoI5I_^T1cEB}B`G`dJqvvFo(px`vp_wH-UG-TIgADoe+5u<?n@@=*aSbZ
zn&&Lg_|q4+{GQ)S5zxBHw+X0G-xw{lbA|oo964G!Z}QP*-!pONypc=NXJDL+jr}?8
z-s6;ewi=g@i`U0Y;?G&-mdyF!j1KQS=kbn%Gd1(fS(!We;H-N-IMK4#IMK2XIDE3#
z&Ka}w=cb5mK<&=_nU(MtM()@^&p5nue}>kKgQ;)VgTbzIb%_mT-7XzZ+MupxYy#hR
zU!CzGeenc9%Oy7u%Vu&QqV*o6sANA=A|ektg3(P0+L5IQsNrE;Me!ApXtKu%I?)XX
z61k70>4*)Fq!$?zi^$!0P{hnBCbs8NxLW&+hh^^Zu&nP{Eq5Q7z?NemPr2Yvy_Qga
zDEMUi2bjC})`bbDUAooswZm~|Y-FzR12R|kE}1Ly$A^}7nHV!Kcv$Ol-p#xaMdObr
zMMS>hS`3eXn8;l5phXVj5e^?Z)Blc_Ru&!6a>Nb-+nqfQZJRv~37b8BZ;odU$XvU=
zU!-|jndad9yRXh&(Yn>A58It~8UJ^UoQ}>_V^Kci&XL!?G!{j<`fI5W(V4hd!m}?u
zb;fJkXB>S;*6}DGXDW^S0`J{9pu}cxfO+g5r}ji2#Kj}maTP`Gq%}r2aC{>Vf$YSd
zL;CB!^7u;nC#}Ywb81;^n{N2%3(yQbTNrfa-s1zyU#NNE5#C*o{stD=x;D)67trqR
zNdrl{m&|+l%O%SWEqS9jPFPG*E-`G%6+cAc&spW&3crHb4li*!A`dZhg|~AV#&30E
z=dOq7-`HNE1T&}LT#vftB{1O8*>6hse2CDA-UG4SzDTyVXPWCXchuz?U;am<%N>QQ
zMJ~B?6zShN;AVXfTD#{120V8tD`C#BYcMhh#CGhCPGI)|xIo%v%*|R7Ez)OVPU>P!
zsmsu{{NPd`_Is6w?v47CyFl=rKZ<<XpcL;pI`d2VC&0GlYKw#c&;9nmfS)84J>K&H
zotMwS_^Zp1v}1c<1BA^+uf+~xj|FY)ndTPCoHF%gP96UA#X(A4x@607&h9uKa+uZK
zyPFsmISegthoAw^d~5^Fg&A5fW6GJBEys>N<G5@$JAdaPT{|IKa*&|K7mXHQAQ3Y>
z`^3)G-_W2Tw$Fe(=`(v+%jHh?z1+z}+uX@$!OfusS9N0X>Un6ypY5~lGJKa&MS$a$
zYc4qDVuwScn5Aywot2BdgxC(5yLI6Y(q}J{W=?JK^qFg?bz^tLaG-y;T{2hdG5}_-
z;G42{$y}}bSl=^_Y`ce23N86mDUC9Eq+DVFlnaiB+9Ofh)-As2)T6yC(1M*t3#Nl7
zFz+6sMfO1ph8Zn>?Blx2$I*HQjcjch%E{<4<K;=n9*6B-xrFK$J0V*4{pAbab)z<}
z4M5$<NcR*|_5mbk$01H`<QH|5x9qH)E7zd~*FtbCf4O|&bN47093xt6WN7hEqjled
zhjqNoUq_uzE?czVC(&Z}zDTXbGNA>#j}}=4E$_6V<$V$~(bv1L=yc0V9{IwV1>!fo
ztVb)Cpv6{&M&sXh9hvl{u_(NG$q#}S8yQ-#`)GdKZew_vH<G6uExFOq9`g*gp8bcv
zWNfEgZC@xQdw={Ef5}|Ic84Fx`MtdTu-(gJi3jVO6-W^*3EB^f4?_zs4Gr*h#sTl0
zIRLR<o5zLzuYC<IHg2@8FZ1~7ILgH?g^*l-XhyevZmuTfI?wlPOU4Vb9U9yEo+IY_
z#c46B<Q;7^fn(c0Citu+-js4=pWRnrrE80H0P`jYn%AqhU20Fp(cGFeh~yqaOH3<T
z;>OStJB$|n94&g3TOWtsK4a~B&PknXS5Y^%O*Gpm--|z4;A`GMMoYd7wB9}Ue9!U-
z7P81qZnBPz{F1SeOR}FC0kRLkRno2)w$|k|oH@8$+1oD6cJ6rFK7E#Ec5P4>*|+u*
zwB*^rIAgy@%Nw9*f`hit81#;fdu#oO3<aG(rk3bEI8)?ow^8H`B1qe<J?FBTuI&r0
zdMF8VeTK?C<`2uxcn?^*^Wy05K7fSX+zD>H<O{mjFuIm7O8Fj)((;nam7RSB8<2ek
zkd$$NqxXAxGm#(<)VAXVozC81f6lyIcD~e243RdfgMpB)J(k-5ci-<Ff;Th|O@+oI
z8royLxOV0boFQ`{u}kK!el<0#>q3!5UgQ2)e-C3s;x*8MSv*U4bkhr=%-)c)Vdn+L
zI(Mxog77BWK4*)EFY<=4^6<pFLU-<sB7B#{cWt@S`{XT7v|u#Rx}Rl|%HDvnUOVu)
zl(IKm@sGNM{@Fv!AdkAi7-C>1X6x4etehE4x$b9AQ$_~Ha$1)UE$!amwhfij?j_$&
zx$dhU`Ox+ZvdH8dvAnKLns-`M!?pobx#vw+y8q;rT%N;Q(YjQ`j6-OB>juktS<u#p
zh88S4XHW2dXu)=)^**|1V6v}-U@d=vl8!D3W8L#c($0CqiLyp`SlZ>}Yu(5C@}Xs4
zaqgrpr%3h{EK}<yr~5^$#KuE&iJc2AZ5+gZ=TFY>=vJ=P#XoB|IfS@>lP}{^fJJ8_
zw#N<(?;ZXONf+DAxo38bM0dCDgI~dRM;C|u4bNddjT}p@Xx#_Df}&{M2frd+MW2?T
zF+7JfzF0pyQb5k|12=8!GPx~}u$#lLV8A1<k-}nEh8Eb^K1w$**!D#S(=Kp#_L{D=
zZem(N11i^DXm0j_lpK3j4=$B<!7*Dme)ccY^yc38wdmM(P-F&?H;=mUeSUlXJZpK@
z&7D(PUFOuSobmc%>n0zgQps)2p~Q%??GnTCJ@Qq{J=T|fDD(V~ui(Nr*C}N%v8rf^
z-8@>xOB|06ji)0zCvQOHaVc=3r@)1WCxV<T&f_wFW<6NA+duHm<@c`N>><dM*i~%%
z$PDn~kr|*59(5&@nf2v%Ze7ac${Pn0-2G>kBQxBiK6|F2kXx5Md-wf47?ZmEWoef^
zd(ZSeSJb-62XGn1TDS4K$^{dMmUsiS<Tyh68kyme#P2z}gzI}gE_wN$E!ONu-Cz+J
z^b;Gza+5b1&?*aHiIF$p$0Mt-1VxU3ACFFQ`0?x^JS_X~q}$z-4;_&>`KVj}49jq2
z3kc!prr=z$mxw@(y%T=?QMdjX9{SY11ZTT<S&SmD$><b$4Sqbln7ZG(hP(ToRNT58
zLwjam#bck8v?lhoOYE|Hmjv9p5C0pi_@i$9&Rn>W;VwO4+GU*EJw&T*T|w@9j;Ixp
z^++JG50SzmW4hvF9|G%({sCzf+cm6s=U%wqo_$hSWEB$d;#HtuWT}`l11lao1FU%N
zBVtMH44^%^j~xBjkyxd|pP>b!?_ave^sl+#z6j2U-hC?F@(r-a*tx7^_y#yqeD4Pg
z&l%+EU7q8XZe8&%sY|oX*xdX%gVf*bKS^&>7r#nf;JnmzrL?XE*?rLW#r35AbGsmQ
z0cv8$q&nvu9r$C<<$)`<FF*;o7dZ2?|4e;&`#G{#|K%cm)a|_h7asp54@>R^CV<Fr
z=cL-baSor|lP8WZAA$>SU3h`il}u&#6(e`f+ZmR3Z!qva>L%Ct7skHUl{X;mn&#bC
zuH^V|8D(-Wa7DK+St|1<ok!-tLr$5$3*w#qOi>Acrl>^La|9#v^GtNz@T;^-=*oU3
z)MP(jFxmF+GVz60eswv&Tetj*6>0I_l*aN6-rwj}T>h>5;8*udX2$m5S1gCY@KGDf
zH(a4Pt5l85sbQpDAsnq+e#JT-d;8Y|0M6XQfJc{P$#~SQuNMZqb%B|7zsPzNUGjke
zH&xX`rA&X+4fdS(qx+e~E&ej<dG39oM)8*sfg>}xW?C0-+B0}5Yj!Qq)w}!NE9AM)
znKq;6@np4KCY0qHxJ&qu8zuZj9`M}VUm1P-y~p~Jua+m04mwx#!QH#G+T1fFsp#EY
zPaW?WICk$6BQnpL$o>=XoUw^9&U$bYXDulzsY?+^U3r;Wx0sl(uEEU9MKtZ$2pk#P
zp`%i+*hU!eN8RA>Ih68#05DQ9l}u2PH>59#ydfGp@&-}rQP=JLaU6%V+Pmj^vUd+!
z@<E}or008i=Uch>{ISVkywHO2I(EA923pQE8Y{r|1u$*)5LTSL&S-hx6irsP{T>tY
z>_6oq3!pK0rmn}fmIjzH`|rYqRwqFVwgL@6C*LDYEv-7Dt0!^2Xo)9A3x*FZIRemv
z;bWu@mIN(v%xK9sf|hsO(ZaLQ^0pY-*Ok{?tI79uSMADrXcXI>KifHbNQhYWy-=R)
zKm00nWd+PW;KpfP%IWsyA}d2nyg2K4a*3kljm@*7uN;QP>b7m%X$UQNTVja}g(=4x
zG&Dy)ZNPRfFTRX0E8EgSlXCzqF_~zcD;j&o%i6iRF3B<Z*G`&T+YRw5wtuwPjEG!$
zrwfh2Y3Jn}-b*`2XJ~>}Li=I;Rvc8pZxHno4}r!Zzu&VB(k`3F-XHf|OzK{+{(kS2
z`=y;nKD6YrC5k4Ow{XPnwF|SJds;b>Xw!ylcq=D*g(Eoz(YV&Ou0`LoFX!^g2gKs;
zzr)t<*@B}DA16Mq{voqSaxh)Ck@XLvIl|j#z?SqG{62kgo$on!6c+DzNT%$A-_euP
z276uFpzH45pzW`$A`~=v)Gs`={bOdx`Z9#<Il3!3W23ZZuE6znKhtK~XEImDW}9wb
zXq;=CqlLzfsfGB}(DLRQT4K(Gz9vTsTHeXL*F)DogO=EWL)C{DlXh39a{@^rv)4!w
ztLrKkOw6fexfi@L8h#*LH)jDPVf7CxUF31J<bOfSn_(CJoAv!cuEdOu(RcR{#8cOo
z!LH?EN1}2@pS}ps@Ox@#_&u>M=aScXeH}uU^S;_;^H}T$T5=?FYQ+AB7VIEeY^rEP
zvDq6=;QHjK&dH&B>U8FmX1{tjBWB(}K}(z_8f)bC1$c1z6^~|QE+X*i-Dlxm{{mXx
zrJ(L7_bgg;Vzk7sqLr7h%ykaL3TB?!;WFNb{D(8;9LY?uKJ|NHIDAct>F{D%_|mRp
z9yvnIjivClU_a0#-kNngGsyC6Y$NwM{8jjnna_Q0DRWnxStadyo+RyJL_7CzP-_R_
z?8fnT97LbJXWZuD&zFK^?@QctaSBX4!SJCacIiw(kyUKn>?>&C=p-;jYkzT(1*?me
zw|SYC;)g{me=(!cVK4n|=8p!P^&mFwz9)j@?Bm3ba*o`rk>i_ka6D_P!o-2CQaA6U
z<Kn@vpe08r8f3<Pk35<FHFrMCb?jki!M~h^d+|O3i1Ow*n#hywi(|C=o~3?$xawAJ
z=V5L+Og8g}jhDvywSDQEJ~EOgUIPuXC3S`9Ee$9u<%r5zk4x~Fx{1-oh<gVdt|jBZ
z{?aaIZ`vhq>>d}Ewf1bUmgWuBd&#tG?i{6ET2to5E!uL)`^#XS+^&q-d57pCtJY49
z7JnWZgT%};s8G&=9D`X8=9kEDFd{kUpxui<<v^?4j{RkxX~~PzhbD~O7A<%<G$@uG
zTYV0fwKn$x{6_3j@EfsrLXdV2*cA3oxunqPi)*H|%2F^Godfqw>YBdg8?Y5?GZ#?!
zm_GyFGsB~vdlihL<2`5j&hsI@L*vw3+F3V4OI}ls-r&N~s%spcVcXyVifjS9kUJhu
zA$s>E9oTVPAbr|ksM&GgF0siR)?nufXOFD_<RtR*xpmX7`=hk#A9hvNk_9Dec>zAl
zcX?AD<r0hMGJ1TEsW0E_dzDu5@jZe>>XNxid-TsG&~lIOVNNOMnknt^y~kO&{A;NT
zG*Q~)d;IJv$Jtw2-h;d>+ueU$BD*Kgp;DT_qB(=CT#-x8V4QLiT$C0(Ay-@CaRlWH
z_Skm8%y&Ou%FI23eAclkobhJoifR>|oslB;I);J81G{PKPvLjYdbsgAFGQ}4Ll}6*
zK{Z%@K#7Qc4x!#P;wMfU&9ieB+UPh0iSQv?sD0r(N&j37p&e*!*OLB`^(8l@&*Y}e
z3%Mz66u)bSKlZMh;bR-;4E18~hyERHaU)0DxVEFMp9Jk5N8RtigQN{9-ad}w>TaGk
zGzl&~&ehQtw{$dG=e8?=KW&Kl{<t3Mas{Rhx<<x9*9eXHm%2pOw82o5z6i}opNaP$
z<z4+FQkS;*D6X7adFLQ{g>n?GmV11Uc_`(8u}gb=54g7F9^X5#<o5Y8421Uh9#t~s
z&g;5$&&nOz<9kffTkdA7w0_UFf0TQCPvWS2k6Wm;$M^D<3#_PE<kWRON_%|I`A9kE
zqqN8Ok`F~+V3|_a`6%u2J?Eq49^ZSMkIT1|x^#%r9^ZSMk2CA-xnvs2`Mvaid(Nf2
z2tT;6^5q*47~_jJf7t!<2rO}AALZCom*@PJPbqBxJZ2mOn6$z3l5x;0(gsO(+c;Ru
zwjq<x=sglI+6LP$KWF*^hMc~D`lT;4=iCeTj%@nJHBs8;`qMv&Vp?wTtjgUZk;6+!
z2U#Q853)vlr0ommMCMO0eA=LP?;3#xbzTJQ?z-`jwl8paDaV$ZIgqC#{gX~B{Y#Ej
zbH%WdHW(?=#sy;RoH7}u4R=N60Mx29hkCyUB^+9?y829<O#fIE)4v1LO&fCWq%W6p
zYUcop%{gN2%sIl<BAdyx6B&-QF*5LFF@$2?{y9kLv#{vpll-+~Z}&YD^U<z?hOK?H
zs~m0ZLr2^E7HAxaA8m|B+c<}#ZGM5HEoK&t(<bBaXjs~CEo2;6UB<z5U7Ck8c24h+
zo6sKLy9Y|Pobcb$9^Vr}nR2F}w8!^g*<0@MJ#N^Pa~4W_e9u|fa&}d|cRt~k>-P?}
zlyZqXhTL*5wA|x+&O*vL3#C22=P9t3dwlN_V9omS6Sv*O-5mn0XH{x~oN1QGoPFVR
z;SsKn(QCCKsl@UF5n{Om&Y!&e4>BNkfQ)gu1MZpNv;i)<{0|~OcYtV!+yPuMxdY@m
z86Df$+!cGK!Q01Qp`5#7`GK_O<BPs>iyKCRGR*oiqNLqRXukX40NO)?oE|^+Db7$Q
zDaXqf+UB-a7mg=wxQ;&BuCJVh+wXaHIBgKbb{zcJ<2&}f#MU2e-=#%6P|>!VylPi&
zed<Re$ZlQdBja$8(#Ac6n!1bQ(T4MpHk^;N!Jk(eSkboOd7RQVkFa*xW7B8Otk9T6
zOXH;9cG;k^57?kGHa4jAkK3TM&p991!QdH;1EMQ!&>_-4XJL5+e|PwXC*~gID%U~1
zwwzGLv|+oH_V^w}D&;)2P}<{rAd4;c_#P2B<-o{FdwkE8l5$MLr9HmKJ=1cJ?<Hrt
z?@P#&y1*Z$J-)|JmvXMv(jMRAP)<4T%9Qr_9*k1UJ-&C@yyqN&+P7WVR9f!wJ=a^x
zVG*T0zV|pE{Mh;4`LXwVmnWgL_KzPscgl&Udsbb^xl`_m`aS2D>tOi?lX>_R78ZU*
zOAf!HB8Ha;UkJaV5r=mYsVC0MSlt!N6QMkEr<@-<;~)$y-<5M9cZ!??;gi(b+$r)4
z<WAwojvR4MQ)WF}JsAhQRMsQ!$(aKf=8VHbc4-5<PaDa-eGae9adfoB;T;XAW6qW)
zy5`WA83z<g)`NF!$HBLqHNUw09S8G4)|_v9avg|MkOF7>!WxmjT)0d6;+@+a@4<4@
z7dVf!AvAo)D`r0Xk5w=GPlR3eAK!NNAK!NNAK!NNAK!NNA9ro`-zC_~IEWD$M`EkY
zGdNe~?;b&({UY5>*NB>uITa$7xzBrx+C7lXwxMcin+NUcF75`+=15)VV|g*Hv3p46
zlzZ4{AyOx%LA%g&tE=&MXa5O=Ot}jd+&&ZQqH`K;cso^S{E~7huvP7PFeyCBRlhvw
z@2;C5nCPK`OyZ{#6cT$ocj%+s<_p(nxt=ozj7z&7EML)e0oTVb?tAQ4YbONIj;-%v
zuhT9da@u9TT6-NIczhFQs^5J8%$YsOvz@)h2Oc{nA9(f}OL+H?<B@SlgOPF2KQa!C
zEptUw$v6N<vNvu6&iRGV?0$ieO&g#jL*wEL&q0fRgce&Q+UAYF1TI+H$NrsjY<VKu
z<{!Gckq;Q9IXm`yd3RXdo`o~Quib~?VX>j=CMNi3ixD~6r(JV2J8=6ae_d(&)}`;A
z5h`^T_n;i?VAc&hth9YE;p)0Uwhi{((l&phy8M1Ew{gc;4wPrxAn?w9CJ-(DPhC0V
z(uOoAr9H;W6x4E$@nXg)cT8;iOy(*LXPa`jDNBoe@+M~e257OLp7m-lq~Azu(?{fx
z+P;9x?;a9gyL<x*K6f74zDK1Axgkd`(Yww0eLapZ5G`^TTKpeq-7jv?<za5s=oM&@
z+tDHyQ_41GS)ajpMqWeP__8avZ?U6M2UC~pY4<&}*~($}s?6GGWnExw*|kjGGVMxm
zmNvLAv*uoDDUC6F+wfd(X`63dyBDFnb%EbXi%n47&C_dJVfb5D{BOR;SN<sX_#VzN
z_o{9GL%(M+cik>dI5ZCV(nLqj96(;KPWSC-?U^C2<<8?PUs-^%@9~Ch10FpzDq?9H
z4`!ahKvND}uQX1ZZ5M7NYXn!7vBBVmR-cHdvCWCEe-f6qZv3m*kU*R5pYySMm)A7B
z4hviTO)7znqtchWXLGdJd@<9<{3Q>cx}wg~XDV^}ObuNcq`~48uwBCP%)!Hdt{kCo
z%N@rGEp~xBF}b^G8tW^^?uje=JwB1rHop|UDRgt>Vi(@xa+MPU-Eu5@+io!G>cXh6
z%teFf{BhCm-A(O@9O2}zJpy54;kC;rlDX#)*mFes3x5$Sy|xivtN0DjV#jo?#x9EX
zSP#azJ?EkkCqBS9$XwZLf(uI9ID)JD_#TBibt$%)D@tO^?VID;09)UEK!VGDu|jL(
zxhSPaIfr`o6|p_?A1`d=Y?|bwT;*cn&MoH>*zrP-uTHGhV0MT@5?^kg@6o2vf?rd2
z<K(`HSJ7uc*;j|vs6_tTh8(qfj_%Ep(xU5nm~G$w(HD^8j6<&Md`~)s%pW;y`L6ix
z@B{JP;X~(p&)5Wxr7w)v>5DYX=?j?U@*yF{xi9(NBS+jbFsbVtl@=Ts5xBY<t6q5B
z`QCRNq=@WOP}9u43}DfF_}()w_w-)caI{L>HyDZD;y+T3XuJIM-sV`o#`nH99`M-B
z6`>9JzIILzE>&7}7gxag2&fe#ojD(@C6Prh#A){_ZW<l&AdAZ<g`a0n{shOEb}v|Z
z`%-_r=T|ppgLz4O)X@ZP@Ao*kcHcv$bRQ5!_iRDxhVMFA;W=W`!xO1x?Mq?>^%>?p
zeJ-X~xy@rkXcCFBbIOtyS;{o${PIBNtjf|G-bs~=%yp2vol_$9qul2G&}X3IU2`FE
z(J$|Ph+Pj}#O!CBbK^e_7M^{2A=-N<%R;sGVs#l+XAe;ga%OOx$U{PxB0t-@IY%t(
zodf46?Mi);IbZ`=e$UF#HD`X#8a?hF?(=OI2g`mz`><dB_Sb*<xBvC$zkc`o-~Z;n
z{oDWj^Y^5xPrv!czx?HI_m@6@|Bv7O=D+;Mzx?I?HLP#{{__2Q|Ni&p^5-v~fBpIA
zKmG9I&%gZo$6pBbfBc!V`o}-wYCr$_hwuLXMZW(Z-~Hy7zx?yh|N7^D{-6K(zyJOF
z->@<KOh9D``1zMVef{z$-}~Voe){`gnP`9h;n#oo<-0%p;k*C*+duvFZ~y17fBu*6
U=$+2>m+$`W@BZ{(fBo+N0V%yCApigX

literal 140054
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
J&Rk0Je*ph5Y-s=h

diff --git a/decNumber/example1.c b/decNumber/example1.c
new file mode 100644
index 00000000..c204b7ec
--- /dev/null
+++ b/decNumber/example1.c
@@ -0,0 +1,38 @@
+/* ------------------------------------------------------------------ */
+/* Decimal Number Library Demonstration program                       */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2001, 2007.  All rights reserved.   */
+/* ----------------------------------------------------------------+- */
+/*                                                 right margin -->|  */
+
+// example1.c -- convert the first two argument words to decNumber,
+// add them together, and display the result
+
+#define  DECNUMDIGITS 34           // work with up to 34 digits
+#include "decNumber.h"             // base number library
+#include <stdio.h>                 // for printf
+
+int main(int argc, char *argv[]) {
+  decNumber a, b;                  // working numbers
+  decContext set;                  // working context
+  char string[DECNUMDIGITS+14];    // conversion buffer
+
+  decContextTestEndian(0);         // warn if DECLITEND is wrong
+
+  if (argc<3) {                    // not enough words
+    printf("Please supply two numbers to add.\n");
+    return 1;
+    }
+  decContextDefault(&set, DEC_INIT_BASE); // initialize
+  set.traps=0;                     // no traps, thank you
+  set.digits=DECNUMDIGITS;         // set precision
+
+  decNumberFromString(&a, argv[1], &set);
+  decNumberFromString(&b, argv[2], &set);
+
+  decNumberAdd(&a, &a, &b, &set);            // a=a+b
+  decNumberToString(&a, string);
+
+  printf("%s + %s => %s\n", argv[1], argv[2], string);
+  return 0;
+  } // main
diff --git a/decNumber/example2.c b/decNumber/example2.c
new file mode 100644
index 00000000..cb197304
--- /dev/null
+++ b/decNumber/example2.c
@@ -0,0 +1,52 @@
+/* ------------------------------------------------------------------ */
+/* Decimal Number Library Demonstration program                       */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2001.  All rights reserved.         */
+/* ----------------------------------------------------------------+- */
+/*                                                 right margin -->|  */
+
+// example2.c -- calculate compound interest
+// Arguments are investment, rate (%), and years
+
+#define  DECNUMDIGITS 38           // work with up to 38 digits
+#include "decNumber.h"             // base number library
+#include <stdio.h>                 // for printf
+
+int main(int argc, char *argv[]) {
+  int need=3;
+  if (argc<need+1) {               // not enough words
+    printf("Please supply %d number(s).\n", need);
+    return 1;
+    }
+
+  { // excerpt for User's Guide starts here--------------------------|
+  decNumber one, mtwo, hundred;                   // constants
+  decNumber start, rate, years;                   // parameters
+  decNumber total;                                // result
+  decContext set;                                 // working context
+  char string[DECNUMDIGITS+14];                   // conversion buffer
+
+  decContextDefault(&set, DEC_INIT_BASE);         // initialize
+  set.traps=0;                                    // no traps
+  set.digits=25;                                  // precision 25
+  decNumberFromString(&one,       "1", &set);     // set constants
+  decNumberFromString(&mtwo,     "-2", &set);
+  decNumberFromString(&hundred, "100", &set);
+
+  decNumberFromString(&start, argv[1], &set);     // parameter words
+  decNumberFromString(&rate,  argv[2], &set);
+  decNumberFromString(&years, argv[3], &set);
+
+  decNumberDivide(&rate, &rate, &hundred, &set);  // rate=rate/100
+  decNumberAdd(&rate, &rate, &one, &set);         // rate=rate+1
+  decNumberPower(&rate, &rate, &years, &set);     // rate=rate^years
+  decNumberMultiply(&total, &rate, &start, &set); // total=rate*start
+  decNumberRescale(&total, &total, &mtwo, &set);  // two digits please
+
+  decNumberToString(&total, string);
+  printf("%s at %s%% for %s years => %s\n",
+         argv[1], argv[2], argv[3], string);
+
+  } //---------------------------------------------------------------|
+  return 0;
+  } // main
diff --git a/decNumber/example3.c b/decNumber/example3.c
new file mode 100644
index 00000000..b84085c0
--- /dev/null
+++ b/decNumber/example3.c
@@ -0,0 +1,64 @@
+/* ------------------------------------------------------------------ */
+/* Decimal Number Library Demonstration program                       */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2001.  All rights reserved.         */
+/* ----------------------------------------------------------------+- */
+/*                                                 right margin -->|  */
+
+// example3.c -- calculate compound interest, passive checking
+// Arguments are investment, rate (%), and years
+
+#define  DECNUMDIGITS 38           // work with up to 38 digits
+#include "decNumber.h"             // base number library
+#include <stdio.h>                 // for printf
+
+int main(int argc, char *argv[]) {
+  int need=3;
+  if (argc<need+1) {               // not enough words
+    printf("Please supply %d number(s).\n", need);
+    return 1;
+    }
+
+  { // start of Example 2 segment
+  decNumber one, mtwo, hundred;                   // constants
+  decNumber start, rate, years;                   // parameters
+  decNumber total;                                // result
+  decContext set;                                 // working context
+  char string[DECNUMDIGITS+14];                   // conversion buffer
+
+  decContextDefault(&set, DEC_INIT_BASE);         // initialize
+  set.traps=0;                                    // no traps
+  set.digits=25;                                  // precision 25
+  decNumberFromString(&one,       "1", &set);     // set constants
+  decNumberFromString(&mtwo,     "-2", &set);
+  decNumberFromString(&hundred, "100", &set);
+
+// [snip...
+  decNumberFromString(&start, argv[1], &set);     // parameter words
+  decNumberFromString(&rate,  argv[2], &set);
+  decNumberFromString(&years, argv[3], &set);
+  if (set.status & DEC_Errors) {
+    printf("An input argument word was invalid [%s]\n",
+           decContextStatusToString(&set));
+    return 1;
+    }
+  decNumberDivide(&rate, &rate, &hundred, &set);  // rate=rate/100
+  decNumberAdd(&rate, &rate, &one, &set);         // rate=rate+1
+  decNumberPower(&rate, &rate, &years, &set);     // rate=rate^years
+  decNumberMultiply(&total, &rate, &start, &set); // total=rate*start
+  decNumberRescale(&total, &total, &mtwo, &set);  // two digits please
+  if (set.status & DEC_Errors) {
+    set.status &= DEC_Errors;                     // keep only errors
+    printf("Result could not be calculated [%s]\n",
+           decContextStatusToString(&set));
+    return 1;
+    }
+// ...snip]
+
+  decNumberToString(&total, string);
+  printf("%s at %s%% for %s years => %s\n",
+         argv[1], argv[2], argv[3], string);
+
+  } //---------------------------------------------------------------|
+  return 0;
+  } // main
diff --git a/decNumber/example4.c b/decNumber/example4.c
new file mode 100644
index 00000000..ce8028bd
--- /dev/null
+++ b/decNumber/example4.c
@@ -0,0 +1,61 @@
+/* ------------------------------------------------------------------ */
+/* Decimal Number Library Demonstration program                       */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2001.  All rights reserved.         */
+/* ----------------------------------------------------------------+- */
+/*                                                 right margin -->|  */
+
+// example4.c -- add two numbers, active error handling
+// Arguments are two numbers
+
+#define  DECNUMDIGITS 38           // work with up to 38 digits
+#include "decNumber.h"             // base number library
+#include <stdio.h>                 // for printf
+
+// [snip...
+#include <signal.h>                // signal handling
+#include <setjmp.h>                // setjmp/longjmp
+
+jmp_buf preserve;                  // stack snapshot
+
+void signalHandler(int);           // prototype for GCC
+void signalHandler(int sig) {
+  signal(SIGFPE, signalHandler);   // re-enable
+  longjmp(preserve, sig);          // branch to preserved point
+  }
+// ...snip]
+int main(int argc, char *argv[]) {
+  decNumber a, b;                  // working numbers
+  decContext set;                  // working context
+  char string[DECNUMDIGITS+14];    // conversion buffer
+  int value;                       // work variable
+
+  if (argc<3) {                    // not enough words
+    printf("Please supply two numbers to add.\n");
+    return 1;
+    }
+  decContextDefault(&set, DEC_INIT_BASE);    // initialize
+
+// [snip...
+  signal(SIGFPE, signalHandler);   // set up signal handler
+  value=setjmp(preserve);          // preserve and test environment
+  if (value) {                     // (non-0 after longjmp)
+    set.status &= DEC_Errors;      // keep only errors
+    printf("Signal trapped [%s].\n", decContextStatusToString(&set));
+    return 1;
+    }
+// ...snip]
+
+// [change from Example 1, here]
+  // leave traps enabled
+  set.digits=DECNUMDIGITS;         // set precision
+
+  decNumberFromString(&a, argv[1], &set);
+  decNumberFromString(&b, argv[2], &set);
+
+  decNumberAdd(&a, &a, &b, &set);            // A=A+B
+  decNumberToString(&a, string);
+
+  printf("%s + %s => %s\n", argv[1], argv[2], string);
+  return 0;
+  } // main
diff --git a/decNumber/example5.c b/decNumber/example5.c
new file mode 100644
index 00000000..5f89d8c3
--- /dev/null
+++ b/decNumber/example5.c
@@ -0,0 +1,36 @@
+/* ------------------------------------------------------------------ */
+/* Decimal Number Library Demonstration program                       */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2001, 2007.  All rights reserved.   */
+/* ----------------------------------------------------------------+- */
+/*                                                 right margin -->|  */
+
+// example5.c -- decimal64 conversions
+
+#include "decimal64.h"             // decimal64 and decNumber library
+#include <stdio.h>                 // for (s)printf
+
+int main(int argc, char *argv[]) {
+  decimal64 a;                     // working decimal64 number
+  decNumber d;                     // working number
+  decContext set;                  // working context
+  char string[DECIMAL64_String];   // number->string buffer
+  char hexes[25];                  // decimal64->hex buffer
+  int i;                           // counter
+
+  if (argc<2) {                    // not enough words
+    printf("Please supply a number.\n");
+    return 1;
+    }
+  decContextDefault(&set, DEC_INIT_DECIMAL64); // initialize
+
+  decimal64FromString(&a, argv[1], &set);
+  // lay out the decimal64 as eight hexadecimal pairs
+  for (i=0; i<8; i++) {
+    sprintf(&hexes[i*3], "%02x ", a.bytes[i]);
+    }
+  decimal64ToNumber(&a, &d);
+  decNumberToString(&d, string);
+  printf("%s => %s=> %s\n", argv[1], hexes, string);
+  return 0;
+  } // main
diff --git a/decNumber/example6.c b/decNumber/example6.c
new file mode 100644
index 00000000..486b9798
--- /dev/null
+++ b/decNumber/example6.c
@@ -0,0 +1,61 @@
+/* ------------------------------------------------------------------ */
+/* Decimal Number Library Demonstration program                       */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2001.  All rights reserved.         */
+/* ----------------------------------------------------------------+- */
+/*                                                 right margin -->|  */
+
+// example6.c -- calculate compound interest, using Packed Decimal
+// Values are investment, rate (%), and years
+
+#include "decPacked.h"             // base number library
+#include <stdio.h>                 // for printf
+
+int main(int argc, char *argv[]) {
+  { // excerpt for User's Guide starts here--------------------------|
+  decNumber one, mtwo, hundred;                   // constants
+  decNumber start, rate, years;                   // parameters
+  decNumber total;                                // result
+  decContext set;                                 // working context
+
+  uint8_t startpack[]={0x01, 0x00, 0x00, 0x0C};   // investment=100000
+  int32_t startscale=0;
+  uint8_t ratepack[]={0x06, 0x5C};                // rate=6.5%
+  int32_t ratescale=1;
+  uint8_t yearspack[]={0x02, 0x0C};               // years=20
+  int32_t yearsscale=0;
+  uint8_t respack[16];                            // result, packed
+  int32_t resscale;                               // ..
+  char  hexes[49];                                // for packed->hex
+  int   i;                                        // counter
+
+  if (argc<0) printf("%s", argv[1]);              // noop for warning
+
+  decContextDefault(&set, DEC_INIT_BASE);         // initialize
+  set.traps=0;                                    // no traps
+  set.digits=25;                                  // precision 25
+  decNumberFromString(&one,       "1", &set);     // set constants
+  decNumberFromString(&mtwo,     "-2", &set);
+  decNumberFromString(&hundred, "100", &set);
+
+  decPackedToNumber(startpack, sizeof(startpack), &startscale, &start);
+  decPackedToNumber(ratepack,  sizeof(ratepack),  &ratescale,  &rate);
+  decPackedToNumber(yearspack, sizeof(yearspack), &yearsscale, &years);
+
+  decNumberDivide(&rate, &rate, &hundred, &set);  // rate=rate/100
+  decNumberAdd(&rate, &rate, &one, &set);         // rate=rate+1
+  decNumberPower(&rate, &rate, &years, &set);     // rate=rate^years
+  decNumberMultiply(&total, &rate, &start, &set); // total=rate*start
+  decNumberRescale(&total, &total, &mtwo, &set);  // two digits please
+
+  decPackedFromNumber(respack, sizeof(respack), &resscale, &total);
+
+  // lay out the total as sixteen hexadecimal pairs
+  for (i=0; i<16; i++) {
+    sprintf(&hexes[i*3], "%02x ", respack[i]);
+    }
+  printf("Result: %s (scale=%ld)\n", hexes, (long int)resscale);
+
+  } //---------------------------------------------------------------|
+  return 0;
+  } // main
diff --git a/decNumber/example7.c b/decNumber/example7.c
new file mode 100644
index 00000000..cc933cad
--- /dev/null
+++ b/decNumber/example7.c
@@ -0,0 +1,35 @@
+/* ------------------------------------------------------------------ */
+/* Decimal Number Library Demonstration program                       */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2001, 2008.  All rights reserved.   */
+/* ----------------------------------------------------------------+- */
+/*                                                 right margin -->|  */
+
+// example7.c -- using decQuad to add two numbers together
+
+// compile: example7.c decContext.c decQuad.c
+
+#include "decQuad.h"               // decQuad library
+#include <stdio.h>                 // for printf
+
+int main(int argc, char *argv[]) {
+  decQuad a, b;                    // working decQuads
+  decContext set;                  // working context
+  char string[DECQUAD_String];     // number->string buffer
+
+  decContextTestEndian(0);         // warn if DECLITEND is wrong
+
+  if (argc<3) {                    // not enough words
+    printf("Please supply two numbers to add.\n");
+    return 1;
+    }
+  decContextDefault(&set, DEC_INIT_DECQUAD); // initialize
+
+  decQuadFromString(&a, argv[1], &set);
+  decQuadFromString(&b, argv[2], &set);
+  decQuadAdd(&a, &a, &b, &set);    // a=a+b
+  decQuadToString(&a, string);
+
+  printf("%s + %s => %s\n", argv[1], argv[2], string);
+  return 0;
+  } // main
diff --git a/decNumber/example8.c b/decNumber/example8.c
new file mode 100644
index 00000000..7fe35b95
--- /dev/null
+++ b/decNumber/example8.c
@@ -0,0 +1,39 @@
+/* ------------------------------------------------------------------ */
+/* Decimal Number Library Demonstration program                       */
+/* ------------------------------------------------------------------ */
+/* Copyright (c) IBM Corporation, 2001, 2007.  All rights reserved.   */
+/* ----------------------------------------------------------------+- */
+/*                                                 right margin -->|  */
+
+// example8.c -- using decQuad with the decNumber module
+
+// compile: example8.c decContext.c decQuad.c
+//     and: decNumber.c decimal128.c decimal64.c
+
+#include "decQuad.h"               // decQuad library
+#include "decimal128.h"            // interface to decNumber
+#include <stdio.h>                 // for printf
+
+int main(int argc, char *argv[]) {
+  decQuad a;                       // working decQuad
+  decNumber numa, numb;            // working decNumbers
+  decContext set;                  // working context
+  char string[DECQUAD_String];     // number->string buffer
+
+  if (argc<3) {                    // not enough words
+    printf("Please supply two numbers for power(2*a, b).\n");
+    return 1;
+    }
+  decContextDefault(&set, DEC_INIT_DECQUAD); // initialize
+
+  decQuadFromString(&a, argv[1], &set);      // get a
+  decQuadAdd(&a, &a, &a, &set);              // double a
+  decQuadToNumber(&a, &numa);                // convert to decNumber
+  decNumberFromString(&numb, argv[2], &set);
+  decNumberPower(&numa, &numa, &numb, &set); // numa=numa**numb
+  decQuadFromNumber(&a, &numa, &set);        // back via a Quad
+  decQuadToString(&a, string);               // ..
+
+  printf("power(2*%s, %s) => %s\n", argv[1], argv[2], string);
+  return 0;
+  } // main
diff --git a/decNumber/readme.txt b/decNumber/readme.txt
index adf7c657..375623f3 100644
--- a/decNumber/readme.txt
+++ b/decNumber/readme.txt
@@ -1,85 +1,81 @@
-This is the readme.txt for the decNumber package.  It includes
-instructions for compiling and testing the package; please read them.
----------------------------------------------------------------------
-
-decNumber is distributed in three forms; as a complete package from
-the IBM alphaWorks site (available under either a trial or a
-commercial license), as a complete package from the International
-Components for Unicode (ICU) site (under an as-is license), or as a
-collection of Open Source files from the GCC source repository (under
-the GPL license).
-
-If you are using the GCC files, you can obtain the documentation, the
-example files mentioned below, and this readme from:
-
-  http://www2.hursley.ibm.com/decimal/#decNumber
-
-(the URL for the open source files is also linked from there).
-
-
-The alphaWorks and ICU packages
--------------------------------
-
-The alphaWorks and ICU packages include the files:
-
-  *  readme.txt (this file)
-
-  *  alphaWorks-license-files.zip (contains the 90-day trial license, in
-     multiple languages), or ICU-license.html
-
-     Note: a commercial license for this code is also available by
-     following the 'License this technology' link from the alphaWorks
-     page: http://www.alphaWorks.ibm.com/tech/decnumber
-
-  *  decNumber.pdf (documentation)
-
-  *  The .c and .h file for each module in the package (see
-     documentation), decDPD.h (used by decimal32), and
-     decNumberLocal.h (local definitions)
-
-  *  The .c files for each of the examples (example1.c through
-     example6.c)
-
-The alphaWorks package is made available under the terms of the IBM
-alphaWorks License Agreement (included in various languages in the
-file alphaWorks-license-files.zip), unless you have agreed different
-licensing terms with IBM.  Your use of that package indicates your
-acceptance of the terms and conditions of that Agreement.
-
-The ICU package is made available under the terms of the ICU License
-(ICU 1.8.1 and later) included in the package as ICU-license.html.
-Your use of that package indicates your acceptance of the terms and
-conditions of that Agreement.
-
-
-
-To use and check decNumber
---------------------------
-
-  Please read the appropriate license and documentation before using
-  this package.
-
-  1. Compile and link example1.c, decNumber.c, and decContext.c
-     For example:
-
-       gcc -o example1 example1.c decNumber.c decContext.c
-
-     Note: If your compiler does not provide stdint.h or if your C
-     compiler does not handle line comments (// ...), then see the
-     User's Guide section in the documentation for further information
-     (including a suitable minimal stdint.h).
-
-  2. Run example1 with two numeric arguments, for example:
-
-       example1 1.23 1.27
-
-     this should display:
-
-       1.23 + 1.27 => 2.50
-
-  3. Similarly, try the other examples, at will.
-
-     Example 5 requires decimal64.c in addition to the core modules.
-
-     Example 6 requires decPacked.c in addition to the core modules.
-
+This is the readme.txt for the decNumber package.  It includes
+instructions for compiling and testing the package; please read them.
+---------------------------------------------------------------------
+
+decNumber is distributed in two forms; as a complete package from
+the International Components for Unicode (ICU) site (under an as-is
+license), or as a collection of Open Source files from the GCC source
+repository (under the GPL license).
+
+If you are using the GCC files, you can obtain the documentation, the
+example files mentioned below, and this readme from the General
+Decimal Arithmetic web page -- http://speleotrove.com/decimal/ (the
+URL for the open source files is also linked from there).
+
+
+The ICU package
+---------------
+
+The ICU package includes the files:
+
+  *  readme.txt (this file)
+
+  *  ICU-license.html
+
+  *  decNumber.pdf (documentation)
+
+  *  The .c and .h file for each module in the package (see the
+     decNumber documentation), together with other included files.
+
+  *  The .c files for each of the examples (example1.c through
+     example8.c).
+
+The ICU package is made available under the terms of the ICU License
+(ICU 1.8.1 and later) included in the package as ICU-license.html.
+Your use of that package indicates your acceptance of the terms and
+conditions of that Agreement.
+
+
+To use and check decNumber
+--------------------------
+
+  Please read the appropriate license and documentation before using
+  this package.  If you are upgrading an existing use of decNumber
+  (with version <= 3.37) please read the Changes Appendix for later
+  versions -- you may need to change the DECLITEND flag.
+
+  1. Compile and link example1.c, decNumber.c, and decContext.c
+     For instance, use:
+
+       gcc -o example1 example1.c decNumber.c decContext.c
+
+     Note: If your compiler does not provide stdint.h or if your C
+     compiler does not handle line comments (// ...), then see the
+     User's Guide section in the documentation for further information
+     (including a sample minimal stdint.h).
+
+     The use of compiler optimization is strongly recommended (e.g.,
+     -O3 for GCC or /O2 for Visual Studio).
+
+  2. Run example1 with two numeric arguments, for example:
+
+       example1 1.23 1.27
+
+     this should display:
+
+       1.23 + 1.27 => 2.50
+
+  3. Similarly, try the other examples, at will.
+
+     Examples 2->4 require three files to be compiled, like Example 1.
+
+     Example 5 requires decimal64.c in addition to the core modules.
+
+     Example 6 requires decPacked.c in addition to the core modules.
+
+     Example 7 requires only example7.c decContext.c and decQuad.c
+
+     Example 8 requires example8.c, decContext.c, and decQuad.c, plus
+               decNumber.c, decimal128.c, and decimal64.c (the latter
+               for shared tables and code)
+
diff --git a/decNumber_readme.txt b/decNumber_readme.txt
new file mode 100644
index 00000000..3b96813e
--- /dev/null
+++ b/decNumber_readme.txt
@@ -0,0 +1,65 @@
+This the upgrade of the decNumber package to the 3.68 level
+
+relevant urls
+
+for the general decimal arithmetic
+http://speleotrove.com/decimal/
+
+decNumber package documentation
+http://speleotrove.com/decimal/decnumber.html
+
+for the errata
+http://speleotrove.com/decimal/decnumerr.html
+
+quoting verbatim from the above
+A decNumber user has reported that Visual Studio 2010 (32 bit) has difficulty with compiling the decNumber source files.
+Here are his workarounds.
+http://speleotrove.com/decimal/decnumVS.html
+
+the workaround has been implemented using
+quoting verbatim from the above
+
+Method 2:
+In file: "decBasic.c"
+1. Change extension from .c to .h
+
+2. Add the following at the beginning of the code:
+#if !defined(DECBASIC)
+#define DECBASIC
+
+3. Add the following at the end of the code:
+#endif
+
+4. Replace the following line 2 lines
+#error decBasic.c must be included after decCommon.c
+#error Routines in decBasic.c are for decDouble and decQuad only
+with
+#error decBasic.h must be included after decCommon.h
+#error Routines in decBasic.h are for decDouble and decQuad only
+respectively.
+
+In file "decCommon.c"
+1. Change extension from .c to .h
+
+2. Add the following at the beginning of the code:
+#if !defined(DECCOMMON)
+#define DECCOMMON
+3. Add the following at the end of the code:
+#endif
+
+In the following files:
+decQuad.c
+decDouble.c
+decSingle.c
+
+replace lines:
+#include "decCommon.c"
+#include "decBasic.c"
+
+with
+#include "decCommon.h"
+#include "decBasic.h"
+
+as applicable.
+
+References to decCommon.c and decBasic.c in commentary should also be modified to refer to the corresponding .h.

From d60c6d6901dc413d79a4ca9dcd361aa976cdc007 Mon Sep 17 00:00:00 2001
From: Enrico Sorichetti <e.sorichetti@alice.it>
Date: Sat, 17 Mar 2012 21:08:30 +0100
Subject: [PATCH 09/16] rexx auto-magics

---
 cmdtab.h         |  34 ++-
 hRexx.c          | 618 ++++++++++++++++++++++++++++-------------------
 hRexx_o.c        | 391 ++++++++++++++++--------------
 hRexx_r.c        | 406 ++++++++++++++++---------------
 hRexx_readme.txt |  51 ++++
 5 files changed, 859 insertions(+), 641 deletions(-)

diff --git a/cmdtab.h b/cmdtab.h
index c01f3bed..49cc2783 100644
--- a/cmdtab.h
+++ b/cmdtab.h
@@ -996,24 +996,42 @@
 #define resume_cmd_desc         "Resume hercules"
 
 #if defined(ENABLE_OBJECT_REXX) || defined(ENABLE_REGINA_REXX)
+#if defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX)
 #define rexx_cmd_desc           "Enable/Disable/display Rexx interpreter settings"
 #define rexx_cmd_help           \
                                 \
-  "Format: 'rexx [option parms]'\n"                                                      \
+  "Format: 'rexx [option parms]'\n"                                              \
   "<none>           - display rexx status\n"                                     \
-  "Disa[ble]        - stop/disable rexx support\n"                               \
-  "Ena[ble] regina  - enable regina rexx\n"                                      \
-  "Ena[ble] oorexx  - enable open object rexx\n"                                 \
-  "Start/Stop can be used instead of Enable/Disable\n"                           \
+  "sta[rt]/ena[ble] - enable rexx \n"                                            \
+  "parms            - package name oorexx/regina\n"                              \
+  "                 - <none> will start/enable the default Rexx package\n"       \
+  "stop[p]/disa[ble]- stop/disable rexx support\n"                               \
+  "parms            - <none>\n"                                                  \
   "\n"                                                                           \
   "Path[s]          - where to find rexx scripts\n"                              \
   "Ext[ensions]     - what extensions to use for rexx scripts autodetect \n"     \
   "Suf[fixes]       - same as above\n"                                           \
-  "Msg[prefix]      - set the prefix for normal messages\n"                      \
-  "Err[prefix]      - set the prefix for error messages\n"                       \
+  "Msgl[evel]       - 0/1 disable/enable HHC17503I and HHC17504I messages \n"    \
+  "Msgp[refix]      - set the prefix for normal messages\n"                      \
+  "Errp[refix]      - set the prefix for trace/error messages\n"                 \
   "\n"                                                                           \
   "using reset as parameter will reset the above settings to the defaults\n"
-
+#else /* defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX) */
+#define rexx_cmd_desc           "display Rexx interpreter settings"
+#define rexx_cmd_help           \
+                                \
+  "Format: 'rexx [option parms]'\n"                                              \
+  "<none>           - display rexx status\n"                                     \
+  "\n"                                                                           \
+  "Path[s]          - where to find rexx scripts\n"                              \
+  "Ext[ensions]     - what extensions to use for rexx scripts autodetect \n"     \
+  "Suf[fixes]       - same as above\n"                                           \
+  "Msgl[evel]       - 0/1 disable/enable HHC17503I and HHC17504I messages \n"    \
+  "Msgp[refix]      - set the prefix for normal messages\n"                      \
+  "Errp[refix]      - set the prefix for trace/error messages\n"                 \
+  "\n"                                                                           \
+  "using reset as parameter will reset the above settings to the defaults\n"
+#endif /* defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX) */
 #endif /* defined(ENABLE_OBJECT_REXX) || defined(ENABLE_REGINA_REXX) */
 
 #define rmmod_cmd_desc          "Delete a module"
diff --git a/hRexx.c b/hRexx.c
index 3d83e7dc..add5322a 100644
--- a/hRexx.c
+++ b/hRexx.c
@@ -17,6 +17,51 @@
 #define _HREXX_C_
 
 #if defined(ENABLE_OBJECT_REXX) || defined(ENABLE_REGINA_REXX)
+#if defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX)
+
+#define REXX_TRY_OOREXX(_FOUND_) do \
+{ \
+    RexxPackage = OOREXX_PACKAGE; \
+    RexxDynamicLoader = &ObjectRexxDynamicLoader; \
+    RexxRegisterHandlers = &ObjectRexxRegisterHandlers; \
+    RexxExecCmd = &ObjectRexxExecCmd; \
+    RexxExecInstoreCmd = &ObjectRexxExecInstoreCmd; \
+    rc = (*RexxDynamicLoader)(); \
+    if ( rc == 0 ) \
+    { \
+        RexxStatus = _WAITING_ ;\
+        WRMSG( HHC17525, "I", RexxPackage); \
+        goto _FOUND_ ; \
+    } \
+} while(0) ;
+
+#define REXX_TRY_REGINA(_FOUND_) do \
+{ \
+    RexxPackage = REGINA_PACKAGE; \
+    RexxDynamicLoader = &ReginaRexxDynamicLoader; \
+    RexxRegisterHandlers = &ReginaRexxRegisterHandlers; \
+    RexxExecCmd = &ReginaRexxExecCmd; \
+    RexxExecInstoreCmd = &ReginaRexxExecInstoreCmd; \
+    rc = (*RexxDynamicLoader)(); \
+    if ( rc == 0 ) \
+    { \
+        RexxStatus = _WAITING_ ;\
+        WRMSG( HHC17525, "I", RexxPackage); \
+        goto _FOUND_ ; \
+    } \
+} while(0) ;
+
+#define SETREXX_RESET() do \
+{ \
+    RexxPackage = ""; \
+    RexxDynamicLoader = NULL; \
+    RexxRegisterHandlers = NULL; \
+    RexxExecCmd = NULL; \
+    RexxExecInstoreCmd = NULL; \
+    RexxStatus = _STOPPED_ ; \
+} while (0) ;
+
+#endif /* defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX) */
 
 #include "hRexx.h"
 
@@ -39,35 +84,35 @@ int ReginaRexxExecCmd();
 int ReginaRexxExecInstoreCmd();
 #endif
 
-void *hRexxLibHandle = NULL ;       /* Library handle */
-void *hRexxApiLibHandle = NULL ;     /* Api Library handle */
+void *hRexxLibHandle = NULL;       /* Library handle */
+void *hRexxApiLibHandle = NULL;     /* Api Library handle */
 
 #if defined(ENABLE_OBJECT_REXX)  && !defined(ENABLE_REGINA_REXX)
 char *RexxPackage = OOREXX_PACKAGE;
 char *RexxLibrary = OOREXX_LIBRARY;
 char *RexxApiLibrary = OOREXX_API_LIBRARY;
-int (*RexxDynamicLoader)() = &ObjectRexxDynamicLoader ;
-int (*RexxRegisterHandlers)() = &ObjectRexxRegisterHandlers ;
-int (*RexxExecCmd)() = &ObjectRexxExecCmd ;
-int (*RexxExecInstoreCmd)() = &ObjectRexxExecInstoreCmd ;
+int (*RexxDynamicLoader)() = &ObjectRexxDynamicLoader;
+int (*RexxRegisterHandlers)() = &ObjectRexxRegisterHandlers;
+int (*RexxExecCmd)() = &ObjectRexxExecCmd;
+int (*RexxExecInstoreCmd)() = &ObjectRexxExecInstoreCmd;
 
 #elif !defined(ENABLE_OBJECT_REXX) &&  defined(ENABLE_REGINA_REXX)
 char *RexxPackage = REGINA_PACKAGE;
 char *RexxLibrary = REGINA_LIBRARY;
 char *RexxApiLibrary = "";
-int (*RexxDynamicLoader)() = &ReginaRexxDynamicLoader ;
-int (*RexxRegisterHandlers)() = &ReginaRexxRegisterHandlers ;
-int (*RexxExecCmd)() = &ReginaRexxExecCmd ;
-int (*RexxExecInstoreCmd)() = &ReginaRexxExecInstoreCmd ;
+int (*RexxDynamicLoader)() = &ReginaRexxDynamicLoader;
+int (*RexxRegisterHandlers)() = &ReginaRexxRegisterHandlers;
+int (*RexxExecCmd)() = &ReginaRexxExecCmd;
+int (*RexxExecInstoreCmd)() = &ReginaRexxExecInstoreCmd;
 
 #else
-char *RexxPackage = "" ;
-char *RexxLibrary = "" ;
+char *RexxPackage = "";
+char *RexxLibrary = "";
 char *RexxApiLibrary = "";
-int (*RexxDynamicLoader)() = NULL ;
-int (*RexxRegisterHandlers)() = NULL ;
-int (*RexxExecCmd)() = NULL ;
-int (*RexxExecInstoreCmd)() = NULL ;
+int (*RexxDynamicLoader)() = NULL;
+int (*RexxRegisterHandlers)() = NULL;
+int (*RexxExecCmd)() = NULL;
+int (*RexxExecInstoreCmd)() = NULL;
 
 #endif
 
@@ -77,51 +122,58 @@ char *RexxPathsArray[32];
 int   RexxPathsCount=0;
 
 int   RexxExtensionsInitialized=FALSE;
-char *RexxExtensions = NULL ;
+char *RexxExtensions = NULL;
 char *RexxExtensionsArray[32];
 int   RexxExtensionsCount=0;
 
+int   MessageLevel;
 char *MessagePrefix;
-char *TracePrefix;
+char *ErrorPrefix;
+
+
+#define _WAITING_ 0
+#define _STOPPED_ 1
+int   RexxStatus = _WAITING_ ;
 
 /*-------------------------------------------------------------------*/
 /* rexx Command - manage the Rexx environment                        */
 /*-------------------------------------------------------------------*/
 int rexx_cmd(int argc, char *argv[], char *CommandLine)
 {
-char *ARGSDESC[] = {"", "Start/Enable", "Paths", "Extensions", "MsgPrefix", "ErrPrefix"} ;
-char *PACKAGES[] = {"", "ooRexx", "Regina" } ;
-
-#define _MINARGLEN 3
+char *ARGSDESC[] = {"", "Paths", "Extensions", "MsgLevel", "MsgPrefix", "ErrPrefix", "Start/Enable"};
+char *PACKAGES[] = {"", "ooRexx", "Regina" };
 
-#define _NEEDPACKAGE 1
-#define _NEEDPATHS 2
-#define _NEEDEXTNS 3
+#define _NEEDPATHS 1
+#define _NEEDEXTNS 2
+#define _NEEDMSGLEVL 3
 #define _NEEDMSGPREF 4
 #define _NEEDERRPREF 5
+#define _NEEDPACKAGE 6
 
 int   i;
 int   rc = 0;
 short RetRC = 0;
 char  Result[1024];
-char *ptr;
-
+char *ptr,*nxt;
+char temp[33];
 int  iarg,argl;
 
 int  whatValue   = 0;
 
-int  haveStop  = FALSE ;
-int  haveStart = FALSE ;
-int  havePaths = FALSE ;
-int  haveExtns = FALSE ;
-int  haveMsgPref = FALSE ;
-int  haveErrPref = FALSE ;
+int  haveStop  = FALSE;
+int  havePaths = FALSE;
+int  haveExtns = FALSE;
+int  haveMsgLevl= FALSE;
+int  haveMsgPref = FALSE;
+int  haveErrPref = FALSE;
+int  haveStart = FALSE;
 
-char *wPackage  = NULL;
 char *wPaths = NULL;
 char *wExtns = NULL;
+int   wMsgLevl = 0;
 char *wMsgPref = NULL;
 char *wErrPref = NULL;
+char *wPackage  = NULL;
 
     UNREFERENCED(argc);
     UNREFERENCED(argv);
@@ -143,27 +195,35 @@ char *wErrPref = NULL;
         {
             switch ( whatValue )
             {
-                case _NEEDPACKAGE :
+                case _NEEDPATHS :
                 {
-                    if ( strcasecmp( argv[iarg], REGINA_PACKAGE) == 0 || strcasecmp( argv[iarg], OOREXX_PACKAGE) == 0 )
-                        wPackage = strdup(argv[iarg]) ;
-                    else
-                    {
-                        WRMSG( HHC17509, "W", RexxPackage, argv[iarg], ARGSDESC[_NEEDPACKAGE]);
-                        return -1;
-                    }
+                    wPaths = strdup(argv[iarg]);
                 }
                 break;
 
-                case _NEEDPATHS :
+                case _NEEDEXTNS :
                 {
-                    wPaths = strdup(argv[iarg]) ;
+                    wExtns = strdup(argv[iarg]);
                 }
                 break;
 
-                case _NEEDEXTNS :
+                case _NEEDMSGLEVL :
                 {
-                    wExtns = strdup(argv[iarg]) ;
+                    if ( strcasecmp( argv[iarg], "reset") == 0 )
+                    {
+                        wMsgLevl = 0;
+                    }
+                    else
+                    {
+                        ptr = argv[iarg];
+                        errno = 0;
+                        wMsgLevl = (int) strtoul(argv[iarg],&nxt,10);
+                        if (errno != 0 || nxt == ptr || *nxt != 0 || ( wMsgLevl < 0 || wMsgLevl > 9 ) )
+                        {
+                            WRMSG( HHC17510, "W", RexxPackage, argv[iarg], strlen(argv[iarg]), ARGSDESC[_NEEDMSGLEVL]);
+                            return -1;
+                        }
+                    }
                 }
                 break;
 
@@ -172,9 +232,9 @@ char *wErrPref = NULL;
                     if ( strlen(argv[iarg]) > 9 )
                     {
                         WRMSG( HHC17510, "W", RexxPackage, argv[iarg], strlen(argv[iarg]), ARGSDESC[_NEEDMSGPREF]);
-                        return -1 ;
+                        return -1;
                     }
-                    wMsgPref = strdup(argv[iarg]) ;
+                    wMsgPref = strdup(argv[iarg]);
                 }
                 break;
 
@@ -183,9 +243,21 @@ char *wErrPref = NULL;
                     if ( strlen(argv[iarg]) > 9 )
                     {
                         WRMSG( HHC17510, "W", RexxPackage, argv[iarg], strlen(argv[iarg]), ARGSDESC[_NEEDERRPREF]);
-                        return -1 ;
+                        return -1;
+                    }
+                    wErrPref = strdup(argv[iarg]);
+                }
+                break;
+
+                case _NEEDPACKAGE :
+                {
+                    if ( strcasecmp( argv[iarg], REGINA_PACKAGE) == 0 || strcasecmp( argv[iarg], OOREXX_PACKAGE) == 0 )
+                        wPackage = strdup(argv[iarg]);
+                    else
+                    {
+                        WRMSG( HHC17509, "W", RexxPackage, argv[iarg], ARGSDESC[_NEEDPACKAGE]);
+                        return -1;
                     }
-                    wErrPref = strdup(argv[iarg]) ;
                 }
                 break;
 
@@ -194,83 +266,91 @@ char *wErrPref = NULL;
             continue;
         }
 
-        if ( !haveStart && !haveStop &&
-             ( ( argl >= _MINARGLEN && argl <= 5 && strncasecmp("start",  argv[iarg], argl) == 0 ) ||
-               ( argl >= _MINARGLEN && argl <= 6 && strncasecmp("enable", argv[iarg], argl) == 0 ) ))
+        if ( !haveStop &&
+             ( ( argl >= 3 && argl <= 4 && strncasecmp("stop",    argv[iarg], argl) == 0 ) ||
+               ( argl >= 3 && argl <= 7 && strncasecmp("disable", argv[iarg], argl) == 0 ) ))
         {
 #if defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX)
-            if ( hRexxLibHandle )
-            {
-                WRMSG( HHC17522, "I", RexxPackage);
-                return -1;
-            }
-            haveStart= TRUE;
-            whatValue = _NEEDPACKAGE;
-            continue ;
-#else
-        WRMSG( HHC17523, "I", RexxPackage);
-        return -1;
-#endif
-        }
-
-        if ( !haveStart && !haveStop &&
-             ( ( argl >= _MINARGLEN && argl <= 4 && strncasecmp("stop",    argv[iarg], argl) == 0 ) ||
-               ( argl >= _MINARGLEN && argl <= 7 && strncasecmp("disable", argv[iarg], argl) == 0 ) ))
-        {
-#if defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX)
-            if ( !hRexxLibHandle )
-            {
-                WRMSG( HHC17521, "I", "");
-                return 0;
-            }
             haveStop= TRUE;
-            continue ;
-#else
-        WRMSG( HHC17524, "I", RexxPackage);
-        return 0;
-#endif
+            continue;
+#else  /* defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX) */
+            WRMSG( HHC17524, "I", RexxPackage);
+            return 0;
+#endif /* defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX) */
         }
 
-        if ( !havePaths && argl >= _MINARGLEN && argl <= 5 &&
-            strncasecmp("paths", argv[iarg], argl) == 0 )
+        if ( !havePaths &&
+             ( argl >= 4 && argl <= 5 && strncasecmp("paths", argv[iarg], argl) == 0 ) )
         {
             havePaths= TRUE;
             whatValue = _NEEDPATHS;
-            continue ;
+            continue;
         }
 
         if ( !haveExtns &&
-             ( ( argl >= _MINARGLEN && argl <=  8 && strncasecmp("suffixes",   argv[iarg], argl) == 0 ) ||
-               ( argl >= _MINARGLEN && argl <= 10 && strncasecmp("extensions", argv[iarg], argl) == 0 ) ) )
+             ( ( argl >= 3 && argl <=  8 && strncasecmp("suffixes",   argv[iarg], argl) == 0 ) ||
+               ( argl >= 3 && argl <= 10 && strncasecmp("extensions", argv[iarg], argl) == 0 ) ) )
         {
             haveExtns= TRUE;
             whatValue = _NEEDEXTNS;
-            continue ;
+            continue;
+        }
+
+        if ( !haveMsgLevl &&
+             ( argl >= 4 && argl <= 10 && strncasecmp("msglevel", argv[iarg], argl) == 0 ) )
+        {
+            haveMsgLevl= TRUE;
+            whatValue = _NEEDMSGLEVL;
+            continue;
         }
 
-        if ( !haveMsgPref && argl >= _MINARGLEN && argl <=  9 &&
-             strncasecmp("msgprefix", argv[iarg], argl) == 0  )
+        if ( !haveMsgPref &&
+             ( argl >= 4 && argl <=  9 && strncasecmp("msgprefix", argv[iarg], argl) == 0 ) )
         {
             haveMsgPref= TRUE;
             whatValue = _NEEDMSGPREF;
-            continue ;
+            continue;
         }
-        if ( !haveErrPref && argl >= _MINARGLEN && argl <=  9 &&
-             ( strncasecmp("trcprefix", argv[iarg], argl) == 0 || strncasecmp("errprefix", argv[iarg], argl) == 0 ) )
+
+        if ( !haveErrPref &&
+             ( argl >= 4 && argl <=  9 && strncasecmp("errprefix", argv[iarg], argl) == 0 ) )
         {
             haveErrPref= TRUE;
             whatValue = _NEEDERRPREF;
-            continue ;
+            continue;
+        }
+
+        if ( !haveStart &&
+             ( ( argl >= 3 && argl <= 5 && strncasecmp("start",  argv[iarg], argl) == 0 ) ||
+               ( argl >= 3 && argl <= 6 && strncasecmp("enable", argv[iarg], argl) == 0 ) ) )
+        {
+#if defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX)
+            if ( hRexxLibHandle )
+            {
+                WRMSG( HHC17522, "I", RexxPackage);
+                return -1;
+            }
+            haveStart= TRUE;
+            whatValue = _NEEDPACKAGE;
+            continue;
+#else /* defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX) */
+            WRMSG( HHC17523, "I", RexxPackage);
+            return 0;
+#endif /* defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX) */
         }
 
         WRMSG( HHC17508, "W", RexxPackage, argv[iarg], iarg + 1 );
-        return -1 ;
+        return 0;
     }
 
-    if ( whatValue > 0 )
+    if ( whatValue == _NEEDPACKAGE )
+    {
+        wPackage = "auto";
+    }
+    else if ( whatValue > 0 )
     {
         WRMSG( HHC17507, "W", RexxPackage, ARGSDESC[whatValue] );
-        return -1 ;
+        return -1;
     }
 
 #if defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX)
@@ -282,31 +362,36 @@ char *wErrPref = NULL;
         if  ( hRexxApiLibHandle )
             HDLCLOSE( hRexxApiLibHandle);
 
+        RexxStatus = _STOPPED_ ;
+
+        SETREXX_RESET()
+
         WRMSG( HHC17526, "I", RexxPackage);
-        RexxPackage = "" ;
-        RexxDynamicLoader = NULL ;
-        RexxRegisterHandlers = NULL ;
-        RexxExecCmd = NULL ;
-        RexxExecInstoreCmd = NULL ;
+
     }
-#endif
+#endif /* defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX) */
 
     if ( havePaths )
     {
         if ( strcasecmp("reset", wPaths) == 0 )
         {
-            InitializeRexxPaths(NULL) ;
+            InitializeRexxPaths(NULL);
         }
         else
-            InitializeRexxPaths(wPaths) ;
+            InitializeRexxPaths(wPaths);
     }
 
     if ( haveExtns )
     {
         if ( strcasecmp("reset", wExtns) == 0 )
-            InitializeRexxExtensions(NULL) ;
+            InitializeRexxExtensions(NULL);
         else
-            InitializeRexxExtensions(wExtns) ;
+            InitializeRexxExtensions(wExtns);
+    }
+
+    if ( haveMsgLevl )
+    {
+        MessageLevel = wMsgLevl;
     }
 
     if ( haveMsgPref )
@@ -316,12 +401,12 @@ char *wErrPref = NULL;
             if ( MessagePrefix )
             {
                 free(MessagePrefix);
-                MessagePrefix = NULL ;
+                MessagePrefix = NULL;
             }
         }
         else
         {
-            MessagePrefix = strdup(wMsgPref) ;
+            MessagePrefix = strdup(wMsgPref);
         }
         free(wMsgPref);
     }
@@ -330,15 +415,15 @@ char *wErrPref = NULL;
     {
         if ( strcasecmp("reset", wErrPref) == 0 )
         {
-            if ( TracePrefix )
+            if ( ErrorPrefix )
             {
-                free(TracePrefix);
-                TracePrefix = NULL ;
+                free(ErrorPrefix);
+                ErrorPrefix = NULL;
             }
         }
         else
         {
-            TracePrefix = strdup(wErrPref) ;
+            ErrorPrefix = strdup(wErrPref);
         }
         free(wErrPref);
     }
@@ -346,110 +431,119 @@ char *wErrPref = NULL;
 #if defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX)
     if ( haveStart )
     {
-        if ( strcasecmp(wPackage, OOREXX_PACKAGE ) == 0  )
-        {
-            RexxPackage = OOREXX_PACKAGE ;
-            RexxDynamicLoader = &ObjectRexxDynamicLoader ;
-            RexxRegisterHandlers = &ObjectRexxRegisterHandlers ;
-            RexxExecCmd = &ObjectRexxExecCmd ;
-            RexxExecInstoreCmd = &ObjectRexxExecInstoreCmd ;
-        }
-        else if ( strcasecmp(wPackage, REGINA_PACKAGE ) == 0  )
+        if ( strcasecmp(wPackage, "auto" ) == 0  )
         {
-            RexxPackage = REGINA_PACKAGE ;
-            RexxDynamicLoader = &ReginaRexxDynamicLoader ;
-            RexxRegisterHandlers = &ReginaRexxRegisterHandlers ;
-            RexxExecCmd = &ReginaRexxExecCmd ;
-            RexxExecInstoreCmd = &ReginaRexxExecInstoreCmd ;
+            char *envvar;
+
+            if ( !( envvar = getenv("HREXX_PACKAGE") ) )
+            {
+                REXX_TRY_OOREXX( Start_Rexx_Loaded )
+                REXX_TRY_REGINA( Start_Rexx_Loaded )
+                SETREXX_RESET()
+                RexxStatus = _STOPPED_ ;
+                WRMSG( HHC17526, "I", RexxPackage);
+            }
+            if ( strcasecmp(envvar, "auto" ) == 0 )
+            {
+                REXX_TRY_OOREXX( Start_Rexx_Loaded )
+                REXX_TRY_REGINA( Start_Rexx_Loaded )
+                SETREXX_RESET()
+                RexxStatus = _STOPPED_ ;
+                WRMSG( HHC17526, "I", RexxPackage);
+            }
+
+            if ( strcasecmp(envvar, "none" ) == 0 )
+            {
+                WRMSG( HHC17521, "I", "");
+                return 0;
+            }
+
+            wPackage = envvar ;
 
-        }
-        else
-        {
-            WRMSG( HHC17501, "E", RexxPackage,"Oh shit, I should not be here");
-            return -1;
         }
 
-        rc = (*RexxDynamicLoader)() ;
-        if ( rc == 0 )
+        if ( strcasecmp(wPackage, OOREXX_PACKAGE ) == 0  )
         {
-            WRMSG( HHC17525, "I", RexxPackage);
+            REXX_TRY_OOREXX( Start_Rexx_Loaded )
+            SETREXX_RESET()
+            RexxStatus = _STOPPED_ ;
+            WRMSG( HHC17526, "I", RexxPackage);
+            return -1 ;
         }
-        else
+        if ( strcasecmp(wPackage, REGINA_PACKAGE ) == 0  )
         {
-            RexxPackage = "" ;
-            RexxDynamicLoader = NULL ;
-            RexxRegisterHandlers = NULL ;
-            RexxExecCmd = NULL ;
-            RexxExecInstoreCmd = NULL ;
+            REXX_TRY_REGINA( Start_Rexx_Loaded )
+            SETREXX_RESET()
+            RexxStatus = _STOPPED_ ;
+            WRMSG( HHC17526, "I", RexxPackage);
+            return -1 ;
         }
+
+        WRMSG( HHC17501, "E", wPackage, "Oh shit, I should not be here");
+        return -1;
+
     }
-#endif
+Start_Rexx_Loaded:
+#endif /* defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX) */
 
     if ( !RexxPathsInitialized )
-        InitializeRexxPaths(NULL) ;
+        InitializeRexxPaths(NULL);
     strcpy(Result,"Paths: " );
     for (i=0;i<RexxPathsCount;i++)
     {
         strcat(Result,RexxPathsArray[i]);
         strcat(Result,i == RexxPathsCount-1 ? "" : PATHDELIM );
     }
-    WRMSG( HHC17500, "I", RexxPackage,Result) ;
+    WRMSG( HHC17500, "I", RexxPackage,Result);
 
     if ( !RexxExtensionsInitialized )
-        InitializeRexxExtensions(NULL) ;
+        InitializeRexxExtensions(NULL);
     strcpy(Result,"Extensions: ");
     for (i=0;i<RexxExtensionsCount;i++)
     {
         strcat(Result,RexxExtensionsArray[i]);
         strcat(Result,i == RexxExtensionsCount-1 ? "" : EXTNDELIM );
     }
-    WRMSG( HHC17500, "I", RexxPackage,Result) ;
+    WRMSG( HHC17500, "I", RexxPackage,Result);
 
+    strcpy(Result,"Msg Level : ");
+    sprintf(temp,"%d",MessageLevel);
+    strcat(Result,temp);
+    WRMSG( HHC17500, "I", RexxPackage,Result);
+
+    strcpy(Result,"Msg Prefix: ");
     if ( MessagePrefix )
-    {
-        strcpy(Result,"Msg Prefix: ");
         strcat(Result,MessagePrefix);
-        WRMSG( HHC17500, "I", RexxPackage,Result) ;
-    }
-    else
-    {
-        WRMSG( HHC17500, "I", RexxPackage,"Msg Prefix: (OFF)") ;
-    }
-    if ( TracePrefix )
-    {
-        strcpy(Result,"Err Prefix: ");
-        strcat(Result,TracePrefix);
-        WRMSG( HHC17500, "I", RexxPackage,Result) ;
-    }
     else
-    {
-        WRMSG( HHC17500, "I", RexxPackage,"Err Prefix: (OFF)") ;
-    }
+        strcat(Result,"(OFF)");
+    WRMSG( HHC17500, "I", RexxPackage,Result);
 
+    strcpy(Result,"Err Prefix: ");
+    if ( ErrorPrefix )
+        strcat(Result,ErrorPrefix);
+    else
+        strcat(Result,"(OFF)");
+    WRMSG( HHC17500, "I", RexxPackage,Result);
 
 #if defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX)
-    if ( !hRexxLibHandle )
+    if ( RexxStatus == _STOPPED_ )
     {
-        char *envvar ;
-        if ( !(envvar = getenv("HREXX_PACKAGE")) )
-        {
-            WRMSG( HHC17521, "I",RexxPackage);
-            return -1;
-        }
+        WRMSG( HHC17521, "I","");
+        return -1;
     }
-#endif
+#endif /* defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX) */
 
     rc = exec_instore_cmd("parse version _v;parse source  _s;return _v || '0a'x || _s;\n",Result);
     if  ( rc == 0 )
     {
         for (ptr = strtok(Result,"\n"); ptr; ptr = strtok(NULL, "\n"))
         {
-            WRMSG( HHC17500, "I", RexxPackage, ptr) ;
+            WRMSG( HHC17500, "I", RexxPackage, ptr);
         }
     }
     else
     {
-        WRMSG( HHC17501, "I", RexxPackage, "Unexpected RC from instore script") ;
+        WRMSG( HHC17501, "I", RexxPackage, "Unexpected RC from instore script");
     }
 
     return 0;
@@ -462,13 +556,13 @@ char *wErrPref = NULL;
 int exec_cmd(int argc, char *argv[], char *CommandLine)
 {
 int   iarg,argl;
-int   rc=0 ;
+int   rc=0;
 short RetRC = 0;
-int   iPath,iExtn ;
+int   iPath,iExtn;
 int   haveResolvedCommand = FALSE;
 
 char  wCommand[1024];
-char *wArgs ;
+char *wArgs;
 
     UNREFERENCED(rc);
     UNREFERENCED(RetRC);
@@ -476,55 +570,62 @@ char *wArgs ;
 
 #if defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX)
 
+    if ( RexxStatus == _STOPPED_ )
+    {
+        WRMSG( HHC17521, "I", "");
+        return -1 ;
+    }
     if ( !hRexxLibHandle )
     {
-        char *envvar ;
-        if ( !(envvar = getenv("HREXX_PACKAGE")) )
+        char *envvar;
+        if ( !( envvar = getenv("HREXX_PACKAGE") ) )
         {
-            WRMSG( HHC17521, "I",RexxPackage);
-            return -1;
+            REXX_TRY_OOREXX( exec_cmd_Rexx_Loaded )
+            REXX_TRY_REGINA( exec_cmd_Rexx_Loaded )
+            SETREXX_RESET()
+            RexxStatus = _STOPPED_ ;
+            WRMSG( HHC17526, "I", RexxPackage);
         }
-
-        if ( strcasecmp(envvar, OOREXX_PACKAGE ) == 0  )
+        if ( strcasecmp(envvar, "auto" ) == 0 )
         {
-            RexxPackage = OOREXX_PACKAGE ;
-            RexxDynamicLoader = &ObjectRexxDynamicLoader ;
-            RexxRegisterHandlers = &ObjectRexxRegisterHandlers ;
-            RexxExecCmd = &ObjectRexxExecCmd ;
-            RexxExecInstoreCmd = &ObjectRexxExecInstoreCmd ;
+            REXX_TRY_OOREXX( exec_cmd_Rexx_Loaded )
+            REXX_TRY_REGINA( exec_cmd_Rexx_Loaded )
+            SETREXX_RESET()
+            RexxStatus = _STOPPED_ ;
+            WRMSG( HHC17526, "I", RexxPackage);
         }
-        else if ( strcasecmp(envvar, REGINA_PACKAGE ) == 0  )
+        if ( strcasecmp(envvar, "none" ) == 0 )
         {
-            RexxPackage = REGINA_PACKAGE ;
-            RexxDynamicLoader = &ReginaRexxDynamicLoader ;
-            RexxRegisterHandlers = &ReginaRexxRegisterHandlers ;
-            RexxExecCmd = &ReginaRexxExecCmd ;
-            RexxExecInstoreCmd = &ReginaRexxExecInstoreCmd ;
-
+            SETREXX_RESET()
+            RexxStatus = _STOPPED_ ;
+            WRMSG( HHC17521, "I", "");
+            return 0;
         }
-        else
+        if ( strcasecmp(envvar, OOREXX_PACKAGE ) == 0  )
         {
-            WRMSG( HHC17501, "E", envvar,"Unknown REXX Package");
-            return -1;
+            REXX_TRY_OOREXX( exec_cmd_Rexx_Loaded )
+            SETREXX_RESET()
+            RexxStatus = _STOPPED_ ;
+            WRMSG( HHC17526, "I", RexxPackage);
         }
-
-        rc = (*RexxDynamicLoader)() ;
-        if ( rc == 0 )
+        else if ( strcasecmp(envvar, REGINA_PACKAGE ) == 0  )
         {
-            WRMSG( HHC17527, "I", RexxPackage);
+            REXX_TRY_REGINA( exec_cmd_Rexx_Loaded )
+            SETREXX_RESET()
+            RexxStatus = _STOPPED_ ;
+            WRMSG( HHC17526, "I", RexxPackage);
         }
         else
         {
-            RexxPackage = "" ;
-            RexxDynamicLoader = NULL ;
-            RexxRegisterHandlers = NULL ;
-            RexxExecCmd = NULL ;
-            RexxExecInstoreCmd = NULL ;
+            SETREXX_RESET()
+            RexxStatus = _STOPPED_ ;
+            WRMSG( HHC17501, "E", envvar,"Unknown REXX Package");
             return -1;
         }
 
     }
-#endif
+exec_cmd_Rexx_Loaded:
+#endif /* defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX) */
 
     if (argc < 2)
     {
@@ -539,21 +640,21 @@ char *wArgs ;
     if ( access(wCommand, R_OK ) == 0 )
     {
         haveResolvedCommand = TRUE;
-        goto endResolver ;
+        goto endResolver;
     }
 
     if (strcmp(basename(wCommand),wCommand) != 0)
-        goto endResolver ;
+        goto endResolver;
 
     if ( !RexxPathsInitialized )
-        InitializeRexxPaths(NULL) ;
+        InitializeRexxPaths(NULL);
     if ( !RexxExtensionsInitialized )
-        InitializeRexxExtensions(NULL) ;
+        InitializeRexxExtensions(NULL);
 
     for( iPath = 0;iPath<RexxPathsCount;iPath++)
     {
         if ( access( RexxPathsArray[iPath], R_OK ) != 0 )
-            continue ;
+            continue;
 
         sprintf(wCommand, PATHFORMAT, RexxPathsArray[iPath], argv[1],"");
         if ( access(wCommand, R_OK ) == 0)
@@ -596,7 +697,7 @@ char *wArgs ;
         }
     }
     else
-        wArgs = NULL ;
+        wArgs = NULL;
 
     return (*RexxExecCmd)(wCommand, wArgs, argc, argv);
 
@@ -607,62 +708,69 @@ char *wArgs ;
 /*-------------------------------------------------------------------*/
 int exec_instore_cmd( char *Command,  char *Result)
 {
-int rc=0 ;
-short RetRC=0 ;
-    UNREFERENCED(rc) ;
-    UNREFERENCED(RetRC) ;
+int rc=0;
+short RetRC=0;
+    UNREFERENCED(rc);
+    UNREFERENCED(RetRC);
 
 #if defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX)
 
+    if ( RexxStatus == _STOPPED_ )
+    {
+        WRMSG( HHC17521, "I", "");
+        return -1 ;
+    }
     if ( !hRexxLibHandle )
     {
-        char *envvar ;
-        if ( !(envvar = getenv("HREXX_PACKAGE")) )
+        char *envvar;
+        if ( !( envvar = getenv("HREXX_PACKAGE") ) )
         {
-            WRMSG( HHC17521, "I",RexxPackage);
-            return -1;
+            REXX_TRY_OOREXX( exec_instore_cmd_Rexx_Loaded )
+            REXX_TRY_REGINA( exec_instore_cmd_Rexx_Loaded )
+            SETREXX_RESET()
+            RexxStatus = _STOPPED_ ;
+            WRMSG( HHC17526, "I", RexxPackage);
         }
-
-        if ( strcasecmp(envvar, OOREXX_PACKAGE ) == 0  )
+        if ( strcasecmp(envvar, "auto" ) == 0 )
         {
-            RexxPackage = OOREXX_PACKAGE ;
-            RexxDynamicLoader = &ObjectRexxDynamicLoader ;
-            RexxRegisterHandlers = &ObjectRexxRegisterHandlers ;
-            RexxExecCmd = &ObjectRexxExecCmd ;
-            RexxExecInstoreCmd = &ObjectRexxExecInstoreCmd ;
+            REXX_TRY_OOREXX( exec_instore_cmd_Rexx_Loaded )
+            REXX_TRY_REGINA( exec_instore_cmd_Rexx_Loaded )
+            SETREXX_RESET()
+            RexxStatus = _STOPPED_ ;
+            WRMSG( HHC17526, "I", RexxPackage);
         }
-        else if ( strcasecmp(envvar, REGINA_PACKAGE ) == 0  )
+        if ( strcasecmp(envvar, "none" ) == 0 )
         {
-            RexxPackage = REGINA_PACKAGE ;
-            RexxDynamicLoader = &ReginaRexxDynamicLoader ;
-            RexxRegisterHandlers = &ReginaRexxRegisterHandlers ;
-            RexxExecCmd = &ReginaRexxExecCmd ;
-            RexxExecInstoreCmd = &ReginaRexxExecInstoreCmd ;
-
+            SETREXX_RESET()
+            RexxStatus = _STOPPED_ ;
+            WRMSG( HHC17521, "I", "");
+            return 0;
         }
-        else
+        if ( strcasecmp(envvar, OOREXX_PACKAGE ) == 0  )
         {
-            WRMSG( HHC17501, "E", envvar,"Unknown REXX Package");
-            return -1;
+            REXX_TRY_OOREXX( exec_instore_cmd_Rexx_Loaded )
+            SETREXX_RESET()
+            RexxStatus = _STOPPED_ ;
+            WRMSG( HHC17526, "I", RexxPackage);
         }
-
-        rc = (*RexxDynamicLoader)() ;
-        if ( rc == 0 )
+        else if ( strcasecmp(envvar, REGINA_PACKAGE ) == 0  )
         {
-            WRMSG( HHC17527, "I", RexxPackage);
+            REXX_TRY_REGINA( exec_instore_cmd_Rexx_Loaded )
+            SETREXX_RESET()
+            RexxStatus = _STOPPED_ ;
+            WRMSG( HHC17526, "I", RexxPackage);
         }
         else
         {
-            RexxPackage = "" ;
-            RexxDynamicLoader = NULL ;
-            RexxRegisterHandlers = NULL ;
-            RexxExecCmd = NULL ;
-            RexxExecInstoreCmd = NULL ;
+            SETREXX_RESET()
+            RexxStatus = _STOPPED_ ;
+            WRMSG( HHC17501, "E", envvar,"Unknown REXX Package");
             return -1;
         }
 
     }
-#endif
+exec_instore_cmd_Rexx_Loaded:
+#endif /* defined(ENABLE_OBJECT_REXX) && defined(ENABLE_REGINA_REXX) */
 
     return (*RexxExecInstoreCmd)( Command, NULL, RetRC, Result);
 
@@ -671,7 +779,7 @@ short RetRC=0 ;
 void InitializeRexxPaths(char * wPaths)
 {
 char *ptr;
-char *envvar ;
+char *envvar;
     if ( wPaths )
     {
         RexxPaths = strdup(wPaths);
@@ -681,11 +789,11 @@ char *envvar ;
     {
         if ( ( envvar = getenv("HREXX_PATH") ) )
         {
-            RexxPaths = strdup(envvar) ;
+            RexxPaths = strdup(envvar);
         }
         else if ( ( envvar = getenv("HREXX_PATHS") ) )
         {
-            RexxPaths = strdup(envvar) ;
+            RexxPaths = strdup(envvar);
         }
         else
             RexxPaths = strdup(getenv("PATH"));
@@ -702,7 +810,7 @@ char *envvar ;
 void InitializeRexxExtensions(char * wExtns)
 {
 char *ptr;
-char *envvar ;
+char *envvar;
 
     if ( wExtns )
     {
@@ -713,14 +821,14 @@ char *envvar ;
     {
         if ( ( envvar = getenv("HREXX_EXTENSIONS") ) )
         {
-            RexxExtensions = strdup(envvar) ;
+            RexxExtensions = strdup(envvar);
         }
         else if ( ( envvar = getenv("HREXX_SUFFIXES") ) )
         {
-            RexxExtensions = strdup(envvar) ;
+            RexxExtensions = strdup(envvar);
         }
         else
-            RexxExtensions = strdup(".REXX;.rexx;.REX;.rex;.CMD;.cmd;.RX;.rx") ;
+            RexxExtensions = strdup(".REXX;.rexx;.REX;.rex;.CMD;.cmd;.RX;.rx");
     }
 
     for (RexxExtensionsCount= 0,ptr = strtok(RexxExtensions, EXTNDELIM ); ptr; ptr = strtok(NULL, EXTNDELIM))
diff --git a/hRexx_o.c b/hRexx_o.c
index d116c224..c7e2f373 100644
--- a/hRexx_o.c
+++ b/hRexx_o.c
@@ -19,7 +19,7 @@
 #if defined(ENABLE_OBJECT_REXX)
 
 #define LOG_CAPTURE( _RETC_ , _RESP_, _FCNM_, _BUFF_) do { \
-_RESP_ = log_capture( _FCNM_ , _BUFF_ ) ; \
+_RESP_ = log_capture( _FCNM_ , _BUFF_ ); \
 _RETC_ = 0;\
 } while (0)
 
@@ -27,31 +27,32 @@ _RETC_ = 0;\
 
 #include "hRexx.h"
 
-extern void *hRexxLibHandle ;        /* Library handle */
-extern void *hRexxApiLibHandle ;     /* Api Library handle */
+extern void *hRexxLibHandle;        /* Library handle */
+extern void *hRexxApiLibHandle;     /* Api Library handle */
 
-extern char *RexxPackage ;
+extern char *RexxPackage;
 
-extern char *RexxLibrary ;
-extern char *RexxApiLibrary ;
+extern char *RexxLibrary;
+extern char *RexxApiLibrary;
 
-extern char *MessagePrefix ;
-extern char *TracePrefix ;
+extern int   MessageLevel;
+extern char *MessagePrefix;
+extern char *ErrorPrefix;
 
-extern int (*RexxDynamicLoader)() ;
-extern int (*RexxRegisterHandlers)() ;
-extern int (*RexxExecCmd)() ;
-extern int (*RexxExecInstoreCmd)() ;
+extern int (*RexxDynamicLoader)();
+extern int (*RexxRegisterHandlers)();
+extern int (*RexxExecCmd)();
+extern int (*RexxExecInstoreCmd)();
 
-static PFNREXXSTART             hRexxStart ;
-static PFNREXXREGISTERSUBCOMEXE hRexxRegisterSubcom ;
-static PFNREXXDEREGISTERSUBCOM  hRexxDeregisterSubcom ;
-static PFNREXXREGISTEREXITEXE   hRexxRegisterExit ;
-static PFNREXXDEREGISTEREXIT    hRexxDeregisterExit ;
-static PFNREXXALLOCATEMEMORY    hRexxAllocateMemory ;
-static PFNREXXFREEMEMORY        hRexxFreeMemory ;
+static PFNREXXSTART             hRexxStart;
+static PFNREXXREGISTERSUBCOMEXE hRexxRegisterSubcom;
+static PFNREXXDEREGISTERSUBCOM  hRexxDeregisterSubcom;
+static PFNREXXREGISTEREXITEXE   hRexxRegisterExit;
+static PFNREXXDEREGISTEREXIT    hRexxDeregisterExit;
+static PFNREXXALLOCATEMEMORY    hRexxAllocateMemory;
+static PFNREXXFREEMEMORY        hRexxFreeMemory;
 
-static PFNREXXVARIABLEPOOL      hRexxVariablePool ;
+static PFNREXXVARIABLEPOOL      hRexxVariablePool;
 
 int ObjectRexxFetchVar (
    char *    pszVar,             /* Variable name                     */
@@ -111,28 +112,28 @@ int ObjectRexxSetVar (
   char *        pValue,         /* Ptr to new value                  */
   size_t        ulLen)          /* Value length                      */
 {
-SHVBLOCK      RxVarBlock ;
-unsigned long ulRetc ;
+SHVBLOCK      RxVarBlock;
+unsigned long ulRetc;
 
     /* initialize RxVarBlock */
-    RxVarBlock.shvnext = NULL ;
-    RxVarBlock.shvname.strptr = pszVar ;
-    RxVarBlock.shvname.strlength = strlen(pszVar) ;
-    RxVarBlock.shvnamelen = RxVarBlock.shvname.strlength ;
-    RxVarBlock.shvvalue.strptr = pValue ;
-    RxVarBlock.shvvalue.strlength = ulLen ;
-    RxVarBlock.shvvaluelen = ulLen ;
-    RxVarBlock.shvcode = RXSHV_SYSET ;
-    RxVarBlock.shvret = RXSHV_OK ;
+    RxVarBlock.shvnext = NULL;
+    RxVarBlock.shvname.strptr = pszVar;
+    RxVarBlock.shvname.strlength = strlen(pszVar);
+    RxVarBlock.shvnamelen = RxVarBlock.shvname.strlength;
+    RxVarBlock.shvvalue.strptr = pValue;
+    RxVarBlock.shvvalue.strlength = ulLen;
+    RxVarBlock.shvvaluelen = ulLen;
+    RxVarBlock.shvcode = RXSHV_SYSET;
+    RxVarBlock.shvret = RXSHV_OK;
 
     /* set variable in pool */
-    ulRetc = (*hRexxVariablePool)(&RxVarBlock) ;
+    ulRetc = (*hRexxVariablePool)(&RxVarBlock);
 
     /* test return code */
     if (ulRetc == RXSHV_NEWV)
-        ulRetc = RXSHV_OK ;
+        ulRetc = RXSHV_OK;
 
-    return (int)ulRetc ;
+    return (int)ulRetc;
 
 }
 
@@ -143,148 +144,162 @@ static RexxReturnCode REXXENTRY hSubcomHandler(
 {
 #define MAX_OPTS 16
 
-short rc ;
-char *line = NULL ;
-int   coun ;
-char *zCommand = NULL ;
-char *wCommand = NULL ;
-char *wResp = NULL ;
+short rc;
+char *line = NULL;
+int   coun;
+char *zCommand = NULL;
+char *wCommand = NULL;
+char *wResp = NULL;
 
-int   iarg,argc ;
-char *argv[MAX_OPTS] ;
+int   iarg,argc;
+char *argv[MAX_OPTS];
 
-int   haveecho ;
+#if 0
+int   haveecho;
 int   echo;
-int   havestem ;
-int   needname ;
-int   havename ;
+#endif
+int   havestem;
+int   needname;
+int   havename;
 
-char *wStem ;
-int   l ;
-char *offst ;
+char *RespStemName;
+int   RespStemLength;
+char *RespStemOffset;
 
-char temp[33] ;
+char temp[33];
 
     zCommand = malloc( RXSTRLEN( *Command) +1);
-    strncpy( zCommand, RXSTRPTR( *Command), RXSTRLEN( *Command)) ;
-    zCommand[RXSTRLEN(*Command)] = '\0' ;
+    strncpy( zCommand, RXSTRPTR( *Command), RXSTRLEN( *Command));
+    zCommand[RXSTRLEN(*Command)] = '\0';
     parse_command( zCommand, MAX_OPTS, argv, &argc);
 
     if ( argc == 0 )
     {
-        free(zCommand) ;
-        sprintf(RetValue->strptr, "%d", -1) ;
-        RetValue->strlength = strlen(RetValue->strptr) ;
+        free(zCommand);
+        sprintf(RetValue->strptr, "%d", -1);
+        RetValue->strlength = strlen(RetValue->strptr);
         *Flags = RXSUBCOM_ERROR;
         return -1;
     }
-
+#if 0
     haveecho = 0;
     echo = 0;
+#endif
     havestem = 0;
     needname = 0;
     havename = 0;
 
-    for (iarg = 1 ; iarg < argc ; iarg++)
+    for (iarg = 1; iarg < argc; iarg++)
     {
         if ( !havename && havestem )
         {
-            havename = 1 ;
-            wStem = malloc(strlen(argv[iarg]) + 33) ;
-            strcpy(wStem, argv[iarg]) ;
-            l = strlen(wStem) ;
-            if  ( wStem[l-1] != '.' )
+            havename = 1;
+            RespStemName = malloc(strlen(argv[iarg]) + 33);
+            strcpy(RespStemName, argv[iarg]);
+            RespStemLength = strlen(RespStemName);
+            if  ( RespStemName[RespStemLength-1] != '.' )
             {
-                wStem[l]   = '.' ;
-                wStem[l+1] = '\0' ;
+                RespStemName[RespStemLength]   = '.';
+                RespStemName[RespStemLength+1] = '\0';
             }
-            offst = wStem + strlen(wStem) ;
-            sprintf(offst,"%d",0) ;
-            sprintf(temp,"%d",0) ;
-            ObjectRexxSetVar(wStem, temp, strlen(temp)) ;
-            continue ;
+            RespStemOffset = RespStemName + strlen(RespStemName);
+            sprintf(RespStemOffset,"%d",0);
+            sprintf(temp,"%d",0);
+            ObjectRexxSetVar(RespStemName, temp, strlen(temp));
+            continue;
         }
 
+#if 0
         if ( !haveecho && ( strcasecmp(argv[iarg], "echo" ) == 0 ) )
         {
-            haveecho = 1 ;
-            echo = 1 ;
-            continue ;
+            haveecho = 1;
+            echo = 1;
+            continue;
         }
         if ( !haveecho && ( strcasecmp(argv[iarg], "noecho" ) == 0 ) )
         {
-            haveecho = 1 ;
-            echo = 0 ;
-            continue ;
+            haveecho = 1;
+            echo = 0;
+            continue;
         }
-
+#endif
         if ( !havestem && ( strcasecmp(argv[iarg], "stem" ) == 0 ) )
         {
             havestem = 1;
             needname = 1;
-            continue ;
+            continue;
         }
 
         if ( havename )
         {
-            free( wStem);
+            free( RespStemName);
         }
 
         free( zCommand);
-        sprintf( RetValue->strptr, "%d", -2) ;
+        sprintf( RetValue->strptr, "%d", -2);
         RetValue->strlength = strlen( RetValue->strptr);
         *Flags = RXSUBCOM_ERROR;
         return -2;
 
     }
 
-    wCommand = NULL ;
-    wCommand = malloc(strlen(argv[0])+33) ;
+    wCommand = NULL;
+    wCommand = malloc(strlen(argv[0])+33);
     if ( wCommand )
     {
+        strcpy(wCommand, argv[0]);
+#if 0
         if ( echo )
         {
-            wCommand[0] = '\0' ;
+            wCommand[0] = '\0';
         }
         else
         {
-            wCommand[0] = '-' ;
-            wCommand[1] = '\0' ;
+            wCommand[0] = '-';
+            wCommand[1] = '\0';
         }
-        strcat( wCommand, argv[0] ) ;
-        LOG_CAPTURE( rc, wResp, panel_command, wCommand);
+        strcat( wCommand, argv[0] );
+#endif
+
         if ( havename )
         {
+            LOG_CAPTURE( rc, wResp, panel_command, wCommand);
             coun = 0;
             if (wResp )
             {
-                for (coun=0, line=strtok(wResp, "\n") ; line ; line = strtok(NULL, "\n"))
+                for (coun=0, line=strtok(wResp, "\n"); line; line = strtok(NULL, "\n"))
                 {
                     coun++;
-                    sprintf(offst,"%d",coun) ;
-                    ObjectRexxSetVar(wStem, line, strlen(line)) ;
+                    sprintf(RespStemOffset,"%d",coun);
+                    ObjectRexxSetVar(RespStemName, line, strlen(line));
                 }
-                free(wResp) ;
+                free(wResp);
             }
-            sprintf(offst,"%d",0) ;
-            sprintf(temp,"%d",coun) ;
-            ObjectRexxSetVar(wStem, temp, strlen(temp)) ;
-            free(wStem) ;
+            sprintf(RespStemOffset,"%d",0);
+            sprintf(temp,"%d",coun);
+            ObjectRexxSetVar(RespStemName, temp, strlen(temp));
+            free(RespStemName);
+            *Flags = RXSUBCOM_OK;
+
         }
-        free(wCommand) ;
-        free(zCommand) ;
-        *Flags = RXSUBCOM_OK ;
+        else
+        {
+            rc = HercCmdLine(wCommand);
+            *Flags = rc < 0 ? RXSUBCOM_ERROR : rc > 0 ? RXSUBCOM_FAILURE : RXSUBCOM_OK;
+        }
+        free(wCommand);
+        free(zCommand);
     }
     else
     {
-        rc = -4 ;
-        *Flags = RXAPI_MEMFAIL ;
+        rc = -4;
+        *Flags = RXAPI_MEMFAIL;
     }
 
-    sprintf(RetValue->strptr, "%d", rc) ;
-    RetValue->strlength = strlen(RetValue->strptr) ;
+    sprintf(RetValue->strptr, "%d", rc);
+    RetValue->strlength = strlen(RetValue->strptr);
 
-    return rc ;
+    return rc;
 }
 
 static RexxReturnCode REXXENTRY hExitHandler(
@@ -298,85 +313,85 @@ static RexxReturnCode REXXENTRY hExitHandler(
             switch( SubFunction ) {
                 case RXSIOSAY:
                     if (MessagePrefix)
-                        logmsg("%-9s %s\n", MessagePrefix, RXSTRPTR(((RXSIOSAY_PARM *)ParmBlock)->rxsio_string)) ;
+                        logmsg("%-9s %s\n", MessagePrefix, RXSTRPTR(((RXSIOSAY_PARM *)ParmBlock)->rxsio_string));
                     else
-                        logmsg("%s\n", RXSTRPTR(((RXSIOSAY_PARM *)ParmBlock)->rxsio_string)) ;
-                    return RXEXIT_HANDLED ;
-                    break ;
+                        logmsg("%s\n", RXSTRPTR(((RXSIOSAY_PARM *)ParmBlock)->rxsio_string));
+                    return RXEXIT_HANDLED;
+                    break;
                 case RXSIOTRC:
                     if (MessagePrefix)
-                        logmsg("%-9s %s\n", MessagePrefix, RXSTRPTR(((RXSIOTRC_PARM *)ParmBlock)->rxsio_string)) ;
+                        logmsg("%-9s %s\n", MessagePrefix, RXSTRPTR(((RXSIOTRC_PARM *)ParmBlock)->rxsio_string));
                     else
-                        logmsg("%s\n", RXSTRPTR(((RXSIOTRC_PARM *)ParmBlock)->rxsio_string)) ;
-                    return RXEXIT_HANDLED ;
-                    break ;
+                        logmsg("%s\n", RXSTRPTR(((RXSIOTRC_PARM *)ParmBlock)->rxsio_string));
+                    return RXEXIT_HANDLED;
+                    break;
                 case RXSIOTRD:
-                    MAKERXSTRING(((RXSIOTRD_PARM *)ParmBlock)->rxsiotrd_retc, NULL, 0) ;
-                    return RXEXIT_HANDLED ;
-                    break ;
+                    MAKERXSTRING(((RXSIOTRD_PARM *)ParmBlock)->rxsiotrd_retc, NULL, 0);
+                    return RXEXIT_HANDLED;
+                    break;
                 case RXSIODTR:
-                    MAKERXSTRING(((RXSIODTR_PARM *)ParmBlock)->rxsiodtr_retc, NULL, 0) ;
-                    return RXEXIT_HANDLED ;
-                    break ;
+                    MAKERXSTRING(((RXSIODTR_PARM *)ParmBlock)->rxsiodtr_retc, NULL, 0);
+                    return RXEXIT_HANDLED;
+                    break;
                 default:
-                    break ;
+                    break;
             }
-            break ;
+            break;
         default:
-            break ;
+            break;
     }
-    return RXEXIT_NOT_HANDLED ;
+    return RXEXIT_NOT_HANDLED;
 }
 
 int ObjectRexxDynamicLoader()
 {
-    HDLOPEN( hRexxLibHandle, OOREXX_LIBRARY, RTLD_LAZY) ;
+    HDLOPEN( hRexxLibHandle, OOREXX_LIBRARY, RTLD_LAZY);
 
-    HDLOPEN( hRexxApiLibHandle, OOREXX_API_LIBRARY, RTLD_LAZY) ;
+    HDLOPEN( hRexxApiLibHandle, OOREXX_API_LIBRARY, RTLD_LAZY);
 
-    HDLSYM ( hRexxStart, hRexxLibHandle, REXX_START) ;
+    HDLSYM ( hRexxStart, hRexxLibHandle, REXX_START);
 
-    HDLSYM ( hRexxRegisterSubcom, hRexxApiLibHandle, REXX_REGISTER_SUBCOM) ;
+    HDLSYM ( hRexxRegisterSubcom, hRexxApiLibHandle, REXX_REGISTER_SUBCOM);
 
-    HDLSYM ( hRexxDeregisterSubcom, hRexxApiLibHandle, REXX_DEREGISTER_SUBCOM) ;
+    HDLSYM ( hRexxDeregisterSubcom, hRexxApiLibHandle, REXX_DEREGISTER_SUBCOM);
 
-    HDLSYM ( hRexxRegisterExit, hRexxApiLibHandle, REXX_REGISTER_EXIT) ;
+    HDLSYM ( hRexxRegisterExit, hRexxApiLibHandle, REXX_REGISTER_EXIT);
 
-    HDLSYM ( hRexxDeregisterExit, hRexxApiLibHandle, REXX_DEREGISTER_EXIT) ;
+    HDLSYM ( hRexxDeregisterExit, hRexxApiLibHandle, REXX_DEREGISTER_EXIT);
 
-    HDLSYM ( hRexxAllocateMemory, hRexxApiLibHandle, REXX_ALLOCATE_MEMORY) ;
+    HDLSYM ( hRexxAllocateMemory, hRexxApiLibHandle, REXX_ALLOCATE_MEMORY);
 
-    HDLSYM ( hRexxFreeMemory, hRexxApiLibHandle, REXX_FREE_MEMORY) ;
+    HDLSYM ( hRexxFreeMemory, hRexxApiLibHandle, REXX_FREE_MEMORY);
 
-    HDLSYM ( hRexxVariablePool, hRexxLibHandle, REXX_VARIABLE_POOL) ;
+    HDLSYM ( hRexxVariablePool, hRexxLibHandle, REXX_VARIABLE_POOL);
 
-    return 0 ;
+    return 0;
 }
 
 int ObjectRexxRegisterHandlers()
 {
-int rc=0 ;
+int rc=0;
 
     if (!hRexxLibHandle)
     {
         if ( (*RexxDynamicLoader)() != 0 )
-           return -1 ;
+           return -1;
     }
 
-    rc = (*hRexxRegisterExit)( hSIOExit, (REXXPFN)hExitHandler, NULL ) ;
+    rc = (*hRexxRegisterExit)( hSIOExit, (REXXPFN)hExitHandler, NULL );
     if (rc != RXEXIT_OK && rc != RXEXIT_NOTREG)
     {
-        WRMSG( HHC17534, "E", RexxPackage, "Exit Handler", rc) ;
-        return -1 ;
+        WRMSG( HHC17534, "E", RexxPackage, "Exit Handler", rc);
+        return -1;
     }
 
-    rc = (*hRexxRegisterSubcom)( hSubcom, (REXXPFN)hSubcomHandler, NULL ) ;
+    rc = (*hRexxRegisterSubcom)( hSubcom, (REXXPFN)hSubcomHandler, NULL );
     if (rc != RXSUBCOM_OK && rc != RXSUBCOM_NOTREG)
     {
-        WRMSG( HHC17534, "E", RexxPackage, "Subcom Handler", rc) ;
-        return -1 ;
+        WRMSG( HHC17534, "E", RexxPackage, "Subcom Handler", rc);
+        return -1;
     }
-    return 0 ;
+    return 0;
 
 }
 
@@ -385,32 +400,32 @@ int rc=0 ;
 /*-------------------------------------------------------------------*/
 int ObjectRexxExecCmd(char *Command, char *Args, int argc, char *argv[] )
 {
-int   rc ;
-short RetRC ;
-CONSTRXSTRING  wArgs ;
-RXSYSEXIT      ExitList[2] ;
-RXSTRING       RetValue ;
+int   rc;
+short RetRC;
+CONSTRXSTRING  wArgs;
+RXSYSEXIT      ExitList[2];
+RXSTRING       RetValue;
 
-    UNREFERENCED(argc) ;
+    UNREFERENCED(argc);
 
     if ( (*RexxRegisterHandlers)() != 0 )
-        return -1 ;
+        return -1;
 
     if ( Args )
     {
-        MAKERXSTRING(wArgs, Args, strlen(Args)) ;
+        MAKERXSTRING(wArgs, Args, strlen(Args));
     }
     else
     {
-        MAKERXSTRING(wArgs, NULL, 0 ) ;
+        MAKERXSTRING(wArgs, NULL, 0 );
     }
 
-    ExitList[0].sysexit_name = hSIOExit ;
-    ExitList[0].sysexit_code = RXSIO ;
-    ExitList[1].sysexit_code = RXENDLST ;
+    ExitList[0].sysexit_name = hSIOExit;
+    ExitList[0].sysexit_code = RXSIO;
+    ExitList[1].sysexit_code = RXENDLST;
 
-    RetValue.strptr = NULL ;       /* initialize return-pointer to empty */
-    RetValue.strlength = 0 ;       /* initialize return-length to zero   */
+    RetValue.strptr = NULL;       /* initialize return-pointer to empty */
+    RetValue.strlength = 0;       /* initialize return-length to zero   */
 
     rc= (*hRexxStart)((Args) ? 1 : 0 ,               /* number of arguments   */
                        &wArgs,                       /* array of arguments    */
@@ -420,23 +435,29 @@ RXSTRING       RetValue ;
                        RXCOMMAND,                    /* Code for how invoked  */
                        ExitList,                     /* EXITs on this call    */
                        &RetRC,                       /* converted return code */
-                       &RetValue) ;                   /* Rexx program output   */
+                       &RetValue);                   /* Rexx program output   */
 
     if ( rc !=  0 )
     {
-        WRMSG( HHC17502, "E", RexxPackage, RexxPackage, rc) ;
+        WRMSG( HHC17502, "E", RexxPackage, RexxPackage, rc);
     }
     else
     {
-        WRMSG( HHC17503, "I", RexxPackage, argv[1], RetRC) ;
+        if ( MessageLevel > 0)
+        {
+            WRMSG( HHC17503, "I", RexxPackage, argv[1], RetRC);
+            if (RetValue.strptr != NULL)
+            {
+                WRMSG( HHC17504, "I", RexxPackage, argv[1], RetValue.strptr);
+            }
+        }
         if (RetValue.strptr != NULL)
         {
-            WRMSG( HHC17504, "I", RexxPackage, argv[1], RetValue.strptr) ;
-            (*hRexxFreeMemory)(RetValue.strptr) ;
+            (*hRexxFreeMemory)(RetValue.strptr);
         }
 
     }
-    return 0 ;
+    return rc;
 }
 
 /*-------------------------------------------------------------------*/
@@ -445,40 +466,40 @@ RXSTRING       RetValue ;
 int ObjectRexxExecInstoreCmd(char *Command, char *Args,
                             short RetRC, char *Result )
 {
-int rc ;
+int rc;
 
-CONSTRXSTRING  wArgs ;
-RXSTRING       Instore[2] ;
-RXSYSEXIT      ExitList[2] ;
-RXSTRING       RetValue ;
+CONSTRXSTRING  wArgs;
+RXSTRING       Instore[2];
+RXSYSEXIT      ExitList[2];
+RXSTRING       RetValue;
 
     if ( (*RexxRegisterHandlers)() != 0 )
-        return -1 ;
+        return -1;
 
     if ( Args )
     {
-        MAKERXSTRING(wArgs, Args, strlen(Args)) ;
+        MAKERXSTRING(wArgs, Args, strlen(Args));
     }
     else
     {
-        MAKERXSTRING(wArgs, NULL, 0 ) ;
+        MAKERXSTRING(wArgs, NULL, 0 );
     }
 
-    Instore[0].strptr=Command ;
-    Instore[0].strlength=strlen(Instore[0].strptr) ;
-    Instore[1].strptr=NULL ;
-    Instore[1].strlength=0 ;
+    Instore[0].strptr=Command;
+    Instore[0].strlength=strlen(Instore[0].strptr);
+    Instore[1].strptr=NULL;
+    Instore[1].strlength=0;
 
-    ExitList[0].sysexit_name = hSIOExit ;
-    ExitList[0].sysexit_code = RXSIO ;
-    ExitList[1].sysexit_code = RXENDLST ;
+    ExitList[0].sysexit_name = hSIOExit;
+    ExitList[0].sysexit_code = RXSIO;
+    ExitList[1].sysexit_code = RXENDLST;
 
-    RetValue.strptr=NULL ;
-    RetValue.strlength=0 ;
+    RetValue.strptr=NULL;
+    RetValue.strlength=0;
 
 /*  the file name is used as an eye catcher even if none needed
-    for source look alike with regina rexx ;
-    regina rexx clumsily needs a rexx file name also for Instore scripts ;
+    for source look alike with regina rexx;
+    regina rexx clumsily needs a rexx file name also for Instore scripts;
     the issue could be fixed with about five lines of code
     it would also fix a wrong message issued, but ...
     */
@@ -490,21 +511,21 @@ RXSTRING       RetValue ;
                        RXFUNCTION,                   /* Code for how invoked  */
                        ExitList,                     /* EXITs on this call    */
                        &RetRC,                       /* converted return code */
-                       &RetValue) ;                   /* Rexx program output   */
+                       &RetValue);                   /* Rexx program output   */
 
     if ( rc !=  0 )
     {
-        WRMSG( HHC17502, "E", RexxPackage, RexxPackage, rc) ;
+        WRMSG( HHC17502, "E", RexxPackage, RexxPackage, rc);
         if (RetValue.strptr != NULL)
-            (*hRexxFreeMemory)(RetValue.strptr) ;
+            (*hRexxFreeMemory)(RetValue.strptr);
     }
     else
     if (RetValue.strptr != NULL)
     {
-        strcpy(Result,RetValue.strptr) ;
-        (*hRexxFreeMemory)(RetValue.strptr) ;
+        strcpy(Result,RetValue.strptr);
+        (*hRexxFreeMemory)(RetValue.strptr);
     }
-    return rc ;
+    return rc;
 
 }
 #endif /* defined(ENABLE_OBJECT_REXX) */
diff --git a/hRexx_r.c b/hRexx_r.c
index 9b960a3e..7aa11f72 100644
--- a/hRexx_r.c
+++ b/hRexx_r.c
@@ -7,7 +7,6 @@
 
 /*  inspired by the previous Rexx implementation by Jan Jaeger       */
 
-
 // $Id: $
 
 #include "hstdinc.h"
@@ -20,7 +19,7 @@
 #if defined(ENABLE_REGINA_REXX)
 
 #define LOG_CAPTURE( _RETC_ , _RESP_, _FCNM_, _BUFF_) do { \
-_RESP_ = log_capture( _FCNM_ , _BUFF_ ) ; \
+_RESP_ = log_capture( _FCNM_ , _BUFF_ ); \
 _RETC_ = 0;\
 } while (0)
 
@@ -35,42 +34,43 @@ _RETC_ = 0;\
 
 #include "hRexx.h"
 
-extern void *hRexxLibHandle ;        /* Library handle */
-extern void *hRexxApiLibHandle ;     /* Api Library handle */
+extern void *hRexxLibHandle;        /* Library handle */
+extern void *hRexxApiLibHandle;     /* Api Library handle */
 
-extern char *RexxPackage ;
+extern char *RexxPackage;
 
-extern char *RexxLibrary ;
-extern char *RexxApiLibrary ;
+extern char *RexxLibrary;
+extern char *RexxApiLibrary;
 
-extern char *MessagePrefix ;
-extern char *TracePrefix ;
+extern int   MessageLevel;
+extern char *MessagePrefix;
+extern char *ErrorPrefix;
 
-extern int (*RexxDynamicLoader)() ;
-extern int (*RexxRegisterHandlers)() ;
-extern int (*RexxExecCmd)() ;
-extern int (*RexxExecInstoreCmd)() ;
+extern int (*RexxDynamicLoader)();
+extern int (*RexxRegisterHandlers)();
+extern int (*RexxExecCmd)();
+extern int (*RexxExecInstoreCmd)();
 
-typedef APIRET APIENTRY PFNREXXSTART( LONG, PRXSTRING, PCSZ, PRXSTRING, PCSZ, LONG, PRXSYSEXIT, PSHORT, PRXSTRING ) ;
-typedef APIRET APIENTRY PFNREXXREGISTERSUBCOMEXE( PCSZ, PFN, PUCHAR) ;
-typedef APIRET APIENTRY PFNREXXDEREGISTERSUBCOM( PCSZ, PCSZ) ;
-typedef APIRET APIENTRY PFNREXXREGISTEREXITEXE( PSZ, PFN , PUCHAR ) ;
-typedef APIRET APIENTRY PFNREXXDEREGISTEREXIT( PCSZ, PCSZ) ;
-typedef PVOID  APIENTRY PFNREXXALLOCATEMEMORY(ULONG) ;
-typedef APIRET APIENTRY PFNREXXFREEMEMORY( PVOID) ;
+typedef APIRET APIENTRY PFNREXXSTART( LONG, PRXSTRING, PCSZ, PRXSTRING, PCSZ, LONG, PRXSYSEXIT, PSHORT, PRXSTRING );
+typedef APIRET APIENTRY PFNREXXREGISTERSUBCOMEXE( PCSZ, PFN, PUCHAR);
+typedef APIRET APIENTRY PFNREXXDEREGISTERSUBCOM( PCSZ, PCSZ);
+typedef APIRET APIENTRY PFNREXXREGISTEREXITEXE( PSZ, PFN , PUCHAR );
+typedef APIRET APIENTRY PFNREXXDEREGISTEREXIT( PCSZ, PCSZ);
+typedef PVOID  APIENTRY PFNREXXALLOCATEMEMORY(ULONG);
+typedef APIRET APIENTRY PFNREXXFREEMEMORY( PVOID);
 
-typedef APIRET APIENTRY PFNREXXVARIABLEPOOL( PSHVBLOCK ) ;
+typedef APIRET APIENTRY PFNREXXVARIABLEPOOL( PSHVBLOCK );
 
 
-static PFNREXXSTART             *hRexxStart ;
-static PFNREXXREGISTERSUBCOMEXE *hRexxRegisterSubcom ;
-static PFNREXXDEREGISTERSUBCOM  *hRexxDeregisterSubcom ;
-static PFNREXXREGISTEREXITEXE   *hRexxRegisterExit ;
-static PFNREXXDEREGISTEREXIT    *hRexxDeregisterExit ;
-static PFNREXXALLOCATEMEMORY    *hRexxAllocateMemory ;
-static PFNREXXFREEMEMORY        *hRexxFreeMemory ;
+static PFNREXXSTART             *hRexxStart;
+static PFNREXXREGISTERSUBCOMEXE *hRexxRegisterSubcom;
+static PFNREXXDEREGISTERSUBCOM  *hRexxDeregisterSubcom;
+static PFNREXXREGISTEREXITEXE   *hRexxRegisterExit;
+static PFNREXXDEREGISTEREXIT    *hRexxDeregisterExit;
+static PFNREXXALLOCATEMEMORY    *hRexxAllocateMemory;
+static PFNREXXFREEMEMORY        *hRexxFreeMemory;
 
-static PFNREXXVARIABLEPOOL      *hRexxVariablePool ;
+static PFNREXXVARIABLEPOOL      *hRexxVariablePool;
 
 int ReginaRexxFetchVar (
    char *    pszVar,             /* Variable name                     */
@@ -130,28 +130,28 @@ int ReginaRexxSetVar (
   char *        pValue,         /* Ptr to new value                  */
   size_t        ulLen)          /* Value length                      */
 {
-SHVBLOCK      RxVarBlock ;
-unsigned long ulRetc ;
+SHVBLOCK      RxVarBlock;
+unsigned long ulRetc;
 
     /* initialize RxVarBlock */
-    RxVarBlock.shvnext = NULL ;
-    RxVarBlock.shvname.strptr = pszVar ;
-    RxVarBlock.shvname.strlength = strlen(pszVar) ;
-    RxVarBlock.shvnamelen = RxVarBlock.shvname.strlength ;
-    RxVarBlock.shvvalue.strptr = pValue ;
-    RxVarBlock.shvvalue.strlength = ulLen ;
-    RxVarBlock.shvvaluelen = ulLen ;
-    RxVarBlock.shvcode = RXSHV_SYSET ;
-    RxVarBlock.shvret = RXSHV_OK ;
+    RxVarBlock.shvnext = NULL;
+    RxVarBlock.shvname.strptr = pszVar;
+    RxVarBlock.shvname.strlength = strlen(pszVar);
+    RxVarBlock.shvnamelen = RxVarBlock.shvname.strlength;
+    RxVarBlock.shvvalue.strptr = pValue;
+    RxVarBlock.shvvalue.strlength = ulLen;
+    RxVarBlock.shvvaluelen = ulLen;
+    RxVarBlock.shvcode = RXSHV_SYSET;
+    RxVarBlock.shvret = RXSHV_OK;
 
     /* set variable in pool */
-    ulRetc = (*hRexxVariablePool)(&RxVarBlock) ;
+    ulRetc = (*hRexxVariablePool)(&RxVarBlock);
 
     /* test return code */
     if (ulRetc == RXSHV_NEWV)
-        ulRetc = RXSHV_OK ;
+        ulRetc = RXSHV_OK;
 
-    return (int)ulRetc ;
+    return (int)ulRetc;
 
 }
 
@@ -162,148 +162,162 @@ static APIRET APIENTRY hSubcomHandler(
 {
 #define MAX_OPTS 16
 
-short rc ;
-char *line = NULL ;
-int   coun ;
-char *zCommand = NULL ;
-char *wCommand = NULL ;
-char *wResp = NULL ;
+short rc;
+char *line = NULL;
+int   coun;
+char *zCommand = NULL;
+char *wCommand = NULL;
+char *wResp = NULL;
 
-int   iarg,argc ;
-char *argv[MAX_OPTS] ;
+int   iarg,argc;
+char *argv[MAX_OPTS];
 
-int   haveecho ;
+#if 0
+int   haveecho;
 int   echo;
-int   havestem ;
-int   needname ;
-int   havename ;
+#endif
+int   havestem;
+int   needname;
+int   havename;
 
-char *wStem ;
-int   l ;
-char *offst ;
+char *RespStemName;
+int   RespStemLength;
+char *RespStemOffset;
 
-char temp[33] ;
+char temp[33];
 
     zCommand = malloc( RXSTRLEN( *Command) +1);
-    strncpy( zCommand, RXSTRPTR( *Command), RXSTRLEN( *Command)) ;
-    zCommand[RXSTRLEN(*Command)] = '\0' ;
+    strncpy( zCommand, RXSTRPTR( *Command), RXSTRLEN( *Command));
+    zCommand[RXSTRLEN(*Command)] = '\0';
     parse_command( zCommand, MAX_OPTS, argv, &argc);
 
     if ( argc == 0 )
     {
-        free(zCommand) ;
-        sprintf(RetValue->strptr, "%d", -1) ;
-        RetValue->strlength = strlen(RetValue->strptr) ;
+        free(zCommand);
+        sprintf(RetValue->strptr, "%d", -1);
+        RetValue->strlength = strlen(RetValue->strptr);
         *Flags = RXSUBCOM_ERROR;
         return -1;
     }
-
+#if 0
     haveecho = 0;
     echo = 0;
+#endif
     havestem = 0;
     needname = 0;
     havename = 0;
 
-    for (iarg = 1 ; iarg < argc ; iarg++)
+    for (iarg = 1; iarg < argc; iarg++)
     {
         if ( !havename && havestem )
         {
-            havename = 1 ;
-            wStem = malloc(strlen(argv[iarg]) + 33) ;
-            strcpy(wStem, argv[iarg]) ;
-            l = strlen(wStem) ;
-            if  ( wStem[l-1] != '.' )
+            havename = 1;
+            RespStemName = malloc(strlen(argv[iarg]) + 33);
+            strcpy(RespStemName, argv[iarg]);
+            RespStemLength = strlen(RespStemName);
+            if  ( RespStemName[RespStemLength-1] != '.' )
             {
-                wStem[l]   = '.' ;
-                wStem[l+1] = '\0' ;
+                RespStemName[RespStemLength]   = '.';
+                RespStemName[RespStemLength+1] = '\0';
             }
-            offst = wStem + strlen(wStem) ;
-            sprintf(offst,"%d",0) ;
-            sprintf(temp,"%d",0) ;
-            ReginaRexxSetVar(wStem, temp, strlen(temp)) ;
-            continue ;
+            RespStemOffset = RespStemName + strlen(RespStemName);
+            sprintf(RespStemOffset,"%d",0);
+            sprintf(temp,"%d",0);
+            ReginaRexxSetVar(RespStemName, temp, strlen(temp));
+            continue;
         }
 
+#if 0
         if ( !haveecho && ( strcasecmp(argv[iarg], "echo" ) == 0 ) )
         {
-            haveecho = 1 ;
-            echo = 1 ;
-            continue ;
+            haveecho = 1;
+            echo = 1;
+            continue;
         }
         if ( !haveecho && ( strcasecmp(argv[iarg], "noecho" ) == 0 ) )
         {
-            haveecho = 1 ;
-            echo = 0 ;
-            continue ;
+            haveecho = 1;
+            echo = 0;
+            continue;
         }
-
+#endif
         if ( !havestem && ( strcasecmp(argv[iarg], "stem" ) == 0 ) )
         {
             havestem = 1;
             needname = 1;
-            continue ;
+            continue;
         }
 
         if ( havename )
         {
-            free( wStem);
+            free( RespStemName);
         }
 
         free( zCommand);
-        sprintf( RetValue->strptr, "%d", -2) ;
+        sprintf( RetValue->strptr, "%d", -2);
         RetValue->strlength = strlen( RetValue->strptr);
         *Flags = RXSUBCOM_ERROR;
         return -2;
 
     }
 
-    wCommand = NULL ;
-    wCommand = malloc(strlen(argv[0])+33) ;
+    wCommand = NULL;
+    wCommand = malloc(strlen(argv[0])+33);
     if ( wCommand )
     {
+        strcpy(wCommand, argv[0]);
+#if 0
         if ( echo )
         {
-            wCommand[0] = '\0' ;
+            wCommand[0] = '\0';
         }
         else
         {
-            wCommand[0] = '-' ;
-            wCommand[1] = '\0' ;
+            wCommand[0] = '-';
+            wCommand[1] = '\0';
         }
-        strcat( wCommand, argv[0] ) ;
-        LOG_CAPTURE( rc, wResp, panel_command, wCommand) ;
+        strcat( wCommand, argv[0] );
+#endif
+
         if ( havename )
         {
+            LOG_CAPTURE( rc, wResp, panel_command, wCommand);
             coun = 0;
             if (wResp )
             {
-                for (coun=0, line=strtok(wResp, "\n") ; line ; line = strtok(NULL, "\n"))
+                for (coun=0, line=strtok(wResp, "\n"); line; line = strtok(NULL, "\n"))
                 {
                     coun++;
-                    sprintf(offst,"%d",coun) ;
-                    ReginaRexxSetVar(wStem, line, strlen(line)) ;
+                    sprintf(RespStemOffset,"%d",coun);
+                    ReginaRexxSetVar(RespStemName, line, strlen(line));
                 }
-                free(wResp) ;
+                free(wResp);
             }
-            sprintf(offst,"%d",0) ;
-            sprintf(temp,"%d",coun) ;
-            ReginaRexxSetVar(wStem, temp, strlen(temp)) ;
-            free(wStem) ;
+            sprintf(RespStemOffset,"%d",0);
+            sprintf(temp,"%d",coun);
+            ReginaRexxSetVar(RespStemName, temp, strlen(temp));
+            free(RespStemName);
+            *Flags = RXSUBCOM_OK;
+
+        }
+        else
+        {
+            rc = HercCmdLine(wCommand);
+            *Flags = rc < 0 ? RXSUBCOM_ERROR : rc > 0 ? RXSUBCOM_FAILURE : RXSUBCOM_OK;
         }
-        free(wCommand) ;
-        free(zCommand) ;
-        *Flags = RXSUBCOM_OK ;
+        free(wCommand);
+        free(zCommand);
     }
     else
     {
-        rc = -4 ;
-        *Flags = RXAPI_MEMFAIL ;
+        rc = -4;
+        *Flags = RXAPI_MEMFAIL;
     }
 
-    sprintf(RetValue->strptr, "%d", rc) ;
-    RetValue->strlength = strlen(RetValue->strptr) ;
+    sprintf(RetValue->strptr, "%d", rc);
+    RetValue->strlength = strlen(RetValue->strptr);
 
-    return rc ;
+    return rc;
 }
 
 static LONG APIENTRY hExitHandler(
@@ -317,85 +331,85 @@ static LONG APIENTRY hExitHandler(
             switch( SubFunction ) {
                 case RXSIOSAY:
                     if (MessagePrefix)
-                        logmsg("%-9s %s\n", MessagePrefix, RXSTRPTR(((RXSIOSAY_PARM *)ParmBlock)->rxsio_string)) ;
+                        logmsg("%-9s %s\n", MessagePrefix, RXSTRPTR(((RXSIOSAY_PARM *)ParmBlock)->rxsio_string));
                     else
-                        logmsg("%s\n", RXSTRPTR(((RXSIOSAY_PARM *)ParmBlock)->rxsio_string)) ;
-                    return RXEXIT_HANDLED ;
-                    break ;
+                        logmsg("%s\n", RXSTRPTR(((RXSIOSAY_PARM *)ParmBlock)->rxsio_string));
+                    return RXEXIT_HANDLED;
+                    break;
                 case RXSIOTRC:
                     if (MessagePrefix)
-                        logmsg("%-9s %s\n", MessagePrefix, RXSTRPTR(((RXSIOTRC_PARM *)ParmBlock)->rxsio_string)) ;
+                        logmsg("%-9s %s\n", MessagePrefix, RXSTRPTR(((RXSIOTRC_PARM *)ParmBlock)->rxsio_string));
                     else
-                        logmsg("%s\n", RXSTRPTR(((RXSIOTRC_PARM *)ParmBlock)->rxsio_string)) ;
-                    return RXEXIT_HANDLED ;
-                    break ;
+                        logmsg("%s\n", RXSTRPTR(((RXSIOTRC_PARM *)ParmBlock)->rxsio_string));
+                    return RXEXIT_HANDLED;
+                    break;
                 case RXSIOTRD:
-                    MAKERXSTRING(((RXSIOTRD_PARM *)ParmBlock)->rxsiotrd_retc, NULL, 0) ;
-                    return RXEXIT_HANDLED ;
-                    break ;
+                    MAKERXSTRING(((RXSIOTRD_PARM *)ParmBlock)->rxsiotrd_retc, NULL, 0);
+                    return RXEXIT_HANDLED;
+                    break;
                 case RXSIODTR:
-                    MAKERXSTRING(((RXSIODTR_PARM *)ParmBlock)->rxsiodtr_retc, NULL, 0) ;
-                    return RXEXIT_HANDLED ;
-                    break ;
+                    MAKERXSTRING(((RXSIODTR_PARM *)ParmBlock)->rxsiodtr_retc, NULL, 0);
+                    return RXEXIT_HANDLED;
+                    break;
                 default:
-                    break ;
+                    break;
             }
-            break ;
+            break;
         default:
-            break ;
+            break;
     }
-    return RXEXIT_NOT_HANDLED ;
+    return RXEXIT_NOT_HANDLED;
 }
 
 int ReginaRexxDynamicLoader()
 {
-    HDLOPEN( hRexxLibHandle, REGINA_LIBRARY, RTLD_LAZY) ;
+    HDLOPEN( hRexxLibHandle, REGINA_LIBRARY, RTLD_LAZY);
 
-    HDLSYM ( hRexxStart, hRexxLibHandle, REXX_START) ;
+    HDLSYM ( hRexxStart, hRexxLibHandle, REXX_START);
 
-    HDLSYM ( hRexxRegisterSubcom, hRexxLibHandle, REXX_REGISTER_SUBCOM) ;
+    HDLSYM ( hRexxRegisterSubcom, hRexxLibHandle, REXX_REGISTER_SUBCOM);
 
-    HDLSYM ( hRexxDeregisterSubcom, hRexxLibHandle, REXX_DEREGISTER_SUBCOM) ;
+    HDLSYM ( hRexxDeregisterSubcom, hRexxLibHandle, REXX_DEREGISTER_SUBCOM);
 
-    HDLSYM ( hRexxRegisterExit, hRexxLibHandle, REXX_REGISTER_EXIT) ;
+    HDLSYM ( hRexxRegisterExit, hRexxLibHandle, REXX_REGISTER_EXIT);
 
-    HDLSYM ( hRexxDeregisterExit, hRexxLibHandle, REXX_DEREGISTER_EXIT) ;
+    HDLSYM ( hRexxDeregisterExit, hRexxLibHandle, REXX_DEREGISTER_EXIT);
 
-    HDLSYM ( hRexxAllocateMemory, hRexxLibHandle, REXX_ALLOCATE_MEMORY) ;
+    HDLSYM ( hRexxAllocateMemory, hRexxLibHandle, REXX_ALLOCATE_MEMORY);
 
-    HDLSYM ( hRexxFreeMemory, hRexxLibHandle, REXX_FREE_MEMORY) ;
+    HDLSYM ( hRexxFreeMemory, hRexxLibHandle, REXX_FREE_MEMORY);
 
-    HDLSYM ( hRexxFreeMemory, hRexxLibHandle, REXX_FREE_MEMORY) ;
+    HDLSYM ( hRexxFreeMemory, hRexxLibHandle, REXX_FREE_MEMORY);
 
-    HDLSYM ( hRexxVariablePool, hRexxLibHandle, REXX_VARIABLE_POOL) ;
+    HDLSYM ( hRexxVariablePool, hRexxLibHandle, REXX_VARIABLE_POOL);
 
-    return 0 ;
+    return 0;
 }
 
 int ReginaRexxRegisterHandlers()
 {
-int rc=0 ;
+int rc=0;
 
     if (!hRexxLibHandle)
     {
         if ( (*RexxDynamicLoader)() != 0 )
-           return -1 ;
+           return -1;
     }
 
-    rc = (*hRexxRegisterExit)( hSIOExit, (PFN)hExitHandler, NULL ) ;
+    rc = (*hRexxRegisterExit)( hSIOExit, (PFN)hExitHandler, NULL );
     if (rc != RXEXIT_OK && rc != RXEXIT_NOTREG)
     {
-        WRMSG( HHC17534, "E", RexxPackage, "Exit Handler", rc) ;
-        return -1 ;
+        WRMSG( HHC17534, "E", RexxPackage, "Exit Handler", rc);
+        return -1;
     }
 
-    rc = (*hRexxRegisterSubcom)( hSubcom, (PFN)hSubcomHandler, NULL ) ;
+    rc = (*hRexxRegisterSubcom)( hSubcom, (PFN)hSubcomHandler, NULL );
     if (rc != RXSUBCOM_OK && rc != RXSUBCOM_NOTREG)
     {
-        WRMSG( HHC17534, "E", RexxPackage, "Subcom Handler", rc) ;
-        return -1 ;
+        WRMSG( HHC17534, "E", RexxPackage, "Subcom Handler", rc);
+        return -1;
     }
-    return 0 ;
+    return 0;
 
 }
 
@@ -404,32 +418,32 @@ int rc=0 ;
 /*-------------------------------------------------------------------*/
 int ReginaRexxExecCmd(char *Command, char *Args, int argc, char *argv[] )
 {
-int   rc ;
-short RetRC ;
-RXSTRING       wArgs ;
-RXSYSEXIT      ExitList[2] ;
-RXSTRING       RetValue ;
+int   rc;
+short RetRC;
+RXSTRING       wArgs;
+RXSYSEXIT      ExitList[2];
+RXSTRING       RetValue;
 
-    UNREFERENCED(argc) ;
+    UNREFERENCED(argc);
 
     if ( (*RexxRegisterHandlers)() != 0 )
-        return -1 ;
+        return -1;
 
     if ( Args )
     {
-        MAKERXSTRING(wArgs, Args, strlen(Args)) ;
+        MAKERXSTRING(wArgs, Args, strlen(Args));
     }
     else
     {
-        MAKERXSTRING(wArgs, NULL, 0 ) ;
+        MAKERXSTRING(wArgs, NULL, 0 );
     }
 
-    ExitList[0].sysexit_name = hSIOExit ;
-    ExitList[0].sysexit_code = RXSIO ;
-    ExitList[1].sysexit_code = RXENDLST ;
+    ExitList[0].sysexit_name = hSIOExit;
+    ExitList[0].sysexit_code = RXSIO;
+    ExitList[1].sysexit_code = RXENDLST;
 
-    RetValue.strptr = NULL ;       /* initialize return-pointer to empty */
-    RetValue.strlength = 0 ;       /* initialize return-length to zero   */
+    RetValue.strptr = NULL;       /* initialize return-pointer to empty */
+    RetValue.strlength = 0;       /* initialize return-length to zero   */
 
     rc= (*hRexxStart)((Args) ? 1 : 0 ,               /* number of arguments   */
                        &wArgs,                       /* array of arguments    */
@@ -439,23 +453,29 @@ RXSTRING       RetValue ;
                        RXCOMMAND,                    /* Code for how invoked  */
                        ExitList,                     /* EXITs on this call    */
                        &RetRC,                       /* converted return code */
-                       &RetValue) ;                   /* Rexx program output   */
+                       &RetValue);                   /* Rexx program output   */
 
     if ( rc !=  0 )
     {
-        WRMSG( HHC17502, "E", RexxPackage, RexxPackage, rc) ;
+        WRMSG( HHC17502, "E", RexxPackage, RexxPackage, rc);
     }
     else
     {
-        WRMSG( HHC17503, "I", RexxPackage, argv[1], RetRC) ;
+        if ( MessageLevel > 0)
+        {
+            WRMSG( HHC17503, "I", RexxPackage, argv[1], RetRC);
+            if (RetValue.strptr != NULL)
+            {
+                WRMSG( HHC17504, "I", RexxPackage, argv[1], RetValue.strptr);
+            }
+        }
         if (RetValue.strptr != NULL)
         {
-            WRMSG( HHC17504, "I", RexxPackage, argv[1], RetValue.strptr) ;
-            (*hRexxFreeMemory)(RetValue.strptr) ;
+            (*hRexxFreeMemory)(RetValue.strptr);
         }
 
     }
-    return 0 ;
+    return rc;
 }
 
 /*-------------------------------------------------------------------*/
@@ -464,38 +484,38 @@ RXSTRING       RetValue ;
 int ReginaRexxExecInstoreCmd(char *Command, char *Args,
                             short RetRC, char *Result )
 {
-int rc ;
+int rc;
 
-RXSTRING       wArgs ;
-RXSTRING       Instore[2] ;
-RXSYSEXIT      ExitList[2] ;
-RXSTRING       RetValue ;
+RXSTRING       wArgs;
+RXSTRING       Instore[2];
+RXSYSEXIT      ExitList[2];
+RXSTRING       RetValue;
 
     if ( (*RexxRegisterHandlers)() != 0 )
-        return -1 ;
+        return -1;
 
     if ( Args )
     {
-        MAKERXSTRING(wArgs, Args, strlen(Args)) ;
+        MAKERXSTRING(wArgs, Args, strlen(Args));
     }
     else
     {
-        MAKERXSTRING(wArgs, NULL, 0 ) ;
+        MAKERXSTRING(wArgs, NULL, 0 );
     }
 
-    Instore[0].strptr=Command ;
-    Instore[0].strlength=strlen(Instore[0].strptr) ;
-    Instore[1].strptr=NULL ;
-    Instore[1].strlength=0 ;
+    Instore[0].strptr=Command;
+    Instore[0].strlength=strlen(Instore[0].strptr);
+    Instore[1].strptr=NULL;
+    Instore[1].strlength=0;
 
-    ExitList[0].sysexit_name = hSIOExit ;
-    ExitList[0].sysexit_code = RXSIO ;
-    ExitList[1].sysexit_code = RXENDLST ;
+    ExitList[0].sysexit_name = hSIOExit;
+    ExitList[0].sysexit_code = RXSIO;
+    ExitList[1].sysexit_code = RXENDLST;
 
-    RetValue.strptr=NULL ;
-    RetValue.strlength=0 ;
+    RetValue.strptr=NULL;
+    RetValue.strlength=0;
 
-/*  regina rexx clumsily needs a rexx file name also for Instore scripts ;
+/*  regina rexx clumsily needs a rexx file name also for Instore scripts;
     the issue could be fixed with about five lines of code
     it would also fix a wrong message issued, but ...
     */
@@ -507,21 +527,21 @@ RXSTRING       RetValue ;
                        RXFUNCTION,                   /* Code for how invoked  */
                        ExitList,                     /* EXITs on this call    */
                        &RetRC,                       /* converted return code */
-                       &RetValue) ;                   /* Rexx program output   */
+                       &RetValue);                   /* Rexx program output   */
 
     if ( rc !=  0 )
     {
-        WRMSG( HHC17502, "E", RexxPackage, RexxPackage, rc) ;
+        WRMSG( HHC17502, "E", RexxPackage, RexxPackage, rc);
         if (RetValue.strptr != NULL)
-            (*hRexxFreeMemory)(RetValue.strptr) ;
+            (*hRexxFreeMemory)(RetValue.strptr);
     }
     else
     if (RetValue.strptr != NULL)
     {
-        strcpy(Result,RetValue.strptr) ;
-        (*hRexxFreeMemory)(RetValue.strptr) ;
+        strcpy(Result,RetValue.strptr);
+        (*hRexxFreeMemory)(RetValue.strptr);
     }
-    return rc ;
+    return rc;
 
 }
 #endif /* defined(ENABLE_REGINA_REXX) */
diff --git a/hRexx_readme.txt b/hRexx_readme.txt
index b1df9669..083e08b2 100644
--- a/hRexx_readme.txt
+++ b/hRexx_readme.txt
@@ -113,6 +113,57 @@ the above are needed to run, to compile
 please let me know of standard installations where the Rexx interface
 fails to find the dynamic libraries
 
+changes ..
+
+implemented the "full" autostart facility.
+
+relation with the HREXX_PACKAGE environment variable
+
+when HREXX_PACKAGE undefined/unset ( the most common situation )
+hercules will attempt to enable oorexx first , regina rexx next
+
+when HREXX_PACKAGE has the value "auto"
+same as above
+
+when HREXX_PACKAGE has the value "none"
+no autostart will be attempted
+
+when HREXX_PACKAGE has the value oorexx/regina
+the selected package will be started
+
+the start command has been changed,
+if no package name is entered the above sequence is followed
+
+the help has been modified accordingly
+
+NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE
+the REXX path will be used to search ONLY for the scripts invoked via the exec command
+
+the hercules configuration written in rexx DOES NOT FOLLOW that setup
+the configuration is read at the beginning of the startup process and it must
+be read by the hercules configuration program to understand that it is a rexx script
+so it must be reached thru a PATH available to the shell
+after that rexx will be invoked passing the absolute path to the configuration
+
+example
+current directory     ==> /Hercules/sandhawk.390.build
+hercules invoked with ==> ./hercules -f hercules.rexx
+
+inside the hercules rexx
+
+parse source _src
+say _src
+
+returned              ==> MACOSX COMMAND /Hercules/sandhawk.390.build/hercules.rexx
+
+notice the full resolved path of the configuration file
+
+to do ...
+some cosmetics
+small optimizations
+comment the code ( pretty linear and sequential ) but better do it
+
+enjoy
 
 
 

From 3eff75e6ca0ab3002a5343fa2621c6224bf294ce Mon Sep 17 00:00:00 2001
From: Enrico Sorichetti <e.sorichetti@alice.it>
Date: Sun, 18 Mar 2012 07:42:57 +0100
Subject: [PATCH 10/16] fixed a couple of hRexx glitches, see hRexx_readme

---
 hRexx.c          |  4 ++--
 hRexx.h          |  7 +++++--
 hRexx_readme.txt | 13 ++++++++++++-
 3 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/hRexx.c b/hRexx.c
index add5322a..a365fdf8 100644
--- a/hRexx.c
+++ b/hRexx.c
@@ -744,7 +744,7 @@ short RetRC=0;
             SETREXX_RESET()
             RexxStatus = _STOPPED_ ;
             WRMSG( HHC17521, "I", "");
-            return 0;
+            return -1;
         }
         if ( strcasecmp(envvar, OOREXX_PACKAGE ) == 0  )
         {
@@ -828,7 +828,7 @@ char *envvar;
             RexxExtensions = strdup(envvar);
         }
         else
-            RexxExtensions = strdup(".REXX;.rexx;.REX;.rex;.CMD;.cmd;.RX;.rx");
+            RexxExtensions = strdup(EXTENSIONS);
     }
 
     for (RexxExtensionsCount= 0,ptr = strtok(RexxExtensions, EXTNDELIM ); ptr; ptr = strtok(NULL, EXTNDELIM))
diff --git a/hRexx.h b/hRexx.h
index f418b618..468e7811 100644
--- a/hRexx.h
+++ b/hRexx.h
@@ -26,6 +26,7 @@
 
 #if     defined( _MSVC_ )
 #define EXTNDELIM             ";"
+#define EXTENSIONS            ".REXX;.rexx;.REX;.rex;.CMD;.cmd;.RX;.rx"
 #define PATHDELIM             ";"
 #define PATHFORMAT            "%s\\%s%s"
 #define REGINA_LIBRARY        "regina.dll"
@@ -33,7 +34,8 @@
 #define OOREXX_API_LIBRARY    "rexxapi.dll"
 
 #elif   defined ( __APPLE__ )
-#define EXTNDELIM             ";"
+#define EXTNDELIM             ":"
+#define EXTENSIONS            ".REXX:.rexx:.REX:.rex;.CMD:.cmd:.RX:.rx"
 #define PATHDELIM             ":"
 #define PATHFORMAT            "%s/%s%s"
 #define REGINA_LIBRARY        "libregina.dylib"
@@ -41,7 +43,8 @@
 #define OOREXX_API_LIBRARY    "librexxapi.dylib"
 
 #else
-#define EXTNDELIM             ";"
+#define EXTNDELIM             ":"
+#define EXTENSIONS            ".REXX:.rexx:.REX:.rex;.CMD:.cmd:.RX:.rx"
 #define PATHDELIM             ":"
 #define PATHFORMAT            "%s/%s%s"
 #define REGINA_LIBRARY        "libregina.so"
diff --git a/hRexx_readme.txt b/hRexx_readme.txt
index 083e08b2..0e53b3e9 100644
--- a/hRexx_readme.txt
+++ b/hRexx_readme.txt
@@ -156,7 +156,18 @@ say _src
 
 returned              ==> MACOSX COMMAND /Hercules/sandhawk.390.build/hercules.rexx
 
-notice the full resolved path of the configuration file
+note the full resolved path of the configuration file
+
+
+03/18
+fixed a small glitch where sometimes the rexx status display
+returned a dirty buffer
+
+
+fixed the logic glitch in the extension separator
+USES NOW THE SAME separator as the one used by PATH,
+only one separator to remember !
+
 
 to do ...
 some cosmetics

From 96fb5337aae9822f7b854d0967e1fbc019cd406a Mon Sep 17 00:00:00 2001
From: Enrico Sorichetti <e.sorichetti@alice.it>
Date: Sun, 18 Mar 2012 14:47:38 +0100
Subject: [PATCH 11/16] fix for the MSVC build error, read the decnumber readme
 found the hstdint.h and changed decContext.h accordingly

---
 decNumber/decContext.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/decNumber/decContext.h b/decNumber/decContext.h
index 82e4fcf2..4835a4bf 100644
--- a/decNumber/decContext.h
+++ b/decNumber/decContext.h
@@ -42,7 +42,8 @@
   #define DECCAUTHOR   "Mike Cowlishaw"               /* Who to blame */
 
   #if !defined(int32_t)
-    #include <stdint.h>            /* C99 standard integers           */
+    #include <hstdint.h>           /* user defined C99 std integers   */
+                                   /* as suggested by the readme      */
   #endif
   #include <stdio.h>               /* for printf, etc.                */
   #include <signal.h>              /* for traps                       */

From 3a446c6528258ea9495f79b5ce30a8f79b3b4293 Mon Sep 17 00:00:00 2001
From: Harold Grovesteen <h.grovsteen@tx.rr.com>
Date: Sun, 18 Mar 2012 13:00:17 -0500
Subject: [PATCH 12/16] Update HTML with new repository locations

---
 html/hercinst.html | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/html/hercinst.html b/html/hercinst.html
index 8badaf83..3f0afa40 100644
--- a/html/hercinst.html
+++ b/html/hercinst.html
@@ -64,8 +64,16 @@ <h3>Building from source - Linux and Mac OS X</h3>
 <ol>
 <li>Download the distribution file
 <a href="http://www.hercules-390.org/hercules-3.07.tar.gz">hercules-3.07.tar.gz</a>
-<br><em>Note:</em> By downloading this file you agree to the terms
+or access the 
+<a href="http://github.com/s390guy/hercules-390">development repository</a>
+or the
+<a href="http://sourceforge.net/projects/hercules-390">release repository</a>.
+<br><em>Note:</em> By downloading from any of these sources you agree to the terms
     of the <a href="herclic.html">Q Public Licence</a>.
+<p>The 
+<a href="http://sourceforge.net/projects/hercules-390">release repository</a> 
+site is a mirror site for  
+<a href="http://hercules-390.org">hercules-390.org</a>.
 <p>
 <li>Use these commands to unzip the distribution file:
 <pre>tar xvzf ../hercules-3.07.tar.gz

From 9e8d356e53bca88b59d12e93ea66ccc4425ddf5f Mon Sep 17 00:00:00 2001
From: Jan Jaeger <jan.jaeger@westnet.com.au>
Date: Thu, 22 Mar 2012 00:49:39 +1100
Subject: [PATCH 13/16] Correct PMCW25_VISC

---
 esa390.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/esa390.h b/esa390.h
index d68e5122..f6971098 100644
--- a/esa390.h
+++ b/esa390.h
@@ -1055,12 +1055,13 @@ typedef struct _PMCW {
 #define PMCW5_V         0x01            /* Subchannel valid          */
 
 /* Bit definitions for PMCW flag byte 25 */
-#define PMCW25_VISC     0x1F            /* Guest ISC                 */
+#define PMCW25_VISC     0x07            /* Guest ISC                 */
 #define PMCW25_TYPE     0xE0            /* Subchannel Type           */
 #define PMCW25_TYPE_0   0x00            /* I/O Subchannel            */
 #define PMCW25_TYPE_1   0x20            /* CHSC subchannel           */
 #define PMCW25_TYPE_2   0x40            /* Message subchannel        */
 #define PMCW25_TYPE_3   0x60            /* ADM subchannel            */
+#define PMCW25_RESV     0x18            /* Reserved bits             */
 
 
 /* Bit definitions for PMCW flag byte 27 */

From 5079ab379c9209f4dd1550787a1c4c6d6288fae2 Mon Sep 17 00:00:00 2001
From: Jan Jaeger <jan.jaeger@westnet.com.au>
Date: Thu, 22 Mar 2012 01:05:36 +1100
Subject: [PATCH 14/16] Correct STFL(E) SIE Intercepts

---
 esa390.h |  1 +
 esame.c  | 10 +++++++++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/esa390.h b/esa390.h
index f6971098..88d0d7a5 100644
--- a/esa390.h
+++ b/esa390.h
@@ -1541,6 +1541,7 @@ typedef struct _SIE1BK {                /* SIE State Descriptor      */
 #define SIE_IC0_OPEREX  0x80            /* Intercept operation exc.  */
 #define SIE_IC0_PRIVOP  0x40            /* Intercept priv. op. exc.  */
 #define SIE_IC0_PGMALL  0x20            /* Intercept program ints    */
+#define SIE_IC0_STFL    0x10            /* Intercept STFL/STFLE      */
 #define SIE_IC0_TS1     0x08            /* Intercept TS cc1          */
 #define SIE_IC0_CS1     0x04            /* Intercept CS cc1          */
 #define SIE_IC0_CDS1    0x02            /* Intercept CDS cc1         */
diff --git a/esame.c b/esame.c
index 0a94ceb0..b3f4f883 100644
--- a/esame.c
+++ b/esame.c
@@ -5573,6 +5573,11 @@ PSA    *psa;                            /* -> Prefixed storage area  */
 
     PRIV_CHECK(regs);
 
+#if defined(_FEATURE_SIE)
+    if(SIE_STATB(regs,IC0, STFL))
+        longjmp(regs->progjmp, SIE_INTERCEPT_INST);
+#endif /*defined(_FEATURE_SIE)*/
+
     SIE_INTERCEPT(regs);
 
     PTT(PTT_CL_INF,"STFL",b2,(U32)(effective_addr2 & 0xffffffff),regs->psw.IA_L);
@@ -5603,7 +5608,10 @@ int     cc;                             /* Condition code            */
 
     S(inst, regs, b2, effective_addr2);
 
-    SIE_INTERCEPT(regs);
+#if defined(_FEATURE_SIE)
+    if(SIE_STATB(regs,IC0, STFL))
+        longjmp(regs->progjmp, SIE_INTERCEPT_INST);
+#endif /*defined(_FEATURE_SIE)*/
 
     PTT(PTT_CL_INF,"STFLE",regs->GR_L(0),(U32)(effective_addr2 & 0xffffffff),regs->psw.IA_L);
 

From 39da1cd7aea697f420151e7fb3c7b231d1f60618 Mon Sep 17 00:00:00 2001
From: Jan Jaeger <jan.jaeger@westnet.com.au>
Date: Fri, 23 Mar 2012 22:35:16 +1100
Subject: [PATCH 15/16] QETH Updates

---
 archlvl.c  |   3 ++
 channel.c  |   4 --
 chsc.c     | 118 ++++++++++++++++++++++++++++++++++-------------------
 chsc.h     |  26 ++++++++++--
 esa390.h   |   3 +-
 hstructs.h |   4 +-
 opcode.h   |   2 +-
 qdio.c     |  15 +++++--
 qeth.c     |  24 +++++++++--
 9 files changed, 137 insertions(+), 62 deletions(-)

diff --git a/archlvl.c b/archlvl.c
index 9e608967..12a01d89 100644
--- a/archlvl.c
+++ b/archlvl.c
@@ -273,6 +273,9 @@ FACILITY(LOGICAL_PARTITION,S370|ESA390|ZARCH, NONE, S370|ESA390|ZARCH, ALS0|ALS1
 #if defined(_FEATURE_EMULATE_VM)
 FACILITY(VIRTUAL_MACHINE,  NONE,         NONE,      S370|ESA390|ZARCH, NONE)
 #endif
+// #if defined(_FEATURE_QDIO_ASSIST)
+FACILITY(QDIO_ASSIST,      Z390,         NONE,      Z390,          ALS3)         
+// #endif
 
 { NULL, 0, 0, 0, 0, 0 }
 };
diff --git a/channel.c b/channel.c
index 053186d8..ab0e7666 100644
--- a/channel.c
+++ b/channel.c
@@ -1343,10 +1343,6 @@ DEVBLK *dev;                            /* -> Device control block   */
 int     console = 0;                    /* 1 = console device reset  */
 int i;
 
-    /* Reset channel subsystem back to default initial non-MSS state */
-    sysblk.mss = FALSE;                 /* (not enabled by default)  */
-    sysblk.lcssmax = 0;                 /* (default to single lcss)  */
-
     /* reset sclp interface */
     sclp_reset();
 
diff --git a/chsc.c b/chsc.c
index 31de6b21..e7ece783 100644
--- a/chsc.c
+++ b/chsc.c
@@ -77,7 +77,8 @@ CHSC_RSP4 *chsc_rsp4 = (CHSC_RSP4 *)(chsc_rsp+1);
             chsc_rsp4->path_mask = dev->pmcw.pim;
             STORE_HW(chsc_rsp4->sch, sch);
             memcpy(chsc_rsp4->chpid, dev->pmcw.chpid, 8);
-            chsc_rsp4->fla_valid_mask = dev->pmcw.pim;
+            if(dev->fla[0])
+                chsc_rsp4->fla_valid_mask = dev->pmcw.pim;
             for(n = 0; n < 7; n++)
                 if(dev->pmcw.pim & (0x80 >> n))
                     STORE_HW(chsc_rsp4->fla[n], dev->fla[n]);
@@ -98,7 +99,7 @@ CHSC_RSP4 *chsc_rsp4 = (CHSC_RSP4 *)(chsc_rsp+1);
 }
 
 
-#if 0 // ZZTEST
+#if 1 // ZZTEST
 static int ARCH_DEP(chsc_get_cu_desc) (CHSC_REQ *chsc_req, CHSC_RSP *chsc_rsp)
 {
 U16 req_len, sch, f_sch, l_sch, rsp_len, lcss;
@@ -131,6 +132,25 @@ CHSC_RSP6 *chsc_rsp6 = (CHSC_RSP6 *)(chsc_rsp+1);
     {
     DEVBLK *dev;
         memset(chsc_rsp6, 0, sizeof(CHSC_RSP6) );
+        if((dev = find_device_by_subchan((LCSS_TO_SSID(lcss) << 16)|sch)))
+        {
+            int n;
+
+            chsc_rsp6->sch_val = 1;
+            if(dev->pmcw.flag5 & PMCW5_V)
+                chsc_rsp6->dev_val = 1;
+            chsc_rsp6->st = (dev->pmcw.flag25 & PMCW25_TYPE) >> 5;
+
+            chsc_rsp6->fla_valid_mask = dev->pmcw.pim;
+
+            STORE_HW(chsc_rsp6->devnum,dev->devnum);
+
+            STORE_HW(chsc_rsp6->sch, sch);
+
+            memcpy(chsc_rsp6->chpid, dev->pmcw.chpid, 8);
+            for(n = 0; n < 7; n++)
+                STORE_HW(chsc_rsp6->fla[n], dev->fla[n]);
+        }
     }
 
     /* Store response length */
@@ -188,13 +208,15 @@ U16 req_len, rsp_len;
     CHSC_SB(chsc_rsp10->general_char,12);              /* Dynamic IO */
 #if defined(FEATURE_QUEUED_DIRECT_IO)
     CHSC_SB(chsc_rsp10->general_char,41);  /* Adapter Interruption Facility */
+
     CHSC_SB(chsc_rsp10->chsc_char,1);
+
     CHSC_SB(chsc_rsp10->chsc_char,8);
+
+    if(FACILITY_ENABLED(QDIO_ASSIST, regs))
+        CHSC_SB(chsc_rsp10->general_char,61);         /* QDIO Assist */
 #endif /*defined(FEATURE_QUEUED_DIRECT_IO)*/
-    if(sysblk.mss)
-        CHSC_SB(chsc_rsp10->general_char,45);        /* Multiple CSS */
-//  CHSC_SB(chsc_rsp10->general_char,46);                     /* FCS */
-//  CHSC_SB(chsc_rsp10->general_char,48);                  /* Ext MB */
+
 #if defined(_FEATURE_QDIO_TDD)
     if(FACILITY_ENABLED(QDIO_TDD, regs))
         CHSC_SB(chsc_rsp10->general_char,56);  /* AIF Time Delay Disablement fac*/
@@ -207,12 +229,14 @@ U16 req_len, rsp_len;
     if(FACILITY_ENABLED(QDIO_THININT, regs))
         CHSC_SB(chsc_rsp10->general_char,67);  /* OSA/FCP Thin interrupts */
 #endif /*defined(_FEATURE_QDIO_THININT)*/
+
 //  CHSC_SB(chsc_rsp10->general_char,82);                     /* CIB */
 //  CHSC_SB(chsc_rsp10->general_char,88);                     /* FCX */
 
+//  CHSC_SB(chsc_rsp10->general_char,45);            /* Multiple CSS */
 //  CHSC_SB(chsc_rsp10->chsc_char,84);                       /* SECM */
 //  CHSC_SB(chsc_rsp10->chsc_char,86);                       /* SCMC */
-//  CHSC_SB(chsc_rsp10->chsc_char,107); /* Set Channel Subsystem Char */
+//  CHSC_SB(chsc_rsp10->chsc_char,107);   /* Set Channel Subsys Char */
 //  CHSC_SB(chsc_rsp10->chsc_char,108);                /* Fast CHSCs */
 
     /* Store request OK */
@@ -277,6 +301,7 @@ CHSC_RSP24 *chsc_rsp24 = (CHSC_RSP24 *)(chsc_rsp+1);
 }
 
 
+#if 0
 static int ARCH_DEP(chsc_enable_facility) (CHSC_REQ *chsc_req, CHSC_RSP *chsc_rsp)
 {
 U16 req_len, rsp_len, facility;
@@ -287,21 +312,21 @@ CHSC_RSP31* chsc_rsp31 = (CHSC_RSP31*) (chsc_rsp+1);
     /* Fetch length of request field and validate */
     FETCH_HW( req_len, chsc_req31->length );
 
-    if (0x0400 != req_len) {
-        STORE_HW( chsc_rsp->length,  sizeof(CHSC_RSP) );
-        STORE_HW( chsc_rsp->rsp,     CHSC_REQ_ERRREQ  );
-        STORE_FW( chsc_rsp->info,    0                );
-        STORE_FW( chsc_rsp31->resv1, 0                );
-        return 0;
-    }
-
     /* Calculate response length */
     rsp_len = sizeof(CHSC_RSP) + sizeof(CHSC_RSP31);
 
+    if (req_len < rsp_len) {
+        STORE_HW( chsc_rsp->length, sizeof(CHSC_RSP));
+        STORE_HW( chsc_rsp->rsp, CHSC_REQ_ERRREQ);
+        STORE_FW( chsc_rsp->info, 0);
+        return 0;
+    }
+
     /* Prepare the response */
-    STORE_HW( chsc_rsp->length,  rsp_len );
-    STORE_FW( chsc_rsp->info,    0       );
-    STORE_FW( chsc_rsp31->resv1, 0       );
+    STORE_HW( chsc_rsp->length, rsp_len );
+    STORE_FW( chsc_rsp->info, 0);
+    memset(chsc_rsp31, 0, sizeof(CHSC_RSP31) );
+//  STORE_FW( chsc_rsp31->resv1, 0);
 
     /* Fetch requested facility and enable it */
     FETCH_HW( facility, chsc_req31->facility );
@@ -309,11 +334,11 @@ CHSC_RSP31* chsc_rsp31 = (CHSC_RSP31*) (chsc_rsp+1);
     switch (facility)
     {
     case CHSC_REQ31_MSS:
-        /* Enable Multiple Subchannel-Sets Facility */
-        sysblk.mss     = TRUE;
-        sysblk.lcssmax = FEATURE_LCSS_MAX - 1;
-        STORE_HW( chsc_rsp->rsp, CHSC_REQ_OK );
-        break;
+//      if(FACILITY_ENABLED_DEV(MCSS))
+        {
+            /* Enable Multiple Subchannel-Sets Facility */
+            STORE_HW( chsc_rsp->rsp, CHSC_REQ_OK );
+        }
 
     default: /* Unknown Facility */
         STORE_HW( chsc_rsp->rsp, CHSC_REQ_FACILITY );
@@ -322,6 +347,7 @@ CHSC_RSP31* chsc_rsp31 = (CHSC_RSP31*) (chsc_rsp+1);
 
     return 0;  /* call success */
 }
+#endif
 
 
 #if defined(_FEATURE_QDIO_THININT)
@@ -466,6 +492,8 @@ CHSC_RSP *chsc_rsp;                             /* Response structure*/
 
     RRE(inst, regs, r1, r2);
 
+//  ARCH_DEP(display_inst) (regs, inst);
+
     PRIV_CHECK(regs);
 
     SIE_INTERCEPT(regs);
@@ -495,44 +523,48 @@ CHSC_RSP *chsc_rsp;                             /* Response structure*/
 
     switch(req) {
 
-        case CHSC_REQ_SCHDESC:
-            regs->psw.cc = ARCH_DEP(chsc_get_sch_desc) (chsc_req, chsc_rsp);
-            break;
-
-        case CHSC_REQ_CSSINFO:
-            regs->psw.cc = ARCH_DEP(chsc_get_css_info) (regs, chsc_req, chsc_rsp);
-            break;
-
-        case CHSC_REQ_GETSSQD:
-            regs->psw.cc = ARCH_DEP(chsc_get_ssqd) (chsc_req, chsc_rsp);
-            break;
-
-        case CHSC_REQ_ENFACIL:
-            regs->psw.cc = ARCH_DEP(chsc_enable_facility) (chsc_req, chsc_rsp);
+        case CHSC_REQ_CHPDESC: // 0x0002
+            regs->psw.cc = ARCH_DEP(chsc_get_chp_desc) (chsc_req, chsc_rsp);
             break;
 
-        case CHSC_REQ_CHPDESC:
-            regs->psw.cc = ARCH_DEP(chsc_get_chp_desc) (chsc_req, chsc_rsp);
+        case CHSC_REQ_SCHDESC: // 0x0004
+            regs->psw.cc = ARCH_DEP(chsc_get_sch_desc) (chsc_req, chsc_rsp);
             break;
 
-#if 0 // ZZTEST
-        case CHSC_REQ_CUDESC:
-        case 0x0026:
+#if 1
+        case CHSC_REQ_CUDESC:  // 0x0006
             regs->psw.cc = ARCH_DEP(chsc_get_cu_desc) (chsc_req, chsc_rsp);
             break;
 #endif
 
+        case CHSC_REQ_CSSINFO: // 0x0010
+            regs->psw.cc = ARCH_DEP(chsc_get_css_info) (regs, chsc_req, chsc_rsp);
+            break;
+
 #if defined(_FEATURE_QDIO_THININT)
-        case CHSC_REQ_SETSSSI:
+        case CHSC_REQ_SETSSSI: // 0x0021
             if(FACILITY_ENABLED(QDIO_THININT, regs))
             {
                 regs->psw.cc = ARCH_DEP(chsc_set_sci) (chsc_req, chsc_rsp);
                 break;
             }
+            else
+                goto chsc_error;
             /* Fall through to unkown request if thinint not supported */
 #endif /*defined(_FEATURE_QDIO_THININT)*/
 
+        case CHSC_REQ_GETSSQD: // 0x0024
+            regs->psw.cc = ARCH_DEP(chsc_get_ssqd) (chsc_req, chsc_rsp);
+            break;
+
+#if 0
+        case CHSC_REQ_ENFACIL: // 0x0031
+            regs->psw.cc = ARCH_DEP(chsc_enable_facility) (chsc_req, chsc_rsp);
+            break;
+#endif
+
         default:
+        chsc_error:
             PTT(PTT_CL_ERR,"*CHSC",regs->GR_L(r1),regs->GR_L(r2),regs->psw.IA_L);
             if( HDC3(debug_chsc_unknown_request, chsc_rsp, chsc_req, regs) )
                 break;
diff --git a/chsc.h b/chsc.h
index f814d3c0..c4d7a645 100644
--- a/chsc.h
+++ b/chsc.h
@@ -194,7 +194,25 @@ typedef struct _CHSC_RSP4 {
 
 
 typedef struct _CHSC_RSP6 {
-        BYTE    cuinfo[128];
+        BYTE    sch_val : 1;            /* Subchannel valid          */
+        BYTE    dev_val : 1;            /* Device number valid       */
+        BYTE    st : 3;                 /* Subchannel type           */
+#define CHSC_RSP6_ST_IO     0           /* I/O Subchannel; all fields
+                                           have a meaning            */
+#define CHSC_RSP6_ST_CHSC   1           /* CHSC Subchannel only sch_val
+                                           st and sch have a meaning */
+#define CHSC_RSP6_ST_MSG    2           /* MSG Subchannel; all fields
+                                           except unit_addr have a 
+                                           meaning                   */
+#define CHSC_RPS6_ST_ADM    3           /* ADM Subchannel; Only sch_val
+                                           st and sch have a meaning */
+        BYTE    zeros : 3;
+        BYTE    fla_valid_mask;         /* Link Address validty mask */
+        HWORD   devnum;                 /* Control Unit Number       */
+        HWORD   resv1;                  /* Valid link mask           */
+        HWORD   sch;                    /* Subchannel number         */
+        BYTE    chpid[8];               /* Channel path array        */
+        HWORD   fla[8];                 /* Full link address array   */
     } CHSC_RSP6;
 
 
@@ -238,11 +256,13 @@ typedef struct _CHSC_RSP24 {
         HWORD   qdioac2;
 /* qdio adapter-characteristics-2 flag */
 #define QETH_SNIFF_AVAIL                0x0008  /* Promisc mode avail */
+#define QETH_AC2_DATA_DIV_AVAILABLE     0x0010
+#define QETH_AC2_DATA_DIV_ENABLED       0x0002
         DBLWRD  sch_token;
         BYTE    mro;
         BYTE    mri;
-        BYTE    resv4;
-        BYTE    sbalic;
+        HWORD   qdioac3; 
+#define QETH_AC3_FORMAT2_CQ_AVAILABLE   0x8000
         HWORD   resv5;
         BYTE    resv6;
         BYTE    mmwc;
diff --git a/esa390.h b/esa390.h
index 88d0d7a5..46a42ea6 100644
--- a/esa390.h
+++ b/esa390.h
@@ -1453,8 +1453,9 @@ typedef struct _MBK {
 #define STFL_SVS                (STFL_HBASE+9)
 #define STFL_LOGICAL_PARTITION  (STFL_HBASE+10)
 #define STFL_VIRTUAL_MACHINE    (STFL_HBASE+11)
+#define STFL_QDIO_ASSIST        (STFL_HBASE+12)
 
-#define STFL_HMAX               (STFL_HBASE+11)
+#define STFL_HMAX               (STFL_HBASE+12)
 #define STFL_HBYTESIZE (((STFL_HMAX+8))/8)
 #define STFL_HDWRDSIZE ((STFL_HBYTESIZE+7)/8)
 
diff --git a/hstructs.h b/hstructs.h
index 4b07c40b..2a503814 100644
--- a/hstructs.h
+++ b/hstructs.h
@@ -605,8 +605,6 @@ struct SYSBLK {
         /*      I/O Management                                       */
         /*-----------------------------------------------------------*/
 
-        int     mss;                    /* Multiple CSS enabled      */
-        int     lcssmax;                /* Maximum Subchannel-Set Id */
         U32     chp_reset[8];           /* Channel path reset masks  */
         IOINT  *iointq;                 /* I/O interrupt queue       */
 #if !defined(OPTION_FISHIO)
@@ -1071,6 +1069,7 @@ struct DEVBLK {                         /* Device configuration block*/
         BYTE    pgstat;                 /* Path Group Status         */
         BYTE    pgid[11];               /* Path Group ID             */
         BYTE    reserved2[4];           /* (pad/align/unused/avail)  */
+        U16     fla[8];                 /* Full Link Address Array   */
         COND    resumecond;             /* Resume condition          */
         COND    iocond;                 /* I/O active condition      */
         int     iowaiters;              /* Number of I/O waiters     */
@@ -1079,7 +1078,6 @@ struct DEVBLK {                         /* Device configuration block*/
 #define DEV_SYS_LOCAL   0xffff          /* Local system active on dev*/
         BYTE    drvpwd[11];             /* Password for drive        */
         BYTE    sensemm[5];             /* Manuf. & model for sense  */
-        U16     fla[8];                 /* Full Link Address Array   */
 
         /*  control flags...                                         */
         unsigned int                    /* Flags                     */
diff --git a/opcode.h b/opcode.h
index bc49a8d3..da92b7d4 100644
--- a/opcode.h
+++ b/opcode.h
@@ -555,7 +555,7 @@ do { \
 
 #define SSID_CHECK(_regs) \
     if((!((_regs)->GR_LHH(1) & 0x0001)) \
-    || (_regs)->GR_LHH(1) > (0x0001|((sysblk.lcssmax) << 1))) \
+    || (_regs)->GR_LHH(1) > (0x0001|(FEATURE_LCSS_MAX-1))) \
         (_regs)->program_interrupt( (_regs), PGM_OPERAND_EXCEPTION)
 
 #define IOID_TO_SSID(_ioid) \
diff --git a/qdio.c b/qdio.c
index d8dbf10f..8e6f228b 100644
--- a/qdio.c
+++ b/qdio.c
@@ -47,7 +47,10 @@ DEVBLK *dev;                            /* -> device block           */
 
     PRIV_CHECK(regs);
 
-    SIE_INTERCEPT(regs);
+#if defined(_FEATURE_SIE)
+    if(SIE_STATNB(regs, EC3, SIGAA))
+        longjmp(regs->progjmp, SIE_INTERCEPT_INST);
+#endif /*defined(_FEATURE_SIE)*/
 
     PTIO(IO,"SIGA");
 
@@ -194,7 +197,10 @@ U64     slsba;                 /* Storage list state block address   */
 
     PRIV_CHECK(regs);
 
-    SIE_INTERCEPT(regs);
+#if defined(_FEATURE_SIE)
+    if(SIE_STATNB(regs, EC3, SIGAA))
+        longjmp(regs->progjmp, SIE_INTERCEPT_INST);
+#endif /*defined(_FEATURE_SIE)*/
 
     PTIO(INF,"SQBS");
 
@@ -296,7 +302,10 @@ U64     slsba;                /* Storage list state block address    */
 
     PRIV_CHECK(regs);
 
-    SIE_INTERCEPT(regs);
+#if defined(_FEATURE_SIE)
+    if(SIE_STATNB(regs, EC3, SIGAA))
+        longjmp(regs->progjmp, SIE_INTERCEPT_INST);
+#endif /*defined(_FEATURE_SIE)*/
 
     PTIO(INF,"EQBS");
 
diff --git a/qeth.c b/qeth.c
index bd2e2e84..ba08378b 100644
--- a/qeth.c
+++ b/qeth.c
@@ -1214,6 +1214,17 @@ int i;
             grp->ttmtu = strdup(argv[++i]);
             continue;
         }
+        else if(!strcasecmp("chpid",argv[i]) && (i+1) < argc)
+        {
+            int chpid;
+            char c;
+            if(sscanf(argv[++i], "%x%c", &chpid, &c) != 1 || chpid < 0x00 || chpid > 0xFF)
+                logmsg(_("QETH: Invalid channel path id %s for device %4.4X\n"),argv[i],dev->devnum);
+
+            else
+                dev->pmcw.chpid[0] = chpid;
+            continue;
+        }
         else if(!strcasecmp("debug",argv[i]) && (i+1) < argc)
         {
             grp->debug = 1;
@@ -1226,9 +1237,9 @@ int i;
 
     if(grouped)
     {
-        dev->group->memdev[OSA_DATA_DEVICE]->pmcw.flag4 |= PMCW4_Q;
-//      for(i = 0; i < OSA_GROUP_SIZE; i++)
-//          dev->group->memdev[i]->pmcw.flag4 |= PMCW4_Q;
+//      dev->group->memdev[OSA_DATA_DEVICE]->pmcw.flag4 |= PMCW4_Q;
+        for(i = 0; i < OSA_GROUP_SIZE; i++)
+            dev->group->memdev[i]->pmcw.flag4 |= PMCW4_Q;
     }
 
     return 0;
@@ -1372,7 +1383,12 @@ static int qeth_ssqd_desc ( DEVBLK *dev, void *desc )
 
     if(dev->pmcw.flag4 & PMCW4_Q)
     {
-
+#if 0
+chsc_rsp24->pcnt = 0x10;
+chsc_rsp24->icnt = 0x01;
+chsc_rsp24->ocnt = 0x20;
+STORE_HW(chsc_rsp24->qdioac2, 0x4000);
+#endif
         chsc_rsp24->flags |= ( CHSC_FLAG_QDIO_CAPABILITY | CHSC_FLAG_VALIDITY );
 
         chsc_rsp24->qdioac1 |= ( AC1_SIGA_INPUT_NEEDED | AC1_SIGA_OUTPUT_NEEDED );

From f57c12fdb31aff0be78ba28cb502ccfbff17f266 Mon Sep 17 00:00:00 2001
From: Jan Jaeger <jan.jaeger@westnet.com.au>
Date: Fri, 23 Mar 2012 22:56:03 +1100
Subject: [PATCH 16/16] Add CHSC status bits

---
 chsc.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/chsc.c b/chsc.c
index e7ece783..0cbb641e 100644
--- a/chsc.c
+++ b/chsc.c
@@ -209,9 +209,10 @@ U16 req_len, rsp_len;
 #if defined(FEATURE_QUEUED_DIRECT_IO)
     CHSC_SB(chsc_rsp10->general_char,41);  /* Adapter Interruption Facility */
 
-    CHSC_SB(chsc_rsp10->chsc_char,1);
-
-    CHSC_SB(chsc_rsp10->chsc_char,8);
+    CHSC_SB(chsc_rsp10->chsc_char,1); // 0x0002 Supported
+    CHSC_SB(chsc_rsp10->chsc_char,2); // 0x0006 Supported
+    CHSC_SB(chsc_rsp10->chsc_char,3); // 0x0004 Supported
+    CHSC_SB(chsc_rsp10->chsc_char,8); // 0x0024 Supported
 
     if(FACILITY_ENABLED(QDIO_ASSIST, regs))
         CHSC_SB(chsc_rsp10->general_char,61);         /* QDIO Assist */