From e0366be6deac9eb9848644ab74a7c8e8effc0767 Mon Sep 17 00:00:00 2001
From: Carolina Zheng <swirlinq@gmail.com>
Date: Tue, 12 Sep 2017 20:32:20 -0400
Subject: [PATCH 1/9] Implement part 1

---
 stream_compaction/cpu.cu | 53 ++++++++++++++++++++++++++++++++++++----
 1 file changed, 48 insertions(+), 5 deletions(-)

diff --git a/stream_compaction/cpu.cu b/stream_compaction/cpu.cu
index 05ce667..8d8d39d 100644
--- a/stream_compaction/cpu.cu
+++ b/stream_compaction/cpu.cu
@@ -19,7 +19,14 @@ namespace StreamCompaction {
          */
         void scan(int n, int *odata, const int *idata) {
 	        timer().startCpuTimer();
-            // TODO
+
+          odata[0] = 0;
+
+          for (int i = 1; i < n; i++)
+          {
+            odata[i] = odata[i - 1] + idata[i - 1];
+          }
+
 	        timer().endCpuTimer();
         }
 
@@ -29,10 +36,21 @@ namespace StreamCompaction {
          * @returns the number of elements remaining after compaction.
          */
         int compactWithoutScan(int n, int *odata, const int *idata) {
+          int j = 0;
+
 	        timer().startCpuTimer();
-            // TODO
+
+          for (int i = 0; i < n; i++)
+          {
+            if (idata[i] != 0)
+            {
+              odata[j++] = idata[i];
+            }
+          }
+
 	        timer().endCpuTimer();
-            return -1;
+
+          return j;
         }
 
         /**
@@ -41,10 +59,35 @@ namespace StreamCompaction {
          * @returns the number of elements remaining after compaction.
          */
         int compactWithScan(int n, int *odata, const int *idata) {
+          int *scanResult = new int[n];
+          int j = 0;
+
 	        timer().startCpuTimer();
-	        // TODO
+
+          for (int i = 0; i < n; i++)
+          {
+            odata[i] = idata[i] == 0 ? 0 : 1;
+          }
+
+          scan(n, scanResult, odata);
+
+          for (int i = 0; i < n - 1; i++)
+          {
+            if (scanResult[i] < scanResult[i + 1])
+            {
+              odata[j++] = idata[i];
+            }
+          }
+
+          if (idata[n - 1] != 0)
+          {
+            odata[j++] = idata[n - 1];
+          }
+
 	        timer().endCpuTimer();
-            return -1;
+
+          free(scanResult);
+          return j;
         }
     }
 }

From 53187cebd7881bc6d51591f7be9947b5c42443ed Mon Sep 17 00:00:00 2001
From: Carolina Zheng <swirlinq@gmail.com>
Date: Thu, 14 Sep 2017 14:43:24 -0400
Subject: [PATCH 2/9] Finish 1, work on 2

---
 stream_compaction/cpu.cu   | 14 +++----
 stream_compaction/naive.cu | 80 +++++++++++++++++++++++++++++++-------
 2 files changed, 72 insertions(+), 22 deletions(-)

diff --git a/stream_compaction/cpu.cu b/stream_compaction/cpu.cu
index 8d8d39d..55e4fa1 100644
--- a/stream_compaction/cpu.cu
+++ b/stream_compaction/cpu.cu
@@ -18,7 +18,7 @@ namespace StreamCompaction {
          * (Optional) For better understanding before starting moving to GPU, you can simulate your GPU scan in this function first.
          */
         void scan(int n, int *odata, const int *idata) {
-	        timer().startCpuTimer();
+	        //timer().startCpuTimer();
 
           odata[0] = 0;
 
@@ -27,7 +27,7 @@ namespace StreamCompaction {
             odata[i] = odata[i - 1] + idata[i - 1];
           }
 
-	        timer().endCpuTimer();
+	        //timer().endCpuTimer();
         }
 
         /**
@@ -71,17 +71,17 @@ namespace StreamCompaction {
 
           scan(n, scanResult, odata);
 
-          for (int i = 0; i < n - 1; i++)
+          for (int i = 0; i < n-1; i++)
           {
-            if (scanResult[i] < scanResult[i + 1])
+            if (odata[i] == 1)
             {
-              odata[j++] = idata[i];
+              odata[scanResult[i]] = idata[i];
             }
           }
 
-          if (idata[n - 1] != 0)
+          if (odata[n - 1] == 1)
           {
-            odata[j++] = idata[n - 1];
+            odata[scanResult[n - 1] + 1] = idata[n - 1];
           }
 
 	        timer().endCpuTimer();
diff --git a/stream_compaction/naive.cu b/stream_compaction/naive.cu
index 9218f8e..79a04d0 100644
--- a/stream_compaction/naive.cu
+++ b/stream_compaction/naive.cu
@@ -4,22 +4,72 @@
 #include "naive.h"
 
 namespace StreamCompaction {
-    namespace Naive {
-        using StreamCompaction::Common::PerformanceTimer;
-        PerformanceTimer& timer()
-        {
-            static PerformanceTimer timer;
-            return timer;
+  namespace Naive {
+    using StreamCompaction::Common::PerformanceTimer;
+    PerformanceTimer& timer()
+    {
+      static PerformanceTimer timer;
+      return timer;
+    }
+
+    int *dev_input;
+    int *dev_output1;
+    int *dev_output2;
+
+    const int BLOCK_SIZE = 128;
+
+    __global__ void kernScan(int n, int *dev_input, int *dev_output1, int *dev_output2)
+    {
+      int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+
+      if (index >= n)
+      {
+        return;
+      }
+
+      dev_output1[index] = index > 0 ? dev_input[index - 1] : 0;
+      __syncthreads();
+
+      for (int d = 1; d <= ilog2ceil(n); d++)
+      {
+
+        int offset = pow(2, d - 1);
+        if (index >= offset)
+        {
+          dev_output2[index] = dev_output1[index - offset] + dev_output1[index];
         }
-        // TODO: __global__
-
-        /**
-         * Performs prefix-sum (aka scan) on idata, storing the result into odata.
-         */
-        void scan(int n, int *odata, const int *idata) {
-            timer().startGpuTimer();
-            // TODO
-            timer().endGpuTimer();
+        else
+        {
+          dev_output2[index] = dev_output1[index];
         }
+
+        int *temp = dev_output1;
+        dev_output1 = dev_output2;
+        dev_output2 = temp;
+        __syncthreads();
+      }
+    }
+
+    /**
+     * Performs prefix-sum (aka scan) on idata, storing the result into odata.
+     */
+    void scan(int n, int *odata, const int *idata) {
+      int numBlocks = (n + BLOCK_SIZE - 1) / BLOCK_SIZE;
+      cudaMalloc((void**)dev_input, n * sizeof(int));
+      cudaMalloc((void**)&dev_output1, n * sizeof(int));
+      cudaMalloc((void**)&dev_output2, n * sizeof(int));
+
+      cudaMemcpy(dev_input, idata, n * sizeof(int), cudaMemcpyHostToDevice);
+
+      timer().startGpuTimer();
+      kernScan << <numBlocks, BLOCK_SIZE >> > (n, dev_input, dev_output1, dev_output2);
+      timer().endGpuTimer();
+
+      cudaMemcpy(odata, dev_output1, n * sizeof(int), cudaMemcpyDeviceToHost);
+
+      cudaFree(dev_input);
+      cudaFree(dev_output1);
+      cudaFree(dev_output2);
     }
+  }
 }

From 3f3fe3f99589a472c2de02e39575984696cccff6 Mon Sep 17 00:00:00 2001
From: Carolina Zheng <swirlinq@gmail.com>
Date: Sun, 17 Sep 2017 14:40:26 -0400
Subject: [PATCH 3/9] Part 2 passes tests

---
 src/main.cpp               | 85 +++++++++++++++++++-------------------
 stream_compaction/cpu.cu   |  2 +
 stream_compaction/naive.cu | 61 +++++++++++++++++----------
 3 files changed, 84 insertions(+), 64 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index 7305641..e29de84 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -14,6 +14,7 @@
 #include "testing_helpers.hpp"
 
 const int SIZE = 1 << 8; // feel free to change the size of array
+//const int SIZE = 4;
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
 int a[SIZE], b[SIZE], c[SIZE];
 
@@ -49,43 +50,43 @@ int main(int argc, char* argv[]) {
     printDesc("naive scan, power-of-two");
     StreamCompaction::Naive::scan(SIZE, c, a);
     printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(SIZE, c, true);
+    printArray(SIZE, c, true);
     printCmpResult(SIZE, b, c);
 
     zeroArray(SIZE, c);
     printDesc("naive scan, non-power-of-two");
     StreamCompaction::Naive::scan(NPOT, c, a);
     printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(SIZE, c, true);
+    printArray(SIZE, c, true);
     printCmpResult(NPOT, b, c);
 
-    zeroArray(SIZE, c);
-    printDesc("work-efficient scan, power-of-two");
-    StreamCompaction::Efficient::scan(SIZE, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(SIZE, c, true);
-    printCmpResult(SIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("work-efficient scan, non-power-of-two");
-    StreamCompaction::Efficient::scan(NPOT, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(NPOT, c, true);
-    printCmpResult(NPOT, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("thrust scan, power-of-two");
-    StreamCompaction::Thrust::scan(SIZE, c, a);
-    printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(SIZE, c, true);
-    printCmpResult(SIZE, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("thrust scan, non-power-of-two");
-    StreamCompaction::Thrust::scan(NPOT, c, a);
-    printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(NPOT, c, true);
-    printCmpResult(NPOT, b, c);
+    //zeroArray(SIZE, c);
+    //printDesc("work-efficient scan, power-of-two");
+    //StreamCompaction::Efficient::scan(SIZE, c, a);
+    //printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    ////printArray(SIZE, c, true);
+    //printCmpResult(SIZE, b, c);
+
+    //zeroArray(SIZE, c);
+    //printDesc("work-efficient scan, non-power-of-two");
+    //StreamCompaction::Efficient::scan(NPOT, c, a);
+    //printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    ////printArray(NPOT, c, true);
+    //printCmpResult(NPOT, b, c);
+
+    //zeroArray(SIZE, c);
+    //printDesc("thrust scan, power-of-two");
+    //StreamCompaction::Thrust::scan(SIZE, c, a);
+    //printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    ////printArray(SIZE, c, true);
+    //printCmpResult(SIZE, b, c);
+
+    //zeroArray(SIZE, c);
+    //printDesc("thrust scan, non-power-of-two");
+    //StreamCompaction::Thrust::scan(NPOT, c, a);
+    //printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    ////printArray(NPOT, c, true);
+    //printCmpResult(NPOT, b, c);
 
     printf("\n");
     printf("*****************************\n");
@@ -125,19 +126,19 @@ int main(int argc, char* argv[]) {
     printArray(count, c, true);
     printCmpLenResult(count, expectedCount, b, c);
 
-    zeroArray(SIZE, c);
-    printDesc("work-efficient compact, power-of-two");
-    count = StreamCompaction::Efficient::compact(SIZE, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(count, c, true);
-    printCmpLenResult(count, expectedCount, b, c);
-
-    zeroArray(SIZE, c);
-    printDesc("work-efficient compact, non-power-of-two");
-    count = StreamCompaction::Efficient::compact(NPOT, c, a);
-    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(count, c, true);
-    printCmpLenResult(count, expectedNPOT, b, c);
+    //zeroArray(SIZE, c);
+    //printDesc("work-efficient compact, power-of-two");
+    //count = StreamCompaction::Efficient::compact(SIZE, c, a);
+    //printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    ////printArray(count, c, true);
+    //printCmpLenResult(count, expectedCount, b, c);
+
+    //zeroArray(SIZE, c);
+    //printDesc("work-efficient compact, non-power-of-two");
+    //count = StreamCompaction::Efficient::compact(NPOT, c, a);
+    //printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    ////printArray(count, c, true);
+    //printCmpLenResult(count, expectedNPOT, b, c);
 
     system("pause"); // stop Win32 console from closing on exit
 }
diff --git a/stream_compaction/cpu.cu b/stream_compaction/cpu.cu
index 55e4fa1..b2f43d0 100644
--- a/stream_compaction/cpu.cu
+++ b/stream_compaction/cpu.cu
@@ -76,12 +76,14 @@ namespace StreamCompaction {
             if (odata[i] == 1)
             {
               odata[scanResult[i]] = idata[i];
+              j++;
             }
           }
 
           if (odata[n - 1] == 1)
           {
             odata[scanResult[n - 1] + 1] = idata[n - 1];
+            j++;
           }
 
 	        timer().endCpuTimer();
diff --git a/stream_compaction/naive.cu b/stream_compaction/naive.cu
index 79a04d0..d16efd0 100644
--- a/stream_compaction/naive.cu
+++ b/stream_compaction/naive.cu
@@ -18,7 +18,7 @@ namespace StreamCompaction {
 
     const int BLOCK_SIZE = 128;
 
-    __global__ void kernScan(int n, int *dev_input, int *dev_output1, int *dev_output2)
+    __global__ void kernScan(int n, int offset, int *dev_input, int *dev_output1, int *dev_output2)
     {
       int index = (blockIdx.x * blockDim.x) + threadIdx.x;
 
@@ -27,27 +27,26 @@ namespace StreamCompaction {
         return;
       }
 
-      dev_output1[index] = index > 0 ? dev_input[index - 1] : 0;
-      __syncthreads();
-
-      for (int d = 1; d <= ilog2ceil(n); d++)
+      if (index >= offset)
+      {
+        dev_output2[index] = dev_output1[index - offset] + dev_output1[index];
+      }
+      else
       {
+        dev_output2[index] = dev_output1[index];
+      }
+    }
 
-        int offset = pow(2, d - 1);
-        if (index >= offset)
-        {
-          dev_output2[index] = dev_output1[index - offset] + dev_output1[index];
-        }
-        else
-        {
-          dev_output2[index] = dev_output1[index];
-        }
-
-        int *temp = dev_output1;
-        dev_output1 = dev_output2;
-        dev_output2 = temp;
-        __syncthreads();
+    __global__ void kernShift(int n, int *dev_input, int *dev_output)
+    {
+      int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+
+      if (index >= n)
+      {
+        return;
       }
+
+      dev_output[index] = index > 0 ? dev_input[index - 1] : 0;
     }
 
     /**
@@ -55,14 +54,32 @@ namespace StreamCompaction {
      */
     void scan(int n, int *odata, const int *idata) {
       int numBlocks = (n + BLOCK_SIZE - 1) / BLOCK_SIZE;
-      cudaMalloc((void**)dev_input, n * sizeof(int));
+      int *temp;
+      int d, offset;
+
+      cudaMalloc((void**)&dev_input, n * sizeof(int));
       cudaMalloc((void**)&dev_output1, n * sizeof(int));
       cudaMalloc((void**)&dev_output2, n * sizeof(int));
 
       cudaMemcpy(dev_input, idata, n * sizeof(int), cudaMemcpyHostToDevice);
 
       timer().startGpuTimer();
-      kernScan << <numBlocks, BLOCK_SIZE >> > (n, dev_input, dev_output1, dev_output2);
+
+      kernShift << <numBlocks, BLOCK_SIZE >> > (n, dev_input, dev_output1);
+
+      cudaMemcpy(odata, dev_output1, n * sizeof(int), cudaMemcpyDeviceToHost);
+
+      for (d = 1; d <= ilog2ceil(n); d++)
+      {
+        offset = pow(2, d - 1);
+
+        kernScan << <numBlocks, BLOCK_SIZE >> > (n, offset, dev_input, dev_output1, dev_output2);
+
+        temp = dev_output1;
+        dev_output1 = dev_output2;
+        dev_output2 = temp;
+      }
+
       timer().endGpuTimer();
 
       cudaMemcpy(odata, dev_output1, n * sizeof(int), cudaMemcpyDeviceToHost);
@@ -72,4 +89,4 @@ namespace StreamCompaction {
       cudaFree(dev_output2);
     }
   }
-}
+}
\ No newline at end of file

From 2050ae82b2373219ec206893a23c591ec12a82b8 Mon Sep 17 00:00:00 2001
From: Carolina Zheng <swirlinq@gmail.com>
Date: Sun, 17 Sep 2017 16:10:42 -0400
Subject: [PATCH 4/9] Efficient scan passes tests, start compact

---
 src/main.cpp                   | 28 ++++++-------
 stream_compaction/common.cu    | 23 +++++++++-
 stream_compaction/efficient.cu | 77 ++++++++++++++++++++++++++++++++--
 stream_compaction/naive.cu     |  2 -
 4 files changed, 109 insertions(+), 21 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index e29de84..674bb31 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -60,32 +60,32 @@ int main(int argc, char* argv[]) {
     printArray(SIZE, c, true);
     printCmpResult(NPOT, b, c);
 
-    //zeroArray(SIZE, c);
-    //printDesc("work-efficient scan, power-of-two");
-    //StreamCompaction::Efficient::scan(SIZE, c, a);
-    //printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    ////printArray(SIZE, c, true);
-    //printCmpResult(SIZE, b, c);
+    zeroArray(SIZE, c);
+    printDesc("work-efficient scan, power-of-two");
+    StreamCompaction::Efficient::scan(SIZE, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(SIZE, c, true);
+    printCmpResult(SIZE, b, c);
 
-    //zeroArray(SIZE, c);
-    //printDesc("work-efficient scan, non-power-of-two");
-    //StreamCompaction::Efficient::scan(NPOT, c, a);
-    //printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    ////printArray(NPOT, c, true);
-    //printCmpResult(NPOT, b, c);
+    zeroArray(SIZE, c);
+    printDesc("work-efficient scan, non-power-of-two");
+    StreamCompaction::Efficient::scan(NPOT, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(NPOT, c, true);
+    printCmpResult(NPOT, b, c);
 
     //zeroArray(SIZE, c);
     //printDesc("thrust scan, power-of-two");
     //StreamCompaction::Thrust::scan(SIZE, c, a);
     //printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    ////printArray(SIZE, c, true);
+    //printArray(SIZE, c, true);
     //printCmpResult(SIZE, b, c);
 
     //zeroArray(SIZE, c);
     //printDesc("thrust scan, non-power-of-two");
     //StreamCompaction::Thrust::scan(NPOT, c, a);
     //printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    ////printArray(NPOT, c, true);
+    //printArray(NPOT, c, true);
     //printCmpResult(NPOT, b, c);
 
     printf("\n");
diff --git a/stream_compaction/common.cu b/stream_compaction/common.cu
index 8fc0211..85b5458 100644
--- a/stream_compaction/common.cu
+++ b/stream_compaction/common.cu
@@ -23,7 +23,14 @@ namespace StreamCompaction {
          * which map to 0 will be removed, and elements which map to 1 will be kept.
          */
         __global__ void kernMapToBoolean(int n, int *bools, const int *idata) {
-            // TODO
+          int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+
+          if (index >= n)
+          {
+            return;
+          }
+
+          bools[index] = idata[index] != 0 ? 1 : 0;
         }
 
         /**
@@ -32,7 +39,19 @@ namespace StreamCompaction {
          */
         __global__ void kernScatter(int n, int *odata,
                 const int *idata, const int *bools, const int *indices) {
-            // TODO
+          int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+
+          if (index >= n)
+          {
+            return;
+          }
+
+          if (bools[index] == 1)
+          {
+            int offset = index == n - 1 ? 1 : 0;
+
+            odata[indices[index] + offset] = idata[index];
+          }
         }
 
     }
diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu
index 36c5ef2..79c33d4 100644
--- a/stream_compaction/efficient.cu
+++ b/stream_compaction/efficient.cu
@@ -12,13 +12,84 @@ namespace StreamCompaction {
             return timer;
         }
 
+        int *dev_data;
+
+        const int BLOCK_SIZE = 128;
+
+        __global__ void kernUpSweep(int n, int width, int *data)
+        {
+          int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+
+          if (index >= n)
+          {
+            return;
+          }
+
+          data[(index + 1) * width - 1] += data[index * width - 1 + (width / 2)];
+        }
+
+        __global__ void kernDownSweep(int n, int width, int *data)
+        {
+          int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+
+          if (index >= n)
+          {
+            return;
+          }
+
+          int halfIndex = index * width - 1 + (width / 2);
+          int fullIndex = (index + 1) * width - 1;
+          int oldHalfIndexValue = data[halfIndex];
+
+          data[halfIndex] = data[fullIndex];
+          data[fullIndex] += oldHalfIndexValue;
+        }
+
+        __global__ void kernSetValueToZero(int i, int *data)
+        {
+          data[i] = 0;
+        }
+
         /**
          * Performs prefix-sum (aka scan) on idata, storing the result into odata.
          */
         void scan(int n, int *odata, const int *idata) {
-            timer().startGpuTimer();
-            // TODO
-            timer().endGpuTimer();
+          int d, width, numThreads, numBlocks;
+
+          int nPowerOfTwo = pow(2, ilog2ceil(n));
+          int numIterations = ilog2(nPowerOfTwo) - 1;
+
+          cudaMalloc((void**)&dev_data, nPowerOfTwo * sizeof(int));
+
+          cudaMemcpy(dev_data, idata, n * sizeof(int), cudaMemcpyHostToDevice);
+
+          timer().startGpuTimer();
+
+          for (d = 0; d <= numIterations; d++)
+          {
+            width = pow(2, d + 1);
+            numThreads = nPowerOfTwo / width;
+            numBlocks = (numThreads + BLOCK_SIZE - 1) / BLOCK_SIZE;
+
+            kernUpSweep << <numBlocks, BLOCK_SIZE >> > (numThreads, width, dev_data);
+          }
+
+          kernSetValueToZero << <1, 1 >> > (nPowerOfTwo - 1, dev_data);
+
+          for (d = numIterations; d >= 0; d--)
+          {
+            width = pow(2, d + 1);
+            numThreads = nPowerOfTwo / width;
+            numBlocks = (numThreads + BLOCK_SIZE - 1) / BLOCK_SIZE;
+
+            kernDownSweep << <numBlocks, BLOCK_SIZE >> > (numThreads, width, dev_data);
+          }
+
+          timer().endGpuTimer();
+
+          cudaMemcpy(odata, dev_data, n * sizeof(int), cudaMemcpyDeviceToHost);
+
+          cudaFree(dev_data);
         }
 
         /**
diff --git a/stream_compaction/naive.cu b/stream_compaction/naive.cu
index d16efd0..73cdad2 100644
--- a/stream_compaction/naive.cu
+++ b/stream_compaction/naive.cu
@@ -67,8 +67,6 @@ namespace StreamCompaction {
 
       kernShift << <numBlocks, BLOCK_SIZE >> > (n, dev_input, dev_output1);
 
-      cudaMemcpy(odata, dev_output1, n * sizeof(int), cudaMemcpyDeviceToHost);
-
       for (d = 1; d <= ilog2ceil(n); d++)
       {
         offset = pow(2, d - 1);

From 6bb4e31d0a751e64fbb29b3eafaf9fae1189505f Mon Sep 17 00:00:00 2001
From: Carolina Zheng <swirlinq@gmail.com>
Date: Mon, 18 Sep 2017 14:58:10 -0400
Subject: [PATCH 5/9] Almost finish 3.2

---
 src/main.cpp                   |  28 ++--
 stream_compaction/efficient.cu | 243 +++++++++++++++++++--------------
 2 files changed, 154 insertions(+), 117 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index 674bb31..dc0b43e 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -13,8 +13,8 @@
 #include <stream_compaction/thrust.h>
 #include "testing_helpers.hpp"
 
-const int SIZE = 1 << 8; // feel free to change the size of array
-//const int SIZE = 4;
+//const int SIZE = 1 << 8; // feel free to change the size of array
+const int SIZE = 8;
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
 int a[SIZE], b[SIZE], c[SIZE];
 
@@ -126,19 +126,19 @@ int main(int argc, char* argv[]) {
     printArray(count, c, true);
     printCmpLenResult(count, expectedCount, b, c);
 
-    //zeroArray(SIZE, c);
-    //printDesc("work-efficient compact, power-of-two");
-    //count = StreamCompaction::Efficient::compact(SIZE, c, a);
-    //printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    ////printArray(count, c, true);
-    //printCmpLenResult(count, expectedCount, b, c);
+    zeroArray(SIZE, c);
+    printDesc("work-efficient compact, power-of-two");
+    count = StreamCompaction::Efficient::compact(SIZE, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(count, c, true);
+    printCmpLenResult(count, expectedCount, b, c);
 
-    //zeroArray(SIZE, c);
-    //printDesc("work-efficient compact, non-power-of-two");
-    //count = StreamCompaction::Efficient::compact(NPOT, c, a);
-    //printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    ////printArray(count, c, true);
-    //printCmpLenResult(count, expectedNPOT, b, c);
+    zeroArray(SIZE, c);
+    printDesc("work-efficient compact, non-power-of-two");
+    count = StreamCompaction::Efficient::compact(NPOT, c, a);
+    printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(count, c, true);
+    printCmpLenResult(count, expectedNPOT, b, c);
 
     system("pause"); // stop Win32 console from closing on exit
 }
diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu
index 79c33d4..2aecb98 100644
--- a/stream_compaction/efficient.cu
+++ b/stream_compaction/efficient.cu
@@ -4,108 +4,145 @@
 #include "efficient.h"
 
 namespace StreamCompaction {
-    namespace Efficient {
-        using StreamCompaction::Common::PerformanceTimer;
-        PerformanceTimer& timer()
-        {
-            static PerformanceTimer timer;
-            return timer;
-        }
-
-        int *dev_data;
-
-        const int BLOCK_SIZE = 128;
-
-        __global__ void kernUpSweep(int n, int width, int *data)
-        {
-          int index = (blockIdx.x * blockDim.x) + threadIdx.x;
-
-          if (index >= n)
-          {
-            return;
-          }
-
-          data[(index + 1) * width - 1] += data[index * width - 1 + (width / 2)];
-        }
-
-        __global__ void kernDownSweep(int n, int width, int *data)
-        {
-          int index = (blockIdx.x * blockDim.x) + threadIdx.x;
-
-          if (index >= n)
-          {
-            return;
-          }
-
-          int halfIndex = index * width - 1 + (width / 2);
-          int fullIndex = (index + 1) * width - 1;
-          int oldHalfIndexValue = data[halfIndex];
-
-          data[halfIndex] = data[fullIndex];
-          data[fullIndex] += oldHalfIndexValue;
-        }
-
-        __global__ void kernSetValueToZero(int i, int *data)
-        {
-          data[i] = 0;
-        }
-
-        /**
-         * Performs prefix-sum (aka scan) on idata, storing the result into odata.
-         */
-        void scan(int n, int *odata, const int *idata) {
-          int d, width, numThreads, numBlocks;
-
-          int nPowerOfTwo = pow(2, ilog2ceil(n));
-          int numIterations = ilog2(nPowerOfTwo) - 1;
-
-          cudaMalloc((void**)&dev_data, nPowerOfTwo * sizeof(int));
-
-          cudaMemcpy(dev_data, idata, n * sizeof(int), cudaMemcpyHostToDevice);
-
-          timer().startGpuTimer();
-
-          for (d = 0; d <= numIterations; d++)
-          {
-            width = pow(2, d + 1);
-            numThreads = nPowerOfTwo / width;
-            numBlocks = (numThreads + BLOCK_SIZE - 1) / BLOCK_SIZE;
-
-            kernUpSweep << <numBlocks, BLOCK_SIZE >> > (numThreads, width, dev_data);
-          }
-
-          kernSetValueToZero << <1, 1 >> > (nPowerOfTwo - 1, dev_data);
-
-          for (d = numIterations; d >= 0; d--)
-          {
-            width = pow(2, d + 1);
-            numThreads = nPowerOfTwo / width;
-            numBlocks = (numThreads + BLOCK_SIZE - 1) / BLOCK_SIZE;
-
-            kernDownSweep << <numBlocks, BLOCK_SIZE >> > (numThreads, width, dev_data);
-          }
-
-          timer().endGpuTimer();
-
-          cudaMemcpy(odata, dev_data, n * sizeof(int), cudaMemcpyDeviceToHost);
-
-          cudaFree(dev_data);
-        }
-
-        /**
-         * Performs stream compaction on idata, storing the result into odata.
-         * All zeroes are discarded.
-         *
-         * @param n      The number of elements in idata.
-         * @param odata  The array into which to store elements.
-         * @param idata  The array of elements to compact.
-         * @returns      The number of elements remaining after compaction.
-         */
-        int compact(int n, int *odata, const int *idata) {
-            timer().startGpuTimer();
-            // TODO
-            timer().endGpuTimer();
-            return -1;
-        }
+  namespace Efficient {
+    using StreamCompaction::Common::PerformanceTimer;
+    PerformanceTimer& timer()
+    {
+      static PerformanceTimer timer;
+      return timer;
     }
+
+    int *dev_data;
+    int *dev_odata;
+    int *dev_bools;
+    int *dev_indices;
+    int *dev_idata;
+
+    const int BLOCK_SIZE = 128;
+
+    __global__ void kernUpSweep(int n, int width, int *data)
+    {
+      int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+
+      if (index >= n)
+      {
+        return;
+      }
+
+      data[(index + 1) * width - 1] += data[index * width - 1 + (width / 2)];
+    }
+
+    __global__ void kernDownSweep(int n, int width, int *data)
+    {
+      int index = (blockIdx.x * blockDim.x) + threadIdx.x;
+
+      if (index >= n)
+      {
+        return;
+      }
+
+      int halfIndex = index * width - 1 + (width / 2);
+      int fullIndex = (index + 1) * width - 1;
+      int oldHalfIndexValue = data[halfIndex];
+
+      data[halfIndex] = data[fullIndex];
+      data[fullIndex] += oldHalfIndexValue;
+    }
+
+    __global__ void kernSetValueToZero(int i, int *data)
+    {
+      data[i] = 0;
+    }
+
+    /**
+     * Performs prefix-sum (aka scan) on idata, storing the result into odata.
+     */
+    void scan(int n, int *odata, const int *idata) {
+      int d, width, numThreads, numBlocks;
+
+      int nPowerOfTwo = pow(2, ilog2ceil(n));
+      int numIterations = ilog2(nPowerOfTwo) - 1;
+
+      cudaMalloc((void**)&dev_data, nPowerOfTwo * sizeof(int));
+
+      cudaMemcpy(dev_data, idata, n * sizeof(int), cudaMemcpyHostToDevice);
+
+      //timer().startGpuTimer();
+
+      for (d = 0; d <= numIterations; d++)
+      {
+        width = pow(2, d + 1);
+        numThreads = nPowerOfTwo / width;
+        numBlocks = (numThreads + BLOCK_SIZE - 1) / BLOCK_SIZE;
+
+        kernUpSweep << <numBlocks, BLOCK_SIZE >> > (numThreads, width, dev_data);
+      }
+
+      kernSetValueToZero << <1, 1 >> > (nPowerOfTwo - 1, dev_data);
+
+      for (d = numIterations; d >= 0; d--)
+      {
+        width = pow(2, d + 1);
+        numThreads = nPowerOfTwo / width;
+        numBlocks = (numThreads + BLOCK_SIZE - 1) / BLOCK_SIZE;
+
+        kernDownSweep << <numBlocks, BLOCK_SIZE >> > (numThreads, width, dev_data);
+      }
+
+      //timer().endGpuTimer();
+
+      cudaMemcpy(odata, dev_data, n * sizeof(int), cudaMemcpyDeviceToHost);
+
+      cudaFree(dev_data);
+    }
+
+    /**
+     * Performs stream compaction on idata, storing the result into odata.
+     * All zeroes are discarded.
+     *
+     * @param n      The number of elements in idata.
+     * @param odata  The array into which to store elements.
+     * @param idata  The array of elements to compact.
+     * @returns      The number of elements remaining after compaction.
+     */
+    int compact(int n, int *odata, const int *idata) {
+      int size = 0;
+      int numBlocks = (n + BLOCK_SIZE - 1) / BLOCK_SIZE;
+
+      cudaMalloc((void**)&dev_idata, n * sizeof(int));
+      cudaMalloc((void**)&dev_bools, n * sizeof(int));
+      cudaMalloc((void**)&dev_indices, n * sizeof(int));
+      cudaMalloc((void**)&dev_odata, n * sizeof(int));
+
+      cudaMemcpy(dev_idata, idata, n * sizeof(int), cudaMemcpyHostToDevice);
+
+      timer().startGpuTimer();
+
+      Common::kernMapToBoolean << <numBlocks, BLOCK_SIZE>> > (n, dev_bools, dev_idata);
+      cudaMemcpy(odata, dev_bools, n * sizeof(int), cudaMemcpyDeviceToHost);
+
+      if (odata[n - 1] == 1)
+      {
+        size++;
+      }
+
+      scan(n, odata, odata);
+
+      size += odata[n - 1];
+
+      cudaMemcpy(dev_indices, odata, n * sizeof(int), cudaMemcpyHostToDevice);
+      Common::kernScatter << <numBlocks, BLOCK_SIZE >> > (n, dev_odata, dev_idata, dev_bools, dev_indices);
+
+      timer().endGpuTimer();
+
+      cudaMemcpy(odata, dev_odata, n * sizeof(int), cudaMemcpyDeviceToHost);
+
+      cudaFree(dev_idata);
+      cudaFree(dev_bools);
+      cudaFree(dev_indices);
+      cudaFree(dev_odata);
+
+      return size;
+    }
+  }
 }

From 974dbf907eebea467b40ed109e3151f2ee9f0e82 Mon Sep 17 00:00:00 2001
From: Carolina Zheng <swirlinq@gmail.com>
Date: Mon, 18 Sep 2017 16:14:08 -0400
Subject: [PATCH 6/9] Finish 3.2

---
 src/main.cpp                   |  4 ++--
 stream_compaction/common.cu    |  4 +---
 stream_compaction/efficient.cu | 15 +++++++--------
 3 files changed, 10 insertions(+), 13 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index dc0b43e..9abbe1e 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -13,8 +13,8 @@
 #include <stream_compaction/thrust.h>
 #include "testing_helpers.hpp"
 
-//const int SIZE = 1 << 8; // feel free to change the size of array
-const int SIZE = 8;
+const int SIZE = 1 << 8; // feel free to change the size of array
+//const int SIZE = 8;
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
 int a[SIZE], b[SIZE], c[SIZE];
 
diff --git a/stream_compaction/common.cu b/stream_compaction/common.cu
index 85b5458..ac28fcb 100644
--- a/stream_compaction/common.cu
+++ b/stream_compaction/common.cu
@@ -48,9 +48,7 @@ namespace StreamCompaction {
 
           if (bools[index] == 1)
           {
-            int offset = index == n - 1 ? 1 : 0;
-
-            odata[indices[index] + offset] = idata[index];
+            odata[indices[index]] = idata[index];
           }
         }
 
diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu
index 2aecb98..35f197e 100644
--- a/stream_compaction/efficient.cu
+++ b/stream_compaction/efficient.cu
@@ -58,8 +58,9 @@ namespace StreamCompaction {
      * Performs prefix-sum (aka scan) on idata, storing the result into odata.
      */
     void scan(int n, int *odata, const int *idata) {
-      int d, width, numThreads, numBlocks;
+      int d, numThreads, numBlocks;
 
+      int width = 1;
       int nPowerOfTwo = pow(2, ilog2ceil(n));
       int numIterations = ilog2(nPowerOfTwo) - 1;
 
@@ -71,7 +72,7 @@ namespace StreamCompaction {
 
       for (d = 0; d <= numIterations; d++)
       {
-        width = pow(2, d + 1);
+        width *= 2;
         numThreads = nPowerOfTwo / width;
         numBlocks = (numThreads + BLOCK_SIZE - 1) / BLOCK_SIZE;
 
@@ -79,10 +80,11 @@ namespace StreamCompaction {
       }
 
       kernSetValueToZero << <1, 1 >> > (nPowerOfTwo - 1, dev_data);
+      width = pow(2, numIterations + 2);
 
       for (d = numIterations; d >= 0; d--)
       {
-        width = pow(2, d + 1);
+        width /= 2;
         numThreads = nPowerOfTwo / width;
         numBlocks = (numThreads + BLOCK_SIZE - 1) / BLOCK_SIZE;
 
@@ -106,7 +108,7 @@ namespace StreamCompaction {
      * @returns      The number of elements remaining after compaction.
      */
     int compact(int n, int *odata, const int *idata) {
-      int size = 0;
+      int size;
       int numBlocks = (n + BLOCK_SIZE - 1) / BLOCK_SIZE;
 
       cudaMalloc((void**)&dev_idata, n * sizeof(int));
@@ -121,10 +123,7 @@ namespace StreamCompaction {
       Common::kernMapToBoolean << <numBlocks, BLOCK_SIZE>> > (n, dev_bools, dev_idata);
       cudaMemcpy(odata, dev_bools, n * sizeof(int), cudaMemcpyDeviceToHost);
 
-      if (odata[n - 1] == 1)
-      {
-        size++;
-      }
+      size = odata[n - 1];
 
       scan(n, odata, odata);
 

From b4e16697f92a7b588b9f1189a472e8461cda37e9 Mon Sep 17 00:00:00 2001
From: Carolina Zheng <swirlinq@gmail.com>
Date: Tue, 19 Sep 2017 14:47:14 -0400
Subject: [PATCH 7/9] Finish implementation

---
 src/main.cpp                   | 28 ++++++++++++------------
 stream_compaction/cpu.cu       |  8 +++----
 stream_compaction/efficient.cu | 10 ++++-----
 stream_compaction/naive.cu     | 17 ++++-----------
 stream_compaction/thrust.cu    | 39 +++++++++++++++++++---------------
 5 files changed, 49 insertions(+), 53 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index 9abbe1e..605af60 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -13,7 +13,7 @@
 #include <stream_compaction/thrust.h>
 #include "testing_helpers.hpp"
 
-const int SIZE = 1 << 8; // feel free to change the size of array
+const int SIZE = 1 << 20; // feel free to change the size of array
 //const int SIZE = 8;
 const int NPOT = SIZE - 3; // Non-Power-Of-Two
 int a[SIZE], b[SIZE], c[SIZE];
@@ -74,19 +74,19 @@ int main(int argc, char* argv[]) {
     printArray(NPOT, c, true);
     printCmpResult(NPOT, b, c);
 
-    //zeroArray(SIZE, c);
-    //printDesc("thrust scan, power-of-two");
-    //StreamCompaction::Thrust::scan(SIZE, c, a);
-    //printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(SIZE, c, true);
-    //printCmpResult(SIZE, b, c);
-
-    //zeroArray(SIZE, c);
-    //printDesc("thrust scan, non-power-of-two");
-    //StreamCompaction::Thrust::scan(NPOT, c, a);
-    //printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    //printArray(NPOT, c, true);
-    //printCmpResult(NPOT, b, c);
+    zeroArray(SIZE, c);
+    printDesc("thrust scan, power-of-two");
+    StreamCompaction::Thrust::scan(SIZE, c, a);
+    printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(SIZE, c, true);
+    printCmpResult(SIZE, b, c);
+
+    zeroArray(SIZE, c);
+    printDesc("thrust scan, non-power-of-two");
+    StreamCompaction::Thrust::scan(NPOT, c, a);
+    printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    printArray(NPOT, c, true);
+    printCmpResult(NPOT, b, c);
 
     printf("\n");
     printf("*****************************\n");
diff --git a/stream_compaction/cpu.cu b/stream_compaction/cpu.cu
index b2f43d0..70d18f0 100644
--- a/stream_compaction/cpu.cu
+++ b/stream_compaction/cpu.cu
@@ -18,7 +18,7 @@ namespace StreamCompaction {
          * (Optional) For better understanding before starting moving to GPU, you can simulate your GPU scan in this function first.
          */
         void scan(int n, int *odata, const int *idata) {
-	        //timer().startCpuTimer();
+	        timer().startCpuTimer();
 
           odata[0] = 0;
 
@@ -27,7 +27,7 @@ namespace StreamCompaction {
             odata[i] = odata[i - 1] + idata[i - 1];
           }
 
-	        //timer().endCpuTimer();
+	        timer().endCpuTimer();
         }
 
         /**
@@ -62,7 +62,7 @@ namespace StreamCompaction {
           int *scanResult = new int[n];
           int j = 0;
 
-	        timer().startCpuTimer();
+	        //timer().startCpuTimer();
 
           for (int i = 0; i < n; i++)
           {
@@ -86,7 +86,7 @@ namespace StreamCompaction {
             j++;
           }
 
-	        timer().endCpuTimer();
+	        //timer().endCpuTimer();
 
           free(scanResult);
           return j;
diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu
index 35f197e..5ca41c6 100644
--- a/stream_compaction/efficient.cu
+++ b/stream_compaction/efficient.cu
@@ -18,7 +18,7 @@ namespace StreamCompaction {
     int *dev_indices;
     int *dev_idata;
 
-    const int BLOCK_SIZE = 128;
+    const int BLOCK_SIZE = 64;
 
     __global__ void kernUpSweep(int n, int width, int *data)
     {
@@ -68,7 +68,7 @@ namespace StreamCompaction {
 
       cudaMemcpy(dev_data, idata, n * sizeof(int), cudaMemcpyHostToDevice);
 
-      //timer().startGpuTimer();
+      timer().startGpuTimer();
 
       for (d = 0; d <= numIterations; d++)
       {
@@ -91,7 +91,7 @@ namespace StreamCompaction {
         kernDownSweep << <numBlocks, BLOCK_SIZE >> > (numThreads, width, dev_data);
       }
 
-      //timer().endGpuTimer();
+      timer().endGpuTimer();
 
       cudaMemcpy(odata, dev_data, n * sizeof(int), cudaMemcpyDeviceToHost);
 
@@ -118,7 +118,7 @@ namespace StreamCompaction {
 
       cudaMemcpy(dev_idata, idata, n * sizeof(int), cudaMemcpyHostToDevice);
 
-      timer().startGpuTimer();
+      //timer().startGpuTimer();
 
       Common::kernMapToBoolean << <numBlocks, BLOCK_SIZE>> > (n, dev_bools, dev_idata);
       cudaMemcpy(odata, dev_bools, n * sizeof(int), cudaMemcpyDeviceToHost);
@@ -132,7 +132,7 @@ namespace StreamCompaction {
       cudaMemcpy(dev_indices, odata, n * sizeof(int), cudaMemcpyHostToDevice);
       Common::kernScatter << <numBlocks, BLOCK_SIZE >> > (n, dev_odata, dev_idata, dev_bools, dev_indices);
 
-      timer().endGpuTimer();
+      //timer().endGpuTimer();
 
       cudaMemcpy(odata, dev_odata, n * sizeof(int), cudaMemcpyDeviceToHost);
 
diff --git a/stream_compaction/naive.cu b/stream_compaction/naive.cu
index 73cdad2..6e61ac2 100644
--- a/stream_compaction/naive.cu
+++ b/stream_compaction/naive.cu
@@ -16,7 +16,7 @@ namespace StreamCompaction {
     int *dev_output1;
     int *dev_output2;
 
-    const int BLOCK_SIZE = 128;
+    const int BLOCK_SIZE = 64;
 
     __global__ void kernScan(int n, int offset, int *dev_input, int *dev_output1, int *dev_output2)
     {
@@ -27,14 +27,7 @@ namespace StreamCompaction {
         return;
       }
 
-      if (index >= offset)
-      {
-        dev_output2[index] = dev_output1[index - offset] + dev_output1[index];
-      }
-      else
-      {
-        dev_output2[index] = dev_output1[index];
-      }
+      dev_output2[index] = dev_output1[index] + (index >= offset ? dev_output1[index - offset] : 0);
     }
 
     __global__ void kernShift(int n, int *dev_input, int *dev_output)
@@ -55,7 +48,7 @@ namespace StreamCompaction {
     void scan(int n, int *odata, const int *idata) {
       int numBlocks = (n + BLOCK_SIZE - 1) / BLOCK_SIZE;
       int *temp;
-      int d, offset;
+      int offset;
 
       cudaMalloc((void**)&dev_input, n * sizeof(int));
       cudaMalloc((void**)&dev_output1, n * sizeof(int));
@@ -67,10 +60,8 @@ namespace StreamCompaction {
 
       kernShift << <numBlocks, BLOCK_SIZE >> > (n, dev_input, dev_output1);
 
-      for (d = 1; d <= ilog2ceil(n); d++)
+      for (offset = 1; offset <= n; offset *= 2)
       {
-        offset = pow(2, d - 1);
-
         kernScan << <numBlocks, BLOCK_SIZE >> > (n, offset, dev_input, dev_output1, dev_output2);
 
         temp = dev_output1;
diff --git a/stream_compaction/thrust.cu b/stream_compaction/thrust.cu
index 36b732d..f817c12 100644
--- a/stream_compaction/thrust.cu
+++ b/stream_compaction/thrust.cu
@@ -7,22 +7,27 @@
 #include "thrust.h"
 
 namespace StreamCompaction {
-    namespace Thrust {
-        using StreamCompaction::Common::PerformanceTimer;
-        PerformanceTimer& timer()
-        {
-            static PerformanceTimer timer;
-            return timer;
-        }
-        /**
-         * Performs prefix-sum (aka scan) on idata, storing the result into odata.
-         */
-        void scan(int n, int *odata, const int *idata) {
-            timer().startGpuTimer();
-            // TODO use `thrust::exclusive_scan`
-            // example: for device_vectors dv_in and dv_out:
-            // thrust::exclusive_scan(dv_in.begin(), dv_in.end(), dv_out.begin());
-            timer().endGpuTimer();
-        }
+  namespace Thrust {
+    using StreamCompaction::Common::PerformanceTimer;
+    PerformanceTimer& timer()
+    {
+      static PerformanceTimer timer;
+      return timer;
     }
+    /**
+     * Performs prefix-sum (aka scan) on idata, storing the result into odata.
+     */
+    void scan(int n, int *odata, const int *idata) {
+      thrust::device_vector<int> dev_idata(n);
+      thrust::device_vector<int> dev_odata(n);
+
+      thrust::copy(idata, idata + n, dev_idata.begin());
+
+      timer().startGpuTimer();
+      thrust::exclusive_scan(dev_idata.begin(), dev_idata.end(), dev_odata.begin());
+      timer().endGpuTimer();
+
+      thrust::copy(dev_odata.begin(), dev_odata.end(), odata);
+    }
+  }
 }

From 951e6099b07d0b1347686bd39ff60244677e72f2 Mon Sep 17 00:00:00 2001
From: Carolina Zheng <swirlinq@gmail.com>
Date: Tue, 19 Sep 2017 18:44:29 -0400
Subject: [PATCH 8/9] Finish performance analysis, start readme

---
 README.md                      | 58 ++++++++++++++++++++--
 src/main.cpp                   | 90 +++++++++++++++++++++++++++-------
 src/testing_helpers.hpp        |  1 +
 stream_compaction/cpu.cu       |  8 +--
 stream_compaction/efficient.cu | 10 ++--
 stream_compaction/thrust.cu    | 20 ++++++--
 6 files changed, 152 insertions(+), 35 deletions(-)

diff --git a/README.md b/README.md
index b71c458..c0c81cd 100644
--- a/README.md
+++ b/README.md
@@ -3,11 +3,63 @@ CUDA Stream Compaction
 
 **University of Pennsylvania, CIS 565: GPU Programming and Architecture, Project 2**
 
-* (TODO) YOUR NAME HERE
-* Tested on: (TODO) Windows 22, i7-2222 @ 2.22GHz 22GB, GTX 222 222MB (Moore 2222 Lab)
+* Carolina Zheng
+* Tested on: Windows 7, i7-6700 @ 3.40GHz 16GB, Quadro K620 (Moore 100 Lab)
 
-### (TODO: Your README)
+### Performance Analysis
 
 Include analysis, etc. (Remember, this is public, so don't put
 anything here that you don't want to share with the world.)
 
+#### Test Program Output
+```
+****************
+** SCAN TESTS **
+****************
+    [   1  42  48  47   9  36  13  34  28  39   3   2  38 ...   1   0 ]
+==== cpu scan, power-of-two ====
+   elapsed time: 2.4675ms    (std::chrono Measured)
+==== cpu scan, non-power-of-two ====
+   elapsed time: 2.47652ms    (std::chrono Measured)
+    passed
+==== naive scan, power-of-two ====
+   elapsed time: 38.5892ms    (CUDA Measured)
+    passed
+==== naive scan, non-power-of-two ====
+   elapsed time: 37.0342ms    (CUDA Measured)
+    passed
+==== work-efficient scan, power-of-two ====
+   elapsed time: 6.30717ms    (CUDA Measured)
+    passed
+==== work-efficient scan, non-power-of-two ====
+   elapsed time: 6.17421ms    (CUDA Measured)
+    passed
+==== thrust scan, power-of-two ====
+   elapsed time: 84.909ms    (CUDA Measured)
+    passed
+==== thrust scan, non-power-of-two ====
+   elapsed time: 78.5352ms    (CUDA Measured)
+    passed
+
+
+*****************************
+** STREAM COMPACTION TESTS **
+*****************************
+    [   0   0   0   3   1   0   1   3   1   0   0   2   0 ...   2   0 ]
+==== cpu compact without scan, power-of-two ====
+   elapsed time: 4.67753ms    (std::chrono Measured)
+    passed
+==== cpu compact without scan, non-power-of-two ====
+   elapsed time: 4.78749ms    (std::chrono Measured)
+    passed
+==== cpu compact with scan ====
+   elapsed time: 12.9883ms    (std::chrono Measured)
+    passed
+==== work-efficient compact, power-of-two ====
+   elapsed time: 13.6215ms    (CUDA Measured)
+    passed
+==== work-efficient compact, non-power-of-two ====
+   elapsed time: 13.4029ms    (CUDA Measured)
+    passed
+Press any key to continue . . .
+```
diff --git a/src/main.cpp b/src/main.cpp
index 605af60..c0aa9e0 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -30,62 +30,116 @@ int main(int argc, char* argv[]) {
     a[SIZE - 1] = 0;
     printArray(SIZE, a, true);
 
-    // initialize b using StreamCompaction::CPU::scan you implement
-    // We use b for further comparison. Make sure your StreamCompaction::CPU::scan is correct.
-    // At first all cases passed because b && c are all zeroes.
+    float cpuTime = 0;
+    float naiveTime = 0;
+    float efficientTime = 0;
+    float thrustTime = 0;
+
+    //for (int i = 0; i < 10; i++)
+    //{
+    //  genArray(SIZE - 1, a, 50, i);  // Leave a 0 at the end to test that edge case
+    //  a[SIZE - 1] = 0;
+    //  printArray(SIZE, a, true);
+
+    //  zeroArray(SIZE, b);
+    //  //printDesc("cpu scan, power-of-two");
+    //  StreamCompaction::CPU::scan(SIZE, b, a);
+    //  //printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
+    //  //printArray(SIZE, b, true);
+
+    //  zeroArray(SIZE, c);
+    //  //printDesc("naive scan, power-of-two");
+    //  StreamCompaction::Naive::scan(SIZE, c, a);
+    //  //printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    //  //printArray(SIZE, c, true);
+    //  //printCmpResult(SIZE, b, c);
+
+    //  zeroArray(SIZE, c);
+    //  //printDesc("work-efficient scan, power-of-two");
+    //  StreamCompaction::Efficient::scan(SIZE, c, a);
+    //  //printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    //  //printArray(SIZE, c, true);
+    //  //printCmpResult(SIZE, b, c);
+
+    //  zeroArray(SIZE, c);
+    //  //printDesc("thrust scan, power-of-two");
+    //  StreamCompaction::Thrust::scan(SIZE, c, a);
+    //  //printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
+    //  //printArray(SIZE, c, true);
+    //  //printCmpResult(SIZE, b, c);
+
+    //  cpuTime += StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation();
+    //  naiveTime += StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation();
+    //  efficientTime += StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation();
+    //  thrustTime += StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation();
+    //}
+
+    //cpuTime /= 10.f;
+    //naiveTime /= 10.f;
+    //efficientTime /= 10.f;
+    //thrustTime /= 10.f;
+
+    //printf("CPU time: %f\n", cpuTime);
+    //printf("Naive time: %f\n", naiveTime);
+    //printf("Efficient time: %f\n", efficientTime);
+    //printf("Thrust time: %f\n", thrustTime);
+
+     //initialize b using StreamCompaction::CPU::scan you implement
+     //We use b for further comparison. Make sure your StreamCompaction::CPU::scan is correct.
+     //At first all cases passed because b && c are all zeroes.
     zeroArray(SIZE, b);
     printDesc("cpu scan, power-of-two");
     StreamCompaction::CPU::scan(SIZE, b, a);
     printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(SIZE, b, true);
+    //printArray(SIZE, b, true);
 
     zeroArray(SIZE, c);
     printDesc("cpu scan, non-power-of-two");
     StreamCompaction::CPU::scan(NPOT, c, a);
     printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(NPOT, b, true);
+    //printArray(NPOT, b, true);
     printCmpResult(NPOT, b, c);
 
     zeroArray(SIZE, c);
     printDesc("naive scan, power-of-two");
     StreamCompaction::Naive::scan(SIZE, c, a);
     printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(SIZE, c, true);
+    //printArray(SIZE, c, true);
     printCmpResult(SIZE, b, c);
 
     zeroArray(SIZE, c);
     printDesc("naive scan, non-power-of-two");
     StreamCompaction::Naive::scan(NPOT, c, a);
     printElapsedTime(StreamCompaction::Naive::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(SIZE, c, true);
+    //printArray(SIZE, c, true);
     printCmpResult(NPOT, b, c);
 
     zeroArray(SIZE, c);
     printDesc("work-efficient scan, power-of-two");
     StreamCompaction::Efficient::scan(SIZE, c, a);
     printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(SIZE, c, true);
+    //printArray(SIZE, c, true);
     printCmpResult(SIZE, b, c);
 
     zeroArray(SIZE, c);
     printDesc("work-efficient scan, non-power-of-two");
     StreamCompaction::Efficient::scan(NPOT, c, a);
     printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(NPOT, c, true);
+    //printArray(NPOT, c, true);
     printCmpResult(NPOT, b, c);
 
     zeroArray(SIZE, c);
     printDesc("thrust scan, power-of-two");
     StreamCompaction::Thrust::scan(SIZE, c, a);
     printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(SIZE, c, true);
+    //printArray(SIZE, c, true);
     printCmpResult(SIZE, b, c);
 
     zeroArray(SIZE, c);
     printDesc("thrust scan, non-power-of-two");
     StreamCompaction::Thrust::scan(NPOT, c, a);
     printElapsedTime(StreamCompaction::Thrust::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(NPOT, c, true);
+    //printArray(NPOT, c, true);
     printCmpResult(NPOT, b, c);
 
     printf("\n");
@@ -101,14 +155,14 @@ int main(int argc, char* argv[]) {
 
     int count, expectedCount, expectedNPOT;
 
-    // initialize b using StreamCompaction::CPU::compactWithoutScan you implement
-    // We use b for further comparison. Make sure your StreamCompaction::CPU::compactWithoutScan is correct.
+     //initialize b using StreamCompaction::CPU::compactWithoutScan you implement
+     //We use b for further comparison. Make sure your StreamCompaction::CPU::compactWithoutScan is correct.
     zeroArray(SIZE, b);
     printDesc("cpu compact without scan, power-of-two");
     count = StreamCompaction::CPU::compactWithoutScan(SIZE, b, a);
     printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
     expectedCount = count;
-    printArray(count, b, true);
+    //printArray(count, b, true);
     printCmpLenResult(count, expectedCount, b, b);
 
     zeroArray(SIZE, c);
@@ -116,28 +170,28 @@ int main(int argc, char* argv[]) {
     count = StreamCompaction::CPU::compactWithoutScan(NPOT, c, a);
     printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
     expectedNPOT = count;
-    printArray(count, c, true);
+    //printArray(count, c, true);
     printCmpLenResult(count, expectedNPOT, b, c);
 
     zeroArray(SIZE, c);
     printDesc("cpu compact with scan");
     count = StreamCompaction::CPU::compactWithScan(SIZE, c, a);
     printElapsedTime(StreamCompaction::CPU::timer().getCpuElapsedTimeForPreviousOperation(), "(std::chrono Measured)");
-    printArray(count, c, true);
+    //printArray(count, c, true);
     printCmpLenResult(count, expectedCount, b, c);
 
     zeroArray(SIZE, c);
     printDesc("work-efficient compact, power-of-two");
     count = StreamCompaction::Efficient::compact(SIZE, c, a);
     printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(count, c, true);
+    //printArray(count, c, true);
     printCmpLenResult(count, expectedCount, b, c);
 
     zeroArray(SIZE, c);
     printDesc("work-efficient compact, non-power-of-two");
     count = StreamCompaction::Efficient::compact(NPOT, c, a);
     printElapsedTime(StreamCompaction::Efficient::timer().getGpuElapsedTimeForPreviousOperation(), "(CUDA Measured)");
-    printArray(count, c, true);
+    //printArray(count, c, true);
     printCmpLenResult(count, expectedNPOT, b, c);
 
     system("pause"); // stop Win32 console from closing on exit
diff --git a/src/testing_helpers.hpp b/src/testing_helpers.hpp
index ae94ca6..68a2450 100644
--- a/src/testing_helpers.hpp
+++ b/src/testing_helpers.hpp
@@ -45,6 +45,7 @@ void zeroArray(int n, int *a) {
 
 void genArray(int n, int *a, int maxval) {
     srand(time(nullptr));
+  //srand(seed);
 
     for (int i = 0; i < n; i++) {
         a[i] = rand() % maxval;
diff --git a/stream_compaction/cpu.cu b/stream_compaction/cpu.cu
index 70d18f0..b2f43d0 100644
--- a/stream_compaction/cpu.cu
+++ b/stream_compaction/cpu.cu
@@ -18,7 +18,7 @@ namespace StreamCompaction {
          * (Optional) For better understanding before starting moving to GPU, you can simulate your GPU scan in this function first.
          */
         void scan(int n, int *odata, const int *idata) {
-	        timer().startCpuTimer();
+	        //timer().startCpuTimer();
 
           odata[0] = 0;
 
@@ -27,7 +27,7 @@ namespace StreamCompaction {
             odata[i] = odata[i - 1] + idata[i - 1];
           }
 
-	        timer().endCpuTimer();
+	        //timer().endCpuTimer();
         }
 
         /**
@@ -62,7 +62,7 @@ namespace StreamCompaction {
           int *scanResult = new int[n];
           int j = 0;
 
-	        //timer().startCpuTimer();
+	        timer().startCpuTimer();
 
           for (int i = 0; i < n; i++)
           {
@@ -86,7 +86,7 @@ namespace StreamCompaction {
             j++;
           }
 
-	        //timer().endCpuTimer();
+	        timer().endCpuTimer();
 
           free(scanResult);
           return j;
diff --git a/stream_compaction/efficient.cu b/stream_compaction/efficient.cu
index 5ca41c6..2d870e5 100644
--- a/stream_compaction/efficient.cu
+++ b/stream_compaction/efficient.cu
@@ -18,7 +18,7 @@ namespace StreamCompaction {
     int *dev_indices;
     int *dev_idata;
 
-    const int BLOCK_SIZE = 64;
+    const int BLOCK_SIZE = 32;
 
     __global__ void kernUpSweep(int n, int width, int *data)
     {
@@ -68,7 +68,7 @@ namespace StreamCompaction {
 
       cudaMemcpy(dev_data, idata, n * sizeof(int), cudaMemcpyHostToDevice);
 
-      timer().startGpuTimer();
+      //timer().startGpuTimer();
 
       for (d = 0; d <= numIterations; d++)
       {
@@ -91,7 +91,7 @@ namespace StreamCompaction {
         kernDownSweep << <numBlocks, BLOCK_SIZE >> > (numThreads, width, dev_data);
       }
 
-      timer().endGpuTimer();
+      //timer().endGpuTimer();
 
       cudaMemcpy(odata, dev_data, n * sizeof(int), cudaMemcpyDeviceToHost);
 
@@ -118,7 +118,7 @@ namespace StreamCompaction {
 
       cudaMemcpy(dev_idata, idata, n * sizeof(int), cudaMemcpyHostToDevice);
 
-      //timer().startGpuTimer();
+      timer().startGpuTimer();
 
       Common::kernMapToBoolean << <numBlocks, BLOCK_SIZE>> > (n, dev_bools, dev_idata);
       cudaMemcpy(odata, dev_bools, n * sizeof(int), cudaMemcpyDeviceToHost);
@@ -132,7 +132,7 @@ namespace StreamCompaction {
       cudaMemcpy(dev_indices, odata, n * sizeof(int), cudaMemcpyHostToDevice);
       Common::kernScatter << <numBlocks, BLOCK_SIZE >> > (n, dev_odata, dev_idata, dev_bools, dev_indices);
 
-      //timer().endGpuTimer();
+      timer().endGpuTimer();
 
       cudaMemcpy(odata, dev_odata, n * sizeof(int), cudaMemcpyDeviceToHost);
 
diff --git a/stream_compaction/thrust.cu b/stream_compaction/thrust.cu
index f817c12..79536d6 100644
--- a/stream_compaction/thrust.cu
+++ b/stream_compaction/thrust.cu
@@ -14,20 +14,30 @@ namespace StreamCompaction {
       static PerformanceTimer timer;
       return timer;
     }
+
+    int *dev_idata;
+    int *dev_odata;
+
     /**
      * Performs prefix-sum (aka scan) on idata, storing the result into odata.
      */
     void scan(int n, int *odata, const int *idata) {
-      thrust::device_vector<int> dev_idata(n);
-      thrust::device_vector<int> dev_odata(n);
+      cudaMalloc((void**)&dev_idata, n * sizeof(int));
+      cudaMalloc((void**)&dev_odata, n * sizeof(int));
 
-      thrust::copy(idata, idata + n, dev_idata.begin());
+      cudaMemcpy(dev_idata, idata, n * sizeof(int), cudaMemcpyHostToDevice);
+
+      thrust::device_ptr<int> dev_thrust_idata(dev_idata);
+      thrust::device_ptr<int> dev_thrust_odata(dev_odata);
 
       timer().startGpuTimer();
-      thrust::exclusive_scan(dev_idata.begin(), dev_idata.end(), dev_odata.begin());
+      thrust::exclusive_scan(dev_thrust_idata, dev_thrust_idata + n, dev_thrust_odata);
       timer().endGpuTimer();
 
-      thrust::copy(dev_odata.begin(), dev_odata.end(), odata);
+      cudaMemcpy(odata, dev_odata, n * sizeof(int), cudaMemcpyDeviceToHost);
+
+      cudaFree(dev_idata);
+      cudaFree(dev_odata);
     }
   }
 }

From 07f34babb47a04d5279fa7e2a84a6ed300f3e63a Mon Sep 17 00:00:00 2001
From: Carolina Zheng <swirlinq@gmail.com>
Date: Tue, 19 Sep 2017 23:26:02 -0400
Subject: [PATCH 9/9] Finish readme

---
 README.md            |  43 +++++++++++++++++++++++++++++++++++++++++--
 img/block-size.png   | Bin 0 -> 70746 bytes
 img/scan-runtime.png | Bin 0 -> 74469 bytes
 3 files changed, 41 insertions(+), 2 deletions(-)
 create mode 100644 img/block-size.png
 create mode 100644 img/scan-runtime.png

diff --git a/README.md b/README.md
index c0c81cd..ea0e0d7 100644
--- a/README.md
+++ b/README.md
@@ -8,10 +8,49 @@ CUDA Stream Compaction
 
 ### Performance Analysis
 
-Include analysis, etc. (Remember, this is public, so don't put
-anything here that you don't want to share with the world.)
+I determined the runtimes by running each implementation on arrays seeded with fixed values and averaging the times over 10 runs.
+
+#### Block Size vs. Performance
+
+![](img/block-size.png)
+
+
+The optimal block size for the naive implementation was 64 threads vs. 32 threads for the work-efficient implementation. I was surprised by the fact that a small block size was optimal: I would have expected smaller block sizes to decrease performance because it would max out the block slots on each SM before maxing out the thread slots. The runtime difference between block sizes was very small (<1 ms), however, which makes me think that block size didn't factor in too much overall.
+
+In terms of occupancy, the limiting factor was likely thread slots. My kernel functions didn't use shared memory and used few registers.
+
+#### Scan Implementation vs. Performance
+
+![](img/scan-runtime.png)
+
+
+| Array size (2^x) | CPU | Naive | Efficient | Thrust |
+|:----------------:| ---:|------:|----------:|-------:|
+| 4  | 0.00033  | 0.0453 | 0.0694    | 1.183  |
+| 8  | 0.00228  | 0.0712 | 0.127     | 1.106  |
+| 12 | 0.00982  | 0.175  | 0.2007    | 2.002  |
+| 16 | 0.166    | 2.091  | 0.595     | 12.76  |
+| 18 | 0.853    | 8.757  | 1.528     | 25.78  |
+| 20 | 2.56     | 37.38  | 5.82      | 78.57  |
+| 21 | 4.96     | 77.58  | 11.43     | 148.22 |
+| 22 | 10.28    | -      | -         | 289.54 |
+
+
+Overall, the CPU implementation had the best performance, following by my work-efficient GPU implementation, then the naive GPU implementation, and finally the thrust library call.
+
+The results for work-efficient vs. naive were as expected. On small arrays, the naive implementation was faster. However, once the array size increased from 2^12 to 2^16, the naive scan jumped in runtime by a factor of 20, while the efficient runtime only increased by a factor of 3. As the array size kept doubling, the two implementations' performance deteriorated by about the same multiplier, but because of this initial jump, the efficient scan outperformed the naive scan by a factor of about 7 for array sizes of 2^18 to 2^21. My GPU implementations failed to run on array size 2^22.
+
+The CPU implementation's runtime increased rather smoothly as array size increased, and did not exhibit any jumps.
+
+The thrust library call was much slower than the other implementations: on large array sizes, it was twice as slow as the naive scan and slower by a factor of over 10 compared to the work-efficient scan. It scaled well to increasing array size.
+
+I believe that the performance bottlenecks were different for CPU vs. GPU implementations vs. thrust. For the CPU, computation time was probably the bottleneck due to the fact that all operations had to be performed serially. For the naive and work-efficient scans, I think global memory access was the bottleneck. GPU compute capability is much better than memory accesses, and the kernels I wrote in particular were independent of each other and consisted of only a few floating-point computations, as well as global memory reads and writes. I also used hardware-optimized branching, which should minimize divergence within warps. I was surprised at how slow the thrust library call was. It's likely that the library call is using an optimized algorithm under the hood, but may have been slowed down due to layers of other function calls, error checking, etc. It's hard to say exactly why it was slow without examining the source code.
+
+To mitigate the bottlenecks of my GPU implementations, I could improve my code by utilizing shared memory instead of global memory. I'm also interested in whether moving the loops from the host to the device would increase performance. Also, I could refactor my work-efficient stream compaction so that there is no memory copying between host and device, which might make it faster than the CPU compaction.
 
 #### Test Program Output
+The following is a sample test program output from `main.cpp` for an array of size 2^20.
+
 ```
 ****************
 ** SCAN TESTS **
diff --git a/img/block-size.png b/img/block-size.png
new file mode 100644
index 0000000000000000000000000000000000000000..9bcdf7270fe781bcad2cfe2a7023600393bb6e1d
GIT binary patch
literal 70746
zcmeFZcT|&I_co}aAkq{RL_kmkL_iP(LXC<vX)4mCC?rut2)!pDA_4*;-B1;X^s011
zFG&c}gh;QUcL*&ocYNmk=3CF}S~K(C%v!%cSXm)(?tRW~*S_{X34W-n&UEI|nPbO}
zF==Yte|+p1P4Tf~C!U|C1%9*Fe&_(a9Cv=Ke(zX5fqM>kLl4(5aXxm8gO&Po9G21z
z{L7tVn)mNM@i@MiL|4tDN<0z@+`M;M;K}if_ZL*}W`(HP8Q&59a^l2;D5K+)#+>(l
zA*p;;s^@(&Lf^c%dUBfQ{+xizy<1n_emdKYJ0vNL%i)I?E6796og*c%WSDYFjW-#;
zxTuI3mFmPxNhv6d)zk4-JJ$IfH&bAE=Xb^G^u-hZdb!hluB~{n<v5Gd=0n3ZC(|{?
z<0^G$B~Je9#sAWYfN4ya?1=H<_maP@<9Fqu+{w#`o$-g6{xKp67ux=N4eG+Pw8x!o
zs*bmQ`PcgYJTyDVPp-Icvgv`%e+%k&<tNjLnKn0?a8=HKZ-TnBCoI6qIjzAle|>T)
z*GYWj5-oSA<iB@Dee$=<z{-XZY$B0=+u9x3)A9U+Odxj1-=un|1gxBQS;+9}U(e0{
ztc3axF1RT6Z|9Nf1*~kQq?>#HUt0M`Rl|H%;dZiP#?gP3YKywESE6z7Uyri#ZXGw#
zzOLx{U!|JA0<63RDq{WXQMv>GY8dvje)LzV`c#0G=N+F5{PigRN5TKQ@BH5?SfU&S
z`j1V%IClb;==jciJdk5(w(INgco6T%m#6#5ItI8t_jXab|4Wk^oPe$CL;G!{PBQw(
z^1)YX$d&#yRX451z1lurv7e4Ha+_=kGrOXEWR+;#@a7c5`lHu1%Mnf;DA`V>!=1@x
zA}qz#nM82?sut#yQ&3xJ=1{XWG*D#CFn!dCJe*v{93jfu1ySXBKYnLRgi!_*Pk1J&
zrO3Tw;+ioucQuf8nrfSoDp*a*G`b+z8Um&I#U1f;fIY_fnK%J*{tT?kh_jequHCnn
zb(#Hn^9{>Ii8{x#hNdqC%BEw@D)Y)lDz!fEyxHft`E-_+B|nxZR`s;s+&!sk>zA2%
zEW|v~gZ6l=nAuG1P4oG1`T1`W*ZDkjQj~|y9h)zVuLlby!@2CspTT_uMhLztsR~Ig
z34u{-ldV;+%Z7i|tc5u&4mRF!DVsA0Y%BcoC+7V;ak5hPRw<tfu7T=_{?TVYa`vi*
zvY&!!+ceTQ-bw-^YrS`;<A%Y9Yb@>~o+QoEB&8F`gGt_DCfT905~kH2MO?~09!tkC
z0$Q;rwe`T1%~gzF3**fI8rC}Ey@j*i&^@3+E0&R-OdV$qbC<|{68MN%Nf#H*=DI2b
z-VIjR9<b&i*w$Ei8L)8f5C4&Za6i>lpC&0dE#^1yo>lD_DYTApqA8ed`29Kl2I=sN
zIGdH~4P9!44>ZX|CwpOa5+nt(Omg|`*pQb!r_PaA8(I3fd$;;6M}2o1d6~709IwZ}
zteMM14T%&~vob?Z2-p?Y(|#u|yZ$n1&8u3jWQCB}`5vbC<leNh^3Ryby%R453%6b!
zZ{c!qd6i$0>D_}G>3t&<7u7s^xLqa@e}9=parMr1hps5?f{=$rqkp2!>{DtueY%`G
z1%!y7ou|i|X5vh1_lH;9z<XU04aFwV;&^{NdXDtmaKh1j*wrYWXbp`K=vP=QRLOg~
z9=^zKW_J#HFtQ$7=Hl6U5xqV8H6lNw42e}q)j*exBK9S!f}L@n;4YQeaM1uBM!q83
zd$Ic*SD;=7Z$l{m*c<8U>hH52B&?NyEH$R5=AHJL)3VGK3-n!U=BN_AYyZPa^yr#6
zR6K#Q^xDcT%tRWhXd?ML?yNYC{q2+lDcHO809qy|P`0XnIg9VCihbVqU#3?+ud~6^
zO?hl&D1ZT<A-LsitY{%bqcWbZ8opZ$i(UGt!kksZq3iiJLT$z2HqS15dwc57T$7SF
z&ZgqxU9V)mWpk{%s!v__g4Prlu0P*iBpwg=vhVSu*JuX^F0mj^k#8(~jqW1+39V1g
z9Y;mxT@^7D1bk-p`bpz#;UpvZO77tf#y+;?T~Z1Q?lrIPX4g;u)-HZa=%<14xP*@6
zSfcXISitfO%7Gb|1W^my`2DJ2X=Hzd{4OkNg4DkdAN3A25?Q_UW3WL|KaoJLCMm5g
zxgJHto$0Aqc@3INkFve!vp+bRKaAMwGYVQS?5(<9$jy$PXycD~`ix{gl46r3iu-)Z
zh+y6F!4c1lndDiS-GV-?juZBGYA~s(Q)pad*KUhj89h35A2`o|reCZ}u9g{g=_$Nc
zRpqmwR3MHi;VPTGJ^k#56y{Mv8=-qr9Jz}NjA$e(0?|i>TjYY<;OnxRb8lg^QrpAs
zqlHh7ERXh#F221BU53#jJC(?cTo0RNQ@oce!jH2hB0SN1dkY0Do*$V-6C9N%-t*g*
zwQsa3{1Rc+;D!LP%=b<5qganja)$$=WYDpdr;*ijd3ObQw2)shbBT<X>O5In$JlyF
zu0Esc;X7qFvSKI@IFGCFNds1_6ZR;o6>z>ip5xHmCdUjmkt1>@AK-BjRrA?7Z`cf{
zo=&8$)1%0kBZ@0ny-^qAQ=Hl6*d#YIb_g7CzG0~sBtzv8aCSLSVv}4`!g!Qi7%ewU
zxhz26^Op&%!a7_o6SqE|yk76g*Tl>Xd7dDWR>hPGFE_RgalSFWJ?OxqD>r@4Co<`1
zmnn!+)OwkLS!3}nj-r%Aq$H5vI4XvoNPN$x<?}%Sbwg?Mr;0hZy5m)0SzIY*E6?Eq
z#O${NeujbBs&_b72$j^wPz}E6@Bi87Y;wZd!SD)#gVt({-3L_XzmRftKw9oeIdq8=
zATVlZ+))>J=td8!P*kB+p7JcR&@>GW#WgrITmaS4rK~<fza|tXaC-W2OkYSkY7$Z&
zAKCj=_F&tb09mk(3nB*o!6d;~0UYtA>9a943?NS@`fd}y6B|2Z26KO{y)HfJ(k6~M
zSTA&W1Wk)qf@FT2jseMaUuhlxqEA?S#x1Cq%*}n-M82Zs(yO-uHTW0fR^tzU3d6SF
zJCv|mivQ%qEEeOq2~y;-CZ8#OUdI9?Wnp2sxM2n5Q0qD1K}Q!(EC$S`-=37@zU&zL
zK=M=PiDqWH@DrYe6?$DxQ(5}xcY_sli`OKM!GV<cj;NG4M9(I8GKh^k;gPle4J^Gb
zD8_rSC}`;SWP*t;G}!S6Tz6is*s6V_j_m-_BS9+xuN0^gDOm>TGd^f5w(#iae2-Ov
zB#x&PvtEw?eP1iNpS+Ac6_IOvY&2f0U47kZ`#jyp+di%AbRYKzn7HX!)h{rcBuIE|
z&cYQ|&{8>?!~uv&qRDE^9ir#Ew^wUEm47K-JzN?b+5RD+g0~ZQ4IoiA(O@Pn?eVDw
zf$FvPtMeSi4gKkwQ4MEKL!&1jW-7OI79BBBF{=g-6$8KqrvAYIcVM3rlJ}RZ3SxPa
z9JsY6PJ_bM>|kQgWRF&vMWr5{l<&sdAl5=H7oA#l6_%!UwuK01nb|tiOO%0J{*f6L
z#N#)o*z@RUj1D{ik@?i&o$Rx&=?+BFpy^oa*6^iINT0jv6g}jgK71K&0~d^^AAIpO
zY{EwAFoLGA&(KUx{s?pt#N8Imf6wz{NrGSFNB4>LpoCkFP`HK6h{xndCEaEqpz)R;
zA0^kU_=<=|B;T@rx8E#|IG1?dExF~2#pp`$kj5CrvNncc8_2FMbw(b+E3NG@cm3UK
z7R<k2Pc(QVst$pf(<|&S6~mnzhbo=f1$?Do*e1LjGpAzFt6P<7o<C2WkP7X1ca;uA
z(1I%LhLQ4$u{W0MXjpRP2v)8Q^g?gVu8UN$ZgfCT1c;o3RvxX#Vcs5PA#>$l2sS~|
zZb}(9?60t1Y<u=I#7VO7t=$3U=y1Qvak3@QhH<QEI)l(6LWBLKE}WC}M+rau0Hl1$
zScVgLm)d#yXM3yv2O0tckICFI<cw4beYj;}Ci=+HCcfwzG7%&0GtLlL<}<IKa;D@C
zs8~_fLf*TT$NePivy+7PdG|ztlKz@y*X6MQ7G^1*t=QmhPm+=@R8W{jN~db2)*G%Y
zkTR0!Xq-T?36?B*&5cJ)h^{LD2LIYJpxW%iSCs?+yF~OCpA>S;tV^Bcv4o<*tNtt}
zgU+kdw0?V}9!r$rhDp$Xx$_1dW$@v%amA+PBk)G1SJRDGuKKxmiFzg|SbbH;+lL-L
zkOT2EFz>>^`^44o8<-f*i+;}@j#=~W51fg(ODA42^(hsMhlcQ1-D_Z{+%bticQ~sK
z{w<)sNte%AXtiqlz0Z)Lggnvo;Q2^IMs=?NmaD(Dc<T|?3ib!Y-sZEaVt-{tw7Cr+
zF=hTcuoN1!26G}SB8t-_)*6d{_?4w;tv)zy<LQ)5^KRi#e1aUe%!qr;9T;aT4c!Ix
z9~O1(IkIdaj7R|U*y@Uw_~9AJeO)#)@th*i?CZQ*>W(kadnS4^3*$9owI^v=<L_S6
zlW39)hb2NhZ%g6qVhzMsJvkG$Y$lUOPI4RB1gJwTHvCO|CVryIFq9?f*3T}Y>M`*7
zEcCC~4Xgtsxr-Ct=m~=yqno}4htdcomK~n9(w}Ntw;SnThoSEJ7t=u66^hoip&#gb
zeWAz=T~SBTS3)c&w3;S=^6p&(cOL!$DSVKVc4{&ZHys(^9A0pqaCz#<`*@@#-C75h
zk`ccM!r?FVyN~+18-Lm%xYw4X!Af#t?jW`jwcFpDKNO~udb#e&HL;`3avYs6%Ox3z
zvY-U0G(y!uvMz)K&YSb;t>oK#;9UtVETfphjev8VjaORNtV{TyhfO9gZ(DX3eU&tZ
zi%Wg>95Rv78Z)VO5N1}}xwS{*hEF{QU-V)#cDkV}5zY?eZQT=6Gm=03__^ptHf&;<
zhwr}Y(E|^!anZ0AsaziI$v$#CNEo*9qw$G<Y4d}dyDoToo=r$s)Tivb0p!Is-q^P|
zt8<|5QiUjIy(<=`$>I*kS!=!N5|2OXe@v}SpTysmqrx_qlkt7tja(yz4bJg%`)d(M
z?!<H4w`D9Eo(caR60GGU(W9g5jzH&!PbG`rP0R<eOu$`GOdzu<^>1Yd<;3cWh`Yx|
z$fv}i1&*I*XG@3|qzr1z)o@ky)hQutv@$6NQ$j}YcftI8TwDs$td)a-WwQtmsPH^c
zf?UGB`AT>UIkB=N*`sN-EuHK?EgKt!Jlsfe2aLdhW}ERn9~(0mXAC|VX9*&!X_~27
z!LPL>5v^mJztAnlYIE*PX;%e+ik<A;JuAHt?vO<m-^F}8cG#bS=)viM?uqDu+a}a)
zzCP_kS+FdS%Lg3~1L>qknY1m-W3E0?L|s3M3OW$?)Z80MOh}3vwsM@hS-sluIcgZ?
zb4e5D3?G3%7givEb*&r%M1`R(;gICw#ggm1i8@eCVja3Fz~mwJ*I-@uOYCu8P;nyt
zL1!wBBfgaVRICFpz{Xrju4jb0*S{s(C!|68=MT?-@<8L!aZZ-rOW!G5FAO?`&3Fy`
zUp8C<C>2w{HVwtL1j~WcUdnnrQA3%lLAM2e*gRUCOXlWgcT}DmkaX@J&dtRyM)HOW
z-Hk0>2NT#j1q()Kxv`zT%g)b?3}b&uMzsm~4-}Q>)-9Kk5}kF8vA9KBhZCc#HYPGO
z$HpuiX!xMt9M3r7KNg@f(x!wGH!~GM?V#>rXUVGj8wg>k#3_2AH9Sn&A<-L}<Jrp5
z8q-<c=H$xlmbj1{n@rlU+y3nS{b;KI8Aya|CU9<e$U@r7I1{HV@<@l>>Ule#hX6E^
z$^by?zUDH`SAZ@AuKKZQrUs0Dlj6kC39oeaiCitIUMHAW(?{Ub*R^Xo2JOZuzs=o<
z89yA);e2t4k&PASVH$+6=p-hWslhx^f2d{={sCzvE~6S0RqPB`*6|reIW>{jz$oP_
zY~fNX%~-*wO+|AT9F<OW7kaOx1zo;Wo~bCR9wtkk7mlcH0mABKDUF6ywHl(6gur{<
z?X8Nua*X)F_laGl>8_N$0eutEkv}D&t~%fxy0D*E2SD(cJARzTj?uH)ttg6%(H&^z
zB@+vroe1-(mEMW!@r#-tlL8%6jj^WU5?UUUVY0tMnK2v85~HS&77n`kSTlS2l&^E!
znNP1lAcBu$`)9tqii=iHOdYWk6-e25<`zn9T$U-H(3dTK0@M|fjZoBUL+5XfijL6n
zleO!phnjNp&)(`TR*;hGcLj75xx~q_p5dcw@6cb!@1~PpV~re6H2~P;f!UXv>#ZVO
zQ_gCvM&F&0^VWSfW$XV`-L?S2el7haHU+S$Zz_H|p#zJWGFH#YLux!yBYDw~1|RFK
zcU<<y$HClzR4g~{oqm7fdaITaahx6fhEp=p+>Mt&2c;u61v!jwZ+ddZ&Pj^2E%HfH
z0R1y@NlkC$x`%BvlmM8fv@lpdvgF-Yty)kq$jdIaSEHPi?A@^6+IFU8(5^(MtSqv?
z&aYY0L}ntJ!&uk5g%kF6nz+^NLRL_;uU>1pLSM46ZZ9%a`0}x`-x5$okn*=y(y*D9
zj+cmSA)MU@`<SLAcmw_NfOW)DWGARo?FbfYNvkn-8m-7X;UTjULbLu*CRPAvrOG{u
zJ*qc?PGzY$el(ffDRVm<1yrmnw?zC?_HELg*bcWtrrLE<nTT+8KjvFFlLE})-p%4M
z?smHvm(NrJ!nCzgYvK(<q6HM=L5gAqOJ#yQLHDVQO|?RZb4b*EMO~&*NZ4o?B;l6s
zsU#09yi1kiRBLc&!+VuxyIUmzZ`HU%BLL()UZRX|apd(}20%o;=XrG6oy1kPmE6a=
zvB#ts9+)^z8LR1d!tHnL&iPk+IDC&xa&!!D(}U0WPB7do=bK_X8doyF>LpKwm4wpZ
zD0qny8?PQ6StgX(xJ^kqO7hl1uyb$;{+NoCe}a+6F)3Q^kG`Q|Kd$3L>Q7C<f}Sh$
z-}g)~&*TR71RG1{s{cS70W~qpt@Nx{q(k3WnYf7KLU*sR6t5;+gMZix&*;S~mK<C(
zAt-L(B~)~MtseT7ss>zC?VQIsunB5^8z$gaJxNI%hN7z#0y~O(vtPMPf0^Ub>ye)$
z^DtXQcOQu+{HaZNf&pyCqlvmerB?PBj?d*5;|*h(Ih0T)s@$D5+rM+*DpwNEz41Zt
z69QIxx{t%+Oyx)Ho?jb{i*W%x^GW&C5w~9AoIb9Qi%xWU(3S#|5J9CRK;F3q@wm-O
zqC}>#NQDb@ugZqq7^Lb!NuWi%Az~}XQp~3|I!Y>Bt|Slt_9_b<!CLv@<q^)NTb&B6
zkMl2zBSLu!fXZa1B-dPuUzBhwWk2lz6gnlev#z}!rI^7uEM}0elu7_I-biHtA*UD|
zwxB4Y5+~)kmA}&?Wh|e3D}Vg!w`QI!rk8Pd{H@+jj-dF~ouF>YE7!CvM5Q>i$5yc-
z1ul%;8dj@s`;IX-@Ci*@5zAJa#uz-trdU}7cljizw!~9(CDOQekBvmrz_>)S)IkGR
z(L*@j^=jjSYvAC8EYWl!2gB#RlZMGA*8q?H+6MgxxjnuQM5ps6(h1a@203k4we;iJ
zJ7%<Y?6(IqF6)jh@dnMDV|De{&$vugF#v4SE8`HVu>>-q;yWf&Rq)P08dA$0`2<P!
z9(WdX3ih5^iDz~|xFKx}QEPUIPT1&Ch2#DBKqV?kQ8t!KK7W1XRx39fRB)GFm<KVH
zst7v94VuL7jQjDylr<_QMuk}v$i;I8?o|qt>D2&H@!r7|03wW|$Dl3Vdz*7t!by+W
zu`PDDF6t+%jXEr^`^`QFAh!#Z*lQFA1$YWQ`LvGbk5H5pCAaK0M6!xrXDb<)O%WZB
z*#}7(AL~3RGdr(y$C7^RN#{BK<YI}o22qci(#6sbx<#f}e#t>E3oA&Cilzvjp9^1o
znvNV7JPMK*%sCBT3_UUJhx1;kk-fhGCQERIe-*i#EY!bdGEpfKI!o(Ga@Ag+@SK24
z?L0ZZr_URj?11^h#eY0;g62R$@!8;A&jO)SY1*`Z5R*LTart&U--P1NbNT(8%erb%
zj|7u1`e8Izq+SgV>l<?Go`O8%znu7#yUHWj)}%8pPF(jYq<-xL@2=acnoY`96`WQE
zR52{~gkq4XmO_&`D~kKl)j#mE`EHZ&GK;4N`?S@=RDFruY-Jg2O~xN~Bo%Y+BjqeW
z^Epf{dH#u8|85@XT;U7PT{0ay@8cHr$L0R@S9hwYEei9tLFYfk(*I73Q(H`*?*X=y
zX;p#(Z0WySPQL>I_g%U-l1xqD|5_Lz8_okA8<|t6;lFo^Zc@_@$NKiuzbwq?pGg%<
zcwmvry8T-yMt?VIZ=~vD8HtLC{%c#esbcBWLuLQkIVoiTit@q0YNh`FUKnr~VX9bX
zWUAW#`l&g!&2)2Wsp2n>y?8>0DwcjBQRlCpE>X|Y?TSOE^xyhhFU|mBq26@Z|FvcF
zf&)0q9}J$}`Tw<B;N<V<Q^h)O_dhEB#~l9utK!;_1E3W&R1CqL@oX!`Pe(Mo-TwMl
zmCv1Kyh)+wS@lbyEW(yEQT9&M&H%MI8_H+`vR^z(&KVjvTE4UFj#-fT{o?BdL>cd2
zy%?){r-tAAh(e|las$X__fQUTi{ndimI&f&fFoGWbMSo?R}Qo$(75mBe{plG)0-?O
zvU!LZT5*-m1i9AN7|OQ&;lb|mS}U*k{iK9`9=Cxs2?7G(5&k=d%vzp&g5lo>h}+?s
zorzF;^051gW$)6<zdDc(f2y0B8$j1Df6}_?2xP7tE(JHcvSYd^nT}z^{*wLXY?pn*
zTY7tZ{H@_k2f^Z5r6K5gk@w%8>u}Q0?DcnqZ~AXe;zlQUG>jKKqLT<JGOG(><ebQ_
z-LrKEn1xE~2&G><9%KH?ahQV)vvT;eGV+!ntB~7BwdXiH^!?<=329upK>Bsw;(8(V
z?Dgh@dNllVakc5rTeI=o5amd=-Sm8{G>l%jodqr2PNTjxbxwDo8QoMcFtWU=ao0j@
z+sMvg-Y3Lo^~ROyz3k@01{g*UPi2rfgEIZ90p?SEM%F7kc!{TP@uvz)o;eOY@~q>a
zsx;x~w%+!^Mknkr={I}@;Mc`8_k0k`6(mV!dQauYm9&k~Q~o7aJ)i4_P6RG^k=;!d
zs~>0>Sd8B`*nNIDrVr9FAED#*c^F8!psP=!iut8S7{`DX#&K*2CE9)j#1aJ`u|598
zt6PL|)X=Pr7Z=->9ZhZ-`mu*}32bZ!=OOOIY$yQOt|UrVUKk|>(_I4XPDPajuqcC`
z?hl7ni5;F(=Z@S>AlmnA3U=RcHf`Zt-iVPinEa4yDzD!id2c3q_xx_I)G1b+${8Om
z^)tbbKavb=8-&Fp*!M*eXQuVmOhYMs-N}y~1AESINjs#Z=dXKX*UzAf4j>ekaPE0-
z6R2@Q*wS+O*c*n*X3GBP5#q;6?Y<i-Q#SIR4;IUGxec8qIjCXXA9Fb=f7DdIwbx)l
zJA+8{Gonwj;H?q?zs{!J&&g0yg?%5e94}R%&_<k}$XG#zD7IZmd(X?XEj#n1@cIH{
z3-wvYe0Ro!O6V?oq~aWh99tolyI7+J2l1NC$L2#MLK2DxUU!^x&g{bTiO^^;Lifzt
z=Nryve74e&-K(E&LOj2_gpWT0=_KfN8HsIk=t{5B7c^widP<j~8?u;m2gW2S`O>21
z%Yd!_Faq7!U_9c!!9%=i6*>}GGZ7+E?A)m&3ls<Y#po1-{DuMttd-kY`v*`xLG?4W
zg|V4gqw7uXkEidCjYJz+LzbD8Ynn@L%t^asrYGBuQ`K#On$yg2{!shCJTJsIotxFv
zB&D<zZ6%cWgB84<_Z;!uJI7QRE089>Q=j#&p1$ynKGT-;XmUt$w4)jsgpc&SFx;c7
zAO^Gt8!N4R0Y3lT=mexqoyYZw8_*1L(d_SM$ies7X+O8{ewDisQ&C2Cf9%E7!l|6j
zA86si3hs#Qm)9>a@jJg08~&tZZ}rlpzJ4TN{~(>aVDE0gx{S2E&x`^`LW!vi84|{c
zBwmFPk8{gWpZwBIFu$xl>S)Gp1|xtHGcHU$Z}D~~I)-cPqn<wGM`TMW)T`7bJS*o{
z!h@2M;{~jb?Hyj|OAlCzEeXr#G#{Qp3-{~o+*h94|Kp6<g8IXj#4~Y_q^@(!&NjGv
z<s7>$O=x3J>+96@el`5##DKXNEoh6CnF`NIC1ze@VeE@i|K01gh9l-7kwVR(OH0fV
zx}VgspX1a+DHjG&ap2}xVgYP$bn{`zlIlz`&2~~FH?cU<p6^I;O<1<}l87_b=gUYN
zI!#Jo>j^_j!^`<~+d1ueG;#EHqS2h;i*Yv3??lUS5M-YLeaTR_E`xm^<)Eh;fdlEw
z0vZsb8Mc^t86%fRIJHRv)(VS^B}BWVkI6!mRh2zrJ_2!PvA`w$t>w53APDtjD-a<F
z+aiqVZ+(voy3(@+y#`${0_)>XmY@qntYQFHkX$k3%aGN`J)Z~I53{Q4FS7A6-7i+!
zS_D(SDL;`Ok=JkD&dK(9l&`kQU?Fh(lSQ}Fa{6Xz)}_UQ*zNO_lKSA%-};Neo4yJi
zwYSYIsQz+35z9Dx_CE{XT1)CRxl;|r=446A2I%F=B*8I&(6NMDdqRnBZw|M<*S;vi
zz_b1JHt&M^_zK=_KLLFQR!uYk4sy1D>I@tSIOYL&s+!a){SP*p&_g@6xp?7?U@!iZ
zcZBF(eKDUi=qy}LhSaGPC=$ix6NXy5(MKod^9CccFCuRw;QLiOPn0Fm_G02O**`Jt
zs<+8;^C<vdioW%ZEHIe)bxA$dA*1NEAjSs*u!LBj+CS&|xhqI=O*}_&^+p;SP8_mA
z&kLNX{9~o@$a~e)0G0U^tjY_-4Zy~#&!8`D8qH_VN>M|-cw&ehB)L8eP`>0NdkKdt
z$^sCz&8wcb4WL{vOCb-7=&xt97=)D(o)l5CZ&*g>oTI!kq7O@tD@{}oR{Bp!I<kXb
z&D%cjebskVw?w=n)+m4yCU*)gNh9C%EZi>Px@^3=wvUi2``Lnob=z!w#~53Vj?hp+
zhEzs|^M^xvbW$qPH&5JjQ9RLhjLr9~u5?>Yn$iW`*YK-iFhktf$vwa?{@<GE46WrP
zwEDr;U51pgf{w!wf`R7fb$t;W4f+zTP@PUFrK1epW?^`T1MpfghH;CjS1}deTh7gz
zy|hEMi(4iPnkP%903r(TWI;F6v=4AMSgIe)Hmz$By&C`@iV1(B=aGK4;Qw^kF7<zc
z0yRzoLE*+8-sIkcbq4fRvjiA?640M^G#B3Ny`E;mxf+ejIx$4GORqVf*qsQOS238(
zlQOWwWMes|ZSP~o4DRvI35bz&ALya7>kn;T>UDv+5;by^nv*p~%X${IN~Zg)kk-2O
zS$IEYM_}Ab5X&^f!#1j!bgJo9W;GDUrFNQZd+5op=CohVaeqZNycC+Xv|I>fr#kA+
zecreFOzXBU^aAyPRdES@k|6&>!0n!UM^-HQ`H}!h?b5m0z<NH|u!0tBqGZZ9+4YyR
z+L}sz)JRiV4Wz@>m)m6(_5J0X1&@7yHVEy!D#3hlHt3ec_F~uTsPP!y^BlRcBwQSK
z;iu|<VwNeyKF{&wp5diI=sM15#w`wwCjlaAs%LZhUS~Th#?ln9$`>6x-cDZadXCKC
z?_;|x-1Mpl)9@0zrN8;;PjYR@foI=EX5@z`JI8+fbkLC1W;nw+M2$9V)3h7x6Z(&#
z_r*V{Q=_b!8SMp>-<Q3IeI5(i7X}Nm*HtSnb%}e#{M7K$#8pIf_hi}@QiIKAC#_Jo
ztzMB(H+kvyez%>c^uTDmKKzDMstWf^TWqjXfM+X^tYF92J_{FQVuu)&i+;N_P=I3q
zQuJ&J{5SnxfB)VW01ai)DtFP1KMAP5^jm+t7g*H^`khfX6$1pi0SlX(3Ra_3OXHfO
zUGHQ|ahl92l0@T$=EHn0$?HGX`@Slin0d1xmT=zZGv&4Ys<eGe&J*6!Rr<r<iv_b!
zV>ZJizZWaQv!B6F43!Ry`gn&dLQc6vQe*bnWz|~41hZG%{<SeJKN1esV=9KHg*SHp
z02f;|UThO4cfBs>t*$60x<<&Sbii^>W9zN@nKeK#_-7}|dEegW$nT}-)f<VnKP|Iz
zzH}xEq+i3pZxqLP(#lfxcfX>(I&ddCnzJi(s_RL@>-4VJyUqU-c3sl{C+z+gI{5!q
z*xfdWCUvHyh?!TG-kfQ=`_TR6{K$~X+p{U3B>9~p6+ho73A_DU@>}^lM_*8Oiy16?
z0AUa#j_rGosLy$;)~#hqNQzFDF$kbS`!7ftP^6)Eh*D&&1DY5I#pO_u*&F?Y<2(}*
z>c74o0JAW+2Z1WAm^xV^Vx{abQoR_huiL&o;=S?_n&P|NPLN;7jg>F`gEWri{x78Q
z_Wvo;Al_in#V1G!RUPgvNckM2SKYQD7DI@eb3G*{B~aH_mZ6I)(Zc%0zzEZiZCk@f
zhl;3T#jRd_A}|ysrb<upniF`WFwwmIfD^08&l}{WzFoV&%)mVVEQlwT$7?ptTtfYB
zgxpNL9Z(nJ@`0)~RU^*a%|rvaO@z5?4#tHlt}Q*REkA%LW4=ko?J7>$svq7$FL@x4
zYr;FWv)c4%)1C9W`f+90B;hQ}yl<V<RH3wVS7awjaboXVpq@=X6dAfRQx<=ui+R_R
z&7=$Prblh7bZ!89``fYik@_ih=@##<FRH`>fcsul;oW;EHtbJ#Ier)zEV!0)YFy+8
zCU@}wXx1bxmG<a<_Xcle=|PZ3`=eE>xSIVH3{s2<vNvypF%@B8i9DG0U#caPp&#c<
z656n7za!0yZ8Y7Q&Z*mA4yMIR^!1cnPpQXtu|jP(LNtH-l80rfWwTa!)^o_s9Lc5_
zIog6;QoGci!jTVTd4)tKZIl8v3V)#PmQd}I*JYqcHTkD1uG-Xe$pR<;FEGIIA29GT
zW|NFOA|p#2d?vYw)K>6fr26G{0%-EXn8qP69Fy91<)H<Fx`7mPmoC+3GqJ?M2;W6(
zA_r!tnQ`<Ab9!7Qb|v>jv#`<zUaCYW#YeJg=JTtDkcaCic~{#!<Xw|+@Zrt}`qFYy
z&@abttcZq}Piu=0)$PNNA2=%80gb4{CxJQnl~{A9b^(Goj~n7$-=CS?%^tmiXK;cX
z2?Um(Jb3(E)@Nt+_X@)8*KXuRQcQczw3tH{Wn>X71tYj1cHfv4TKStnVhn7F)d2a?
zZq5*%s2{Dj)6*cdzDLFd5S-X|cdw`-f`E};wGS81P3b&R9%s2Jy&4RRYrFv<s0;`~
z>3fb0#Pts9&kOBQq0KA3@mQJfH@4rq9a9R$Isd#%C%5vU!t!8(<GgI?g+o`BGGHLC
zl3Jr5sO?dYXjvAs8%8bThrJf^%I+cGdtn_Hi(2I|+;UU0@Uc2L#yxRZQz&W5Bi7xi
zaic!4_-wjjlXEA~d@H+m*o|nNYwYNvKrF4jg~_%#d4dr)mJWb{*P!Y+e&gTP*{HQe
zVo3m7)k1z%Ws!9&J9}?LYB?|k?C$tnvz$6qwmH>>^<({#%lf#Qoj>e@Fc#n+S|lLK
z)}GR<n*2gnTs<?Kb5$*vfE2Ei<J;GQ7TiZwD&4EauI)B3*bj^yCv+f*dBxqVvirf_
zNvO3#vmYL5T+%kF-qZOa!+yd?@J<V4<VL~e%B>Pk`#K$r8%@4aV;F`ayZpM-lIt^0
z{qR7)Y#to$NR;!g@`tTV(;j*mmCc_@ac}G#?XSo>VkXQ@G>0Z3!G@oWWPx$Z)uXrc
zYz>?~HXmbn@AG=xd|mQ1sOgc9L4F1|#VIz6Se%K-`Md(mXm2b6)0%i=3+?NsrUw9x
zCL(&P4OiC-)(S7EUdQ@8(eK~Q@&E;^Jm@!#?PyBOY~uAYxds5@>mhL<LeeGiL^s>r
zzyLKYuXup%wVJ8n;Dg_iy_>(evT~BXMbu<DP|LdWy50eL$Te})nn&x`!R;_#Bm3Ij
znaiV&x&6uAmNk>%3TJcJ=f}r+GVm-eE@qb{v)nO?sdx`i^I=O`D@msUY$osE_QPfS
zgI)WE9yDS^QrPVF7QwEIUlzu&f{{mg^_dV4kd~i1Fmq&Lbvq2IXX#<LjlBTI&ph?A
zlOcUMiqqMjjw>c&l=x6vIi0W)-BAJW<se?Hg`#8YV&LQ`s%CYmql#M!^WD>JhNJ8Z
z&QE;60cSc?6NHgE*w*6Z7~NPrvcHS~+m~I~_~g<_v1%=R*+Zwi>W}Z7d1u5?0Q3PD
zzw%OExB;_az0(0?TdLgx0~x^F;w2lUiN4Om`?X4W7fRnEKPIV6D-@p&=l25W%>Gm{
zCmYJT-y&d+1sRdZ0i_T7N84qXc0FHtS%ZXq6FD;jlk|Y0?1Pg#+0$_acmokj5!_d5
zbt3GNAG2d1jqys#%8re5(wt=i|3RD*^GwP~@fJX}|A#coet{G=>T0<IOhZ@2e}QKf
zw71;hJzNb6;Gc*KhuSf20%NUjcj7T#OLIx?BMD32`z^*1n77}x4%aC6R|(T};GO!9
z+w(aE%l&(`c5|N=)ApAMu>?<Lv-O4^;slJBaJgzN#IDQw2+OXUkSJD8%C?)gL`HUC
zb`R`kV$d)taj>xWO!ZNR#qP!$F%it2RO2(!UpxmsdM>ly?+q(K{4m?@&QgGN`W{h;
zp`(K`-s1{pE{@#Ia&}w0Z-+-wzH`=tHoQl5Zp0?CLrM}kqd(C&c`MN!?oRpXM!d;Z
zhFf0K6~pK#cx^0BP)3t#9D<fg9DFlt`S-iq6;3ISZIq-??0x`tMw{&6U?}+Oxw4+}
z?$qkY5<y{wTPAkGmk7FCo8!XMua7l^-mwqAi$IT9C+tD!^J421in#0w{Wtip5>^!1
z!w2oFI%+n%wd{e0CBs6eNdUpi-Qh_hukhRnCaq%!r$Yt-j&~Ty_B{gm2@J6;g-^zS
zd0&Sxx*aP@+3F|k_iD@X<;n#?;gr>B5eH+zT3|MqHbx^594Q_fH2r#Yo@;t)Q#zJo
z_ZymDJ)F@g(-^F35xsp1gMW~3T^p=52e6H*$SgFs@S0J21fXw#;_%J;LZM)e_QA4H
zeEe$iRMjYDdDS9y)bke;a9bj;c5hyKe@^z~nS$b7aVyZuPGyJe=n!@8!L@9}D`$f_
z<ZBAwl4h;a^j`G_!Fi;M-jy6<WZ_7q4u^ngEr8CoOwm(Vy4~7sU^nPJvT>Pu_2Sn$
zx;9r5n(n=MST%%Ip)0o|Xv^A<-ILu~Mh&+Gc2;Hd@H$y@;Nd-o8!WOmGv~{8y3B^-
zIWEIHhrJTGcG|Y=$CZpKy7Y#ppu_NdGq2VR`}z)2MWlW{yx{4ENZFVv^67?_?8G5%
z=nV?7!am~VZ??0dHB{ItSf%Q2KF&U@&@P4;vz6UU81$``tvcR0G)=2r)tR?>z;8cS
zDr`UZL4CNGgs!|>fQRFtop7RvcsX8tgQvU+(_LZ{xgnnY_@KM-O$N=-z?B3u-vLST
z#25eN%mk5&D*=*abMYDDL>kKcWPh0PyuBAfz?~@7IAn=ta^+B#>s69=C`6Un_<1+Z
zLYB=Z<8mJo?0U29dxgRsCoPW*$$$z7yE<uaI*+5N6X0A*UZviXT%!Zc%8lR^)Oz-%
zIbdjc@t5f<F<G0okCg|ctu$~!m)r?TdNGaf`8Smv$?&J1npIVP&ximzX$&1eaK7Id
zwCT4fpHU_*2FK-%uD+9Xi8D}fwA;Ra$K)1tt;I~(LO%<1S{O@*Y!D9MzqIpK>sD+Q
zmH}PORt;Ri;j=%THD7T1Y@+@&+lg_9p>jumT<?<jQ`<59uN0jcrHnU*U567s)xan?
z({=!OfbFQgWvtBtUVm!*^WFUjpwInmVv0KS-I2VPARW}W+sJ$PbNnQZ;*ZPF8Y=JN
zADUztUb*ajKu;!ND2+Vp6?zq#Q3dXCmSkS{Lr1zw$41&pQl`?9A(sLc5=yGF>pCI3
zzY7~S@5DQzEjHp6o>$Q?H@!kvsf@~DYmj+(w8>bkSmFY$sL91-2y&iJ!s9(xVYdX5
z(LHpCPxeLAMe^{1r4yN8JQj{BPagD{+#2$`(%5)wDKKt$(XJfz-6{)JxMxe)FIyhd
zCpcT~Ox-8%n!CB_>7vGeje7Ka?AI#5yNlxy0;|Z0U?KS<>1c^#>yZ&YO}pZ$Ak2+k
zozJ)1cX^_cQYu&iab$704@I|i834ylhg%x5FMg(eR(4cT_EpHA+`fJK(FE@l|2Jow
zbH5#|mk!P=AN@K}#i0lEe0CjfS4j6i?a2eO>9f)g<{x%n=j8p!&VayfsnOlK_n~@A
z`h5?7mCtvT-Fa6-&g1J^d_%ycmPdn|+24FXn{Br|R>$lWv~~&S`AMp~t|ZZi2?>wl
zhKE9y3xrsnZmI8;OOjhRy!Z<&-8eQ;26VIBTWKSd5Ba;0$7yLi@-8nPZe8_!;gcaX
z9p`m^M#wc|_7I5hgL$Q&c(*pceo$T8!uDJGtovl44Y(6i4|fHWo=MYBFXSKo+<pG_
zba_zE)#^YkLX$&jmzw{+;t2dR1|z!{(^<gNKbtew6;2|pMZJ>Q^6Q}v$#cdm&$EaG
zT(t4mKavY-*b7<`crO*YB+$0e5O~y+q{PRxw~;AZBkb~}oG@w`xNu`|6zCQx%yN~$
zb639waU57XALM8+o3D6rJPbOE?kq!Jd(m?Em|bS%89%P|vUl!7WGuMG*Qc!GP}j4r
z=2?Ji(gxR|4Z;vU|COb(Kd&a!ov}t`HmL!Y>@$>CvzM(Lz7uHQxsp6>cv)_Uvgyb2
z&ZMd8vJalJl0mMdDI5IhyAzgEUQuEJ=YPlS*4goSVH@M~dC>K1{jxJE_dK`Gdh0m%
zM=`eY;m4LbbTz*_s@ppE%ny1c+<(Q2S2-eDBzR}`=^G0UVWor5wp8s0`#7o!hHw4m
zsa{hgA4;>6qTCi;Wvo)UKut)wW3X<8#L!qKc%xdu!Tc6n7FPdU*6m>a`vQkW@`9n6
z^YEC5d<tR@&oTUa0fX56-f2BA)ieB#%VB$d>;1j`Ag1k<QAfn79PbU(=+iPpVF;Ug
zuQ(mEFZ53A-i>W?mpZTO(aI48Oak|?3HDtZ!O(CC{)``ok*w)i#rtzljERUu2l_|)
z_*4~aEM-MkeUK_<eIj41>UTIL1U4DpP{5BMmR?yh=oTE=+exg8o>~((r8|`fa(w>C
zu;!47#{7FiGPROf4iU+R->zge{<02Sl#yCo7mW#Q0Wb?CZyyK>XJcPP#p=F2DlgeT
zAc4ipe%(MlfzmP^l8}c&iwA~U=P8ZXg=kK(PI>xV4TeaIqIQ9QT{>_tyT=;biFW9B
zt(7!N^PyJKjZU%PqutKs={QT~pH{bTy|=r-s}SnrHV@n$h-ws$EClZODPZoJavTPS
zD(HV;mt-{;-*J$k6Vh6>A~LF>V7F{_eEBu1r}P0+a|?fYVEn~pE+g(8M1AZOI%O9R
zOGKtT0H&EH%B@HtplR3Oc;sqqeXts+xqUtiVc@S9S!N3~!8ns(O&0TW-yVH!_;lYQ
z=*nrtK*CksxiRXL&};)z5mYbwada|`J>@8<Q+>yM(H4x`s0HpO$o;0}PG%6Vh6j4=
z-t8`1s0`WW5RF$Aw$-29Q%CIqVDY->m1uMGtezllCyg++dZXX^1pLA7it(@4`Y$m6
zY*?XtP>!T*^}CZ&khS|j!E9W@BTAP(tV)-GfCngw4-I85I3k?t#mpC53KV~LK2aW%
zF?LuQGnQZ3QQF%1YCkM(WVx*EMYlnOCA+-(Ko${$-=u6YNM#02m*RMu1MLY~Qp4Y#
zsl54`unWoAAmQB_tIMtvX1h;q4AtTF+;;Z4%n6nF{g^mqrQW2YDGBnlEZ&{1e^cw3
zZ@i2{s>0@Wmp!>(44z`L@}2mzdBkX#l36s;{&Xs-V>+dfLDpphEu_9p)?;+;2bX<P
zunv`5t~f<AIN7%MgAZ^DCT^Ll`1_LH?T?4Yty@mDMlHmV#GR~-lE!Al*HW1-&(C;D
z7+UW4CFp|L_C`q-@CCcocVkZ_rS?t|W&|Bf5lS!MS$i6kM&gGpUT<wo%AShSjcgX+
zN@tn^aJ#EPx5>u>28@m6-D;m=(CVN^SWA?3D({!;A=abnGdEDZ>c3ypW>7hSAd)`2
zAom0*m|p}Exj(tyGPkc_L7QmvJe(AF;bW9l_+rj!sSRLQ63xf_;r%`fZxBfS&4-~L
z<3)gta4c4)h&LI%%xqm5;7(LMlJtT<o!$I723!W@J@Zxb^as{kW}(i-Kp&KrE-=BL
zIt=k_jz-JQBf|K^+$7;V54=K<DNK$@cytz0(JZ9A7JRei?f%?pKaTLi4=<W`jj|+-
zUc(z4_Rhv;6xt=P@b;uVKlX-PH@+|4z51W;0(ibWRB_xPQ7e%Ts%{eI_iRf+;N2rN
zjAo#U?CI6xBaW~T69Y_<>iZzQ-6t1Tm;hqPH*G_NHYvlv<(<i8niQX?u<1S4Ye(5n
zjf$ML`AOi<7F_MqNpkXE;18@TfvZ?2cgA`h9&*e}(%gm5yPLZsIPME2ws^D#u<0qT
z-5<L>6Q#|0_SrTq^LXhaO7@wQs}6mO;z`#*kdFk1ldOwL@CQnetrPwUT`LH36|)eB
zZdV|{UG>ci|4?vXfxu7bQr<~?-_t~_hU$FudSJ0e0j~O4Hpupy6y2u_t-RFAkUXXO
zf+U@2*l{SSL3b$1H5G;I<(mIcn)QZbMZY_<yET<i?4|wt32m4qxw5}+HD)_Xirgp?
zP<=A1AUFGqPBS|<@?h;sIGFLl#uB!Ml4F<)nyiW)2rjExdL6Fkr{OvEZbyFO0K7it
zyUesuK%UpmK(?-T1=&i)fP#9GeH!xSU^kMEcwtU6o3Np5k%%lgR7rBmc*|abmZJ=b
zfVhQ!@-9JlCGqCxqYy5|ItBSdBsYFFJpFv;J(8v31W%sPfu!XM=;mfgfaQ>t|KQ8K
zX<gA~8?~)eWCZi!s{4p!f1c9w1hZL~uEXYvxzoz8oZW;To&Dvu2?^v<_@m{YIx|(T
zeUkM$mRcgWaIiQ}nDgrDqi_@Kn4K5escFFAU~4^rK-^%jaLmy&Ml2<DCWv=9zRI0U
z(&6p2o0XDEc3*g1-j&neI5erJ<Luxui3%tQ87ivnt;+vBCPA15>KgVDvzBv>wM8Gu
zxg~@%zDVdj2;`D$h<k)dN8OEhYKy-O&v!-SqAJ4Bd!1q;X#eNRXz=AdqX8jqLt5^+
zeM_IU=4I;CI6-26ee9sSf5Je$do1*0c=1E9<L3mPSia6zWT5dd({_f9;*t4m#_FZr
zBP*Np{Nfi1uIrRwnwyMNIU}Vpi}ZBw)nY<~$NgxS;XZnCCLm6^t4zGXnQ2WDQwj>*
z30EVks~ImzD8!{y@Qd+?tEJU$B(1z9Kb)UVL0Tx}2lm`x(v`px?6`3!1gzpY$E~v%
zcy8=i$=yo2$ta-p;1oC(KUOZ0dc}Wpmk^yU#I)v8J^RGr2NC-0+T#h6X+M>){8c-s
z4d=B_9u=4y{RWHNJp;Gcu&DuKr_`$tkD*2D>A;t)L6De}<yyzQ6Acs0qxLSc=$;?%
zR8WGSDPugrda1AA%R##0`oUo}J4&~4kP4Xm^a?-35iMQ&4E*&InQ2!~HwbS%k-3(B
z;NoH&4h)Vcu8rM4R|~Ji-K=^m-!3WtW=PL-;M+SLwHN%Hz3n7kG>fb{nM`)Quq6Ka
z2G?ejPk^i<?gslRw2&SBY19Tf3-G3=-HKnVx*e3q#C6Je!PeH)FS~H%RvE&%O}^~m
zds~Nf+`+Sm4K$`oig^?lcDZn%^GUd?yE3Schf;;95`T>e-tVolv~(6ERd2pY$=bv{
zb>yZ{7-ni0-xZd0<Nzr`bz`^=GV*A91#W5_UdM!>-85NgBADK;8$O(PupAgjGeoME
z+HZHYaE7jUzWk`Lm3D4<x|wFUtv&&@Fm7gTJOjOXacqPXN4Xr0ij0{q(W1?tqF^84
zU{`B4c98D1vxhr%xaFhmk%l};`&`r(_QZ-^KIa6+ciBePz5X6Kil59xnCc}#tHhBc
zq2>1li%V{MW8qgito4*9lRC=Ek0XAD@@;unT%#b(o9mw$Hb}fs$Hd;j#NJH}V3xmr
zAh;D*--4oCmS^2bI%J?+q#wiCu;hG>A9!~5qsstnuafbaW-8C~W~R=_I|>A;5NyM>
zyH&d)UWlRO5N=44r*b{?pRtSwUq$#Ys$#Fi1lbK<=q#pF`{ei{T@jc%iLN4#csIWI
zw3w=)g4gEddCGl3c;!owgOl^k{d}%f>_*_Mgwt-!pjuGUL@oJ8g?aZ25AxU0I*Q9$
zCyevL<?-6JmI`~EL7cnpWt3E#?_~ZXdp*o~+c=}Rdqs@%$2vRq_~Yc%V!YV|b$BNT
zJ}%`7Gab&ugDo|`j+;(wa939=xmFEH{PKl2+#|<?v2O~#(lYbAqafG8f&M1Cd)sYT
z>Vzt2+ej(H#puBOeN~%y!a<g0v4%NfG3M@a+)8qfbG?{q+3Cfjf-d{b2MG$(JO#bo
zzDI}Wmeb;tYF9o_zQf4pGatgh%0o%3zl?^sTKDFvX;o@uwn~HERe4)nS|kiP=`K-l
zv?aX>cyT08VfW8MMmJ5FpG=&$ZX9$vY_N;D^0)3mN|ZZ3-BlUxiW{2CR8(k9Dkkp_
zWfqwAD1jFsN8vN__Wmh(z7rL3!;^a81^3M1ro3rbpR#M)tz|aep%I=v2)MjWP(?XH
zJ!RdpV3m-?cvkC(eymfDlvwB$Qg35O$NC=j@l0!oK%sV<#KjiTD<awPepa*(-6F#_
zqV_Yu{iFQ`+}yOhw5uk4P4l#g8g8tyXD3^8cypgWE4i7F6*hTFk2ZQ*`dm3{HK*cK
zjp<(dW}ZMzld~8>8IrZGu$Z>`$g?>mauf#&kRI=|x8aN^RP+uwhGV>z+H~(M=KKC<
z$a~R>%;z{KOJQEEly4uZVeO=VfvyCBP|=E1r<Umy@7*=mB;)R)W;wGY<ZaVfHpx}w
z%{4CWvrR>3IJVJxrxg{DRvu{BRvK<-CZ~GFsur>Nn7r*6O37qZ8IGx?ksge=ee?o*
zx@<tUDP=UZNZ{dPiS4K~wjcSU*~)IugE@o@yMI@#oGwN67{Bp?1osRaDe*sKX+6wF
z<8PbKCJhW9)Ul_e7yfiV>5;M?F;d$-va~s075!;JsNdw`h_K>eZKQo=Sy!1N7{qwh
zjwHJ}7sjTA*!tb8eqbfASJK8JII_g^+YHLgjI$OtilLE;83}d4y$g4wY1M_(v|<QM
zp9_o3s^``0S82`4V`P5+&MPH`+t=@zRi&-$q;pkHFWV3NvV?Dp6o+yh`l}4TPhxiG
zS4NbgHbw%5+B%bG)s{T7xhTz+<tDuHgs@#~h5h1{xbh;){ZQ}m9t>QB*ENZYoHRIe
zqjh*Zd6eRAKlG@-(otR4DaUv6hOG4jdB`{gfsaE>3UYgdqiUP|?V~##rp;>?lq))~
z9B&X(!w{K9pCQYZg;?D6!Ul)(4w5@7JHSOLgVP@!D(V+%JCr0HJX4^kU|#2ln!-A!
zd&!ZLZ`edcp0`~eJ(`p?9M<4F1inULODnFV&}VDG^2lozJ>JA>ELSgjg>w6zGRDnv
z@}m~A_{Ow#qXPFW!_={+Un0CK`5O<;2hg&HtlG3=-hwWZ;)oU&G#}5lZg6qQ78gep
zx7}>s!m8{YP$<4)G@{WNm^U45+Z^4)it13CoKnV^iQ)v-g>|6QNVGa>Li-)KYutY=
zP4bbZ@kGnx+aJWWe!302_OBAyTVg%vrSuN`xNfgV2bm+{HX_}_&*=7uA823}yVai-
zj8Hz}7oWaA#uGoPC?o2#@Ikj*@UZHI<)BM47r68l%R6@u1W7hL{<iNo(pBfL6sK=1
zwXXSQt(egs)M^R`Z56MgL@{oLLzO)E!S39RFp8moE|-{=^`|+VzU$$XM|z#BCGPmT
z!-39A&*StER&P7nWU@Xh)#wQmN5HQ>Dp1DHEen9(7vAO?Q~t4ik9-RARN9_H;I%u+
z>-GF)*)T`z1MSts=H#D7G%N1*l3v04GtiAomkQesiu?Uls-;>KViAJp&>pkjZjB?M
z9Hg61C)5fS!6mKQU-hJ35fo+Zze~qrROWg*eO|_zS?6sXP!K<QERWn<w9A;Q+V_rj
zUjsGw5G~iPUfj;B@Sqfr?mS6E-<Z`yn>nP$?x14_A6QFoa=i_zSpDO!rN+Id$`+XC
z^ui@BcI5&EkS@!HtSs^tU2MX7vZ7S6wy4HYNG->TQSo@($=K3QvF)^p0_)M6>A|?3
z`~?qA+Y4BI8Rg*`!?=)xiOx;ZhebYcl$+=SQQXCy(R)W%`FPJlNygD8<zqvHS86+O
zZO_gNUp;|uyg1beT;B6vUkkt764T-L10bafiKkJN)n~8|u&0MHhR7P!(JW@@&QV8+
zPdRd%kBmkKRha)WpOwLhCG7>TXcYAwaL7KbU3B^3;Nw_0qJ$_Kw0g3_opazUZ6Q@6
z|7=H6wn5yi%Kev>duMLU&<ujs&1TbUr?(=Y;s0RoJ)@$`vi;#UH<-FbKm?%;h~%VX
z3NsQ*DT2gOq6CRbkWeZ?$&x{mih^XxL7)&NCnZYGQF5-LDBk^)GTryynYr`t>ATkZ
zVZO9$wcS-uJ?ET#_TIm+rAwsO{2$`07w6y3RxNaOZ8Y7QF+EGF;k^_!7Cm@rL;QSC
zed&VCqjrCd$=ow*PwnFxo1)TWqlA>`>b1^sIGz*<)kdoi5+f_06nxyc)$TS>yXU?6
z3a63If}kgh=6a6ZPmCclj$*bJ2C9zBw`<GHxCG-b75VnG96Td?OLVR;_SjLgMb%`U
zm08RION<Wl)K$WVPrf8B6BM5uLy4*Az1NzBP1l6&>n6=#NX2t8&yv?ZJFQ04x6k#7
zIlpHtYKu3Yd3(R7$~W&G9zVe^+>6(9_^dc<DLqpV)a5+r*ezz7GD#-IR`!%C<l1S@
z-p^+&EKlgMp~<yQo?W69o+<{^Ew86*!*2RmcjtSik*iMqw}i_Yg;2#6ZRXL@o0a<=
z8=1|A9ak;Uz7AQM-(1%VUs`O2Gj23Q_q2qx*_fJVB{ODL=bG1P_RhxK6l+khAG@5_
z^uWSKPq?E=az<E2LoX|}`$eme<&cnlmZRAyr+LnPVVfP&zIMqeIVD&_@%q%su#p2t
zruw>;^WRzf*5ChmdWI$AaPS9bL$L_<A#Ed}N!^3L3KdHL%=z*3%itjGk&a;B2o$QP
zYCT{nx@74MZ)<33pkI5YqR4>TT$gwsq2V)bP|#JL?j3sXtVQO+{wLmK2Ej)n=|yej
z79tf>k3JZl5BA?ru*bzj+jjY?eOdhQxcKJH6|KW8t1RM@%+Us=+eCkk=0O)Pd;~>r
z<`eHga*Ha@+HyO?6Ze(l{YH|42<bb?a=LxY$fZ5U4Cwz=qyrU7Ep?5b3|;KX>t<gt
zxGYu(EzZ_^+;j1?TI1%y+dWnLEIha|#w>szK#%rGj~|+i9-eZZb;OSDcX)b|3|%7A
zsy++q5W+Er_piqu%`bM|KW3xhzOeIz&IV0bB|i4ocT0>$t%33}5~7v^cKLNAwzu13
z=DyiA){@=}MfA01hlb*+4(hO8BbWS2?GSg;>X|*k*K}#JQi^P~mUsrZq~>ZxmYr#1
zdv{Ap_Srozw3K~-Kk4X;k@|c%^N`|3yh6mRkIc$Blza1<Ls?>9Mur@*(|wao5&Ifz
zC9#^b-f8hr)nT1+=!`v8f=lD$>*x>ge|emI8AF{A$c*xyO5bcz{Y*cg+!Pes2k3-r
z&$%w|jb%AHK|J>2ny>9~#YRb${Ln&;kcI09s2-!c<B9cAr^K>jUE0YSk&~-0exBwM
z3KUYA8S^-SV%6zXma5XKjl?}oNL`L>bn9c4q<0ZaoZ5?BySS!J{xnZ&OEVqF)^6l2
z`)H9uH_6y-xfWd^h|d;YO#XVxp>!|Lsr^QiA#;anhr+f!A^TxDwBGkMme>{uH&o6V
zYKI-19rjo!rI>N^l09SFXG|#ot?Y;?D{6Vl!en8zt2w+&b@QMtQ_;1e$GUmM+o9Oi
zpYO>U#GEx&;`2G8y5wQ4r@YaSrwxWKk<}#OOaXj${ArO1sw*KKv%^Px@-}UIsV6pO
z%J2J%G*(oXJA{&0U2U<zBYt1o+_SjR6zAg?v=fif8MSNNn_pwmJu7XugZ^I95NYy$
zJgLh1&esj4M4pLi!ID_h{KL|@XHc;v$J(0$l1vC^!gk_cb1%+bsWuqRn{Oo9T`-NJ
zb}3_TuwZ)nM2#v?M`XG7>nV;XRvj0g^hM&8=OQIN?a{ip4>v@1NlhkN9vxzjQbM!-
z!ka7Xp9igskn<0wOuCJEh<&pa4CbD(v5oj+$bbJvVL5i}XA#-Rqj~O^*E-(&h;iRd
z>gSHCxnK2ZvjFHj@3RvL_Pb9UdGYMGdEn{a8a1NgRFPsoIg*^Tu^h>10GOQVsFAE7
z5v9~S*O-huBjtMDC9jitoztaqGIRiaEKM!OiO^}q9py!qVNfc9y<vdTcm%XPhY*LW
z=-)|^$;u8JfrGR@6YL35hs1>H0uO~3#Mul9Kc;S1axvT<UcA^Rv=3j)ay8nUBdgDt
zcleTv)o)Twf{e8Td6y3wZL)hkBY&bn*Xi4Ot`8FerNz?+vQ19<-t!pz3FV^hIEptt
za`ovh-c5(N{wm^|VXK9y1gQ<<Qf<RN8T7~LKF^;esyDjbNMy$Fh|N%AZhw&&mLb!n
zDtwT(T%><`*?n5^$`%aO;{?m2jVYz<PS;~kJ&R%Z>D?1d0ahf$R0eItJ$ja<@2!iB
z3t_$MzV<m_GgsJ`vS;0?8@@ItM}G-;!mP!XH8r$UmR@984Hq_NE%b;>!4uOd(_S(&
z5Q{nzP|Jz8{5P6-WOSNY2rth_c@AkAIwgF?8rHtWWheFz2)k3YXD9NbvJ>mF1-sZD
z*&CAGnnjAU6NlN3`>pn|9Jue$5G8u(nBmXr+9Og{^e*1bi<jP~C*Q%D_UHV<vNn82
zxOZdTDWh2Bb2|B%+N4R%LPb=?a-7fRfDb~f{yc3E!#}@qBVurnR??pp9ZOzH5X84S
z-mLi6_pORFcJHFJm-;q_k+_fLXZU?tYMl}kqn~TL5JqwguB&NTU8z4}BUNku)SpwZ
z)^z;E7xt5fL)fr7p)Ft5hCT}gqHs8z*4_ja4wl*%N8F7{OL4J$i+y~xq&)>YLNm3Z
z7HZCKll!!>j*7tfv%1P{qORXmIwMCn!PH!!8+u-Z)<He~XX(r$Exs`OGy+R8p&d`A
zZOSZ)Fs&&+llPixvxvx6g2xZRs=LzE)evUO+eC`NNl9R{`0LSx$6=N=nb!?5?il=D
z2Sno07D^}h_0w;`mK>|DIhHj_(o|MXaYWWtYrk2G_MDbhTglil*`E$t9#%{TMEW|=
zk<Bu94g^2oh$4>)<EfUFMOcw@_PjFk!+GRSf8IhvnMtG{<#ppQ@5oShnmrP^==Tj1
zn&LAj-7cIo#;_?y9SL2OjjXx#%iWahL@xg2$d#5(<+YIWku_eg?HM>4^+wU1$_^#n
zC)<aqW?O8`jv5TM9`C%<X+;%SLfx*CjW_7Or1{(eo%~SB;7(4F1~9}AC~Ep*X%}g_
zyz3114F7=`O&c84a5!4)sQ7`SB4T_#KUIzlN$$h1>u?`4Rwvtn#ZmhyHp#4=!x!Qh
z`_N)DA0h%Ef!8E=;s)8e7ePHH*&T@N`#NLVnjP2g#aQZ3kbX|*;$NS(z%g0|O9ih!
z-peyyCN*JoR{bdJ!e>!eQ^Vdj1FQ$5j=LB|9KF!=#C!bt`fH~7h=p>&UCT3#V`?io
zmT)or#v3&Q?2eb_R33Gq<ylrry$_-?_ubeYm08Cm`Kw|9i_tZa5YjMn!Hlm<b#c^)
z3n3Ms4k{EPc#Sd4Rq9YDv|t9#R_sw^kPo~Ubx?Hp*>&_TbfSM*VmEwpRwF9#ED{#$
zuq;-ee!V>xr{jd6o^R5WDr_aN?>u9%=?e9{%?ZvshQcwE+1ZIF{Ie7H9jJV?db&WZ
zQ(1=Bc=$Q%xXZ~Goi?9c?G3J?oZqLrW7u);YcZpX<tqz5!6WX#2s{wxE*xbY9D<7=
zo^cR<<xf~STawqh>B<T+jnu2To}?s=hzQy^v!eA2MrRHXYO0>1vLvz$>#3_3=C!h{
zu9pZ1CfDA%cY_!c)2{7gv1odq2ug|jWanys11}L?mnR>Ox?LfBkdoUoAf;1QuMo&w
z`Q%NxH8(@%@nEh1pJqAuRcu;v(n($mYyO!=MW#GaZ67fr#q$-6ri?pBMjm07g!>|N
zPwR-JhDkY`OTxYm`K;~onq9CYX@#E2y?JK%38weSn;2a^@3}IUTF#%WAaBqnTRk9G
zZc8&d_>^twG+v-dt(7brDZ8;ln(B)E7arM2jl+$_Md*lGCXBR!NAY`-XWYKwM;lKs
z6_3e0xBaBnLC!toFA;mIw}zA)9BcVJ$;rwYSg0X${<UnIt2s_(#!*=H%{XC%vF>ik
zyFfdbDqz<m`95g=Aw~>iHLmaQEKY||e!ktCexI0RNmBHXz+6s)va>Vq4vU2;e<G-m
zh(itwTn!rp37{^TS>T4CMQMz%?{RHmwsW3NO{;g?7ah{v$fcTywu9EJR_r4KqMSM2
z?d_yDxE?1^e#NwM@vO?IZGTrEN%mu{4JK4gZtMuNdoxJqoPqi`pu8g%;g~;DyW|Le
z9ATpC;#~2}a%)*q2Z;v>zD?KhiczfuhGpyWYM_aIp5Zm}<z|E);fCkobc#YOz6xuW
z^sEu|S;qrGgJsOI@bjfB3)i$+6>b!DcTLPAOtV9Zm{AZ7eE*)P^Qs`FkrH_XjCr$d
zThGk@Sv8_rU3K3wp(YB*_!K798YtcZ;FEvLka%61cklJHGrJsg-kgqFSODQqnXwM}
zaQb%*4K3)EZeSNzWF|TA30&!xM{BWdoBdUwby5F$^#t}f%3x&of#GJL%3GH0X44h?
zEVJAthB3Ak0(A%5#7To01qb6Fk}pzM|7DG7_GNWqNpWgl^m85L^}7Ez>5Rou)6CgV
zOCauGTcAn4dvc_`DWa)K)B`t={VUlqnO8*)sHYSG0`FfUK$x!k(3j8nYr8bJ(+NbG
z6jkZ8s43e{kstK_O@1)Bed}eW3M3dry+mOnFeXmVctfS-jAX@>90-_V4>c<OzQk&f
z@5oAXoFjV;gSG=U#J7Yw_*bB98Bh^veSud}yAmrZcTL7+Kv|!2ai95?@M7;gJG<a3
z`sz4D7#YXy>ZNf0hVxsKqWke)(`qV&S6aT~^hL6FP8Gi%>6V$;dZR=mR~qA-gs(Ic
z>$cCGjdP2RPFd8ki-a(IKE5Sp&>Iv_%z9{FAFPHkFy9?}^RC!{3wJa-ceLITT4Z|X
z#y3-Ecu-`+j=O^7L}&kWq9xpZ#-dqpGknG(M}$`(?AW_m<Vk(+?I4VKq6_9*Z$@B7
zX_l{|_5=I*2NPON&WIXSPZknhJ1RV+l5|jGZ71&TirT$2S>n|Q4RvObRz8t!<{DEL
zC6ZTGGPf80Z4V{arJnOU-zTfrCGSG0>7H2#COE+(PFy<|chF!EtLlJkrBG~5FAWOl
zU-w==C_CwH4-ZBW(xLv}g><zqbZM?Dvm_n0h)&d9S5YZBqjr+GEB(+>2;8Eej_g$4
zkEkBK$Q_jZx^kIV5^acm&Yiw{ozaF`(O~zzr$01gv*BxslU%>)2#&NWM?`*LQ;k&2
z$HI<)V6Z`>D1Kp+sDT9$ib!iI8}YZTaL@^#+K>|Zfoe$&(I+Bz?vyyPy-xO=Cp!#c
z%$?4uf(G|;aRB;~k?dq59aLH^BdtvlkI`B9`u!yp_4Xl?u5_pm*vJjq=;XkX8}X{4
zdlb*@Q+yanQ6>fyr#$4b2E7zrS#ec6hmEQ4$<KLBUxk9OB?5WxB@9r=BZ?{2k6(&d
z3sYeRp^zsqMOWPreebcvn7M1mzf&pGVqg8>+v&Jt_7gept1Lxixdji?D_+SJXzZ^*
zSmuTIjNe{6^A(iwlY<Ic<hPOeo<AePy4@as5Y~zQo5H%6O#$VP5FvWjjsqgUA-aRI
z51YbZjYu7i1KXI?Hv!pEh-DXTlhFDliu&$Z-j@3A+l@b~zPt41<T_LX`UqD+$hhgX
z&*p6YkRPJ=u3v$Mrx|#pXus<NpOP#@fEy{{U>&9h0(9-B<&hJ=Ys$tY|B<H5`CrnM
zh4@VcvdU$;@1?i>Kqnm%(FT<5wAxvbOf?+`gRnjg=i3x5pNq!-ftK(3L>1jO$NF>a
zJEd2k<@W7R57v)sIN^2O!<(o4<7>=L`sVKA5ITKj`DN04TLecgR%OK7`rIolNHYVL
z0z+-s-XutZf)8-d@!0)}uUlhu(Ygr<K_Ki~x&AlV<VXI8QVmbQA3r>(hEK0zpB=(X
z!@mp?2i1Ddv*VXcM5Z7iGmpHRYh{63@9IJPy@Bc79nP<3GM~C;G+GzYz^h_=@~V#|
zZ^_!L@5KFhdr7A?%gPJaZlKm&(TI<?@|<Ui<#UeMsy&D_5C>8j|EhtgLdl~-W;dUm
zyAO&%ro_d>FXZ^%7^Mq{>|9`Z<*?!e?=4(Lv2}Eka}z}KMsVxow$vD9!K>Y<(n&qJ
z4&KX!Ks~j4c^i?9^ju}UJ4|xSGAFIgYg;1zm{ag@L%R<!9bxL(wqtibVzE8Yf8dx{
zwp^znudZ~cgp%!Uke}wu7u#?V0aM#=nM5>orFj<}?;KbmtU?%P(siUd8l?{UMGHQy
zNQAXmPG`&z_1O>?kSBFaJx9(vVh|7H+$><-@GWM&>xgljiEswC)IPamgNc^CZw$ip
zQ239M6gRoYPVkVG)x;%ysKNDzr{rELVXwY2U<kH+E*4uw&l~XtguVvXx8%K;b|m<V
zC`6+bD7tv|T>ACo3p$C(iCum9v2G~_yO%sJrJju3vkKoybzt%!I7&LTP`67nSzWg6
zf3zoU&M`~s=Xppy9QIs>fEZ1`Bf5}mGQqSrA#ss?!8i-wr07Xv*8$<9uHyhm3j)wv
z1ny5Opw1h1*Q82ZV6@@L486bm5?p5|-424v9ntG}yReg2w`>LIq=n{9<(-mhxZnL2
z8()*+js}YdMAnbU&Na+4l$wl06l9o>B(Xt~zC0L~rMXE~^rG+TI>sD*%0KuV#nvEK
zm>1{O4mV!E;vZtNtaRv`GD3eJV-3kMy#v^0(f*Uxl6EuQQvlCb`H9cu^Wazi*TXKn
ze@unQsIhig2W~?V#SU^A`-<>^#2QEoezcGL(=6ZK)8{Q5e>L?wNU_GeU?g;^nk}~O
zrm7QZzA}C8SO;fX{t0p5)n<WDEw3YSA|b2G0xu~(8m?Eio()a|#tdxmq9?Up9Dy7!
z$qLK}k^A#F2-_(h7Vth0DI^uX>@NJuA6m$bf2xIqxYLq|$%0rbB=Q<Dys*4=5X`g9
z7KW>}`S6Pk;)0=!az`5wqXA2&_ot?Y+!3YO4w)ZHv-rgZL1GF>o>M4+;nvBQRV6Y^
zV;mJ9lifH%(KQtXyd!Z6KZ1iRTs%=LS2ou*aKvve6YDGOi}rqQw*3^<8FiaM^uRL+
z#+)xQqwG7gjUzUT{7B07F_Mn9*T(S2)sOVGv*-<W-6$Ab0AA=hl~HnO7M@Tmg+8j|
zf(F%6v>wPYkR(~fdjsw<CyKOoE6))U@!`2P{+gJIsIF=KY9u~NJuv|Z^FzlVyO=e_
zq^PQn$ORC#7k@~|vsYy;{)4pLR8Z3RzTX$M#AKBW|KLj(Illz~HGRshS#?mlM5PXG
zW}#9mU2tk?mlP%QQMF8ZSu)y%`4S}1FwTtJ_b<9?B~k^{viLoXr&2Q-)JA)I`(!50
z9Wh#a=6CqP7a0<0_rJ*(8*WqT*M#eO@}ub;W$Y#ro6hdqn3BOmW&t91C(t^B$eqI)
z$<Do^4E9(e8hS+8jD3n$FL<<#KoPjho5oAajfEGQL?@mVXGDBWRy?-Uepx@Zgd2J|
zs3ctr6vwYfNG6$RsoutLY~Y6^-$LHWD@531JMwvmxSt)w{WkK>ISnn=$svKLkH)eK
zrPn1LUMr;1<D+_r;4@K#*r|-4a(JEM-~bPsQ4D!<QJa9sHaqyj|3{&)!bgV?b9Xva
zfEr{yewbWvC%8SbQwy>`!iw@zzK`I2*RB2&<s_WPl?WtsA2CLB*VHbs{KKwlRPe}1
zdM>+0YYq?cBR?NcphL_?+|{6-Aj@jgI*)Q4XC=5}0#fS)^S5N@+@Ijud#dx}+5->5
z|LEEOqi6q*p8Y>IBLA@w`Hzjre{4jyY(%~r&UtvbS#xXVrf3#{yNl`*N|WT_rL87O
zTl$}FlE_Na87&QZ^EMn1>3?YEFS+vbp3Oe6Z|3a(uMPy}TMh&%AqVcptOYY-eM3YI
zP>Fnh&*TZQaqzqFue4MkNsqN3^qhi8Hr1yUo(Iow9<%EXK->g6bR4HcV9HXlhiFzd
z#R3c_@fg5ZChe6L4B7y37O=bnJp3t*!V<C`rD8|@A64u;>Y1kyZ9lye8!{zCnMsuj
z3Ir-VVk@wK5s7^;nb-kV2=6a4Yad!3yh!os!T-UhXZOG9(*rNb`(ZH%_a8Su0OC&T
ztBCtOK%o{4rLP=-w#k0uS#ZT(8;jrc_ndv*uzkBQMn@r}fWb-k%B0(R&b@dr4ErKA
zkWI6cp1yqLd&d6iAT)fpEZJU<)R{0uoyS2QoKak*Wm{Tev#;NO@iv%vkG>WFkHL@8
zutp8MthV4FkjW^Zf30*tT8bF3SnJs{kr3Oviylh=pSWXV2gJsI%LA7GJx|k7U8IX3
zUTgm8>8}GT^jN1a$ncAt6s5u#7;ZImO$Bw$HU0KSk6q;cv#cO%mcV^{a?p-xd2n$;
zeEzwZ?9F$#E-Vl^wXEA-;9J^3WM~_9YehJEMMch0*6}4cGVMpozC;f&=W5l*1=t}&
z9;Ou{aLClZXB(vgEJ`CqFs<muDga|$#{hGh0dce)jG@Y0oc-7qb+ZQLxH6?NCJ}mN
zUtN@_&0y^Ml2nNLcG-vXfzLXj)Ww7xEXkf{zj{;=)2!yZaA%N)O%>zZ`l9jqTFd8{
z_->Y(cImYiL)^Lf$T9I8(}+(2WM_Pofl2NZdw<eM<JnD^*z{c6e!x8<)_uR+Q#_&G
z!h=;tsV&YQCAO%Trq$M9M*L)63GJ6Y6a4ZBON7@GZ;{vb`)4u_b6g>~L4osbAGHGl
ze_U47+#M3{++>LRVsNo$8A>j2V1xDon6FXX-oB_oJEdOzqSu04A3Xym_+WvqVgZlf
z!{bkiPp)&+6wP|s5J6J)&SU+c%be>JGJXWqxIamEYMK{ZahYruJ&jTsp?mn>{NTVo
zkUQ_@zvTz_^Tfvk;#^K9(k?_oBaRtWJrw3pg&yFFl$2bkI;rhqvGT{Jp2Xj2>QU<a
zqyKxIAI76yxIIQBd3`DiU16<DRhLg!UnF2!YiC4gFynlzGMX($KYkgi7n7&}6-uYJ
z3cRUKuxxp7h$)q&TSgA%AVo7`b|wWU;UAivLEY>K=H>=$(f5>Y9wiM2p$)k>Q7}r%
zwfQJcI@F?`80|^vsv_g#ve;tmPrL`$#*2kAL8o(kSSX#`s2`nN`ESv(P)tvzA(#aH
z*K21oEe=%{c+Eq%&ub(o(`rVJux0K?e1R;t^Owz%wpel@mRPc}ED>|^<*_v|qT)|@
zd|%y2WEh%@iqT@{klAh@ccbg_t(lzWK6DIM2dR~I;hwXtx8;?n$jKFgpNEP2J!iu4
z(<R43IC&g#5?G7@3|3o@#FG|Z4~(n^Lu*{rLmKh*yn=;Sfi&9@<G10~&%ihm61naA
zas08HVp1Qa<{WriCrGk^7`5wWC=IApxff%<1jJ6p$b8HDIi0aD?5V_jw6bWxd*Km)
zIKacfVm?Lo!5=`5cEblvlT2~xN@~fvEbLF*RNL6#-G8M@Nd4sRlpG%WwKpl$ADjvH
zx=;|Llz!z)&fvcGip?PEi{yb;KQo3>p`ZknQ4^ul{9(oC+5qq9S{G+8-aWLB1-v(T
z#XMsTYfYmQ+qupo=9@|C&i4C#C%@q-i~S;2aw6<|v1;+XSiLe6JVL7&kTvy_A5+ME
z{f=uB<n`G`;9N)<7{xdkt`yHY^R9Qcm#l1dh|}MZ^O__Hdr_bAdc0HbEI<Dt8k)F@
zPezAm7TY8gbkA@9$TzTY{lZSN?BVODUc?=ttv_?-$hGT_y?#D%`}D&X+dfc<alYVt
z{3=C#;g{Wpw>-$J>D6{`yP8*HP|oO{E)~aijr;2>6O&>&t9h$=b}CYe&U@!z5~I#S
zvj{Rvq!t;MIIP|l?ESE@Bmcu50+(o3`q|O@Zz^T2ebOHYgcxOROXCo&WYkUCMb0^d
z&QRwhamw4Qpyw{5MoK!3k^|#NbZf$&ly6pa>Yi-*prDVNb7cueTALfHw<Pgm=I?=&
z5z0dR{6to#J6M<MQR5efOY+Ye0|hldV8Tba(nE%i;Fk3#Z@1M{$9y=;=5YRwki%h&
zkvN&JFe^5;$;xV0i+D|j**AyXpO#F!Dm2n))mJmP^Q-y*){0l4l4nl*{&kv;SzzNW
zdxxF1>H(p8?MXk8S0zNaR1-pr?uOTFY6UpM7(nIChUCty4bXWW)3n3P;;Eb(KD56Q
z9P?poc<4kI$WBP4m2fwnS<sM)FKs3W`&TCi{=#X0BK;hhwnB7~H(Vp%W;<8voP}Ua
zjh~*`{Qk)or!x_nRDphVpfzD(WCT(Q)if;LC1ncq78X6BHX?ZwhxNpdoZn$LS`@ff
zK53#(bk9l7>fl4{bM*}9>OJsgYfas8A=jv|w<Cv2;P=Igt|v@2Q*UZ`CiHX2bAL^D
zQdy}}Wo09{C+d3_T(M}mprHTj8jQi6;uaoTFuQAVrF2Zc?$+ni{;WpkJW1ITC$n3X
z{r5I2SMu(w@a=;|L`g)LjPZ6*cUi3nd>ZOc68JQ4Y-Tnlh(cDBcC|qb%N}Lnj&q-I
znv&Wj5r8hR;21K9;&7hJD8(O-Z&FF&K5~7JaDXrC+_Uxlk7kFMUYf!GP#u9O)hk(v
zE0vRipTH`*Tl)5M!I(@nPSW0Zy1AWdw@ohS?44H*Cl0#d&;P1<U8WkJI+vcWcBH)f
zvDE!JnvQhmY13t!43Zz`h-M#A)nPb5I#e!<hZ`+6@p=K&?OurqyC&XKImtG7K0eKm
ze#I!}vQ*Hd&6#QLQ<wz|r#*FZ_sBA*qyuZ^*JP*rXGm2d%JCCu)j{?`n)v1xmW=}$
zQdYCqD=YJrN8_aUa^8tNN-J#vo6DiZsZ$knU2z9oP9PSsp``8u?y()B{SS8-7X9KC
zhI*sZ9r1)g{^I-R!6}gq5)%aWoV@c5{Vy+5zrRKmTQUS&_1E21+bmd>oTmqVy}PfE
z48M!7{sXGABa9X~As;luHQr$f9M)r8>3mljzV4D#+9Me-V!~;00tKE?CeA5Z1)04@
z*2r|uFvOPW+Xl=9WXmmiwZhwPBV>N~sZ(fFhuYD_!X`ad(F!%mh#J9;pVUI4hW7Kf
zZbvr8*Oc!Yh0Xp%tTlEzOQrgT%U%+rE(e$1-Hcx+U$A8|3YooSOX|K@*ZLJKi|Uuj
zFscmu%{_MT_N(`{)15aTXgqVd)NgaI_qu15QFTOWKfAn5Xgh2c`~!hyKGPBX##_&W
zBz`*^DdClvbqsf;r=t-)k)LnJ<NW%Re?@0-CH1D4W8}hEzJ-C+_Nf$DSo#P(`n71W
zaZfJUeutZ<lS%Phnl8FykmKD*jYYDCWutFxsotsSZ#RS=HHxlj+#8LW|HS{S@uC2$
zRL<iBzItsP&g#SVVw<D<4k{OQccF)KD)40@M&w<Xy>^NZ-_VlpR$w};e7H+493x$}
zt$%)Q1n|wPK^-c|s;$KSRXvA+X2#w*k0V6&&#0b=MOhxcn0Uc4CZCj37}?jQ!bTFT
zEcr>pT<NrAl@qK^?sxsxRoB$QN2g*l(VQex)|ki1d^xx93o0Fgnjulc^znh*qjbeL
z_DBU>p#rCEtmIem*&>_QG`+e`VEo<g$4BJ*g4^k&Sh4T$-G!UhhFIezBmGOVCW}vA
zGOy|<MdLlZ=!YhCvHeL+Z;CrJ6%r-4Rxg%UahMi8Kr>R3I4{>XuhHN43uftX)~!n|
zr%q=|u+)Zh!1bC0J`J2kE#OmrIzEQ(_3STe!GXJin~jP>qYC_8F2>0XI6)kN*tt#<
z&klZ!8|BoSj}v!EWbFC<<XzSYQs?xh`3gUocJ+kK)OI`ueoirvKWjmukx-HoZlvGE
zLDLf~N3#~?3P-Gg0ZlqU;QIZ5<pjz<N?5eOm$&obj|58H{6MpzIfU)#em3RHuV5o_
z%jCAz_G0ycK0}EsD>rv(zJ^2P2sT<diaO_B_5eyzqYx=n-qief>05(@w)M_z<G{PI
z<mU}VUxz#i8>)fqaEPXk$CLGZ_h_joG2tsvic+vBo-HEI!<OCDo7Bxw8<>?l?zq%X
z7)#oCx+%314w#`77(^;l&MfbKC5-HK5-R0%3c^w(KwkQ(rTWz}cfXB*VQ>c$5?4a5
z;`ei$3K7B`nY2R3cM?qB+ViLJtn5nT(C$p;?h5Xt!En!|huC{<5C$*n%pXSGn29`!
zUpkh)i@cxz3Yvef(B)%GmqR&Ii!#Dvdk2IKY`Bllv9s>&|FX3d;^;rQ6q2yB=(Q{_
zIIGx}d(n<uIw*Nqlh?Zm_xoZn?fwUg!T&EVM(u1lvvt++W&P0PtfDpc6p2gk9TrC^
z$G;~cLC)`?kV58kGqyQ`-cf=d-zO{Z=5mt1<fj%~%KXD*S+Ak?uay&U);R)>CipY?
zX%1j-KhMI|Fhj%(v8PTeYk9m;qh`=(reYn44VTRg*Ic>^XLALNGup>R)g^hmy5n8C
zG9ETohx7LeIZ!eS;@#`VJ@W`3ulqX+v^HQbm3v#=&)~IGnP}3v+Y#Rq6K?VdS?#Gt
zdbS0xggH;^zLvE&v-aF`7Ejq9c&WcTjx71N_H-5nU4MZ378YYSod_^>(dw#pfwh6W
zB=@yG%KDs1Xtd`RwPD$CyBbzTfUU+^&A-AXk9mhD5WQ)Upkl9k5Pm=r-C!c$a=B;G
z=`2+`ws%;_Zf35Ge%<AgaNxm-+S!i_i(*An6L8=9qy}C2_J@=~(e;0(40(Nnrr}Kc
zs##L{J;|x_>1O8FRw}~dMVTr0Pj3p6I-GD!dCZO62v^ot!Jc7RrK2@jt+J{7)#~>%
z^7$`6BmHcdrtN8|*qQ8h9mf!`X0&wx*S)&8U`wt;d12d8Y<gF%wxU?qi;LTh|9lin
z9b@F(@&dTj@&T<6snF~fo6Pz!31iTM&H5)Mk2^mpO$g?C5sn(l8Lo3)qB*KXJ*FuW
zpK_}5Yb>9_2lD7QUez^vdG3Bs$)7QM7c`zGl(oQqcwVQW9#!gs<Pkrvn>EiVn4Ew`
zD)ua-E-qYcoSl20eP-hcjJS&;#%pIaIFz~Vi7Xvsa^e=VX|UIwtTH+t5g4n1<eog~
zA^Ox3(YST)5|87~*T}bap_eRtaRxS*GKDM7*3UmobT6k`GIYm9&L8g3qcsZ<Tk|yA
zw`=Zw7DAw|g+$ZtUJi`bTY;XyLJfC`BK~%AGQJa;L8+NNz5Ymi@m}?>Oz|?g&O}qO
zMO}Zk(N*}B!Pk~Eo`e(q&oNu7$XJn%u8VBk9Kf<F4J`$HwEB@;cf@^9B~&P>MAB45
zs;uI|UQ9Kejd$<c(`=c-J@+sLW*wPC^)7^Yf;b|6bMEzX0$0L@&+9-<sX>O4jz9xJ
zEUp(E76d!%jiix8aXe0eS*~G<)7OPjxoYoSGGEJ3jC{^w`}KKUE$ykjS}KLvYMQz1
zIc)J7{aDWV!|RK1GzQt7UUdtfbD0p=LDCGb7+pHEr($nCr+_-4$_!5aBXG@s3Cufe
zN2os5iOdD$m0HR04?$!F4$uMeYh@gRiQkffok%xhxfK~AfvXsk*XM;{1PrkXj%+(o
zZ}hiGE-|FD8qLJTelAfGfmmb!*$>&xn0iGRi_0j(-!j>Tp1KgO@vQx#1Z{kYNI<)O
z8`J?SkUy6fS24XWooz{7!zd$dz1vxD-xMCzD1wd&v+r%NNaKu|_c1z*e$W(jHN+Je
zM)tPXX|evwa%RF8QG~zZZ6x_kJ#Hgy(+P}cI2FN^Z7?U@`R+WJ#f-%@C*`ry<JR+V
znxuJ_&H3>x<IODdp2Am!WtzY7jsW4{4B{U8rF}U2plXZO2#pIeoz0geeAF#=*mMx_
zkfdwr@DuJz$oKbG5;FVxtayW3E|+eK9#<cYqh*W6EqbOy-a21)bkob#W)#bp^9woy
zD@XD!f+292Xx?%XMsiTyZgU)*DA(?i^1wf?jfHD8b~>-GWUU-aDu4d21Wa1!TSJ;3
z%P`Yu?bgzMlghcd$WSSCw^P{++FIp{F{?$d9(=T#pE8nqANDhHTV@#6KOaPIE}^}_
zZqK2m(g?K}@!*hlD%WA8c9{>al!&+Q9%2?2L;2z?M<=Q0@0@rseB*LxGs^zu$L^6U
zCCJSC&~t30cdPLdPP=8s?xepg>X&gSqlvkWp0N(4UoS@|DiqmtJ?WB(x2_1%Kf=Y`
z0k<krLqe4G_J>nF$1RG=AB{PvF^C;x&ls(AnW~($r&&ZVzv_MRzWq(d*RY3d(|Ca?
z>((Td5#&e*3e(I2?})YWof2Ua3?sR~6!2hZn3lDS1GIG&IyZb);BMe`=x7E<+1zr*
zX9OOdxuwGP;<Vlw;7W}=K`p(^lyx#(;*UM1?X}1I-Ee-oCS8D_G{KDp%Des0E;DYh
zKatS4I|QtVhOlN4fmwJBC^Ri*AlKe1&s4gTopU)vYYrm+cw%-uKJZ){-7%#-%RXjY
zw=0)x-NLC%?q9L>j%O4$Phra=kq%t72X;t1O($^D?t14sOa1()u{Hk<<8an+o$B1-
zcuECTq4psNN~kJNC)Krf>X`4<U%uM+>W>oh_SuxBD=<SwS7rWV&-b$^FVb`X?;|}X
zTnFr1qwhD&cFy28$<bZ@reAlWj21G->qLh<@1Bfx*OzrM*@eFS{CyGJhI9AG^`_Pk
z@CJR(k*^raHbB`nXK~Xyq@8+GXvp~KboOSY>f3n8u3jI=+aC)PZD=M|qi3Cr3hqrb
zc{W5OXNcRl==a<k)v9KApBpI84iieE=7XL3lLE7fkQ6R>jy6|xW-DVr{gaI0oOnPn
z<htLwJP92!GSrRD3*F$U$}C=OY?DhnC(0nWJ+E4?I>Px4f4UJz>Z!`LG&amM$=zJJ
zb4{W0>w$TZ{G@$WPDdHL2tNK>*~14UcO-n>blNa_*`PM_{(4{K>RT=k7bJ~Hym!oW
zuZMCFjk=3zXxLQ*D4-PXI-qxntJ$gM-WQBm-PV3f$CtolH!U5T`g0>Nv`z5aVz!t?
z)7_s*x*}>Kz3yu+at%el5Vh`*p7$k`){gyeWiamny}calgghh}r;ZEPoJ%;(9{@Bp
zyk^?Xj8`Sp4}ewFZn4h=SXwpSye0YiN@B)exXZg$yHkpyZ(5ux0e<7RYV)t7Z{z$p
zl4G|$U*a4y>)VN99lQKaro!|~1lyO!*F+{+$Gz3Tq!#L!va@y$8?tB}$a^@j$Ec+Q
z4ulvJgCNtLaho{1ERDZ3h3*z_ndj#TA&eiC=jKv;!O52clM3uP#62_0SKhkDR=I#z
z;M??v9zoTU!iL|3scgJwK}t?MLX7w_2F5+wy)gDZj%voo74y}~h}n>j>Sgp_STsuo
zNP>CNWOBSj5D^Jf%bW80?6qOM>8lZU;<a`<HB{_JA=N9gGdLwx1NEF*gAyfz_FJk{
zi}wEVBdxE8(~BgnkJ%R3S6fk<AxtBANMEB&ppB04C6eP!e<YQB15;%6Z;!^*3j~rq
zx$q-3<jx#Zy$RzB#Ql_h73+yuR-;^`N>zs{m7hFW-SROdBuLWLSaIRuXS0Pf@eQ`5
z+xLv5q}~h-_7*G!1WFt=#V{ku<lUOsp^}hts&`ps_(2_gKka@yB!yk=!{H=vNP;)E
zsq<O3Or#U+%vAnH>-pbOl|j3|ld3F+7jg7uz>m=w!rqP&gp$u)oUOD8IkbsWA{BIf
zFW@J6_e<<}4?cCl$*QRw$Q}D&un?mC!Ygl{r1Umxv&GSR{(ITCoC^iVLbPs)C>S+}
z9#KaUlSdW}_Od8=fAA|w$(Lo<sJoa};pp<!cSsq;LRgZO*ae-P4=y9gnMM%&s(IyE
zHS4$^AkCEZ5nfzDOpyn#BlV^fbkX%D;qB2O=hw?Ls4`G+T{ceYB;%oLky87X^N|yL
zPPyoa8vXiqwGf`^*3i4M)1HZR$TyUeovcoz+f&D$Syk}G68+k@Z+e8kN(kS@_zJ$p
z`;cmymO2vR1W#v^4ooo^Mcpv(&gcIti{zm2s#iWxxwc9@S_FI2;-ZQ8$eQJE?Uij`
z9xua*8|#PDW>Z1Kb^-N=vzB@a(?3D#vY0<7zuRN@pz7S^&9*f)A>mVwdh*Ro2g5aP
zMxD1%UCU!Y2S}=Zpi7jI*Dsi?vB^-=zOUji5~9}dwq46cf$JFeP5ew<GpqE&$kQDw
z6X_Fm-jXrleHN?{N+((?nRO?n+U!eJSj*>4r-qjFklvwhv-E+=tyS{>=d0uhHf~|C
zI*mSEULTG02~x{l-n*cQ;WMB6J;;8saHW<hs%P<d&>fU$OFqh><CE;|{3uyAY{jHj
z=*`L}<-JI=L>C7Mn3{w;I(R+4g4emy^bzio{1;5!<NZj-L~{Iv>uA)cg*IJtam4~R
zO0vJWmF#y~|H)*3+;d8DwOjD{CmpMD+L0XxC4Tv9%VmfKA#Db=p&>;t?LT_#&$yQ{
zzELQM4rAJO@40?g0zO`lcg0@U1s|d>>#5A*_%w0z=Fm2^ki(Vf8UD@Cn^rk-PLV~F
zDX$D)cGhS!SP~)+WYAjfiM!TA(raQml7>&=`9jS2^TvIVJ{dJKiEA=BlT$V23=3RB
z;bQ99C6u)g=o-!#t}AI8&%5CMx@q*_CCQm;WpUhoTHcD*@{&@OH*$_S29ZjRTP=Ah
zY*ZCzOc`5^GiE5PWGDxTZ{zHSA3Ts44%Juj$nhskN@&9Zv0CrgvKqncNMQ>g;{K&&
z*!$k)G^EPQqcw#+<@bBVby4~6gfXPzqUv}?`am5s-gk7fX4FI9!pHde&^F9oZ<_IX
zB%HBlR&snjasM+-2b?_r(-|=3REq#0U<uf><3-}qv<d`5{peD#cB2!4CrcHA%+{CM
z?~Rr-qw8k#kbGoP?;!s&i>U-;B!g?`R;-9nLdd?Zm^k@lXshoh{m=S-(6U{<O>j7-
zv$E9hda$CU^3@8ZuXMQc4}GQ3f3vSdx2p&Wwbb;QG@W9xcobdEk3L`9R&z;D{!ccS
zqyn_x+uq%<PCy0&OTdY*g?WQUS0!hQ7InXIJlIs|w>eNk7cFWeVRc|Q>zRBtn$iRg
zYnK(+71My<pu>JVb?aX%iKk$TNj^|i<+U?0pM}8uf8AbM8}jEpC`Fo6|Avsi>l<f>
z_3MsUL`qP)<{Lt9pMB~g-F{ms39v`{%fa&e!msrCN%xG?bImX&v)(ku18|6bTrqAz
zF~MtZyo(|DZ3QsDL^w1R%4OGy2Oe1nk}ad)L=V@A_MdAYmu}%zMU*OmZ2=%CzMO|_
z`P9&)@N)d#2<t;y;~)6gNS(tOnV|WD&DQN*m$8?8VcFBnOu=p(=^+gpP%e<gtN-%?
ziEJM(rH=W;U`q0?3yvbt%WpK~6s2Vg4^4bjWg6p!?sxa)6)?49mjaLAVC2f+CS0M{
zK07p`SWq%m9W83{x9j|Zyyy@+0WJ$82jp^s9)AT*<lWPlf*L^ZLU@N+et<QaNXz)Y
z0v5snlHXFYCd0&w!H7BaercCiBrNaD*jy%CDd2?LXb_x`S8;9d^0i^eY1uFiry1d-
z1xgBx%2dcnKnQ}0c5R)~QpFu$lMGs0eeJ{-yn;Z5hl?w@zV5qk2^bK}*g(4YHG&Ny
zaiN=TG>YNNSI|W}ITFGokG~VQVb<qHvaX-SkRMPv_w3Mc)coPT8nv881QA2P!cqVW
z-6qT`ZOYWT#luk6&!B$sa<r+WA*66A{+9fQ#y22X-1c8Lq06eA{`1D%6RCYt<{LOj
zh3;$SHuL;`9OifZo#T*&cA;&@WZH4sKlVLGR`|lquy~5RBc5(1>O6F+eq8BoNVo+y
zzAI}^s#$k_Mt8O`rt77sl%4=_0*x!|hCYmR9``Irq~W&LDJXYX1z3Rqm3e{|j0Ncl
z)r?k4xyj!eOR_SG@ge<Wd?-`PXGOt?nP?AS9ReCAmcL6N^f%iT^(SQ>=}VuT5htgO
zL5anxl(8)8_8o_UL=FAFqyW&M50Pi?qOQ!}A3-&JY6Rw?CN&O~-#~~_4v2hw9e^=M
z2k0gF6%Kk$L+OKI(abSXsrG&gKJ`TpE;@D^C-`>Oud-~54dRar`q9}PwTjFqbpeJ{
zgmjd`%pTok#P8pL>g=_Mi*NL_*3ec@sR+qcqH9YkJ8&G8A?xu1Iu(gcdsrw4mUemP
z<81&Bs;31b1-s_>BhEL4uZTUfE_U8SHqNEAy?~V&T@3<d&AXTvU;|8uYiv(Z$KY%`
z48nX-L$M>ZVPOCxM%!<fj0?KOwzI_FW~X*NL$|T88<|^l@t37zU8uwMPjs;v!#ROW
zaZ*S&n>q*BZYj+=APmFMdvQ-hHa1`Gi@-n}yj`nwKCgmZVEoONDKAjaS%{cg1>Njb
zs@uG6V4a*tFU<DF`EX_9#%C5aEtUMqnpHmI1GP0FoZoVj)zS}0&1^tJKRAl!CENc2
zh-qFP`-<cJROa5u3&Holwb4FdesBjSey&(-+TPHPm~OF6yBbSuN$`T^Tb>9oX1vEx
zs|EL)gV3mgx8`g-ilQUI3<;{|X`xs!vnt)T=P)mrof<KH%W^HU>$Z~40QQZKV&i>0
zG4Zv=)!c&G_rT0L4E!-|Zi_Vg6HGTXKF~OPIBO&k@GBv=$F{4`L`n^pO2^^7pHWD^
zQMzB|w&@3`xzlq1UKwpbLc;vcnKvSvqd}Xl?5INMhO~aIAlZD}FWk~2#W5PTH0=o2
zJXcZ}CoLjwxxn{o4tF!zNY8tc(3&W(dxOLprllkS6L+{>2w^yfvs1`M4X*M<rI2r2
zysk}kKq{tvvr5ML<>R1rmqOxC=qhzqJBbh`Kw{5Hgq(6Uo>_rJHFdza8f&wP9?o)0
zaJM(%#^-#(*X*D-OP0&x=UG>bYn(K><Ip6-rVy8`zP<)Ca&GortP{+*Js@m?Xr1Qb
zh&UbMr@K`WYT~}HG!4i1N|Xf-mAH2qx*7Yeotwtw)y+9HECA5qFvy98VY}SjZKuh<
z#&^;ijpSP#k9iDzBm^eTc3?E|BYQ?2Myf>To0Ivt4Eo96VgsTTmLTJ4=QSRTxT%7Q
zM1RqIiinW73q=RqXeP(3BllcqqUp$u{brmyo!PguH(GR~+UY5@t#td4OzTiQ(ore^
zOg=*Cag=yW6&sdT%H2wYjQ}CEpH1GT%tC1W@M?o?RHKSg+n(?;{B0R^=Hc+WBuXH=
zWR|cYRTvMImS&I3bv$c+VQPMi#N;k?XUWX{^vGp9!%Ft)COO{JbqTm2G$O6vgvJgh
znp1^aY4JK1f=PjqQ?FfRw1e$fn4-~1z(Os=Y)pn?^^v9%tJ2r*Q$(4ZVm6F!n8cjw
ziI5~o)Z+?!2>_7!a!REsajQJ`d%_I+rR?nRx0{=K!U&3hfIV$gDW@~d*fx%-2iLSJ
z_g*7q_&b}a9&7d>N2=+7`R}I%$kccU(H+Kzx6L+0kwb2F><A~y>Y?l(Cj(NdE*WuD
zN?kS}{loY2$!zQ>9+o1I$rb6z#M^YNimanY@~!)nD{4hli2an5;7#&PO+KWk)|Bj)
zA`*_J`7O|hwqtP{KAmUdd8mhEIn*?gg-?c&u1<kJI4Wu2bqJO9vf-dLkX_l+3n!Bn
zMk6hF3LexB=T55*^Yrz!o!(i(j`mv*jS`h6U1Yq9+NFbPq;wTT0PdU*E{3w<Z%G9O
z`6wHFm#;?pq{=Gnn42lG%>~IQI3s-v%30pJ#!xPt5fJ;SlQ;S{oeKcoOPsircle3g
z{bi{<4#7vN1sf|}wRuG&+;LRP;K+K@WneG%^FX2*r07>wUrIm@7|h~YZPkYW@%6vr
zpH)3;3`&$f8@RW(>@2;5+x19^1(nY1V=&!^B@ec(O!%lz!qgX}2Tw=G_N*0hb$YgE
zlB$pPB2ROI1PVYhk$N1={Tb!xqlqJ;>M`xUH-5WgXNcc_E;}{&aSl>H9Ts`xhVGjO
zw!u^B(T9155=&O*o(g$bY}V^@>>+h7@j`-v7C8CisHpx=Muk+sMuS}mrms_TBhAcN
za~2#nF&-g#2NHBBjiIZQ#*kGRJ=;Zd*=qb2haz|?fFCWO^P_P3&_@9o*RrhpWH!WG
zzb7YA6mSE8B_yj|F+kVnQCBK!`IKDhXQOKKVJ%;Qg}dT(k#SbQ<vRdRayO<YvE_ul
z%z?^}0#eBRQ;-7L%rG%)0m!7WIn2&WUog%tLb-!oM2qdQHgh?Yey!x+>DMaQ%nR2s
zUc_ZX_Xj}u+suRYMxxWM2u5WIy`_44uc-{`lJfw-3WaX>Xh|2h(HZu+doEfuq2JZ%
zr3B^tDG+RW_NayYGTS|zgOo$oACZRgcS6?y04e_vX9o<iDAm3>ULmW^xTIbrzHDq#
z6Ty?Jx_+;Qme&8RY6wUjFo-C2kwM+%U})@w%wN_wfVFITBR3XRH3OScT|s}_Rs#pK
zVgm8<0)>aRg#|8prK`@JYPdOs)sG*pgY^W40~3Ywg#fn}*P*+ion@%t02~mD8~!4L
zPpx5~Ggo_>Hlv*M-ZpsYl&*M`YXD`Je|jbu6L?Td#X1!7QjUN_C1paD&RZB?!au?I
zAd_r}cY~N0H=H{Nx3F36>1rn)3a_E>_cwm(<-haB6>Lw`%EhdJW|f#b1ldD*i^>vg
zbBrwAb@|wN4eL=9k!nAW`y$j1&|IBDhsWQ-EiTi4FB(2EyCv>&;QoZUJ?Ty3pkSEF
zrFaX!RqK!x5sD51+5qoJDh{Gk!3dDMg&)|iAk40RfdsUo>9n8b;c<d1t;84nIdVw-
z{_5T%&1Wki=cZ%(97!Pq>HDj^yE2LF%sOMpU88eKU=qU9H*veZwMRP?4*zV~e5wnz
zaW2{+qmpKE9e#!EYvR{S@*9;$4}MQdougdf<~fvTMXVag-vW2O{1fgSa&%!jA#%;c
z+&Bo6=NDj7nW+N^xWf?8?5_vYDFC`2$L%ve5Oe(BnrH@pu8H;>=ozr${;A31f8=3_
z{v93`vIIf@(h}SPn5d}1NNT-f!AG#+3^HrX8bZZMZKMj)0$PRx3|4GyY(UMG?ugT4
zCl4WHpijI1a$wvwstQ3QMv%x2KFPqF)+K;3L<qh1y&DC<^=lBx1-U?Yp;vDn!b!QI
z@rRy)MCU*38KC9Am$NHlu+z&iYnKZwOh`?3MU+}rvYhMdFZZ9(bYK)k4bI*`*r(E)
zvG<x};x-+E_<5ZN6C9LyDU6iy;w?tXO4OfZq*$Lw=1fD-PUM<j0NqA3|D%z~sma#l
zZ=Bf~v^l^0aZRQE!J01qOKS?%j@I2C3;c#*l?zZa+k(_%BI{H0k#=Z?|6fm00pi=9
z<Svg(yO7Zc%VS3_nSbZCw)`IKhLiq#u%oSL<eA2Vgl(aIpTBd4{H?Kb^%4H3Vks1^
znebhaFAvzBpa3FJ=S;oj0TEP86|+qpe_W$TTG;t=Wz{K&d%zj|&Ga@vq`%&4SO8pQ
z_(%!naTEoRT~I+tmNG7U^)k$S&lQ+&i*?OM%>j4zjXx7|kq-8D&tFC%z^uvdWP}fj
z`UM<aIlZ{ejf`d5oXyj7qI<C34e*H~yBE~2#SbU^Em7Z&9_#C1!&5J?cf6;S_)u|l
zGyaahkHewOZ5S+5!_c7bR1O1r*};c9_bPOM=x!6HZ}wjAezV}AXD+Q+0E=?f<(4Fs
zI?vVhc)^3tMT-ov$nDdj`?c9=4oDl8D(XJ7?RKljaP5mw>jHH)YJR63<r+d7CEu%G
zDWv)hNk3uNut1F&_R;=)64}*X%MPaEw#8;y#n~WWbxBkBs;piE;9try)w_XCX@=hd
z1hT#Z0=VGy#}*AvrwCjKW6K)p^t7^N^5=AC%>H6;H!4x35f0p&ozYoEw@i+UdgKQG
z2J~y|6R}Pz>j;gEMcyWGkB?!Hba;cU1e;TNvCYKEJr2+?$QQPg2xtVpM<xQtf9HL}
z2WOn?dHIJo8!r40-fZjt{$`;)_ofFbudss>bEPQ{V6eAgbdHt(j+wfk02YoIH!k`(
z=jMnfs9u6kBSMrj;h!=_tt}nn%}?U0SpD{X-4Fkb0JJ5bkT=*revjNI1w#m!Pa!hJ
zB0a(ywE%G=2X}Vs3ZC%*6Tlm~V0P-fe;6=SGznk)U9wfi5MP^bT|pN410HQF&Zxt4
zqKv{1E}$r!9S0!hPo>Amk3^UOJFj6y?nht}`u06ANf+?0jn+vAHX?}G3A?(-_1Eha
z_0`gKw3$K0F@iw14_+1OmV2o>^QvdQcIsR2RnvJe@kVeGqE>rnN#m2_b2D`g&vN*H
zkc%|kKD1o4-uHz40`NkIFQW)aD+q=m6+U|E;F0>%{(RBX_KIs>j$=*I2NsZ3p^zj1
z>eNS$#CNDOsl#*XS81jjND8pbT~5-O)}ray%ai{b2lMYOH>-XBpyf9FKU;1kB2ks)
zj2)(eF_Vi&G|hZXY)`Dib?mn!=H{6qZqwT!K~<m^4xDWS1CZShgza5wA;D8tO24;2
zNs-mcX$#cNS|fW2KyE}>vmc<sc&1k3)h$}fDIXwcd%^#AE|FfQa$^-;y3+`!cQM@Z
zdkL!$cn1OPbeJz1lT5dV3Bp*35q30t%$ysW*%xyZONwS*+FNrK9^m?1pL+N4KwR1k
z;!(7c2Q3l}RIX?Z8wm)4MXgz*=i<#+rC5fa&I)yzVa(v~bBd6^Ep6H!Q{|nm1lfs*
zh|xN{&N6{jdoP@BI^9~khQuyST@yHBK(HCfDyZ4J`glxHeA?~n4Y}pCSB0C>S2jZT
ziQ%U7STwa@<Zk)GNUb+AS*9Gwci1S<M3h(fGA8gGlcB9hg}%kLqYO5|yr2AEFwTte
zSj;RuVhcJJ(mkSLZFWUxFG9zr#X`fx6K6Aa5*j9K^DTjR4vU-5QhDktN_I*NlgA2k
z@}Iv81xP6k=ki2zhoaQR5^>~uLbPpX%ViTCuRTHUhO;e3awC3ej+*<((=`l`S?-Wn
zg;48I+1b|ly{<e%dDe`F#pb)NFM10vsLW04&Sqm|5{rRhDpYos)#->GB%=rekR`d+
z8=>Mw>CrlQo2)Q&T+gsk(En&l+=Nn!H<>f5GkTTov8_=<SH$|xtk3T}oJuH3c>X>H
ze`8;ysFmQ`Q-l!zerr5AZZ_c$wWb;ne$p1G^oF5=LTa~n|04=QkO_%ri>^XOx^RI?
zOzfNwQepaLA`+JMK{sASw^IRuIL9AK8TO8odNKM%KceDeJca8$Z!}U8M6^qqrqEbL
zkdy)W*ig2JDv*nmbOR@|2H4WJCTnh`=tC(C=e?$ZyXv*(=Fww7g2D|b2WxwqdDhS-
zyq8QttMQ>_d(77`zMS9E-R(K#odGVdPJwebMQMHqh}u5tOEmmW5_AB+{nilADNnYT
zo16Ft%acThn?H$ck``+P8zr)e5GuH)MR86MC_`)X{6ynZdabq6U>uUkk#oPZ^r`+%
zCJ|q-#(0|Xr4)1k3BYvaJ2*d@6}9rArEG9#{@)1U*cZ>?#UX>7(?1D#?&l0@0WdPJ
zZ5`?`O=f^R1^rm=x7=V2>M^DRflL)c*Bvn%MbIE!bfA#-pD&CR9!%pn-dj)&wQ0z;
z5f5yn#1HVU41ViB(#R-h(R9cJJ3@Os433nhdNGGnV6#{rg-lfTgG@xhxnKM{IJff&
zMojIo^#hO4?CR%>wi5H_3V$v!pM<;i`ON1(kiY8~{{i{i=it9UFovg-`$+ShcYk^L
zudalY0U~R$uKW&HkN<%=Onv9iGlws2eJZ5}{Uv=XT{aB*bLleivQTck_|hK;8-EXP
zLkJuDhAu7a;k18+GbM3GG6oj&#~b_Yp-`fPIZ0hU302I=x4e<3Ynt2nof2?k<7{;<
z8mC~SGd2H-gmi)qC8Ab-!E9z!>`3Ea_rvP3BmlgYeAy%lWi0}9JxB`3?2g%GND~~v
z3s*R?A(E7&@-|0@uK5?nA6b$Gf~lN*@Q2D|`@d6}{P@)Gu=1yGf;w^y-O^GoJ6>Bt
zY^(vWW`nBvFql7*b$>(^*MAySPyxQF69@iSWfTScPX!NBIeuLG7tnopx{R|D7rygd
zl%@V^Edpe8^4xY)lt$Il-rp;U*AM@DCGr0v2l?@-;uOyEJkh5;P;m7N`i>BY;#eax
z1DW)2WoLJ-N2cR})r~ZASALV{t};CyLyZBNhN*xlD5j7beJepi>+6{oUit$b&u{T}
zvLOVI=R=*sy?e|?%&Wj>798(j)O$W^Uy20W2Y+k-<z9oQ<Jyn@oKE4Mx1#@QTEvf_
zN8xq7`a>vX|4%6WlTD?qphsc;{3n$DCzSpdG35V`Lg|~4t>QR}2#%^Y)A!60v=ITM
zj~`H7w)kpVU;Z7w8W7GAVk}|aA6L{3>XI6Nm!-H=VhJ?wYF44z8bPEj+IBrT-KOcq
zHME?n!Oc;hJt+LbcUu|QQQbe6fk7qt9ui~<h6t5%dpnKt>4f?Pq=ATd#~^YWiVlH0
zuUjbwBop`70l!Y|C|Y&-U9jiF{10-r{C_29gJK;)6c#`$lWM^}Dr?$B(YY?aUe2uL
ziG1`CDmfT(9u^9+f~a|izGD>Xn~3~h9pm!`(KkZ0Z9Ck3BQlMf<8^@uk~WfR&dsAk
zs8OSX41RSV0S#5&Ab9@pB*~a(fWpPkPeskh8*v*gzaf20g;bMHsu^D_+5BD#-~PQ6
zHve7<zmfjE4CW^0)Mti}oSvO5L6kEYP$jo6jGl>|+ab5t{seD{EHL*5`=h2I<EO6e
z9%3hZ7K1p+bpEiJXQJq0z!beyNaH96Z};99(96*1N^=W$TVCqfjC<u$`%t|7lx^B^
zRn9Zzpwkf%kjUwA7>oXfgZ*Ugd^Uvp->-p-Na9N+M(=ahxGfyys=2G`GeKWX3>|_V
z#|wwI?JkQ-65(#F3C^5(^=_aDVzKQw4HpH#sr<Q#%=Gbze%K@T81NxoFFt$rc|6A!
z1*AW=pm$7&mX)0bFz(&2@$3U1^VfYSnkNuw5XU*)7ilp7jvhHXl!)@rxDuwE)%gFl
z_ulbT|NZ}X85Kg=*$reTS(zn?jLO~_AzR2M3K>PVj3cr`_I7NtWp9qzvB%*Uhu`z1
z-t%*PzPIapUDxlA-|u$4|LFGabk1u&$79?_i?3|F<rUZM9_c7xXQVz<cm#_Qv+eYu
z)Gcky6JwC*22~v<C4lpesXR%n);A!oMuMDZ-Mr9LHo$p{UD5H_v4Emfq8*`5dQfiz
z+4saxe&?S`Rv<}{?JbZuQUqpAFF><y5{rPWSqNwz&rvk*yD>uS^=)s6y-vvj0Cuyl
z!w*M)A@XIuL6E5#reCzOLnvo;3J_=CjqigiSz1HjyV?`Ps@R9@LXpvXJFgiIpOyhZ
zq^N%P72dDvpo!q#3FL?cXSS+^FRzE;m{)WE)`}Hg{TExYVCz-=m|%IOjeM|}Jr`;h
zU}y>tJC|?C{xPGM8UDeH{ul_?Pq?_BOfK>PpjYv?E?A4TJ!gOthF8D0rq*$x+Lye*
zxU#O}xP!y9{MOlU44`^OeN5aG&O1wMBT)vVr@~Lr-&-95Q6}*Ys-k68i%Eg0zVA+Y
zxB9pKBfVR2864KvjIl<)^jo(^f(q8!gI$0@bCuB&OI!I35I{u-YZ5=<fpY&ToAda$
zvN<RVk7%>Y@3;0=aM4WLIq8C&8~hF0nk@6LL0drxs?|&P=We<4Kj@aPl%T17H~xtR
zVkQW{pF4SbobaL3J^s^3Z!l$|HCKmD8cr9h{vcmIIQ{RCFMl1?@tm9NH!K9|H{PVh
zzs8${LeK$wzoS1u+XfT=3us&4?VrE|gR4`gPDuO-&CZ1Vr)dlzuTPB>{)xuEXZ?#?
zGI@sliNwFdE%|j+IxN_e{8vuyP3GTX4i;H%#gcV`QnH53`#f>|kKUM$LA_u764wiV
zpap07Vu}FP7xRDJn(zqB)u&?kCxjKi)kXTUES@yB-y+lg)0AS6*JsSVcPBu{1zqa-
z6Z?Ry``?M?ejW9M?9HhA8>FCv`Co$+fXwzc`1CK;p80qGn1WB$<o8eTZ@|^1Oyli4
zm?UrsCGG!vEzOMKH8uEt|EBBYfo|FJUgn0yaO+kz5DhUzM(KI%Eso9aLA=!CCHPU+
z*jIhYamOum_pZ+m)AftTwN~liQqpI0bO_LWab;ajbM1?%U3;Gt{M^I<dMz1nQ3I;@
zF+E@>-NVyX@ofi$={S1;Gl$Bb0M8D!q@~N&J|9(4t>nUw_BRWA71;GKNVTY3r$%<<
zex_Pg<{{ASYP6YeHxaNJQ%`W){KmB6unM@$48fgqhurQz9?sEBqMJ4yJr*31{1zt|
z2LRMStjA%9e>lB;F1r5K^Xp}>QeI^%GatOXF2q8)hz;$FbtgPSs8K}8A`*k|EXw5C
zEUiSHi;!Y)2N<O<cRUY%(*pQ$-NX&V72FCfAN}~80kUPLbrLf^$tk|!uNV$RY<qxS
znkItT?rmH1JU&Q1-8Jud+YzWLCEIaVuGeh_u;)<4y8<9V#K9UI^j;b%qx3*Lij?69
z)9qA=$v(bJN4aYz2iP^Qe_I_%(PTk<WR{^DK+x%~97_+ei+o-cbAHBqc%UdjFWJVA
zE3gqp7>m;P`yY?cEsG47;6D{$wnG4i6~X!&9uM>$ZuvA$Lqb{AvMxYMN3op+(oS$+
zg=0qH9eeMwtb{0zEEqtKZIk<Wle<lPKUq9ed=U0&)N`v7@11ZHh0Y_eYe`m+?%>@?
zn`-~0?jHY5_GZ8ReD!{4r{AwOMKowraLvr{XPgw|LFi*nY93}%Y=i_mHm8s{hvh=r
z3!sSt$OTN#D$9ew000t58~3V}_Z-J~KghePip=e`F<=&@X%qVO1gs~tj{tP_y0bAa
zN5;_W8#+N7Nfm&QpI8a-%WWVI8O&RUsOy8-T53nTp2v=u^UF|X1M%YLKKapW9u31V
z8sn>g0PorQkgM#o(Tl(d_~9IP6eL+v_F}Gee~a5=BXG|1u-P+Q&LyT{6@YP>N-n~j
z=VRu81K*GG$(+qqK-QjHJ3d<L3V`2O8=1UYNSV5y6RkCy`uig8XB2eaeavZJZ2bu6
zELJct4)1#|e)5xL`}X!|?PkL8KIwS^XIeQW?YJooB6*u~WMGZ!!Ai+s$+ru%%ErQa
zlN*4kFE78eVzJV1nisqfLVLCT&RM!!E<}D>QIM-B=XS1<Y`Mw9uV7S7>cI{G;NFBo
zoP%Fi2QDsk)ad7Q`7OnjnzTTmk5W=Moo2bxSkeg}-}awS8QIP-w5Xsp`JNor0{A2T
z%YZ4b(b<?LFH$7_15HujE_;||a;1KOHMZ+sr!RMOj%HEj;V2js`?B<5?6O1j$D$hz
zq)S;2F7u)O6k*pRzPfK6ep;@tvLR7pfN#9B4zFB%`>kR*#t>>##D{4E8X!~I)e;ow
zz@#P!dO$)7xn=VoUG6#qwZMMv$9El%_h82w9y<jv&NBBXJf>q9VD-#F{(_<G$&j2I
zOD6QfbXNg^8kOC!7(ePh2~<Y<!+LGq`MTx~X{;;rBJZddP2Z`+)Qcb1ZvxAN^w^YF
zEZ8a{*=OnYh;M)T9a2ui9hm54hMRsg09tt&>2daFC?rR7TT;_ivjWVXWu)h{_styT
zF&yM2y+9&jy4>dDW^&J^qHE5IJ$f(!4S>ca-QDt}7Xu##pe8qEzunnncgz-80+$-a
zF}>n|Q)=m##QjbE;%4GTcr_dS^&@a|Wv3<sT+NDJx9MT}^*V%(0xSYOF@v6*U^yyJ
z!k=iIq2Db<5Fbqu2bkd&IBh30h+-30C%a7Fd5oLf<5)S%#LYUf*Xf8qe`&?<4U6IF
zUbc+u9@CT_m;E>RQEFA;NrC``WG+4qiVMgUs1Ieh)2ddTA1Sl*h^Y@Hrez>mw6ATb
z##B>8f3&T5T$rva$75RgakH!V_%n-WMkF8ZQ8r0G!VY#YM&aQCA!BZygS({dCu6{j
z%@qW?i3IC8Id{o`7qaDsD}2|r5q9_uM%D%1+0s12UW;@<LFes<X;yg<^*1oPc*IOW
ztb6yzY~zTczb6c+RP@n~P$*^LwZ-iNVcLQ~@LYMN98_{t_mmPg!;@U@$ZZ6|(Saxr
z2UNNf7$AC6C6;q#UG7$N6%H18>&Q(E>&6<SiJ}b}`?w++Ra0s6LuQ*QBH$Hp>+XM#
zk{$ctiNr>*9_h$81i;Y#uyor-E=a(l+<!fT*%0?gef*{7a`{q@lmn``Gy82l!@*E<
z0BkP?7Sp4PSvnlv$!hdQEO@Lg;4i<I{lcu+>*3&&U(-~m#~DBlmUTl6W=Ne6j~nWS
z_Z<{wFsC$v<~FaHo(|^A7FK*$X@s?@oa9)N(kx^1WBui)_o}gBovOydyFy*g3VA@G
zh8(_Q4(Gqk*Wg!))H|Bf3xIT8(sNn|EbC_6ZZu$SB)rE7+$P>sa=St!QyXTVmH6<A
z)TJa_vrm#ZRX~Xk0jUAWcVFNSqd#X=yutga{<6@*Gj3OnjlMLoq69&eEXziqI5*&p
zM~Lfvv?wjEd3JLDHBzyNO|5bYm;1U0O3kzA$h2i&|5XsT{rsokl5+V}!5^Q)kf)k(
z79Iz?DAU<wMHG4Cbz01@oT3A(zLdjK$J>ysQHuajks|9aplbwt%bRt9Vp;57C`V=X
zmPYHNdFz2Y!E20<TB|?9FR!*KDrv-}M;v?ZycMg>EcaHc{2_16<}s({A?2sF!6fwQ
zEAFvl)sl`BilXsEiDYHzW6O7A{(~v1XN%1mPcJ{Fy?va2!Hc*y9*|wKDX%=B&B`Ka
z1WWMI*L<z*cW(U=+XgEmMYxrOsp~n1;YL&kHNhG!-qw)z$zxBs@CT+bw?32-(kV7Y
zksMb8os=BP05YW*+K_e9wYM1sKPp@<%h4(Mzw7T$a>=hTn0167jJxotZ$vlh@9`#j
za|d=Y9Ig8;`2-;YK5SXrTsGl%Z@b(?*Q_^jFtJPF$Kc^4>Q6T)CZb!ln6^`ZjQpPD
z;+C9lCC%AVHf1h<v~Kv~8scK$!BATmShYr^{by{ptdDoBgGbb?t2iMe@g5I{{sO0V
zLwep36aB!u$GRhYHE%Zk72OQtOWx8<-+M6$jSc#_TuT$b1!$()-+AVJ{NAxL*{Q=^
zS4r_r>|W=9mbDJ|?bio@VHUcs_-!I6ZC?aX<UgVB@%z4HS>}z1Xaca5G-i`?`x;#?
z1NS<MfIf78?IlE`Oxbtrn9z_F0QhLMK5Vk?!|;3%oeAO%Kn^te?-Rd1jnrGlobZ9?
z_dS>ehn}L$_Ig?o+AArONXJejdv078@(TYQ=h4v#RlTBIs~J{$FpCD*bNW|!a93ms
zOU)i$K!Xi-xLlMJ5o=YRG1dA;)dX+gLiJ9T0L}oZ?oLMkN>^iV!cJk2?T#lh%_DPS
z!O6i@H-0@!v^JqZ;Xu2Vk?}cfR)O@An4!1)3kiJ&%vWUV@ip9`+|XxYGqRjs?~hsK
zUV=pb;PJ5>qejNOV1z^yvT~=a!fW=)!8IDU;GMFh)U^d(5*^jI4z%M*=J>D=aZ@IT
ziu!d*<5(&zf;iHuVH(=qwxLux#n1Id_h*sBSu2HU7oy7onhoAW`SeOSxN5IRa*))<
z>kt&{jq9p?eRYjtPCL~2@Quuk;_s?oNpsFmu}{bIT3TWXzVW>}%34@5)B7H=kyGV%
zv<2gy!VT5mV-{&3ucWMA_h|%DUWXbL1{=vPx6;wjB6o4EV`PX}?(=D8fvHTXX&D6~
z=i>5b#pza*xoetNDc+=%zbn=aL07;JDlV?sp)i?QIhic^nhoc=HjYiqUO6@E7%Fco
zi1dqXY&C;0Mfza&*4SK)0jZ@r?bFA(<&C8S;(MHXZ#&O=Zqn==&s!g*qEqztQ<7ZR
zZCBDXY3CJgy|_#fUgt)@aOCHS_Pfo%sCUKsT=3P#klk+)*IUz&@ee$^u^U<PKah#Y
zlwf%*s=1W96V_)W@TJogX7PS#Aibf%bj_d0x@$_6p9GEEd$0LyOcUE#l1dk0{tAyg
z@a))XgOPn`UH_o9$5t$=|CD@^AWX&$b*Ni4(lz@+Y?9}jQ{~Ds^^_Ss9)(BCXWX32
zZ(lII$Qex<aoP5_h*d>+@G~$Vk!hABQ<MFQ_k!HYvfp_Q=wZ9Fh;nG>O|@m$a=Y{d
z8lO+Rq+~+-<>iBsvT}u_oYGN?nF9>pIuw|pt{9_~I8jDnG8e-xGT)F(D32^-&gW3b
zJ5^`EPM|F3;bb4E6;Ni!TvYca_%8jYZ%<KU7V$J@Few^}Kz}`su@JSJ8sEhNi)Lxe
zx^!5&(kYr9;u>uzHU&FP`t35~xg*!l(FWo*h>>sV<y5}rb}VU+B(~!kvJ)WGV)F?U
zY^g0H>s+v+p~qzuV*uNb-Gr~$=x%>JM$fZ@y^0_&cdz}fg3)M{ehS_sSNfS7`Q3tk
z#a(QqSqg$&C5g8EZ`t)Pun-B2I;Gspx$-7VUCeK)>^lub&Y2!=pDfkFo&dX{&SMz-
zOzGwWeTR#iaYo+QRvdT17xxje*L-RuW4avs=+H1{^HX{$kT9pNyfH~2H%XsHL-e*;
zcjehxI=RnYd+0}M;+90`=;wFtuZl3<*}myc7_$9g-BudM-*HeTctY`x!6b(z51&Q-
zIQRPL;6109>N7RI!k0=p)l-(X!p+334#LFu!cYhjg3H?KHELyzMP=zcIk0(K<`KEg
zTbCNRG#2~B2(AxB?MzcJ_s*KcHOI>a$v2m6`3q+iD(W^@C>M6cYsBTsC`KROESA}E
zc9a@QkkK#gk_xx+EOv|NVx6|#uLiEjNJlS`HRrCZ;Hxav4Y(h_igr;Y6U67*l_3H>
zfUJc8#nnE_g{`;bVLHsSm3F=|PLmtHGta|V=55C_njATlH~g3HJ};lyZ9!9xpv&DD
z?nFtnsnE%DT;{hDb=|F))X9x3dUp(UC{nByoX}r|%6v{Sx?9Efth|#mcFv)Y-o2?q
z*lyxozmjcPB8cSW)NEf6PG!#?pV&Smy%Wj4hNH4RGj~Tj@9MDWM76P+R(+V8m{?!G
zV(gPG1IiqiN|0h$(}O7HdE(mVvvRCD24;5YW8SS;*ZlLNewd%iVLJ0ds(4R?iQDk|
zfyDg2F>`op-eMr_gD~+IH%dQNFulzi+iaCOv--y1PADGdWY#yPz^4V{JF+nItY)W{
zQ8a9gkVP>luj{Dm_^@jbaZ#;qs|@@4m<dT+zmdGr=w|a*i~-$3CoTnH>F8<qoBnf5
z3fg=`dJ~OwK4ZpmV(r<OpeW9T7pO=_IUA<<=G!$NibI1<jAN*_3|LkZlb$%?OqF;n
zl_06A)Hk=P!nr1Mn~_LTip5|>BgzLoGu6zvCcd{c;$7RcCZ3#q6!ei2cly;>Th~H(
zYTnE?nJOYW&dj^s<N}Kd?vr^pc~gxZL#E}2dizf{20<Lm_bDsedLh?qPtK<1Ng!d+
zJwcKStQNJ8ElacgD5IZBUbE3d*HI#6$ZDh5-&}i!#11vdXF7OV`(~?9@rv|~K`}K?
zna)B*L|3-mhzV|Zgwcv!7PH#>BE`C#h<jo)m#DnCj+IKEWN)mCe)&S;<`Ac%oMUDV
zlVS+P+sP1l-DdZ2q&a7UV8xElH%oVfg{P;E5VnCux#JKQVObRu+7)dtGILC#v?HSs
zUAQUk0~R1N5m!lJEaq=#j<;@Jw6CSf>`xfYd2rL7Cfu9T-PV;nf9rg-tW#XqlaaIR
zXvY@o<R;zgmC<M8hMFgiCXWw1lNS(91r@UCo>oE)6R05e=ofJ~F;e$C4Q;U}RHg;3
z(^$NG2g^8fo!wdvWK+W#{q`lAJ}u8YL~Edw*riZg97X%&O4EW93_bk139nOZBK)Ov
z(GQ#$h28q*VInkbj+=2PZSHe40Ul<Tv&4g>56`Dc(!#cnL8Os1uRDRvsdJjvMo^cw
z^Lc#z9Llm$?4&z^lYoSYIomR;Z*pC<cqPo@M3k`mq~<`*pg#e#elYdU2DTtj@7}4^
zf|;Lv`3VkR+O3)<w7%|CAWZrYzpLh^5Ml0isNzLQ|3Md^m-+U%-@1*$r9vbx!H&GX
zM}Q})?phQz#pY{B#QG?G$?3VY#^TOY*;LAvs!MQ16{dJyYU=a^)=QX#j3et?F@shS
zMg#CF918tQBOa)a8~H9p$EI(oCm~MYW_`zq8up4>$>l+~pQ<RqBh@$BY9lt4E<}k(
z?p!NNV>WQj4(j;Hm)fu&2fkm4Qx8{l)O~M>H8nbAk~e9VsD#9O!R&Q)vT6LgX~p5z
zs#T^&Z!+F*y`IiZ_ke{@swFQ9FY<EqM;w;NS4%Erb#(72?bAuxQz3&VDRD?W>=b=w
z`ePNBy0RLRF0E|zt{;9C-_KBuGZCfV$vv*$LJeDBxVJaR&}w3DV3~>VZbg$`6I3K}
zL{W$+hpj)ti`v!0?gL4J9+N664=HucOl-!f00T}kJ!xjEPo^Y^AywKNZ~gkFnOrH4
zKtFRPAY(+0VOfndaleE$%ctV=`aNG|bjio`$bNzgCEeCwOgt;PaapifkgGEMs*1RZ
z+QC!4jO?x+TMHVZc_($WWk2vP`{H3>dEd3DXHRm3a`$HH<@bu^-_e;BxJ#4MITWoX
zbk;@ck6{DhXWcTh7E#u7nQ-G{p=G~l-^~Uz1D#SCoj!qtft!A&yQ=u*C#vw?A}OYB
z#jH0q0`EK@99*zRv8`V+;H?JTGtYb7mNVH2xKvD1v}#i+$w=f~nWU8OFFlGz)M0v6
z_w)(0EX{MPhqwl8^~=>Kx#@xqj?7S{1KG@iX1RC@s4LeURIDB1;z<<*KYj5?NIS}V
zq2IcJlr<k``9^UteT_{-Z?g89ER#s5iR8%HUNQ=n&ux!9`^k%_!;td+)6=00CM>L(
zIj06;$=2Qu4iWh~z5E#SD>OT~3Zo-SLytz=)ckIXH8C+{dW^gtf1Ht%K7jt_H?qyJ
z|J+GrTgf4Pre9@0znm{0(kgaHpFoz1(ITsF&>_*E;mCKXsL#>|)VT(kJF(#HWWgFg
zUQ~RpH(o6mkTJd2uS5F`B^G#zG;v*Ul4lm9jD}n`Ts1KF?KH-5Z+$m$kiMsZX;;zE
z`9K<uiu9LP?}jty_vfDLtIqc4SP|64$f;tS9e^IXcylIu>0A~lc;=Urv|H);2C-nv
zJ+npVTXuGd*ElRX$r-vKbboNnM{YcEzao6U?O`MbYu4G^r3h<PxJs7RrRKO{j14LJ
zIh7K6r5CA);||IK@5}uXHB^X5jjD59UOw&fbytn*VZzIA!uJ0_rq)FrG_o1|eyJX4
z4GgYqS9Q!tjuG?FA<&<-<ZXb!An}i6&0}p*;Lkb(_CY$lkp)>I%hLQze~$RC)bcl_
zv}7I34aXHGKW(AtKy}!8T*1@c&GewoK7EEJEf)w>6wc=0AFj-^T{0k177bQXE#dgl
z=R)%EW<zH64JlnV0%A?KbdQ7lBX~KAbNE};8->d;_?TOT;(H+!S3>+})vKGu9Pdx1
z^>^*|MI+rp%?=C81eGvvq^l%Q#U)ihF6u~k?OHy!9^F3LKZE1U%^#05CPwrWUC5Mt
zqQL9&&+t6n^%TbzZ&c1H&PuOBTo;m4x7UUdI_O0cIk<gi@bHD#W=%cD$UV`h@-Nn<
z%B0_;+EYS>rtb5OWGM%a^;K$%%Bti?-xKd2%`nf&w&Ko?wS5*G$SxN&y^h57U@E&v
zpjw#gVW>LZKYDqIKrZ%>cXlJGyLzS<OKNfp7unr)R?$Z1tv45_jMF7sGVAF-qUx<2
zoK}vzluvd?joXkd>+GmB4q;5DME93Nk`R^X1{<j4r4@Qzr3)S2&wHCm&DkOL412&A
zW?djT`V18$fv0cR7-AGVs$M_K!Dm9h=@c`SXt=CRN~;=<_nGZlb3XyGS>@h&=gbAw
zC9N2A+&2qUkhF%V<dYfNiO>hGR-z^(DQkkDXtT7|=XhR2JQQdg0zSm&8y;A!M?MTs
zvP?Ex0S7Ea_uC*^CNj&!r4`9Umh8`Qv+nh6?y(pBT$P(4p<=fNl+kJg7tt5OE^^+R
zlB^4EWInW=bl;6|DuStUFJ_4!k1dF)9k8lx*5tWZWm%<d4c9sfHC@GGo3<6B+4ta$
zp+-89D`^NCwCl?~`<}e%MeLTCuzfxC3Na5^+}n%>Lqw*58S3z}LUu`9vo~)Eosw^6
zu!~JW5I56Nc7i0A9x7AqonXN}UL^JCqiQ5eh?!j8>FLwHm*Kw0hS+QzM37}O?}%!b
zXw+EI{l}hW;(hM=xBE8al{`PTq`pyP07e9zfO`%#E$EWxd_J~ddEj@pXIoyrvo&_M
zHY#Z&FtI-3{`-O}a-rvicx|r?Bk;5FN!1c+=c3QWsYss_DKfewqNMRW&eFS{bDT}i
z=4e*&$S80$Qk`l3r5*FFr%l-}`UzN&y+*{#>vVGO->`>WC%Hkvtz5U`#$Sk04xO>x
zZ-^@8v*ka)Sz7P(x5cD*XnQ%D?hMc>qC!7hBDg3gS9sy{nZm)lI0O{aduY}?j%}s!
z%NG&N_o&{_4-Blkp>m5QCqcQ*BrxOC5tso)ygwdK3kDJeWN?V7a(}+m*thP+ENH{+
zsGR<$dCy|;AY+4j@4QIcU5v$k|5o_4t-MqDRIR}al)<Nb7oq8?4f8PRF`8CA_N@Kh
z0o~>&mVXllEkOiNSQJfJf0Ugf$nw|3Y+)ZxkXqZ!b|hC~>_4W+QZG%8&2oOJ6y<eW
z8oaQ(w^H7E+1!2IxUqOc74I>oX{2~#%U5H&g~oF9eX`!fNV66n`&p_gA@cZ=BI^T>
z=>qi?6isHOrQ_Qf^Il@>{kavV$_`cQTtd{@)XH%+>wI$hO8IC34sUV?E@$Uh2J7qd
z^6_rcL-76BrNc%GVt_FbVsJ+;h#GIL@gKx=?Q$A>R=)cfihqm{AG#veFj^RUlr-sV
zu}`VK$!|5=PxEy2(7(jJzN2!laK&lsz_%1eeXQz8)6YZxer}gr<u1l9s6<f!MR;5{
z-Y{1@Q<&!2xnQ}`v86N&DDprRga*-NBD7jBZDXCY`3-&|G%SK@LQ@Yt@N^pG1qrnw
znYIq!7thM*M1>oSLg<dk!wzpeF1*HDvVtE{;I!XblXzc0WBZo3{=?i8M+bLGdqtpV
zmWqSbef>gYf*h(B=;5<A?Ol6J1}p{gA?1-!!^2ugUiV<#@%&K@?0PS4Fd$5<e{F!b
zRD_Ufz>A#P`K+znzj)AOdWeOMVx6#9?zm1|7sw9%Zuuy*Y|Zjw*cgBEn!)JqL0|J-
z7;MDy(N+&}bmzjM@;ae)OdccPft|Pukng4<tn;e?9POtN9NE$TL62wuUa?=Kb4!BB
z+f<bkES=Q}maahb_4SJ9y}|E0QsI{YOsK5oDxJVwUMTHVI3%6OH2QS3Fqmuy2wC`S
zn0>Kexx@{b3k0~b^eYCefG*pO_=X9k2GTvC&Uf3RDf>Gv_ldgBc*97N9cbgZnnn*I
zxOK`4n`2he-qbkS`hJZf8`XL-Pqq=$S54+5#C;;TG<6*)MgfxiPiQzKNc$U(8Lg+x
z!<I2x0-oV1NY`@W!-xBaXAjc$@4dXsv~}jThwK}H9EGe~UW)N?^VD!)-tmxO=n+vf
zC$JXirCrA_%aW%DDkYZ9&GEqD1)%3|bkG5t+gt-bp*8{_hf9fI0ViW$C7fIE1j^U{
zL*xMEzf4Ol_8X05*5rXz6>4Dfqj^q-C%x~a*jzudmknT^0F$c+_)K^cZ~APiLjsq4
zb6pOTVXPtUrEhjRSy)%uKgc>95?|d|pS0bFbo=aoq4fduN<<@i{wZt*EmJL95jRJk
z`bo?H6HK2W_90%f{?M34{4N|QZ@)(Zv>V_4c%P6${9*{?p!4|LrpAdG1dvg`^5Fko
zc>?q<i8OOOgbQZR&h2gdpkl)D2z}b2{=@=uTxnn_+yHc`6Ffq#Ui8aa&nK>zG+lo&
z@~i)kjQoGDeJ;?^IC<mUIZO|JLJN>W_i=tJ0Glf$hFJGCzsvHWvHk$=gJ;|=@Snjc
z0U(Z9nc?IK3TgXKb^*AB|At)v1n+^4dICOr`#bok;J@Ibe_8qcxAyvf!AJiEAN?o%
z4E_r~`uD&`|I-%dw?*&2OX+`1vG>=a_g@_6e@>42cL)%0Yx+;(IE#}bA^4Lp-RSeE
z6Wgrq?%y!S2eSVv=2-ZCFW?jZA=g<3qQ6Mjl_Iq=pr`QSBk9N=@*btc|3HKSLVA9@
z@lO%>Kxpd$5Kt$4Z0%wTjWV<T%uPt~wd;5F%?{gnBfl}o!O7I~{{_UdP+=v|i+B0%
z0z@@COpDz1HedYso-zk?10Z$3pGGoCe_)wg@cvCKvru8X${?V9WY6v(zCvBNgegc6
z`LJ~N_$O$5?6(&v`7ge}KR7K>64=0k_{HOK1?{*Ot*o_aQjdl7Y=Pqh1%%1p*o=a^
zHRXv31G75z)yl0-v9x`moYRA^%xn0jsBH*K&uC+x{Pk%M-#P>c8hV}<pA<afOJkJ|
zpLyH^XPxFQ1xTPkfG>JUfVVv?x;s_?aWFV=rrew67JmQzpAP56MXkOl)G?rQ=2?+E
zu%t<H5#FFch$9~pcO4gvC*27qJ`8XoPT6Dq2iGA(h$bHvdg=*@P$+jbTlFA-%0sUB
zs0V<^3C=V8qtl%pl+Y$b-+M`fx%qf*XBtR#wwt0bYo724&&@EH$c){j?H{-K=gUM>
zuY<Jfwg+h4>rHC90cC*>Q&dE*Tgp?CgLV@!yQYQenLj_GKYqKxH`UeB`Dum{0Bmrr
zCo?^K(}v8lvI78~uB;T9nT5|>463pj;;}RK;<Nww5EpMviNksCXY^ZNA&2mxfe>mU
z-Gej(AeZO@An<J?1Ez=Jolq}v#c%KEj|%`#uI3hBB5ZQQ-$FWjGmeAX8I+|c|L1Fk
zexmL~XnJL-gu<~81Icncs`|%Iu?AsQqqkF7y1#4f_>UhL9^Vw{Fdq4QhtAJ2^Ox&+
zW&YF_`uE0uxM#)RN7v79%B7!%wJ4<DuwMPg&m=Gl{5x095oYv%Il*1%J>T_lw)<ah
z^kf{^qShw=mlKeh)v)A~vbD$lFOL*F0hav0tmEZs41kQX4FD|ZAy8K4Xw8pP5qsaW
z3IL|jMei7>63(mwKp6rEk8$%`Plzl`ofs31mD+ald)V0WF)|zi@teNqj5>L1eK7(b
zKc0cGqzGWT7FQ%bJ?3K$sfr_ju%yQZu=r~qfib*I^U6{0$<bJ#Cf_-o194ikI}X)x
z2yfXMc;?)c_e@xFJsdKkW-M7jh&S}wt}xGObfwKVnJtwOA3PqE5FnhIg)F=RA?R}>
zn4(IsZFIAE^$-x@2#Bg$ewM6Y3L&M)^?=ws0aG`S$aBvFHntQH;#GR(5H@Z4>e^xf
z3}azC?L$ccpxwD=iy@z<V|4Jb`XN9gZBt-Z%|&VjlvJa#9bUKt$z^irTqUM63>*n(
z&ILfKyk-m#6kId}20)$MM1oVV5Uh&MtwCP$0hpjLcb3dEHLH`yn90CEuJUxJId(k_
z4xMuQrd|2EBFO&B7KkvDPaf@*NV`|A`*3qaa%!oHOyen1xz8Ur^weBahm37dS8VLA
z{cdo@D|TiOQrZUELNxaY+TbWHxXLm>2=R{WDbNzidH3JK2))1c(iJl=0N3~eOlg3*
zlE)*rMM(y>7L8bN1$(l#K<jRh07L7FRDx+9T*^~<22f^=0MZGk0043UGtV(-Uh5sB
z^tgAxTk!^f6eqF%)QA|^-o2NpVs5!<XKad(_j8ZgbhkbZk^$-BhqeGqJ>cJyk(Qt-
zvK7-s%hWOn0Gt8bZqo#f3`f%p19zgb@&PvNSk-L`o8dZuM5Xl?EnGM(d_au`gH2o8
zp<jisxXbfsE3jE?C$ABD<lf&bwD!Oo)rI7D_&#+xq@=HCA9GZnIro|4+6owpjRd;u
z-iV4xjMc`6V7Jds5V9c-IMg>L)1zA6-3~Kg@Z3HkG@XLbv;m$#Y?zfEAghCO+WGi;
zBg|zI6@f*V0c0#j1cc}jm%5zp+X82eL5wGY6n0%bXp=+@TPM$ejN??n;sL1WJ2oZ0
zh3Q{@E(Y+SON~temD7Z%$gEABoOVA9`WVC4O`i39-|o0)KSrLg<{e}bZTll7ibBz2
zGi<5eQmro+pkEQ;N(!vH+ewuDVQQ=DuZ5wfG{EBkgmyB!o}G@VOWFtq!*37+G}ZMu
zizi%`G@J*vGBlsr9RW;79CG8e4&OSkpsrGQ6Epkhf$wVd!RqZh#(e5(E~X`5had6p
z7f=W;fI!E){$IjxhH&DoL;=7z0(u7llY8-#m)-^RHx=L2S{IuQku-}N9YLD}rk%#x
zYNXWDo@Cm9cn0(>ilCf7K%kfg^KcQpv)>O;y!%@+d3qul%kI42$dAxSHF$Y-Y>GU#
zPFZBu%Q5~V0naS~RNWbO+kS=Wv4Ij#ejP&lM%l^Mh(WbV1o?>NIEfOFqHabkCI@pB
z4;#mpcPJh<C>9o@h-aQB5~%iWFF1t`E$tz*a=D-)AOdm+$N`{f1i+|Rs?<Tow-=;i
z5^u7m&^k?dHO5XJ&LaSq;QA4Q`zYxsNQABO<3ZelNSYuJZVv>k;$pFh!>dF)ZkZV|
zF$cjMRb7W;yV}^K&tI`)e{4YB%hvW$TeW$inpBt6&t~PkeUpRm3xIty>ynJx`pA4|
z5#RgfjTcJ6)f7L|OsR@JM%`HV*r|f_>QpPoToaA;my*L6oP!>jqb_gLDY`W$>5V8b
zx*84Xx1u%Rx$J{xq4jmi_}T!3FHpho@bZTeojm02^Am>a@Z$qGDqgX!WT|YzYMSqc
zyr(X@XW`%-xAV7$_*TQm5SUQIXEsx~gq~EA&p(AHP)WOS&MaG2(0`71#BNt}G~PTx
zQO10x#6#+3<@-u0V!{g#oO42DGIQ432ME=0uG@WRv{=|*u;r`awG-d96IUbUH0lVv
z{t~Q%`}{@g6w3D@_d5pMF1N4yEu1sDzG+^~qN}#3#BJJ&`{)K1vAm<GsKN|6@2bv?
zm1FC*)#Q{+<eB%@WE;4X-S=>ny0Pv&Aj8#rL_mI84Y7nDA}gOAIk1@>gx}EJuNk9h
zcKG<pysV**X7oiVl9acfL;dkWKXQAeUJpQ2Y@)}z3KoPMSKF(2>#N#n*Bo;l)?$QA
zV0JrhJMm>(!UuB}v|h`Usb-z($b!gSK)Q^Xc@_BH%{e(ssCF5>F_R@!={))<QCTOY
zK3B7dt@r{@&ig>$#+m3|brUZ2Y+xo*%;vB%!Us8zb!?^@mRm4*4Il#wisuf>+;ydz
zMc4>$Wv6V57npP<bmVX9WTdR!#mTA^f9Sr8I#A~A%x6Du)b_pflji9r`S0=mmxfLE
zK0PFy$qLXiD`;lA0aly}L=E~h_8B9Az0%V-REmxLb&&gk&-WWNJPxkVE>ca#b9FvW
z$j)GpTI&?PGU4v493OjuIB`!8S`%qXTcll2lGMhPdoPPeWS6R^bwA^>v37qqS;3{$
zzR>Kwu_rGe?b30hI=?TfAoQ%`vsnB>Wwk@`IZx)9o#<-;fqoD%SP-ylB+DN~RBJ27
z@^f~o%3Wxa%PgFNy&QQi@9SUqyjE15)Jqnb`He_L<oOTl&jIz(4%oO)6eBIV>g^v4
z6y18wW2dq%z6<7}LPbN$WZFlY!u<w`VwEer%52@)S|vA})~C>o(YCnT2XHXU3~Iv4
zi76QZxfSd?p1y=5D5?>aVv}erw-%D<7k9j6Djx)mK7GMu3^P_WBSE#i)U=a($6iA|
z52?^k1C_ORqzCJ`Q8DSgLuJcSZ^3Qb>SZ&v;TLXew7t;-PGG@RoTf#FSR~A028R@s
zVsbQUi7DlXs)q#hr#UENsbJ0R{gsY*Ph@_0lZD-VM=NwwH+t%rgS4E7B0=Wh33pKG
zYxsy%VrY3Ls(};puFpkoH%ph1@Y77v6I+C^W!YMhT!?HIdzHQ~A<cl18eEZY+7#t)
zXr#q-Q!)k1ZTgee4@gfR&9n#b<f>C0t(J7MDZ>ROejs`gR#43caY<AwqWm_2jZ}<k
zOtt$#6Ssn!GvcM}7sK-u{sa{5<xZR5SemnfwY_G|c>D*dw*_<7)y8ob_ts|^js@jn
zZZgFIqh?!UDPy%+h8O&%8J|~|jtn>?q_8;M2S^%Hhb_z2oxuF``4+~~94XSYnv$5F
zL>lw_HLhkRJ5lFBD0j0P#g@n1fP)*o-Nt36&5(0Oy>Vpr;`DrG%FFs;<(z4UT%*#^
z6PN?Qws(Cm<aRUU8LQy3?p^viwk4jOciFjk8@G-)6UZmll==r>bLRKQmPz|yVV@-m
z;uIamGy0xGK*900WLyXky6WCuy!zcNijY}?-4%H|jFVc&_&enoa8zn!G)4Ah40CMo
zs2!J;w=@QA&t+;bt6A8e*0g>?Ak5;4p7t}mw0JY&36leCv)n@4Ye3ArjE<U;r!@UT
z6Vg`ygGLafi0D)s(Dg#;fS^!SZBDl44bSi>a(#knV>rHwQxSR8^2R!K{~Xz%N>NHW
z%KG!jRy6#kS6=~`Te_yj*pkZuYwHrk=}_`uOXMvR#!Sw2D<vKy7IBSDkGe(G>RBfR
z&Z6q$F&}TQWqT6?%}onL!e@IeL+zTOJi~%mx3Q;Kaya!79%61kd}WgwBXVXWeb4)M
zm9;9W6<Hu8<6T35@4)K(nLLg7CYSclV%pOtzEW0aLw?<poR_Sa`E$Oht=L_s9d}u4
z{3kDU469p%?`N=OWIf3Z-=9gys}if6(~+%olo|WZb&#M?W%?381H${~?vq_tQR|PZ
z9)N!^>(rk>;!yERe=P@Ghas8|2_)BCM8AM+846!~us7q;XT{NXD#z*WSY%vw^nkJ1
zs2tWv6dSPd7GJA*mr#}=9Hy|IIxl-e@4fR3B!cRr6LTS8BcjslIcAz(i<QSCIOkDn
z(?!TGV&<L%WC~*ONgt60MBy4&pW|d)%Q;G;c%{7AH|`rqHLO})IQ|R+*0bj9)9Jj%
zeR0B$Ru&F3368^ok0birF<|Kw<1J~LzM?NHw<_6v7t`Yq$E_6MF+fCp>pF*SrJx*4
zO!U!0rO9)0G%)#~Y;KSI_?S0-@Y(1&Wlgm{yxqf;&eDjpl;`)v+Zv@byOj{0HgFFN
zVn~CY*OjNBvp`%@GFraBuNo_2fIP*tZP)IgI`h4QJ(tL5dY>`>*9`}61NYq&Qp=c3
z!#^!tDyV`4=e#Pg#_W6LZ4bIXNfMa4?an!kC55cD9e!@`x$b)o?at<}TzxAfd#p8%
z^W3`eTpMv1&F9)R`%j-LG<WDf2Q?>YksiN_dCU`wCb{3H`_Y-FqN5pgad8svDF`?M
zb?q^{^$=e|{hT*r4)f+GEv}ST>7hTC+UV+0D_3irjE{b#-b=h`i)dix6tKuDTJ5#f
zDTbZW@#y7L6(rbYoAo;t$*ttplet~6^Y-fdw|98L&h%u4kko!(5I=U-G9rB-%*CF~
zE@rpT5le~vU75D}6fc9+h6rg;)r=>HC-F63((?>rB0)3)Tr0?YI^4{RtYSCul9`7{
z8$aDV11XC;9o05m$gumt^mNQ}(H9tc)g`;zr1V$eofimwSK|PsY$MW`r`Hd@D0ByL
zMcS5{*I3S?hf}x94z3shj8`4v#g@(T6Viq^o*cu6rSX+nBnXy2@|k1pmOKRD4Z7N~
zch@BbB{kjCdvA4S7QMLXJ7DFX&Dw7w%qghNXPoapfJ~1p&+W?E{6cf32KRxc^WOP|
zwJYzU#zPFttq;yUQnbfiFt9bJ^!U~sW#LQo*(!KNi7i-DHt}OQTM>L|lc{F+n#;pN
z)Iu8Af{y8IK6x22j*d0);a^XDh4sfDgx5o`G_2vhuObXTkUf$(jr+$RtprppktMc)
zfBH7~odh;MRSW;q6!mL=`YQO5*Cy7P{5i|9q(2`W|9bZ;@G+q}D}~IT4^8$cvGSFd
zg)>dbU#|xLRwDQqTQxxH$zLvo>^k>TMy-h^&Oa{v<o^h-KV=+!6=CrIolEcI`09b#
zuTgyXd^rEvG>E?mp`1{&RkgRcSPU}BCV?XK^=9#-ywuIou%FM~lC`^xlXyPw=et>4
z#KLh~fO&d2fdbZ5sWgT7I#7clb=h9Lc>f(WIT4WN#p(gxob_$oa9SAYc4$fV6D<bU
z4MgKKBx~L%JoO5@j!1a9TU81r`164(bArdq7bE=hZ9LL_CBcuI2P&y{LtqW42TrS0
zk=%Opp66Z^)LQIa<r|0;bKidhHfvwtuPk<SOZ5lGJLpO!q)BgtteEnxE~!ATZ^#r&
z?_gxG4xnr=>3U*NH^6jW2fipiJ_MAi<SqGYpkR9m8}S177^u@CgiQCwyH#~GeV=#C
z#epoIH7?(AZDKm~As4Gi?#}7vxuQq+e?1Qxwx^60U?a&r8EX>kSbz@f02L+-7!LrU
zsVG$VjlhJ{)iIDFOhdNxcbKxvA^qU!8~S&LfRHHuK`-YX$TZFai!>W2kXsvsH~}*o
zpNm)TlWiI?w8shYw#N!^&sXdtvtn_oKxxH8WC1X57KW1KBr1V0jxWST*|-2c5wBNK
z(;>%(w3hf+h28hJZGh&BiQ+~6VWY5hz}9BjULNMnVY!~bV|X7V+ea6jR)FaoAtYf;
zCGO!i1THald5QGrTw)`)$xo9_X;1rkUlCY1R)u%Pw!0;#KS<O2yE51|T;!ym1B9zU
zP8d$Ob@iU{5IC>FI(oZT(GR?B5m1o0vZ^?B`&nx^pl}j5Fh*Ln$E^WJDh}sEIA+Cq
z8dRI!HUk$J(pa3l<(lF$yM-n@DCjGu7T;e?_Bs{Su#_nBT#kFm6wjDW+=9h4#T*49
zwYK>h^G`uRxuBk@Q~y=J9>MSZ1BO{P;R%NS9Fyr%H59{|ePhxmv)l_GhYOS~n9EH4
zEiB!Z5BIj}f!UMfLT9|;l<Y$e&cZMjMIvCliVtymms90#lmbyHst}KZ(aHCmMY+}c
zW(5>a@Ym}IxZgk}s639exEHd5hwJsR;ejkc(@gI3yfD1k%NMD7skOP{f$_2z14(W~
z%`PCy8Ckd+)8#^*3dB(11U<1^O&N>=-eR}sA!XuvP(q<DcUZcw`fDhu;0;~TB9Dq8
zKUw?IwO=J#)x0|GV^xe}U6`4w+WABpQ7rV?3;S%-YJ<oGDBRS6Dqd^7L>tEspcnhL
z4OskEb&orN(M2Fl=b)?&!$_$;_14$C2kHMTr`8#2%E=VAf7jU?Hh~dpS>#FSyFMg7
zr;cZU=YnU^D>x3+);U)1e=RrdNwVphtSKElb&9l0=H4A;(cL%4N4szzNl<#T^Jy0Q
zxi%+KpVl(U>baTwb74?9=e7~37ZfI%*XE5&V32jamTuh3kBCll^Fd)kXn?hKy+!S3
zz!&9w`9pp$S}wEb-k=_d*VS>aOU;^bR9X+$Wf?oF4E8RGxjCV~M^!7IlMCFP-UHiI
z9pJf>2+#qcd7r6R@<OUGL1X;xnSkR1l}y^<6*1M5)j2T^EY?Do2H8(`lx|-vNOfS^
zl=U3vmllx+1^XmljY($|WeTlGPThP?@_fA9!FKpNxA)`nqwfI+pj0VF3mmLE^6e%-
zpxGGNFJw3WhUsBsLr(4MGlckK0>#<}S6DP%e_)9kw?{J%e>cB$)93+}@Jov@%UH`|
zjUnKc5&LD!|L2p4z`q5*ru8FXUg_t?;T3>WifY$8+Kjq8aVyzcUuwP<%)Sk@1!&Uv
z_(zm-bC#@J?$L<}e_v}+GnN*4@6p4-DMVkc9$auI0##t#VfMXBU~X<e;`0&azz>uc
zufI2+bH2?V9M}tlz$vw&e#p9kI$yJG)v$=D%l2DE7*LF$dc~{CkGT<6@N={C(!{m+
zkgd{*`8h{SrKVchbI%uw+)U=qj=Y8?r76^w(vvLRtTo$B7wy`0)0{`g1Mk+Q*B_Y;
z42<=e-LACEQ3&A_%bjW51M{}j*pETLN_+aH7_e4yuar{Y?}fC)sNRxnf2VH0CjS|%
z$HoPG&LXZm%jh@?gn3R`>eqK#OSJagcl7(xALj+x^P~m^Q8Gi$-5V&mSpMv<!Nk9&
z?|m?R%?jJIep^t3p2_b@KRdiW{`OMTNQL8?#0?pVs3zZ+KfW{3znkJ^Dkth~j5_Ef
zdGun5-g`*5%Ejj)ch#-Ws-3Ij6@Fm95Of3D+JUtk*$IV*B<I2cg5?PoK^KUkx#ESQ
zI<rY@YVGT@erX9VY!lUf1BT_ekRpN)PjzFn;pF!1n96{se3;LP@q=|it>N*JI##R=
z#9qswUlS!-75r<a$|m;ug(-Y72?kq{a#8ZH3H<13J#Hxj2WNJQm7S!-g9{Zvf38UI
z^^IMtl>R8Iim_srlqb#e6FE2otT*JHHNKa(eW}Aq57O(P4_rxk-@GqN!r6{ffU{DW
zfG|{haenLPh8VJ%X2rNP>HTx4{T72raN#^*G#^B0D@XY#|215B0D>Nwx|IL%{qsh4
zkL4+z{52F}#G`6q#*6yxu)pG`vI{ptI;8kC9{erLy7rVY_L?@^UxGON*}F9o{FMDh
zmw!H--{ZJYFhN6YGJYNM*BL?xPGb*iD~J8}qJO@h|32xzjMM)PkH6+5|C!+-v9Mk9
zYdv^(Z5=eA{ebLUVbT@%_1d%3K(y~16v8?I-N-r+c9R0hi>!bhKBXlrND?U~Ln%$c
z2L&9_oT5P(sSbQbhd}SVt}jDrrufMc5Ko$`>0%Mv@UJ`K6iw&%eAxUV7J8*M(vme2
zJIRlOtMS1i!sv(<#w?Eyx-v!}G$F0~#sVArd<aR2mVz+19@wp3dI{n?=22PEGSH{1
zTOKX|rjuhAQWatJkz6{|sq(R^Y*|a0WKQ6c4MoF8RzQp3oT%&0d7N@5yXk4D^`#DM
zzuI-JL{WvH@L~hHJ!<x~pGFQ-T1UQ@tLeG(S%5g{GEH<z_@w2@VuYf+5t8jmr;Y`#
zFHsU7D$$%Ff&;0AIuN$gVkhC;$zt<Y9hUtL)_%&{j;plg_CH97gl0p&f=;7qeylUw
zg$H+jKrtOC&!*MU<GBCWgEF73E^!7xm*;--Nz#vEGh9m?Bu6)FrfLGb)rnLskM5pk
zbCL+$nEe)34+>vYXNc*wYw3+2Lu<Gx4p<!Tr{lIk3#|PkFKi+~MiD3i2YsGrr9gSm
zOf@mk44GOEvVb!la+d60fkNRMumMJhT<83Ft^B2lQW*+!uuFWX{4ujb?}u%{UaJGF
zbABTadLt4u=RoqTprcL#-LRRLqbkSwrPXNafn4`bNOysGqWIz!`f_>!R{I}zreVD#
z=pbr7wwDARK((^%j6jfAynwYX1f8e{ojlmrz4=(bi7Hn=JW}R{jcD3%o_u??)U3@{
zr?Kl&qI9XXHs6cwFETHD7G4H<A4BKur7xuks*{jzt3H$rg6{-y)`$B?ju*=Y(afQt
zd_s#ZU*~-R=*l)x^wW#FD7zhkamhCZ1WkF4p_&cUC$(wkX>Q>8nleBPDkz}sMCY|S
z^PHAbSm_vqP550RTXI7Nft&_HP4DSww1ywfc_K5?5V#?rrZ~B=_DK)!v9adGRd=oY
zW0(nOZ%+ejU3^fdCWdrT4i5wu6JHz9x4MF&USsp@^r8E~4xve$?S1V9ZfGO)Y9hB8
zKs063JWK`er;shgk1>++PNKX<AZhkfC?lzdQems=y?Mcbd_m$aya(q(7WbV&{TH{q
zjAR|^gL*MW-E*7;<A<vo|3PA_lf3t&g(lF>M1zP__ngP@%MQN5H{yrW#QL)>AErU2
z2M;oHEd||q{928d$C?Zam*376T{Kl1FeAxMfkNJ~XJFnEL4qF3BRW>1m&%^j;QEK3
zGvEdp$XC#g^XXL-7u9_QT5D$wzG|_F8)lW6*1pjNmte&x2suX?JdHb|k7hIjB>^4=
zO1Y+B1_mg9RG<7YroEo1b=#l9q%|R-IpXM~Dq^Y*asZlQGmdC5q`G-<&fQnI{o}LE
z%sT;JkXZWy`z}7$>B4GAwk2TZY43gS94K|=xh`wS*UKMCy8wV7D(9o4rK0XF(HIIV
znJ<CFnc_8*_snHU-v$w!HmI~<!6&ze@FhB0+HB*tz8QFnlJULh&d^YRLZYBaXWR|b
z?nGvknw2{blTKU3%N1&_YBZuw=$t~^yAP>M5i+UON2uK9{X-xoL*Be}bDAtni4NTT
z23b%K6nq*cw&8m(K@K+qLY|~J`GrR>F28n3%c?jDn;99fid*KB6F8vd^3ju5tL65i
zmfPXw6jAI8APv3*xfoM9fzE72NB%{(n=z#RT1%B^L|~r7y9FHfl<%MXj;sadr2;9)
z`AJ)De!GyJbFDl!^jwna7xl;J%MX%J{6(vcay09Kcp;0$ql>H#oLnjjnqPjT#(IpH
z(cWw-EbUDZaIIi!z00T_XWF=ch2ymd2lsO~o@uggq}9Xz4hy4#Kb(gd=OL+j3X1C_
z<l1C;8fbBZY$t(oA>7kVaWBhEt)`uI87|aZV6<(c(`=?{Q;(bPf-yjVDM4YbJC^2Q
zTivn`ZSFC;wz8%*L~3~V@)$Oe5y?x)?SE7Bc%mLfugt4(YemWGTOL(K?83dkXJy|K
z_-7q@I-(;7A;<cpdWci%6-YN$?Z@?P_+Hee)p+?cH9l848?Bs_5)EUula1`w7Z3#2
ztG>g9GNap(r^fGGGW>Q;6sKsop+REIF8rY5=7$TM=|P{2f-D~Tt7@#?kqu;MW_<hY
zC4)REwk>UW^hf^cQw}mNpxVTKTPVA*u)8;)Oa1vt0xi)@_SM|B`HQ1o5i}S>uyB|G
zDl9NNe;A8Pr~KAS;S|22k2QY7&!4Y6+tDs3Cv7msRxQ5}7ERWo%y7EtL2rNT?M~)$
zT3%8ITZ6ml5ZI}kv(m}6s7omd1rpcn5uJ{cD$gTnurA+5xSE};0;yQ`+@hcvT@SR=
zMvWwQSH}$<A2E|9nX``jn6yXtTvN<oDV*Rr-2-&6$xUu?B|Heo%L<B(6LWX5$V-W3
z=Vjnl|C*?ALkEebdrnt?#hYxqlct=g5r|hJjNrdrm;lU2XKd?IS(Q@5<AwG?znmC&
z=id8L0($nh-#b66JkfO%+*9LwmPjMaS?LK70W(fo+-AzjCc4nl?t%4^GY3{>0wv0~
z3r}&Tj1i>>_OP`XiH+T7k)Pr<Xm~q>)x2DMcwy*8uA)^~81p&VX4y7-ZL5qrx#FOB
zqog#8Bt9!dgFg?Wf$Hq7)yPVFLw=vS=w2<WvXo2Bz~q^v`7+CvG9{~F8EUp|{@Kn9
zNDD=EMbN#lBQorVR<Fa18Mrz<0raa;241?xPRaUUc3L;zo<R|`iQlq|A4+w9Y;C-4
zg=s*~0ql<G1rc6XzGfa)Xy3b4ERjYG=lGKL78JCeFNbR0K6&cF;iq=pnG##hkPlO~
zyb)>iI#)|nK(PkkBRuTEF+TiE3B9QBr%bWxdbH=Cm25?C-q=$@A~h?=7dQ#X2Blhc
z%tXh1GxU&bvFeI+7qp)cvqrRaz2tJLL=9;1Om!Y{hL8IBC!w{jA63jy*>k7*6gz3L
z`8_;2_dbD5)ag(!3(Qg-$zS6$d}YQEtl@e0a<-vij$bJbbQ34v>U#+KI=Y()YJW|+
z5}Cnh`ZzT9_oB2e$lFk%yOn=C3?InQ1{&rS{`N771Vk@Ul?x}u&fjw`vUC}6PG)|`
zzm>4lqrg0@nic(3y7}!`67t}je0gQR>QTRcT!nMqXo+df`EMDW8FWtnj`*K>`|l@3
zGJygvH_$Zs?Z$sTqeo%jobnc{pa1qTH@JP5Z?4c#{Zr!V^%0!Y+`x|IZy&orxBqZr
z>u*VCA4o;DNMnUhhRh%D<o}0{d@*iE6EuZf7XOyHOL+N`4;f+hQ3N!__7rk|9b*z+
hK{b9n%c95FTGUhX@nf&9p925MNGaUQx%<@n{{h*X|2hBw

literal 0
HcmV?d00001

diff --git a/img/scan-runtime.png b/img/scan-runtime.png
new file mode 100644
index 0000000000000000000000000000000000000000..965df7785502249072a7e582c9927a3f71eb9d5a
GIT binary patch
literal 74469
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
DUxNZl

literal 0
HcmV?d00001