From 06c20d49e6b203377c0097dc81c1107993d38753 Mon Sep 17 00:00:00 2001
From: 5000user5000 <ck10600760@gmail.com>
Date: Thu, 13 Nov 2025 14:05:37 +0800
Subject: [PATCH 01/11] feat(core): implement JPEG decoder C++ core modules   -
 Add BitStream for bit-level reading with byte stuffing support   - Add IDCT
 with ZigZag ordering for 8x8 block transformation   - Add Huffman decoder for
 DC/AC coefficient decoding   - Add main JPEG decoder supporting Baseline DCT
 format

---
 src/cpp/bitstream.cpp | 118 ++++++++++++
 src/cpp/bitstream.h   |  74 ++++++++
 src/cpp/decoder.cpp   | 415 ++++++++++++++++++++++++++++++++++++++++++
 src/cpp/decoder.h     | 177 ++++++++++++++++++
 src/cpp/huffman.cpp   | 179 ++++++++++++++++++
 src/cpp/huffman.h     | 126 +++++++++++++
 src/cpp/idct.cpp      |  97 ++++++++++
 src/cpp/idct.h        |  87 +++++++++
 8 files changed, 1273 insertions(+)
 create mode 100644 src/cpp/bitstream.cpp
 create mode 100644 src/cpp/bitstream.h
 create mode 100644 src/cpp/decoder.cpp
 create mode 100644 src/cpp/decoder.h
 create mode 100644 src/cpp/huffman.cpp
 create mode 100644 src/cpp/huffman.h
 create mode 100644 src/cpp/idct.cpp
 create mode 100644 src/cpp/idct.h

diff --git a/src/cpp/bitstream.cpp b/src/cpp/bitstream.cpp
new file mode 100644
index 0000000..d3085e6
--- /dev/null
+++ b/src/cpp/bitstream.cpp
@@ -0,0 +1,118 @@
+#include "bitstream.h"
+#include <stdexcept>
+#include <algorithm>
+
+namespace jpeg {
+
+BitStream::BitStream(const uint8_t* data, size_t size)
+    : data_(data), size_(size), byte_pos_(0), bit_pos_(0) {
+    if (!data || size == 0) {
+        throw std::invalid_argument("BitStream: invalid data or size");
+    }
+}
+
+uint16_t BitStream::readBits(int n_bits) {
+    if (n_bits <= 0 || n_bits > 16) {
+        throw std::invalid_argument("BitStream: n_bits must be between 1 and 16");
+    }
+    
+    uint16_t result = 0;
+    
+    for (int i = 0; i < n_bits; ++i) {
+        // update byte and bit positions
+        if (bit_pos_ == 8) {
+            byte_pos_++;
+            bit_pos_ = 0;
+        }
+        
+        // 檢查是否超出範圍
+        if (byte_pos_ >= size_) {
+            throw std::runtime_error("BitStream: unexpected end of data");
+        }
+        
+        // 處理 byte stuffing: 如果當前 byte 是 0xFF
+        uint8_t current_byte = data_[byte_pos_];
+        if (current_byte == 0xFF && bit_pos_ == 0) {
+            // 檢查下一個 byte
+            if (byte_pos_ + 1 < size_) {
+                uint8_t next_byte = data_[byte_pos_ + 1];
+                if (next_byte == 0x00) {
+                    // 這是 byte stuffing，跳過 0x00
+                    // 繼續使用 0xFF
+                } else if (next_byte >= 0xD0 && next_byte <= 0xD7) {
+                    // RST marker，這裡簡單處理，繼續讀取
+                    // 更完整的實作應該處理 restart interval
+                } else {
+                    // 其他 marker，可能是資料結束
+                    // 目前先簡單拋出異常
+                    throw std::runtime_error("BitStream: unexpected marker");
+                }
+            }
+        }
+        
+        // 讀取一個 bit (MSB first)
+        int bit = (current_byte >> (7 - bit_pos_)) & 1;
+        result = (result << 1) | bit;
+        bit_pos_++;
+    }
+    
+    return result;
+}
+
+uint16_t BitStream::peekBits(int n_bits) {
+    // 保存當前狀態
+    size_t saved_byte_pos = byte_pos_;
+    int saved_bit_pos = bit_pos_;
+    
+    uint16_t result = readBits(n_bits);
+    
+    // 恢復狀態
+    byte_pos_ = saved_byte_pos;
+    bit_pos_ = saved_bit_pos;
+    
+    return result;
+}
+
+void BitStream::skipBits(int n_bits) {
+    readBits(n_bits);
+}
+
+bool BitStream::hasMoreData() const {
+    return byte_pos_ < size_;
+}
+
+size_t BitStream::getBitPosition() const {
+    return byte_pos_ * 8 + bit_pos_;
+}
+
+void BitStream::reset(size_t byte_pos, int bit_pos) {
+    if (byte_pos >= size_) {
+        throw std::out_of_range("BitStream: byte_pos out of range");
+    }
+    if (bit_pos < 0 || bit_pos >= 8) {
+        throw std::out_of_range("BitStream: bit_pos must be 0-7");
+    }
+    byte_pos_ = byte_pos;
+    bit_pos_ = bit_pos;
+}
+
+uint8_t BitStream::getNextByte() {
+    if (byte_pos_ >= size_) {
+        throw std::runtime_error("BitStream: unexpected end of data");
+    }
+    
+    uint8_t byte = data_[byte_pos_++];
+    
+    // 處理 byte stuffing
+    if (byte == 0xFF && byte_pos_ < size_) {
+        uint8_t next = data_[byte_pos_];
+        if (next == 0x00) {
+            // Byte stuffing: 跳過 0x00
+            byte_pos_++;
+        }
+    }
+    
+    return byte;
+}
+
+} // namespace jpeg
diff --git a/src/cpp/bitstream.h b/src/cpp/bitstream.h
new file mode 100644
index 0000000..8b0b3ea
--- /dev/null
+++ b/src/cpp/bitstream.h
@@ -0,0 +1,74 @@
+#ifndef BITSTREAM_H
+#define BITSTREAM_H
+
+#include <cstdint>
+#include <cstddef>
+#include <vector>
+
+namespace jpeg {
+
+/**
+ * BitStream - 處理 JPEG bit 層級的資料讀取
+ * 
+ * JPEG 的 SOS (Start of Scan) 資料是以 bit 為單位編碼的，
+ * 而且包含 byte stuffing: 0xFF 後面必須跟 0x00，解碼時需跳過 0x00
+ */
+class BitStream {
+public:
+    BitStream(const uint8_t* data, size_t size);
+    
+    /**
+     * 讀取指定數量的 bits
+     * @param n_bits 要讀取的 bit 數量 (1-16)
+     * @return 讀取的數值
+     */
+    uint16_t readBits(int n_bits);
+    
+    /**
+     * 查看（peek）接下來的 bits 但不移動位置
+     * @param n_bits 要查看的 bit 數量
+     * @return 讀取的數值
+     */
+    uint16_t peekBits(int n_bits);
+    
+    /**
+     * 跳過指定數量的 bits
+     * @param n_bits 要跳過的 bit 數量
+     */
+    void skipBits(int n_bits);
+    
+    /**
+     * 檢查是否還有資料可讀
+     * @return true 如果還有資料
+     */
+    bool hasMoreData() const;
+    
+    /**
+     * 取得當前位元位置
+     * @return 當前的 bit 位置
+     */
+    size_t getBitPosition() const;
+    
+    /**
+     * 重設到指定位置
+     * @param byte_pos 位元組位置
+     * @param bit_pos 在該位元組內的 bit 位置 (0-7)
+     */
+    void reset(size_t byte_pos = 0, int bit_pos = 0);
+
+private:
+    const uint8_t* data_;      // 原始資料指標
+    size_t size_;              // 資料大小
+    size_t byte_pos_;          // 當前位元組位置
+    int bit_pos_;              // 當前 bit 位置 (0-7, 0 = MSB)
+    
+    /**
+     * 讀取下一個 byte，處理 byte stuffing
+     * @return 下一個有效的 byte
+     */
+    uint8_t getNextByte();
+};
+
+} // namespace jpeg
+
+#endif // BITSTREAM_H
diff --git a/src/cpp/decoder.cpp b/src/cpp/decoder.cpp
new file mode 100644
index 0000000..440b428
--- /dev/null
+++ b/src/cpp/decoder.cpp
@@ -0,0 +1,415 @@
+#include "decoder.h"
+#include "idct.h"
+#include <fstream>
+#include <stdexcept>
+#include <cstring>
+#include <cmath>
+#include <algorithm>
+
+namespace jpeg {
+
+JPEGDecoder::JPEGDecoder()
+    : width_(0), height_(0), num_components_(0),
+      restart_interval_(0), data_pos_(0) {
+    std::memset(qt_set_, 0, sizeof(qt_set_));
+}
+
+JPEGDecoder::~JPEGDecoder() {
+}
+
+bool JPEGDecoder::decodeFile(const std::string& filename) {
+
+    std::ifstream file(filename, std::ios::binary | std::ios::ate);
+    if (!file.is_open()) {
+        return false;
+    }
+    
+    size_t size = file.tellg();
+    file.seekg(0, std::ios::beg);
+    
+    jpeg_data_.resize(size);
+    file.read(reinterpret_cast<char*>(jpeg_data_.data()), size);
+    file.close();
+    
+    data_pos_ = 0;
+    return parse();
+}
+
+bool JPEGDecoder::decodeMemory(const uint8_t* data, size_t size) {
+    jpeg_data_.assign(data, data + size);
+    data_pos_ = 0;
+    return parse();
+}
+
+uint8_t JPEGDecoder::readByte() {
+    if (data_pos_ >= jpeg_data_.size()) {
+        throw std::runtime_error("Unexpected end of JPEG data");
+    }
+    return jpeg_data_[data_pos_++];
+}
+
+uint16_t JPEGDecoder::readWord() {
+    uint16_t high = readByte();
+    uint16_t low = readByte();
+    return (high << 8) | low;
+}
+
+uint8_t JPEGDecoder::readMarker() {
+    uint8_t byte = readByte();
+    if (byte != 0xFF) {
+        throw std::runtime_error("Expected marker");
+    }
+    
+    // 跳過填充的 0xFF
+    byte = readByte();
+    while (byte == 0xFF) {
+        byte = readByte();
+    }
+    
+    return byte;
+}
+
+void JPEGDecoder::skipSegment() {
+    uint16_t length = readWord();
+    data_pos_ += length - 2;
+}
+
+bool JPEGDecoder::parse() {
+    try {
+        // 檢查 SOI marker
+        uint8_t marker = readMarker();
+        if (marker != MARKER_SOI) {
+            return false;
+        }
+        
+        // 解析各個 segments
+        while (true) {
+            marker = readMarker();
+            
+            switch (marker) {
+                case MARKER_SOF0:
+                    if (!processSOF0()) return false;
+                    break;
+                
+                case MARKER_DQT:
+                    if (!processDQT()) return false;
+                    break;
+                
+                case MARKER_DHT:
+                    if (!processDHT()) return false;
+                    break;
+                
+                case MARKER_SOS:
+                    if (!processSOS()) return false;
+                    break;
+                
+                case MARKER_DRI:
+                    if (!processDRI()) return false;
+                    break;
+                
+                case MARKER_EOI:
+                    return true;
+                
+                case MARKER_APP0:
+                default:
+                    // 跳過不認識的 segment
+                    skipSegment();
+                    break;
+            }
+        }
+    } catch (const std::exception& e) {
+        return false;
+    }
+    
+    return false;
+}
+
+bool JPEGDecoder::processDQT() {
+    uint16_t length = readWord();
+    size_t end_pos = data_pos_ + length - 2;
+    
+    while (data_pos_ < end_pos) {
+        uint8_t qt_info = readByte();
+        int precision = (qt_info >> 4);  // 0 = 8-bit, 1 = 16-bit
+        int qt_id = qt_info & 0x0F;
+        
+        if (qt_id >= 4) {
+            return false;
+        }
+        
+        // 讀取 64 個量化值
+        for (int i = 0; i < 64; ++i) {
+            if (precision == 0) {
+                quantization_tables_[qt_id][i] = readByte();
+            } else {
+                quantization_tables_[qt_id][i] = readWord();
+            }
+        }
+        
+        qt_set_[qt_id] = true;
+    }
+    
+    return true;
+}
+
+bool JPEGDecoder::processSOF0() {
+    uint16_t length = readWord();
+    
+    uint8_t precision = readByte();  // 通常是 8
+    height_ = readWord();
+    width_ = readWord();
+    num_components_ = readByte();
+    
+    if (num_components_ != 1 && num_components_ != 3) {
+        return false;  // 只支援 grayscale 或 YCbCr
+    }
+    
+    for (int i = 0; i < num_components_; ++i) {
+        components_[i].id = readByte();
+        uint8_t sampling = readByte();
+        components_[i].h_sample = sampling >> 4;
+        components_[i].v_sample = sampling & 0x0F;
+        components_[i].qt_id = readByte();
+    }
+    
+    return true;
+}
+
+bool JPEGDecoder::processDHT() {
+    uint16_t length = readWord();
+    size_t end_pos = data_pos_ + length - 2;
+    
+    while (data_pos_ < end_pos) {
+        uint8_t ht_info = readByte();
+        int table_class = (ht_info >> 4);  // 0 = DC, 1 = AC
+        int table_id = ht_info & 0x0F;
+        
+        // 讀取 bits 陣列
+        uint8_t bits[16];
+        int total_codes = 0;
+        for (int i = 0; i < 16; ++i) {
+            bits[i] = readByte();
+            total_codes += bits[i];
+        }
+        
+        // 讀取符號值
+        std::vector<uint8_t> values(total_codes);
+        for (int i = 0; i < total_codes; ++i) {
+            values[i] = readByte();
+        }
+        
+        // 建立霍夫曼表
+        huffman_decoder_.setTable(table_id, table_class == 1, bits, values.data());
+    }
+    
+    return true;
+}
+
+bool JPEGDecoder::processDRI() {
+    uint16_t length = readWord();
+    restart_interval_ = readWord();
+    return true;
+}
+
+bool JPEGDecoder::processSOS() {
+    uint16_t length = readWord();
+    
+    int num_components = readByte();
+    
+    for (int i = 0; i < num_components; ++i) {
+        int component_id = readByte();
+        uint8_t table_ids = readByte();
+        
+        // 找到對應的 component
+        for (int j = 0; j < num_components_; ++j) {
+            if (components_[j].id == component_id) {
+                components_[j].dc_table_id = table_ids >> 4;
+                components_[j].ac_table_id = table_ids & 0x0F;
+                break;
+            }
+        }
+    }
+    
+    // 跳過 3 個 bytes (Ss, Se, Ah/Al)
+    readByte();  // Start of spectral selection
+    readByte();  // End of spectral selection
+    readByte();  // Successive approximation
+    
+    // 剩下的資料是壓縮的圖像資料
+    size_t scan_data_start = data_pos_;
+    
+    // 找到掃描資料的結尾（下一個 marker 或 EOI）
+    size_t scan_data_end = data_pos_;
+    while (scan_data_end < jpeg_data_.size()) {
+        if (jpeg_data_[scan_data_end] == 0xFF) {
+            uint8_t next = jpeg_data_[scan_data_end + 1];
+            if (next != 0x00 && !(next >= 0xD0 && next <= 0xD7)) {
+                // 找到下一個 marker
+                break;
+            }
+        }
+        scan_data_end++;
+    }
+    
+    size_t scan_data_size = scan_data_end - scan_data_start;
+    
+    // 使用 BitStream 解碼
+    BitStream bs(jpeg_data_.data() + scan_data_start, scan_data_size);
+    
+    // 計算 MCU 的數量
+    int max_h_sample = 1, max_v_sample = 1;
+    for (int i = 0; i < num_components_; ++i) {
+        max_h_sample = std::max(max_h_sample, components_[i].h_sample);
+        max_v_sample = std::max(max_v_sample, components_[i].v_sample);
+    }
+    
+    int mcu_width = max_h_sample * 8;
+    int mcu_height = max_v_sample * 8;
+    int mcu_cols = (width_ + mcu_width - 1) / mcu_width;
+    int mcu_rows = (height_ + mcu_height - 1) / mcu_height;
+    
+    // 準備輸出緩衝區
+    image_data_.resize(width_ * height_ * 3);
+    
+    // 儲存 Y, Cb, Cr 分量
+    std::vector<std::vector<uint8_t>> y_data(mcu_rows * mcu_cols);
+    std::vector<std::vector<uint8_t>> cb_data(mcu_rows * mcu_cols);
+    std::vector<std::vector<uint8_t>> cr_data(mcu_rows * mcu_cols);
+    
+    // 解碼所有 MCU
+    int16_t prev_dc[3] = {0, 0, 0};
+    
+    for (int mcu_row = 0; mcu_row < mcu_rows; ++mcu_row) {
+        for (int mcu_col = 0; mcu_col < mcu_cols; ++mcu_col) {
+            int mcu_index = mcu_row * mcu_cols + mcu_col;
+            
+            // 為每個分量解碼區塊
+            for (int comp = 0; comp < num_components_; ++comp) {
+                int h_blocks = components_[comp].h_sample;
+                int v_blocks = components_[comp].v_sample;
+                
+                for (int v = 0; v < v_blocks; ++v) {
+                    for (int h = 0; h < h_blocks; ++h) {
+                        int16_t block[64];
+                        decodeBlock(bs, comp, &prev_dc[comp], block);
+                        
+                        // IDCT
+                        uint8_t pixels[64];
+                        IDCT::transform8x8(block, pixels);
+                        
+                        // 儲存到對應的分量
+                        if (comp == 0) {  // Y
+                            y_data[mcu_index].insert(y_data[mcu_index].end(), pixels, pixels + 64);
+                        } else if (comp == 1) {  // Cb
+                            cb_data[mcu_index].insert(cb_data[mcu_index].end(), pixels, pixels + 64);
+                        } else {  // Cr
+                            cr_data[mcu_index].insert(cr_data[mcu_index].end(), pixels, pixels + 64);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    // Upsampling 和 YCbCr 轉 RGB
+    upsample(y_data, cb_data, cr_data);
+    
+    data_pos_ = scan_data_end;
+    return true;
+}
+
+void JPEGDecoder::decodeBlock(BitStream& bs, int component_id, int16_t* prev_dc, int16_t block[64]) {
+    int16_t dc = huffman_decoder_.decodeDC(bs, components_[component_id].dc_table_id, *prev_dc);
+    *prev_dc = dc;
+    
+    int16_t ac[63];
+    huffman_decoder_.decodeAC(bs, components_[component_id].ac_table_id, ac);
+    
+    // 組合成 64 個係數 (ZigZag 順序)
+    int16_t coeffs[64];
+    coeffs[0] = dc;
+    std::memcpy(coeffs + 1, ac, 63 * sizeof(int16_t));
+    
+    // 反 ZigZag
+    int16_t matrix[64];
+    ZigZag::toMatrix(coeffs, matrix);
+    
+    // 反量化
+    int qt_id = components_[component_id].qt_id;
+    for (int i = 0; i < 64; ++i) {
+        block[i] = matrix[i] * quantization_tables_[qt_id][i];
+    }
+}
+
+void JPEGDecoder::ycbcrToRgb(int y, int cb, int cr, uint8_t& r, uint8_t& g, uint8_t& b) {
+    int r_val = y + 1.402 * (cr - 128);
+    int g_val = y - 0.344136 * (cb - 128) - 0.714136 * (cr - 128);
+    int b_val = y + 1.772 * (cb - 128);
+    
+    r = (r_val < 0) ? 0 : (r_val > 255) ? 255 : r_val;
+    g = (g_val < 0) ? 0 : (g_val > 255) ? 255 : g_val;
+    b = (b_val < 0) ? 0 : (b_val > 255) ? 255 : b_val;
+}
+
+void JPEGDecoder::upsample(const std::vector<std::vector<uint8_t>>& y_blocks,
+                           const std::vector<std::vector<uint8_t>>& cb_blocks,
+                           const std::vector<std::vector<uint8_t>>& cr_blocks) {
+    // 簡化版：假設 4:4:4 或 4:2:0
+    // 這裡實作簡單的 nearest neighbor upsampling
+    
+    if (num_components_ == 1) {
+        // Grayscale
+        for (int row = 0; row < height_; ++row) {
+            for (int col = 0; col < width_; ++col) {
+                int mcu_col = col / 8;
+                int mcu_row = row / 8;
+                int block_x = col % 8;
+                int block_y = row % 8;
+                int mcu_index = mcu_row * ((width_ + 7) / 8) + mcu_col;
+                
+                if (mcu_index < static_cast<int>(y_blocks.size()) && 
+                    !y_blocks[mcu_index].empty()) {
+                    uint8_t y = y_blocks[mcu_index][block_y * 8 + block_x];
+                    int pixel_index = (row * width_ + col) * 3;
+                    image_data_[pixel_index] = y;
+                    image_data_[pixel_index + 1] = y;
+                    image_data_[pixel_index + 2] = y;
+                }
+            }
+        }
+    } else {
+        // YCbCr 轉 RGB
+        for (int row = 0; row < height_; ++row) {
+            for (int col = 0; col < width_; ++col) {
+                int mcu_col = col / 8;
+                int mcu_row = row / 8;
+                int block_x = col % 8;
+                int block_y = row % 8;
+                int mcu_index = mcu_row * ((width_ + 7) / 8) + mcu_col;
+                
+                if (mcu_index < static_cast<int>(y_blocks.size()) &&
+                    !y_blocks[mcu_index].empty()) {
+                    uint8_t y = y_blocks[mcu_index][block_y * 8 + block_x];
+                    uint8_t cb = 128, cr = 128;
+                    
+                    if (!cb_blocks[mcu_index].empty()) {
+                        cb = cb_blocks[mcu_index][block_y * 8 + block_x];
+                    }
+                    if (!cr_blocks[mcu_index].empty()) {
+                        cr = cr_blocks[mcu_index][block_y * 8 + block_x];
+                    }
+                    
+                    uint8_t r, g, b;
+                    ycbcrToRgb(y, cb, cr, r, g, b);
+                    
+                    int pixel_index = (row * width_ + col) * 3;
+                    image_data_[pixel_index] = r;
+                    image_data_[pixel_index + 1] = g;
+                    image_data_[pixel_index + 2] = b;
+                }
+            }
+        }
+    }
+}
+
+} // namespace jpeg
diff --git a/src/cpp/decoder.h b/src/cpp/decoder.h
new file mode 100644
index 0000000..b3e1206
--- /dev/null
+++ b/src/cpp/decoder.h
@@ -0,0 +1,177 @@
+#ifndef DECODER_H
+#define DECODER_H
+
+#include <cstdint>
+#include <vector>
+#include <string>
+#include <memory>
+#include "huffman.h"
+#include "bitstream.h"
+
+namespace jpeg {
+
+/**
+ * JPEGDecoder - JPEG 解碼器主類別
+ * 
+ * 負責整個 JPEG 解碼流程：
+ * 1. 解析文件結構 (markers)
+ * 2. 讀取量化表 (DQT)
+ * 3. 讀取圖像資訊 (SOF)
+ * 4. 讀取霍夫曼表 (DHT)
+ * 5. 解碼圖像資料 (SOS)
+ */
+class JPEGDecoder {
+public:
+    JPEGDecoder();
+    ~JPEGDecoder();
+    
+    /**
+     * 從檔案解碼 JPEG 圖像
+     * 
+     * @param filename JPEG 檔案路徑
+     * @return true 如果成功
+     */
+    bool decodeFile(const std::string& filename);
+    
+    /**
+     * 從記憶體解碼 JPEG 圖像
+     * 
+     * @param data JPEG 資料
+     * @param size 資料大小
+     * @return true 如果成功
+     */
+    bool decodeMemory(const uint8_t* data, size_t size);
+    
+    /**
+     * 取得解碼後的圖像資料（RGB 格式）
+     * 
+     * @return RGB 資料指標（每個像素 3 bytes: R, G, B）
+     */
+    const uint8_t* getImageData() const { return image_data_.data(); }
+    
+    int getWidth() const { return width_; }
+
+    int getHeight() const { return height_; }
+    
+    int getChannels() const { return num_components_; }
+
+private:
+    // JPEG Markers
+    static constexpr uint8_t MARKER_SOI  = 0xD8;  // Start of Image
+    static constexpr uint8_t MARKER_EOI  = 0xD9;  // End of Image
+    static constexpr uint8_t MARKER_SOF0 = 0xC0;  // Start of Frame (Baseline DCT)
+    static constexpr uint8_t MARKER_DHT  = 0xC4;  // Define Huffman Table
+    static constexpr uint8_t MARKER_DQT  = 0xDB;  // Define Quantization Table
+    static constexpr uint8_t MARKER_SOS  = 0xDA;  // Start of Scan
+    static constexpr uint8_t MARKER_DRI  = 0xDD;  // Define Restart Interval
+    static constexpr uint8_t MARKER_APP0 = 0xE0;  // Application Segment 0
+    
+    // 圖像資訊
+    int width_;
+    int height_;
+    int num_components_;  // 1 = grayscale, 3 = YCbCr
+    
+    // 顏色分量資訊
+    struct Component {
+        int id;
+        int h_sample;  // 水平取樣因子
+        int v_sample;  // 垂直取樣因子
+        int qt_id;     // 量化表 ID
+        int dc_table_id;  // DC 霍夫曼表 ID
+        int ac_table_id;  // AC 霍夫曼表 ID
+    };
+    Component components_[3];  // 最多 3 個分量 (Y, Cb, Cr)
+    
+    // 量化表
+    uint16_t quantization_tables_[4][64];
+    bool qt_set_[4];
+    
+    // 霍夫曼解碼器
+    HuffmanDecoder huffman_decoder_;
+    
+    // Restart interval
+    int restart_interval_;
+    
+    // 解碼後的圖像資料 (RGB)
+    std::vector<uint8_t> image_data_;
+    
+    // JPEG 原始資料
+    std::vector<uint8_t> jpeg_data_;
+    size_t data_pos_;
+    
+    /**
+     * 讀取一個 byte
+     */
+    uint8_t readByte();
+    
+    /**
+     * 讀取兩個 bytes (big-endian)
+     */
+    uint16_t readWord();
+    
+    /**
+     * 尋找下一個 marker
+     */
+    uint8_t readMarker();
+    
+    /**
+     * 解析 JPEG 檔案
+     */
+    bool parse();
+    
+    /**
+     * 處理 DQT (Define Quantization Table)
+     */
+    bool processDQT();
+    
+    /**
+     * 處理 SOF0 (Start of Frame - Baseline DCT)
+     */
+    bool processSOF0();
+    
+    /**
+     * 處理 DHT (Define Huffman Table)
+     */
+    bool processDHT();
+    
+    /**
+     * 處理 SOS (Start of Scan)
+     */
+    bool processSOS();
+    
+    /**
+     * 處理 DRI (Define Restart Interval)
+     */
+    bool processDRI();
+    
+    /**
+     * 跳過一個 segment
+     */
+    void skipSegment();
+    
+    /**
+     * 解碼一個 MCU (Minimum Coded Unit)
+     */
+    void decodeMCU(BitStream& bs, int mcu_row, int mcu_col);
+    
+    /**
+     * 解碼一個 8x8 區塊
+     */
+    void decodeBlock(BitStream& bs, int component_id, int16_t* prev_dc, int16_t block[64]);
+    
+    /**
+     * YCbCr 轉 RGB
+     */
+    static void ycbcrToRgb(int y, int cb, int cr, uint8_t& r, uint8_t& g, uint8_t& b);
+    
+    /**
+     * Upsampling (色度子採樣重建)
+     */
+    void upsample(const std::vector<std::vector<uint8_t>>& y_blocks,
+                  const std::vector<std::vector<uint8_t>>& cb_blocks,
+                  const std::vector<std::vector<uint8_t>>& cr_blocks);
+};
+
+} // namespace jpeg
+
+#endif // DECODER_H
diff --git a/src/cpp/huffman.cpp b/src/cpp/huffman.cpp
new file mode 100644
index 0000000..6bf05e0
--- /dev/null
+++ b/src/cpp/huffman.cpp
@@ -0,0 +1,179 @@
+#include "huffman.h"
+#include <stdexcept>
+#include <cstring>
+
+namespace jpeg {
+
+HuffmanTable::HuffmanTable() : built_(false) {
+    std::memset(min_code_, 0, sizeof(min_code_));
+    std::memset(max_code_, 0, sizeof(max_code_));
+    std::memset(val_offset_, 0, sizeof(val_offset_));
+}
+
+void HuffmanTable::build(const uint8_t bits[16], const uint8_t* values) {
+    // 計算總符號數
+    int total_symbols = 0;
+    for (int i = 0; i < 16; ++i) {
+        total_symbols += bits[i];
+    }
+    
+    // 複製符號值
+    symbols_.clear();
+    symbols_.reserve(total_symbols);
+    for (int i = 0; i < total_symbols; ++i) {
+        symbols_.push_back(values[i]);
+    }
+    
+    // 建立霍夫曼表（使用 JPEG 標準算法）
+    int k = 0;
+    uint32_t code = 0;
+    
+    for (int i = 0; i < 16; ++i) {
+        if (bits[i] != 0) {
+            val_offset_[i] = k;
+            min_code_[i] = code;
+            
+            for (int j = 0; j < bits[i]; ++j) {
+                code_to_symbol_[code] = symbols_[k];
+                code++;
+                k++;
+            }
+            
+            max_code_[i] = code - 1;
+        } else {
+            min_code_[i] = 0xFFFFFFFF;
+            max_code_[i] = 0;
+            val_offset_[i] = 0;
+        }
+        
+        code <<= 1;
+    }
+    
+    built_ = true;
+}
+
+uint8_t HuffmanTable::decode(BitStream& bs) const {
+    if (!built_) {
+        throw std::runtime_error("HuffmanTable: table not built");
+    }
+    
+    uint32_t code = 0;
+    
+    // 逐位元讀取，嘗試匹配霍夫曼碼
+    for (int i = 0; i < 16; ++i) {
+        code = (code << 1) | bs.readBits(1);
+        
+        if (code <= max_code_[i] && code >= min_code_[i]) {
+            // 找到匹配的碼
+            int index = val_offset_[i] + (code - min_code_[i]);
+            if (index < static_cast<int>(symbols_.size())) {
+                return symbols_[index];
+            }
+        }
+    }
+    
+    throw std::runtime_error("HuffmanTable: invalid huffman code");
+}
+
+// HuffmanDecoder 實作
+
+void HuffmanDecoder::setTable(int table_id, bool is_ac, const uint8_t bits[16], const uint8_t* values) {
+    if (table_id < 0 || table_id >= 4) {
+        throw std::out_of_range("HuffmanDecoder: table_id must be 0-3");
+    }
+    
+    if (is_ac) {
+        ac_tables_[table_id].build(bits, values);
+    } else {
+        dc_tables_[table_id].build(bits, values);
+    }
+}
+
+const HuffmanTable* HuffmanDecoder::getTable(int table_id, bool is_ac) const {
+    if (table_id < 0 || table_id >= 4) {
+        return nullptr;
+    }
+    
+    if (is_ac) {
+        return ac_tables_[table_id].isBuilt() ? &ac_tables_[table_id] : nullptr;
+    } else {
+        return dc_tables_[table_id].isBuilt() ? &dc_tables_[table_id] : nullptr;
+    }
+}
+
+int16_t HuffmanDecoder::receiveExtend(BitStream& bs, int size) {
+    if (size == 0) {
+        return 0;
+    }
+    
+    // 讀取 size 個 bits
+    int value = bs.readBits(size);
+    
+    // 檢查是否為負數（最高位為 0）
+    int vt = 1 << (size - 1);
+    if (value < vt) {
+        // 負數：需要擴展
+        vt = (-1 << size) + 1;
+        value = value + vt;
+    }
+    
+    return static_cast<int16_t>(value);
+}
+
+int16_t HuffmanDecoder::decodeDC(BitStream& bs, int table_id, int16_t prev_dc) const {
+    const HuffmanTable* table = getTable(table_id, false);
+    if (!table) {
+        throw std::runtime_error("HuffmanDecoder: DC table not found");
+    }
+    
+    // 解碼 DC 差分值的大小
+    uint8_t size = table->decode(bs);
+    
+    // 讀取實際的差分值
+    int16_t diff = receiveExtend(bs, size);
+    
+    // DC 使用差分編碼
+    return prev_dc + diff;
+}
+
+void HuffmanDecoder::decodeAC(BitStream& bs, int table_id, int16_t coeffs[63]) const {
+    const HuffmanTable* table = getTable(table_id, true);
+    if (!table) {
+        throw std::runtime_error("HuffmanDecoder: AC table not found");
+    }
+    
+    // 初始化為 0
+    std::memset(coeffs, 0, 63 * sizeof(int16_t));
+    
+    int k = 0;
+    while (k < 63) {
+        // 解碼 (Run, Size) 對
+        uint8_t rs = table->decode(bs);
+        
+        int run = rs >> 4;    // 高 4 bits 是 run (前面有幾個 0)
+        int size = rs & 0x0F; // 低 4 bits 是 size (係數的 bit 長度)
+        
+        if (size == 0) {
+            if (run == 15) {
+                // ZRL (Zero Run Length): 16 個連續的 0
+                k += 16;
+            } else {
+                // EOB (End of Block): 剩下的都是 0
+                break;
+            }
+        } else {
+            // 跳過 run 個 0
+            k += run;
+            
+            if (k >= 63) {
+                break;
+            }
+            
+            // 讀取 AC 係數
+            coeffs[k] = receiveExtend(bs, size);
+            k++;
+        }
+    }
+}
+
+} // namespace jpeg
diff --git a/src/cpp/huffman.h b/src/cpp/huffman.h
new file mode 100644
index 0000000..aef8209
--- /dev/null
+++ b/src/cpp/huffman.h
@@ -0,0 +1,126 @@
+#ifndef HUFFMAN_H
+#define HUFFMAN_H
+
+#include <cstdint>
+#include <vector>
+#include <map>
+#include "bitstream.h"
+
+namespace jpeg {
+
+/**
+ * HuffmanTable - 霍夫曼表
+ * 
+ * 儲存 JPEG DHT (Define Huffman Table) segment 的資訊
+ * 並提供解碼功能
+ */
+class HuffmanTable {
+public:
+    HuffmanTable();
+    
+    /**
+     * 從 DHT segment 資料建立霍夫曼表
+     * 
+     * @param bits 16 個元素的陣列，bits[i] 表示長度為 i+1 的碼字數量
+     * @param values 所有符號值的陣列
+     */
+    void build(const uint8_t bits[16], const uint8_t* values);
+    
+    /**
+     * 使用此霍夫曼表解碼一個符號
+     * 
+     * @param bs BitStream 物件
+     * @return 解碼出的符號值
+     */
+    uint8_t decode(BitStream& bs) const;
+    
+    /**
+     * 檢查表是否已建立
+     */
+    bool isBuilt() const { return built_; }
+
+private:
+    bool built_;
+    
+    // 霍夫曼碼表：code -> symbol
+    // 為了效率，可以用不同的資料結構，這裡先用簡單的 map
+    std::map<uint32_t, uint8_t> code_to_symbol_;
+    
+    // 每個碼長的最小碼值
+    uint32_t min_code_[16];
+    
+    // 每個碼長的最大碼值
+    uint32_t max_code_[16];
+    
+    // 每個碼長的符號起始索引
+    int val_offset_[16];
+    
+    // 符號值陣列
+    std::vector<uint8_t> symbols_;
+};
+
+/**
+ * HuffmanDecoder - 霍夫曼解碼器
+ * 
+ * 管理多個霍夫曼表（DC 和 AC，可能有多個）
+ */
+class HuffmanDecoder {
+public:
+    /**
+     * 設定霍夫曼表
+     * 
+     * @param table_id 表格 ID (0-3)
+     * @param is_ac true 表示 AC 表，false 表示 DC 表
+     * @param bits 16 個元素的陣列
+     * @param values 符號值陣列
+     */
+    void setTable(int table_id, bool is_ac, const uint8_t bits[16], const uint8_t* values);
+    
+    /**
+     * 取得霍夫曼表
+     * 
+     * @param table_id 表格 ID
+     * @param is_ac true 表示 AC 表，false 表示 DC 表
+     * @return 霍夫曼表的指標
+     */
+    const HuffmanTable* getTable(int table_id, bool is_ac) const;
+    
+    /**
+     * 解碼一個 MCU (Minimum Coded Unit) 的 DC 係數
+     * 
+     * @param bs BitStream 物件
+     * @param table_id 霍夫曼表 ID
+     * @param prev_dc 前一個 DC 值（DC 使用差分編碼）
+     * @return 解碼出的 DC 係數
+     */
+    int16_t decodeDC(BitStream& bs, int table_id, int16_t prev_dc) const;
+    
+    /**
+     * 解碼一個 MCU 的 AC 係數
+     * 
+     * @param bs BitStream 物件
+     * @param table_id 霍夫曼表 ID
+     * @param coeffs 輸出的 63 個 AC 係數（不包含 DC）
+     */
+    void decodeAC(BitStream& bs, int table_id, int16_t coeffs[63]) const;
+    
+private:
+    // DC 表（最多 4 個）
+    HuffmanTable dc_tables_[4];
+    
+    // AC 表（最多 4 個）
+    HuffmanTable ac_tables_[4];
+    
+    /**
+     * 從 BitStream 讀取一個有符號整數
+     * 
+     * @param bs BitStream 物件
+     * @param size bit 數量
+     * @return 解碼的整數值
+     */
+    static int16_t receiveExtend(BitStream& bs, int size);
+};
+
+} // namespace jpeg
+
+#endif // HUFFMAN_H
diff --git a/src/cpp/idct.cpp b/src/cpp/idct.cpp
new file mode 100644
index 0000000..ff6b90a
--- /dev/null
+++ b/src/cpp/idct.cpp
@@ -0,0 +1,97 @@
+#include "idct.h"
+#include <cmath>
+#include <cstring>
+
+namespace jpeg {
+
+// ZigZag 掃描順序表
+const int ZigZag::ZIGZAG_TABLE[64] = {
+     0,  1,  8, 16,  9,  2,  3, 10,
+    17, 24, 32, 25, 18, 11,  4,  5,
+    12, 19, 26, 33, 40, 48, 41, 34,
+    27, 20, 13,  6,  7, 14, 21, 28,
+    35, 42, 49, 56, 57, 50, 43, 36,
+    29, 22, 15, 23, 30, 37, 44, 51,
+    58, 59, 52, 45, 38, 31, 39, 46,
+    53, 60, 61, 54, 47, 55, 62, 63
+};
+
+void ZigZag::toMatrix(const int16_t zigzag[64], int16_t matrix[64]) {
+    for (int i = 0; i < 64; ++i) {
+        matrix[ZIGZAG_TABLE[i]] = zigzag[i];
+    }
+}
+
+void ZigZag::fromMatrix(const int16_t matrix[64], int16_t zigzag[64]) {
+    for (int i = 0; i < 64; ++i) {
+        zigzag[i] = matrix[ZIGZAG_TABLE[i]];
+    }
+}
+
+const int* ZigZag::getZigZagTable() {
+    return ZIGZAG_TABLE;
+}
+
+// IDCT 實作 - Naive 版本使用標準公式
+
+void IDCT::idct1D(const double input[8], double output[8]) {
+    for (int x = 0; x < 8; ++x) {
+        double sum = 0.0;
+        for (int u = 0; u < 8; ++u) {
+            double cu = (u == 0) ? 1.0 / std::sqrt(2.0) : 1.0;
+            sum += cu * input[u] * std::cos((2 * x + 1) * u * PI / 16.0);
+        }
+        output[x] = sum / 2.0;
+    }
+}
+
+void IDCT::transform8x8Float(const int16_t input[64], uint8_t output[64]) {
+    double temp[64];
+    double temp2[64];
+    
+    // 先對每一行做 1D IDCT
+    for (int row = 0; row < 8; ++row) {
+        double row_input[8];
+        double row_output[8];
+        
+        for (int col = 0; col < 8; ++col) {
+            row_input[col] = static_cast<double>(input[row * 8 + col]);
+        }
+        
+        idct1D(row_input, row_output);
+        
+        for (int col = 0; col < 8; ++col) {
+            temp[row * 8 + col] = row_output[col];
+        }
+    }
+    
+    // 再對每一列做 1D IDCT
+    for (int col = 0; col < 8; ++col) {
+        double col_input[8];
+        double col_output[8];
+        
+        for (int row = 0; row < 8; ++row) {
+            col_input[row] = temp[row * 8 + col];
+        }
+        
+        idct1D(col_input, col_output);
+        
+        for (int row = 0; row < 8; ++row) {
+            temp2[row * 8 + col] = col_output[row];
+        }
+    }
+    
+    // Level shift (加 128) 並 clamp 到 0-255
+    for (int i = 0; i < 64; ++i) {
+        int value = static_cast<int>(std::round(temp2[i])) + 128;
+        output[i] = clamp(value);
+    }
+}
+
+void IDCT::transform8x8(const int16_t input[64], uint8_t output[64]) {
+    // 目前使用 float 版本
+    // 之後可以實作更快的整數版本或 SIMD 版本
+    transform8x8Float(input, output);
+}
+
+} // namespace jpeg
diff --git a/src/cpp/idct.h b/src/cpp/idct.h
new file mode 100644
index 0000000..cc68717
--- /dev/null
+++ b/src/cpp/idct.h
@@ -0,0 +1,87 @@
+#ifndef IDCT_H
+#define IDCT_H
+
+#include <cstdint>
+
+namespace jpeg {
+
+/**
+ * IDCT - 反離散餘弦變換 (Inverse Discrete Cosine Transform)
+ * 
+ * 將 8x8 的 DCT 係數矩陣轉換回 8x8 的像素值
+ */
+class IDCT {
+public:
+    /**
+     * 對 8x8 區塊執行 2D IDCT
+     * 
+     * @param input 8x8 的 DCT 係數矩陣 (已反量化)
+     * @param output 8x8 的輸出像素矩陣 (0-255)
+     */
+    static void transform8x8(const int16_t input[64], uint8_t output[64]);
+    
+    /**
+     * 對 8x8 區塊執行 2D IDCT (float 版本，更精確但較慢)
+     * 
+     * @param input 8x8 的 DCT 係數矩陣
+     * @param output 8x8 的輸出矩陣 (會自動進行 level shift 和 clamp)
+     */
+    static void transform8x8Float(const int16_t input[64], uint8_t output[64]);
+
+private:
+    // IDCT 的縮放因子
+    static constexpr double PI = 3.14159265358979323846;
+    
+    /**
+     * 1D IDCT
+     * @param input 8 個輸入係數
+     * @param output 8 個輸出值
+     */
+    static void idct1D(const double input[8], double output[8]);
+    
+    /**
+     * 將值 clamp 到 0-255 範圍
+     */
+    static inline uint8_t clamp(int value) {
+        if (value < 0) return 0;
+        if (value > 255) return 255;
+        return static_cast<uint8_t>(value);
+    }
+};
+
+/**
+ * ZigZag - 處理 ZigZag 掃描順序
+ * 
+ * JPEG 使用 ZigZag 順序來排列 DCT 係數，
+ * 需要將 1D 的 64 個係數重新排列成 8x8 矩陣
+ */
+class ZigZag {
+public:
+    /**
+     * 將 ZigZag 順序的 1D 陣列轉換為 8x8 矩陣
+     * @param zigzag 64 個 ZigZag 順序的係數
+     * @param matrix 8x8 矩陣輸出
+     */
+    static void toMatrix(const int16_t zigzag[64], int16_t matrix[64]);
+    
+    /**
+     * 將 8x8 矩陣轉換為 ZigZag 順序
+     * @param matrix 8x8 矩陣
+     * @param zigzag 64 個 ZigZag 順序的係數輸出
+     */
+    static void fromMatrix(const int16_t matrix[64], int16_t zigzag[64]);
+    
+    /**
+     * 取得 ZigZag 掃描表
+     * @return 64 個位置的對應表
+     */
+    static const int* getZigZagTable();
+
+private:
+    // ZigZag 掃描順序表
+    static const int ZIGZAG_TABLE[64];
+};
+
+} // namespace jpeg
+
+#endif // IDCT_H

From fe70d4b9bd030bd25ab85f12dac851577bd7a1c0 Mon Sep 17 00:00:00 2001
From: 5000user5000 <ck10600760@gmail.com>
Date: Thu, 13 Nov 2025 14:06:02 +0800
Subject: [PATCH 02/11] pybind

---
 src/bindings/bindings.cpp | 87 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 87 insertions(+)
 create mode 100644 src/bindings/bindings.cpp

diff --git a/src/bindings/bindings.cpp b/src/bindings/bindings.cpp
new file mode 100644
index 0000000..3226c61
--- /dev/null
+++ b/src/bindings/bindings.cpp
@@ -0,0 +1,87 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/numpy.h>
+#include "../cpp/decoder.h"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(_fast_jpeg_decoder, m) {
+    m.doc() = "Fast JPEG Decoder - C++ implementation with Python bindings";
+    
+    py::class_<jpeg::JPEGDecoder>(m, "JPEGDecoder")
+        .def(py::init<>())
+        .def("decode_file", &jpeg::JPEGDecoder::decodeFile,
+             py::arg("filename"),
+             "Decode a JPEG file from disk")
+        .def("decode_memory", [](jpeg::JPEGDecoder& self, py::bytes data) {
+                std::string str = data;
+                return self.decodeMemory(
+                    reinterpret_cast<const uint8_t*>(str.data()),
+                    str.size()
+                );
+             },
+             py::arg("data"),
+             "Decode a JPEG from memory (bytes)")
+        .def("get_image_data", [](const jpeg::JPEGDecoder& self) {
+                int width = self.getWidth();
+                int height = self.getHeight();
+                const uint8_t* data = self.getImageData();
+                
+                // 建立 numpy array
+                auto result = py::array_t<uint8_t>({height, width, 3});
+                auto buf = result.request();
+                uint8_t* ptr = static_cast<uint8_t*>(buf.ptr);
+                
+                // 複製資料
+                std::memcpy(ptr, data, width * height * 3);
+                
+                return result;
+             },
+             "Get decoded image data as numpy array (H, W, 3)")
+        .def_property_readonly("width", &jpeg::JPEGDecoder::getWidth,
+                               "Image width")
+        .def_property_readonly("height", &jpeg::JPEGDecoder::getHeight,
+                               "Image height")
+        .def_property_readonly("channels", &jpeg::JPEGDecoder::getChannels,
+                               "Number of color channels");
+    
+    // 解碼檔案並返回 numpy array
+    m.def("decode", [](const std::string& filename) {
+        jpeg::JPEGDecoder decoder;
+        if (!decoder.decodeFile(filename)) {
+            throw std::runtime_error("Failed to decode JPEG file: " + filename);
+        }
+        
+        int width = decoder.getWidth();
+        int height = decoder.getHeight();
+        const uint8_t* data = decoder.getImageData();
+        
+        auto result = py::array_t<uint8_t>({height, width, 3});
+        auto buf = result.request();
+        uint8_t* ptr = static_cast<uint8_t*>(buf.ptr);
+        std::memcpy(ptr, data, width * height * 3);
+        
+        return result;
+    }, py::arg("filename"), "Decode a JPEG file and return as numpy array");
+    
+    m.def("decode_bytes", [](py::bytes data) {
+        std::string str = data;
+        jpeg::JPEGDecoder decoder;
+        if (!decoder.decodeMemory(
+                reinterpret_cast<const uint8_t*>(str.data()),
+                str.size())) {
+            throw std::runtime_error("Failed to decode JPEG from bytes");
+        }
+        
+        int width = decoder.getWidth();
+        int height = decoder.getHeight();
+        const uint8_t* img_data = decoder.getImageData();
+        
+        auto result = py::array_t<uint8_t>({height, width, 3});
+        auto buf = result.request();
+        uint8_t* ptr = static_cast<uint8_t*>(buf.ptr);
+        std::memcpy(ptr, img_data, width * height * 3);
+        
+        return result;
+    }, py::arg("data"), "Decode a JPEG from bytes and return as numpy array");
+}

From 80e6c834f73d227e555ac665dc0711425a39934d Mon Sep 17 00:00:00 2001
From: 5000user5000 <ck10600760@gmail.com>
Date: Thu, 13 Nov 2025 14:06:37 +0800
Subject: [PATCH 03/11] project setting

---
 setup.py                                 | 47 ++++++++++++++
 src/python/fast_jpeg_decoder/__init__.py | 82 ++++++++++++++++++++++++
 2 files changed, 129 insertions(+)
 create mode 100644 setup.py
 create mode 100644 src/python/fast_jpeg_decoder/__init__.py

diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..e112a98
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,47 @@
+"""
+Setup script for Fast JPEG Decoder
+"""
+
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+import sys
+import os
+
+class get_pybind_include:
+    """Helper class to determine the pybind11 include path"""
+    def __str__(self):
+        import pybind11
+        return pybind11.get_include()
+
+ext_modules = [
+    Extension(
+        'fast_jpeg_decoder._fast_jpeg_decoder',
+        sources=[
+            'src/cpp/bitstream.cpp',
+            'src/cpp/idct.cpp',
+            'src/cpp/huffman.cpp',
+            'src/cpp/decoder.cpp',
+            'src/bindings/bindings.cpp',
+        ],
+        include_dirs=[
+            get_pybind_include(),
+            'src/cpp',
+        ],
+        language='c++',
+        extra_compile_args=['-std=c++11', '-O3', '-Wall'],
+    ),
+]
+
+setup(
+    name='fast_jpeg_decoder',
+    version='0.1.0',
+    author='Your Name',
+    description='A high-performance JPEG decoder implemented in C++',
+    long_description='',
+    ext_modules=ext_modules,
+    packages=['fast_jpeg_decoder'],
+    package_dir={'fast_jpeg_decoder': 'src/python/fast_jpeg_decoder'},
+    install_requires=['numpy', 'pybind11>=2.6.0'],
+    python_requires='>=3.6',
+    zip_safe=False,
+)
diff --git a/src/python/fast_jpeg_decoder/__init__.py b/src/python/fast_jpeg_decoder/__init__.py
new file mode 100644
index 0000000..b42bcd5
--- /dev/null
+++ b/src/python/fast_jpeg_decoder/__init__.py
@@ -0,0 +1,82 @@
+"""
+Fast JPEG Decoder
+=================
+
+A high-performance JPEG decoder implemented in C++ with Python bindings.
+
+Usage:
+    >>> import fast_jpeg_decoder as fjd
+    >>> image = fjd.decode('path/to/image.jpg')
+    >>> print(image.shape)  # (height, width, 3)
+    
+    >>> # Or use the decoder class
+    >>> decoder = fjd.JPEGDecoder()
+    >>> decoder.decode_file('path/to/image.jpg')
+    >>> image = decoder.get_image_data()
+"""
+
+try:
+    from ._fast_jpeg_decoder import (
+        JPEGDecoder,
+        decode,
+        decode_bytes
+    )
+except ImportError as e:
+    raise ImportError(
+        "Failed to import C++ extension. "
+        "Please make sure the extension is built. "
+        "Run 'make' to build the extension."
+    ) from e
+
+__version__ = '0.1.0'
+__all__ = ['JPEGDecoder', 'decode', 'decode_bytes']
+
+
+def load(filename):
+    """
+    Load a JPEG image from file.
+    
+    Parameters
+    ----------
+    filename : str
+        Path to the JPEG file
+    
+    Returns
+    -------
+    numpy.ndarray
+        Image data as numpy array with shape (height, width, 3)
+        and dtype uint8. Channels are in RGB order.
+    
+    Examples
+    --------
+    >>> import fast_jpeg_decoder as fjd
+    >>> image = fjd.load('photo.jpg')
+    >>> print(image.shape)
+    (480, 640, 3)
+    """
+    return decode(filename)
+
+
+def load_bytes(data):
+    """
+    Load a JPEG image from bytes.
+    
+    Parameters
+    ----------
+    data : bytes
+        JPEG image data as bytes
+    
+    Returns
+    -------
+    numpy.ndarray
+        Image data as numpy array with shape (height, width, 3)
+        and dtype uint8. Channels are in RGB order.
+    
+    Examples
+    --------
+    >>> import fast_jpeg_decoder as fjd
+    >>> with open('photo.jpg', 'rb') as f:
+    ...     data = f.read()
+    >>> image = fjd.load_bytes(data)
+    """
+    return decode_bytes(data)

From 53221074642c234a43451a7ef5cd243cf8d907cc Mon Sep 17 00:00:00 2001
From: 5000user5000 <ck10600760@gmail.com>
Date: Thu, 13 Nov 2025 14:07:52 +0800
Subject: [PATCH 04/11] =?UTF-8?q?python=20=E6=B8=AC=E8=A9=A6=E5=92=8C?=
 =?UTF-8?q?=E7=AF=84=E4=BE=8B=E8=85=B3=E6=9C=AC=E4=BB=A5=E5=8F=8A=E7=B7=A8?=
 =?UTF-8?q?=E8=AD=AF=E8=85=B3=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Makefile              |  82 +++++++++++++++++++++
 example.py            |  69 ++++++++++++++++++
 pytest.ini            |   6 ++
 tests/test_decoder.py | 166 ++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 323 insertions(+)
 create mode 100644 Makefile
 create mode 100755 example.py
 create mode 100644 pytest.ini
 create mode 100644 tests/test_decoder.py

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..1b7c7ab
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,82 @@
+# Makefile for Fast JPEG Decoder
+
+# Compiler settings
+CXX = g++
+CXXFLAGS = -std=c++11 -O3 -Wall -fPIC
+INCLUDES = -Isrc/cpp
+
+# Python settings
+PYTHON = python3
+PYTHON_CONFIG = python3-config
+PYTHON_INCLUDES = $(shell $(PYTHON_CONFIG) --includes)
+PYTHON_LDFLAGS = $(shell $(PYTHON_CONFIG) --ldflags)
+
+# pybind11 settings
+PYBIND11_INCLUDES = $(shell $(PYTHON) -m pybind11 --includes)
+
+# Source files
+CPP_SOURCES = src/cpp/bitstream.cpp \
+              src/cpp/idct.cpp \
+              src/cpp/huffman.cpp \
+              src/cpp/decoder.cpp
+
+BINDING_SOURCES = src/bindings/bindings.cpp
+
+# Object files
+CPP_OBJECTS = $(CPP_SOURCES:.cpp=.o)
+BINDING_OBJECTS = $(BINDING_SOURCES:.cpp=.o)
+
+# Output
+EXTENSION_SUFFIX = $(shell $(PYTHON_CONFIG) --extension-suffix)
+TARGET = src/python/fast_jpeg_decoder/_fast_jpeg_decoder$(EXTENSION_SUFFIX)
+
+# Targets
+.PHONY: all clean install test develop
+
+all: $(TARGET)
+
+# Build Python extension
+$(TARGET): $(CPP_OBJECTS) $(BINDING_OBJECTS)
+	$(CXX) -shared -fPIC $(CXXFLAGS) $^ -o $@ $(PYTHON_LDFLAGS)
+
+# Build C++ objects
+src/cpp/%.o: src/cpp/%.cpp
+	$(CXX) $(CXXFLAGS) $(INCLUDES) -c $< -o $@
+
+# Build binding objects
+src/bindings/%.o: src/bindings/%.cpp
+	$(CXX) $(CXXFLAGS) $(INCLUDES) $(PYTHON_INCLUDES) $(PYBIND11_INCLUDES) -c $< -o $@
+
+# Install package
+install: all
+	$(PYTHON) setup.py install
+
+# Develop mode (editable install)
+develop: all
+	$(PYTHON) -m pip install -e .
+
+# Run tests
+test: develop
+	$(PYTHON) -m pytest tests/ -v
+
+# Clean build artifacts
+clean:
+	rm -f $(CPP_OBJECTS) $(BINDING_OBJECTS)
+	rm -f $(TARGET)
+	rm -rf build/ dist/ *.egg-info
+	rm -rf src/python/fast_jpeg_decoder/*.so
+	rm -rf src/python/fast_jpeg_decoder/*.pyd
+	find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true
+	find . -type f -name "*.pyc" -delete
+
+# Help
+help:
+	@echo "Fast JPEG Decoder - Makefile"
+	@echo ""
+	@echo "Targets:"
+	@echo "  all      - Build the Python extension (default)"
+	@echo "  install  - Install the package"
+	@echo "  develop  - Install in development mode (editable)"
+	@echo "  test     - Run tests"
+	@echo "  clean    - Remove build artifacts"
+	@echo "  help     - Show this help message"
diff --git a/example.py b/example.py
new file mode 100755
index 0000000..2328640
--- /dev/null
+++ b/example.py
@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""
+範例：使用 Fast JPEG Decoder 解碼 JPEG 圖片
+"""
+
+import sys
+import os
+import numpy as np
+
+# Add src/python to path for development
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src', 'python'))
+
+try:
+    import fast_jpeg_decoder as fjd
+except ImportError:
+    print("Error: fast_jpeg_decoder 模組未安裝")
+    print("請先執行: make develop")
+    sys.exit(1)
+
+
+def main():
+    """主函數"""
+    if len(sys.argv) < 2:
+        print("用法: python example.py <jpeg_file>")
+        print("\n範例:")
+        print("  python example.py photo.jpg")
+        return
+    
+    filename = sys.argv[1]
+    
+    print(f"正在解碼: {filename}")
+    
+    try:
+        # 方法 1: 使用簡便函數
+        image = fjd.load(filename)
+        print(f"✓ 解碼成功!")
+        print(f"  圖片尺寸: {image.shape[1]} x {image.shape[0]}")
+        print(f"  通道數: {image.shape[2]}")
+        print(f"  資料類型: {image.dtype}")
+        print(f"  數值範圍: [{image.min()}, {image.max()}]")
+        
+        # 方法 2: 使用 Decoder 類別
+        print("\n使用 Decoder 類別:")
+        decoder = fjd.JPEGDecoder()
+        success = decoder.decode_file(filename)
+        
+        if success:
+            print(f"✓ 解碼成功!")
+            print(f"  寬度: {decoder.width}")
+            print(f"  高度: {decoder.height}")
+            print(f"  通道: {decoder.channels}")
+            
+            image2 = decoder.get_image_data()
+            
+            # 驗證兩種方法得到相同結果
+            if np.array_equal(image, image2):
+                print("\n✓ 兩種方法結果一致")
+            else:
+                print("\n✗ 兩種方法結果不同")
+        
+    except Exception as e:
+        print(f"✗ 解碼失敗: {e}")
+        return 1
+    
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/pytest.ini b/pytest.ini
new file mode 100644
index 0000000..9855d94
--- /dev/null
+++ b/pytest.ini
@@ -0,0 +1,6 @@
+[pytest]
+testpaths = tests
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+addopts = -v --tb=short
diff --git a/tests/test_decoder.py b/tests/test_decoder.py
new file mode 100644
index 0000000..1578884
--- /dev/null
+++ b/tests/test_decoder.py
@@ -0,0 +1,166 @@
+"""
+Unit tests for Fast JPEG Decoder
+"""
+
+import pytest
+import numpy as np
+import os
+import sys
+
+# Add src to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src', 'python'))
+
+try:
+    import fast_jpeg_decoder as fjd
+except ImportError:
+    pytest.skip("Extension not built yet", allow_module_level=True)
+
+
+class TestJPEGDecoder:
+    """Test cases for JPEG decoder"""
+    
+    def test_decoder_creation(self):
+        """Test that decoder can be created"""
+        decoder = fjd.JPEGDecoder()
+        assert decoder is not None
+    
+    def test_load_function_exists(self):
+        """Test that load function exists"""
+        assert hasattr(fjd, 'load')
+        assert hasattr(fjd, 'decode')
+    
+    def test_decoder_methods(self):
+        """Test that decoder has required methods"""
+        decoder = fjd.JPEGDecoder()
+        assert hasattr(decoder, 'decode_file')
+        assert hasattr(decoder, 'decode_memory')
+        assert hasattr(decoder, 'get_image_data')
+        assert hasattr(decoder, 'width')
+        assert hasattr(decoder, 'height')
+        assert hasattr(decoder, 'channels')
+    
+    @pytest.mark.skipif(
+        not os.path.exists('tests/test_data'),
+        reason="Test data directory not found"
+    )
+    def test_decode_sample_image(self):
+        """Test decoding a sample JPEG image"""
+        # This test requires a sample JPEG image in tests/test_data/
+        test_image_path = 'tests/test_data/sample.jpg'
+        
+        if not os.path.exists(test_image_path):
+            pytest.skip("Sample image not found")
+        
+        # Test using load function
+        image = fjd.load(test_image_path)
+        
+        # Check that result is a numpy array
+        assert isinstance(image, np.ndarray)
+        
+        # Check shape (should be H x W x 3)
+        assert len(image.shape) == 3
+        assert image.shape[2] == 3
+        
+        # Check dtype
+        assert image.dtype == np.uint8
+        
+        # Check that values are in valid range
+        assert np.all(image >= 0)
+        assert np.all(image <= 255)
+    
+    @pytest.mark.skipif(
+        not os.path.exists('tests/test_data'),
+        reason="Test data directory not found"
+    )
+    def test_decoder_class(self):
+        """Test using decoder class directly"""
+        test_image_path = 'tests/test_data/sample.jpg'
+        
+        if not os.path.exists(test_image_path):
+            pytest.skip("Sample image not found")
+        
+        decoder = fjd.JPEGDecoder()
+        success = decoder.decode_file(test_image_path)
+        
+        assert success is True
+        assert decoder.width > 0
+        assert decoder.height > 0
+        assert decoder.channels in [1, 3]
+        
+        image = decoder.get_image_data()
+        assert isinstance(image, np.ndarray)
+        assert image.shape == (decoder.height, decoder.width, 3)
+    
+    def test_invalid_file(self):
+        """Test that invalid file raises appropriate error"""
+        with pytest.raises((RuntimeError, Exception)):
+            fjd.load('nonexistent_file.jpg')
+    
+    def test_decode_bytes(self):
+        """Test decoding from bytes"""
+        test_image_path = 'tests/test_data/sample.jpg'
+        
+        if not os.path.exists(test_image_path):
+            pytest.skip("Sample image not found")
+        
+        with open(test_image_path, 'rb') as f:
+            data = f.read()
+        
+        image = fjd.load_bytes(data)
+        assert isinstance(image, np.ndarray)
+        assert len(image.shape) == 3
+
+
+class TestImageProperties:
+    """Test image properties and correctness"""
+    
+    @pytest.mark.skipif(
+        not os.path.exists('tests/test_data'),
+        reason="Test data directory not found"
+    )
+    def test_image_dimensions(self):
+        """Test that decoded image has correct dimensions"""
+        test_image_path = 'tests/test_data/sample.jpg'
+        
+        if not os.path.exists(test_image_path):
+            pytest.skip("Sample image not found")
+        
+        decoder = fjd.JPEGDecoder()
+        decoder.decode_file(test_image_path)
+        
+        # Width and height should be positive
+        assert decoder.width > 0
+        assert decoder.height > 0
+        
+        # Get image data
+        image = decoder.get_image_data()
+        
+        # Check that numpy array matches reported dimensions
+        assert image.shape[0] == decoder.height
+        assert image.shape[1] == decoder.width
+    
+    @pytest.mark.skipif(
+        not os.path.exists('tests/test_data'),
+        reason="Test data directory not found"
+    )
+    def test_rgb_channels(self):
+        """Test that image has correct RGB channel order"""
+        test_image_path = 'tests/test_data/sample.jpg'
+        
+        if not os.path.exists(test_image_path):
+            pytest.skip("Sample image not found")
+        
+        image = fjd.load(test_image_path)
+        
+        # Should have 3 channels for RGB
+        assert image.shape[2] == 3
+        
+        # Each channel should have valid values
+        for channel in range(3):
+            channel_data = image[:, :, channel]
+            assert channel_data.min() >= 0
+            assert channel_data.max() <= 255
+
+
+if __name__ == '__main__':
+    pytest.main([__file__, '-v'])

From 67c498f5c6dbc03c7007aac497dfa3c79bfff808 Mon Sep 17 00:00:00 2001
From: 5000user5000 <ck10600760@gmail.com>
Date: Thu, 13 Nov 2025 14:08:11 +0800
Subject: [PATCH 05/11] ignore build files

---
 .gitignore | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 .gitignore

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..a93dc29
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,38 @@
+
+# C++ build artifacts
+*.o
+*.so
+*.a
+*.dylib
+
+# Python build artifacts
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.egg-info/
+dist/
+build/
+*.egg
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Test images
+*.jpg
+*.jpeg
+*.png
+# !tests/test_data/*.jpg
+# !tests/test_data/*.jpeg
+# !tests/test_data/*.png
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Documentation
+info.md
\ No newline at end of file

From 8e329315e86a2e92c9706116fddaccb97a1015d3 Mon Sep 17 00:00:00 2001
From: 5000user5000 <ck10600760@gmail.com>
Date: Thu, 13 Nov 2025 14:08:27 +0800
Subject: [PATCH 06/11] doc

---
 README.md       | 108 +++++++++++++++++++++++++++++++++++++++++++++++-
 tests/README.md |  36 ++++++++++++++++
 2 files changed, 143 insertions(+), 1 deletion(-)
 create mode 100644 tests/README.md

diff --git a/README.md b/README.md
index 5295477..277dd5b 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,108 @@
-# Fast-Jpeg-Decoder
+# Fast JPEG Decoder
 視訊壓縮期末專案
+
+高效能 JPEG 解碼器，核心計算使用 C++ 實現，透過 pybind11 提供 Python API。
+
+## 特點
+
+- **高效能**: 核心解碼邏輯使用 C++ 實現
+- **易用性**: 提供簡潔的 Python API
+- **正確性**: 完整實現 JPEG Baseline DCT 解碼流程
+- **可擴展**: 模組化設計，便於後續優化（OpenMP, SIMD）
+
+## 安裝
+
+### 依賴
+
+- Python 3.6+
+- NumPy
+- pybind11
+- C++ 編譯器（支援 C++11）
+
+### 從原始碼安裝
+
+```bash
+# 安裝依賴
+pip install numpy pybind11
+
+# 編譯並安裝
+make develop
+```
+
+## 使用方法
+
+### 基本用法
+
+```python
+import fast_jpeg_decoder as fjd
+
+# 從檔案載入 JPEG 圖片
+image = fjd.load('photo.jpg')
+print(image.shape)  # (height, width, 3)
+
+# 從 bytes 載入
+with open('photo.jpg', 'rb') as f:
+    data = f.read()
+image = fjd.load_bytes(data)
+```
+
+### 使用 Decoder 類別
+
+```python
+import fast_jpeg_decoder as fjd
+
+decoder = fjd.JPEGDecoder()
+decoder.decode_file('photo.jpg')
+
+print(f"Width: {decoder.width}")
+print(f"Height: {decoder.height}")
+print(f"Channels: {decoder.channels}")
+
+image = decoder.get_image_data()
+```
+
+## 測試
+
+```bash
+# 運行測試
+make test
+
+# 或直接使用 pytest
+pytest tests/ -v
+```
+
+## 專案結構
+
+```
+Fast-Jpeg-Decoder/
+├── src/
+│   ├── cpp/              # C++ 核心實現
+│   ├── bindings/         # pybind11 綁定
+│   └── python/           # Python 包裝
+├── tests/                # 單元測試
+├── benchmarks/           # 效能測試
+├── Makefile              # 建構腳本
+└── setup.py              # Python 安裝腳本
+```
+
+## JPEG 解碼流程
+
+1. 解析文件結構（Markers）
+2. 霍夫曼解碼（Bitstream）
+3. RLE 解碼
+4. 反 ZigZag 排序
+5. 反量化（Dequantization）
+6. 反離散餘弦變換（IDCT）
+7. 取樣重建（Upsampling）
+8. 色彩空間轉換（YCbCr → RGB）
+
+## 開發計劃
+
+- [x] Phase 1: 基礎實現（Naive 版本）
+- [ ] Phase 2: CI/CD
+- [ ] Phase 3: 效能優化（OpenMP, SIMD）
+- [ ] Phase 4: 基準測試與比較
+
+## License
+
+MIT License
diff --git a/tests/README.md b/tests/README.md
new file mode 100644
index 0000000..c2fe0ad
--- /dev/null
+++ b/tests/README.md
@@ -0,0 +1,36 @@
+# 測試資料
+
+## 準備測試圖片
+
+在運行測試之前，請在 `tests/test_data/` 目錄下放置一個測試用的 JPEG 圖片，命名為 `sample.jpg`。
+
+### 使用 Python PIL 生成簡單測試圖片
+
+```python
+from PIL import Image
+import numpy as np
+
+# 創建一個簡單的測試圖片
+width, height = 640, 480
+img = np.random.randint(0, 256, (height, width, 3), dtype=np.uint8)
+Image.fromarray(img).save('tests/test_data/sample.jpg', 'JPEG', quality=90)
+```
+
+### 或使用現有的 JPEG 圖片
+
+```bash
+cp /path/to/your/image.jpg tests/test_data/sample.jpg
+```
+
+## 運行測試
+
+```bash
+# 確保先編譯擴展
+make develop
+
+# 運行所有測試
+make test
+
+# 或使用 pytest
+pytest tests/ -v
+```

From c1476fe4792fa00390f6efd5c9a05fe0add8c723 Mon Sep 17 00:00:00 2001
From: 5000user5000 <ck10600760@gmail.com>
Date: Thu, 13 Nov 2025 14:18:06 +0800
Subject: [PATCH 07/11] create CI

---
 .github/workflows/ci.yml | 80 ++++++++++++++++++++++++++++++++++++++++
 README.md                |  3 ++
 pyproject.toml           | 27 ++++++++++++++
 3 files changed, 110 insertions(+)
 create mode 100644 .github/workflows/ci.yml
 create mode 100644 pyproject.toml

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..91ce952
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,80 @@
+name: CI
+
+on:
+  push:
+    branches: [ main, develop, feature/* ]
+  pull_request:
+    branches: [ main, develop ]
+
+jobs:
+  test:
+    name: Test with Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.8', '3.9', '3.10', '3.11', '3.12']
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Install system dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y build-essential g++
+
+    - name: Install Python dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install numpy pybind11 pytest pillow
+
+    - name: Build C++ extension
+      run: |
+        make clean
+        make all
+
+    - name: Create test image
+      run: |
+        python -c "from PIL import Image; import numpy as np; img = np.random.randint(0, 256, (64, 64, 3), dtype=np.uint8); Image.fromarray(img).save('tests/test_data/sample.jpg', 'JPEG', quality=90)"
+
+    - name: Run tests
+      run: |
+        python -m pytest tests/ -v --tb=short
+
+    - name: Test import
+      run: |
+        python -c "import sys; sys.path.insert(0, 'src/python'); import fast_jpeg_decoder as fjd; print('Import successful'); print('Version:', fjd.__version__)"
+
+  build-check:
+    name: Build Check
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install numpy pybind11
+
+    - name: Build extension
+      run: |
+        make clean
+        make all
+
+    - name: Check build artifacts
+      run: |
+        ls -lh src/python/fast_jpeg_decoder/_fast_jpeg_decoder*.so
diff --git a/README.md b/README.md
index 277dd5b..d5d0ca6 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,7 @@
 # Fast JPEG Decoder
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 視訊壓縮期末專案
 
 高效能 JPEG 解碼器，核心計算使用 C++ 實現，透過 pybind11 提供 Python API。
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..655bbde
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=45", "wheel", "pybind11>=2.6.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fast_jpeg_decoder"
+version = "0.1.0"
+description = "A high-performance JPEG decoder implemented in C++"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "numpy",
+    "pybind11>=2.6.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pillow",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = "-v --tb=short"

From a19d0e7df123d5b2a258b6896476a9da699141a3 Mon Sep 17 00:00:00 2001
From: 5000user5000 <ck10600760@gmail.com>
Date: Thu, 13 Nov 2025 14:20:06 +0800
Subject: [PATCH 08/11] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=20py=20=E7=89=88?=
 =?UTF-8?q?=E6=9C=AC=20(=E5=AF=A6=E9=9A=9B=E6=B8=AC=E8=A9=A6=20py=203.8~3.?=
 =?UTF-8?q?12)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index d5d0ca6..58cf2b4 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@
 
 ### 依賴
 
-- Python 3.6+
+- Python 3.8+
 - NumPy
 - pybind11
 - C++ 編譯器（支援 C++11）
@@ -102,7 +102,7 @@ Fast-Jpeg-Decoder/
 ## 開發計劃
 
 - [x] Phase 1: 基礎實現（Naive 版本）
-- [ ] Phase 2: CI/CD
+- [x] Phase 2: CI/CD
 - [ ] Phase 3: 效能優化（OpenMP, SIMD）
 - [ ] Phase 4: 基準測試與比較
 

From 10b1219edf0d215b77c07818dd0b0971e653b82a Mon Sep 17 00:00:00 2001
From: 5000user5000 <ck10600760@gmail.com>
Date: Thu, 13 Nov 2025 14:20:19 +0800
Subject: [PATCH 09/11] =?UTF-8?q?=E4=B8=8A=E5=82=B3=E6=B8=AC=E8=A9=A6?=
 =?UTF-8?q?=E8=B3=87=E6=96=99?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .gitignore                 |   6 +++---
 tests/test_data/sample.jpg | Bin 0 -> 1167 bytes
 2 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 tests/test_data/sample.jpg

diff --git a/.gitignore b/.gitignore
index a93dc29..9762dcb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -26,9 +26,9 @@ build/
 *.jpg
 *.jpeg
 *.png
-# !tests/test_data/*.jpg
-# !tests/test_data/*.jpeg
-# !tests/test_data/*.png
+!tests/test_data/*.jpg
+!tests/test_data/*.jpeg
+!tests/test_data/*.png
 
 # OS
 .DS_Store
diff --git a/tests/test_data/sample.jpg b/tests/test_data/sample.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..5cba5d15026c3c570c36d29180a91a4bebd91a59
GIT binary patch
literal 1167
zcmex=<NpH&0WUXCHwH#V1_nkTWcYuZ!I^=Xi3x;&fCY$HIapa)SXjB(+1WUFxOjND
zxwyG``Gf>``2_j6xdp@o1cgOJMMZh|#U;c<B!omnML>oyG6VInuyV4pa*FVB^NNrR
z{vTiv<X~`MaA0OsVqg+vWEN!ne}q9E=uTEfFkpZJMkb&e+1NQaxwwG}whAyXF)}kV
zu`q*N4OCqVlxJWOWEE00bYv3_Ok`Io6ftU?xR68HY2!iBpo<?=jFXC*IJv~cB_yR(
z)zmdKwM<OS%q=XfoLyYq+&w(Kf<r>X!XqN1l2cOC(lau%ic3n%$}1|Xnp;}i+B-VC
zCQY6)b=ve9GiNPYykzOJ<ttXM+O&Dg)@|E&?A&$e@R6g(j-NPr>eA&aSFc^aar4&0
zM~|O8efIpt%U2&ieg5+G+xH(oe}VkP$iNKo7LbH^49#DHKz}i@urRZ*gZ#zFR1U<<
zf-J0xhHOHPf$WKe!b(Ps93oB=7j8VrscandK{To8BA1wo$wSqTAg_UaMx4i*$nqK7
zV+eoUV&GwB1V$dSAcH-_pAVPTS{26jP0jpXv8Gn*@^aCenPKzGyZ*Ht3%m2F@MqpH
zX{*rXcOUK6)w=xdW5g{Od%5U`AE$25pOgIQ?iaI?)&9GWmPLgw_tTd4+VT?0e7JGy
zc6*C6MqmYgbHY=XM%CWKP+)%i>FyVGu`k2sTC6(`(wq!to(3`N-5zV_)i0g#XL~Jg
zFW7A$xiz^^XU?@)-wt%;pZoID-Y?v|G^zyb%H^WHFy_0D@w`22cm6z<h^zqQ4PUsI
zAS(9R>)v<%^d9VZpnv_e<zfD~`)L1SkVh_^sf*s%c5Z6s<*qkdK>kh6Gy{ecgk581
zwC(wG36MMIssY0(b{aT5fewYS*SCRPYH+&z!p%!-?cPI!`4|%WM@?$(`E!QAAeWzB
z1#-hiuw*}yZ!XRNhWX1lkYm%mw*20M2va!w;YU!Yg90_@B`6|cjs=A;I8Y&Om25-u
bjo+LwGqA_LfIL=X2lULdA3)FW|Gx<U-p2Vd

literal 0
HcmV?d00001


From 7f18fdb8f291584d8f2f692f144b2e5010631f84 Mon Sep 17 00:00:00 2001
From: 5000user5000 <ck10600760@gmail.com>
Date: Fri, 21 Nov 2025 14:56:11 +0800
Subject: [PATCH 10/11] =?UTF-8?q?=E6=96=B0=E6=B8=AC=E8=A9=A6=E8=B3=87?=
 =?UTF-8?q?=E6=96=99?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/test_data/lena.jpg | Bin 0 -> 106738 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 tests/test_data/lena.jpg

diff --git a/tests/test_data/lena.jpg b/tests/test_data/lena.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..7e83c443702a1525adc1ac0597ed9c95f4f8b862
GIT binary patch
literal 106738
zcmb5VcTiK^7dDzefP`jf(ltOR34+oER0uT*k&=X71Oe$tRl!CV5HN%ULJvr2(z^(X
zh)NUbAVme~LF$X5fL?$1&Yk)G{hl*(=A5(3dd}=Ud(D2<+JC42eg#0WCKwX{5C{MO
z|6PE;vj9T?E6e}zzdP$cfY?F*1DKtijU58!<b;4B5Kit>+?-szTo4Ek9}n*-D3lM%
z$;~go4;A?L4E<jx!2h*m1%dxHgmOW+{(b$w#NRFeAD9Ke0$>I50a*BetbD+~Jpjpn
zJlTN%0QmpG_KzS3m<0%c{42&m0YFw35Gxxyh>eAf70Av3WMSn4fY|t@RM=5g90JmA
z!GfyM=|wx>`qv{uG6whswcXS3>mf0Q<YHlntem=01A*x75!*fbuQzcZfQ9w{wDrGN
z5F0yy<6q$wzW>h@J3A|Yg#`%uN9!L=Rw)p_3X08Y=YN)>>s8Z>UXLsY%IvZmsNvy4
z*F%a=s~Zv;7XQuwxLN<-`g{OAK=b&b+Rftd-(p|CSUSGGznh{;ejWiUC+Xvf9K)k?
zyD}3{x1feVW<`JMsf34-HTy6SuGFK3Ga*R+j^Miv?)gv`9&LjNk2(n@l85Q~ktLcZ
zt-WDCE}QwVU)L8LpueAkt=YjE@>v>k7Ce6$Q}l#8sGz10XGTT6uVvt*NJ80Q*!twd
zV8=ri-6Cgc)+bk9_UG}o<Tff=v=Ls}C9kdiUa-0=;gaH@r0kn&fGfPZ@oba!F4H&b
z6s%J^oC7@-S*d|LccIg)7onn?sy&tGUxqyJ!;X{lqvW@jU6eVDf$^nljO4iZ0LVaX
zMdh}%lsHhVIP-hCYC6Z8Ok9|d^Ac;=6y#o6Y8z=!5H+GLGej*naWEq=NT?WY@Dqa3
z6acbgfFcRsyhx2PTCbU-+vb0!?V7op83}b^qa6}qLg-(GpW{aq@*q#(PdUL<g`Vhv
z-Vqj%g^kNOdGi{IHy~Znys)n5G=I|1kRt<dI%52|5*S4Q=L@GPNTLdEXxl!H))zsw
z?*_`cAp}ZNTT2DR=)E^0KOrTs7~MV&i+E+oE2pWbCS~H{CCs3P+WJ+WHVM*c@~G_-
zGQJo%;%V9|Qc5JtOekeWe<kJ7<5|GO?1RdspZoHJ)A7?pRU#@{WwjQm_AniLI&w)#
zHh7G%gb0*TtveM)d3A@sc!3?5@n8AlA}s)XlrDk!^O5hr;!;C@tBd?&i=8hmgH~~y
z>Z{G7Fz7veta+01uHs<a$H#d-j0id@br_<UnTI9D3)I;nrOxz9jDnQKiK|3D?N`Vj
z`yV2Cy}6d}ri(2<89S%|Nyk!yh<xyU)|-#M6E1IcK($L6bmn=(q9AZA0TlX7Nj38b
ztY5Fk&#A9!qaFG0KeIq7@$`PJ?wc*Fei<Op@r`m@A5ErpP&(*fVj?T9jT~pRb&6qK
zF27bu6jqpxL&S=$pRFdO6xp&kaf-!J49pkdk+unS)$Kna#5Pr&B))Jmo2I{aT=ckR
z-qMN-&}F-fEng2iti5pC{k1eOugt>1#TB!A{PeMMV*e*jm}p^t(F_~=7Ky@z@h^?E
zQlH_^8<kXSC2~c$#sI}eUKl`|T!_quL4yh9%l>6j-Bq8=cln6H`dKT}Cw=x3<{1q!
zHD=ZfH0ky@9>rGo{5=@?^7}K6mv1lnuAdHwFE6r`?=Ot4oUwi#^6E{2xFz<@>sF<k
z`7LcI!$hLO8B5fOV*7{u=eb4HarIQsGj2VJRyqJkWuUf)d_7}0PsA||TEr#hx62Se
z{tMuAoM(Nlu$|Nt7jyr6$NK9x7NCw2e(Wv+Pf6#i`>%3qD-k*CtDeoY%>3zQ>Pos|
zl>J{V2Y0XD8i#|j@+EH<XOH*&NMM^nd?~)y4sSz{cQJ?<liP{AKzi;#bQs1l^?qGN
zl<F|aTD-fs@89#SuyjBSFhiX4mMi?%3Gq_+2E)l}_L|r6<?b!Ftm(?Euz;hQ^^$mr
zuE_Of=|b+F#SPZ0Ei2{Y<^AWC?{*O9Q7BP-RawMdmH(&6JzFt=)-@&jq|cnKdWDnp
zHnKrNV*9cc6eE54f%RgT5ilFWkahGe_7Hm{AXZ-2fOs@h0pP!G-sxi@ix>jaU94*M
z2RC(+35~$}k<67$?xN|&H3AnpuSet{IXOTr+?TQft>o1R_G|{=8GBO!Ex&Dk0LTWN
zmWB{!xMelmsfsLxykeBRF8@5-=*24!hj9c3V-;8F%7UK7R_!A`ERFwCs>C-}t+3oj
zz<6v6PNJN&r7#9W)py_WhHEvu(e1yQE6&Txc>rkey!uhP2(+Y0y!glSP@2tB(xr-<
z5eAbpy^WlM>bP`zY{%%}wbv?LTZDJ}Xi9lG>pI`jguBd$Y7c52`6&@57?;|$diJ41
zlJW!}OSqZLTTXlvjFzl4ng?^V9*uD~e3e};d?8slQC=H%RQy11+fbMQ&`_93#&eQy
zu&4i=S~u1?&nGv~L@vQ50ybrssKu1WpMr=uDS3tAkA}O&?6@Krt2DD1tuH1Rqd!Kd
zJzqGP^iEKN-shAufOitJK%`kKu|<4BMLm}$RKPI0OxA0&*#Ag4@8WZvQ2+=WH5aP$
z=V0;rGAhsy{`fjJQOEqfLySkUcY`G&2<XtRzr0hC%})^-{+i*VBTz0dwO|GX;({_j
zWxx^&S&$(x#uN;d)rW)9F+dbj1`#`|_qh{*;DtNihnEU1?(7}?SBnCgo@8;M0fPBM
zyJG1F#j&0sCgP%jkpKrtqP3Rmajhu(K-Y|Utmd%mW`q^wLI)1xQl=U$du5A0v{*FK
z9!-y5%%xO#V5GGQs7jz|1)b9KMOf`|20*_1wyt&NPrOA0dz+7$y*|i?mfrL*QGKOJ
zM2fY*K{;po<uk<|P$5M6-YW;Ky2}kj4r6NJo2kwtgo8CK@k!Q~?#5?o2q`{564K4P
z?we;Lpdj3UkzBJ9g}SEgTWn62hDVO_)+Ju_ePPJv4MeHwe{~=Zkvg4Q3=7r61hu0t
zSn)_{IfS1Da*Waqq>7jIy(vd;FhZMiQ&Do*WnVn@hP2L2qc`$3)nUpvW#8TFV}p<3
z(mmQ@!(K`z>BcQ8eNjh)b$*o<P*0U*$HyZ!g&axMtliTCcc>ZXrCe9hYW4)mvLfZJ
zrTS+B-MbzWCpq8eaPja|W1z=crN(lCjr#Z1#;L=b;x;PYeODVd;wh=Xg7ER3Jgdr~
zzIV*Zu0?U{x^U}GMju)<Phd#ze6`QG_qY-=#NPlZ!8TauMLP_@u&~IR^cnTX(bss(
z%pZh_wkRad`M$iVY7w_Cr#@%lkn!0F=a@rKu?gOQ=-|ZoRr3XtV6wcfY5?xU!*F_%
z3AbP+KfQ!;1@Rg6<)A#bt0A3bW&Mp3`*2y!B?Tjl&4?vVpOeeP582pMGhVgx<<Ht{
zWs<V<4gz~c@ORG4!ko%s%vpkQe%iZM?ryezdSK1gu3}kW;8eb^m8{XPjNU1ScP*s;
zw?o9rjWU&q2Pw2Gtk0*gzXWQO+jrFvMkP3syZ7w3UwHbw`RhAPaU_0jRyeE4<lE$=
z`THK}c~Dq}xMV6{U8{}3FNLnmQ4*cS19z{oK1&>KN6rWy<wp<q@OX#BTzd37wN&a<
zPo|T1)xY(=ka__Odm?m$Bqn6Ho57taxqbJmfEv|6eNUq`+WYLrebX1`8b1-9Vehv9
z+1VS53OoJon)H`TU}BOT<?MO*iuGYeL(Ny;nODx<?OaT(#`sJ~nF~=w1~XuMr3H?o
zJ*;3aUBmdY+8m?uM8r+4xTB}~m;MN8XSKHPLPW<XLh=<lrf;^fg8CV?&b}#*f(8a5
z<+Qo~7#D%XnfW6oSrjY;0!x<*W18ia>Km(h$tPN2IK@ij-Cn-RLgM=3^bHB6{Yjh%
z8EpJFzA!q%KoBOP!4u;d@rJynAPcKNu33CO(AJ;0s}kIBSi$MkH<md<kX%E;6F!Ae
ztDfSodtrGTJ#2VK!X61_IY$kr8E)?vw+wUzb~rMy2pdbC)GJh8xP8CFu(}I}ryTl>
zQfRnNa*Ry)TJCwvk|IxRKMKlWcU%zzpz>yQIWc-3sdj;S3aG$Q*NStZq30iWmA7Uq
z0<Gv@MiXC8fS?}dB^(1+2CWyZ`qNt)UA8tXf4+ZHe27p;`1*YyL_X^a5-N6;!hZvQ
zwR~k9x5v6oMLmy;1f7(DqFw=6G`>uxR*T7Iv*6GF^g%*wT-EcRy`|eBKy4VO8@L!L
zj2v%A$Fq?SchFD`%&SU@B^Y<;!Sf1H#A3yIw}#jRFS$tND}726G~ijdlcb4ZQOj%O
z+{I1B0c82)IIWds2{ganJ&mtlpPu_wgD(!PLJ0s&CKi`hwG>@TpFq9P(r#8i2lk%%
z_b(ue*wUo9U+BBNnQLQ!5nM9=sB0Qt&C37c`7RgMim?Lf0|!kSD>9fi_I{w}KJD2-
z@xS;dy>$Y$aw?MAMk0y>t5PoO!+{*`uf|XORLdI(&z~ZIK3L4CrmnHgz!@Lc*VJw>
zs=&wx;~z*{ABi*zrtdsUpNUJHh-ke!X=cP)KWvN^P5sT>OEGLh>p&T3@hx9}*YILj
zQo23b+-L)Q;!T?d34;14w1Eow&uiLazz(TPF;|1=`f@ka*YQSkQe)N^H(w=FeeML6
z&D-9x*xLuMHhV3u6(&8?OInDXo#C-w_YBF(<-~lsQ~4n%$SL1s87VW9#qPLk&KlI8
z%P9+rF}+x7Rke8;WmUPt!8iT#wAkAVxmBz}54qa8%u;lzurh1jmp5Ku!)ILzg4>xs
zx))ACW_efbRZkg*s{Q%mAON(ZHQX6Xt$~_U0>~a|VYCj45sgGaqNCFh5WdoOzTN+7
z)lp<isCl$fAZwhgF#^Cnw=`m!EUGj^D5XjB3u@(aj~2`)hpR#c3yLxw{a<eEF(7dA
zt)m=_aKjzVC?Ukmdq0fn!<et;2&`$epFW9qVtD5z|3*5#yrJ*?F8he6-QE7=@bgZL
z_gk3@549CP7UgSBKDe(~<>&AkU?0j`wef^Ed@4yld?|BTO1@j@<sTxilt%2i-fJaN
z<=QbRJuH4pu*}EGukJFi)|uDAx}$lwja^@EC4Wq~;q}qiBl>G5_P$R*I*i8AAHSu=
ztmz=<Ej5<FM5q16uJvaI-kfrfVpSR8ab#G=`^no~ir1tm3p2}c(rj5-N<xl<(e>HM
zxU#YAc<bPWYheu;S%w2H51V~m^DqwVtU{WLF2a2Xr@Z&~Q37M5?Wi3L5hvgg*e3<|
ztC)On&Dpmxehj1RFW-;qE#Bh}{r$_*$VK>Z^o4m_<tO|EIen;Nk9t3Q7LRZhOBSy8
zzx}^}NMS8Bj+YNiEm1OpM(DGmFq+WEW^ta+9SB9No*`d0@rmpk4_L*^u0mtDyZ+F5
zOHSUh#UJ23re!JEub#7owMWCPL_B4i6GwybT=8N=D%0;>cxgb-59hEFJNBky$+(&>
z1AU;JHs60IK4}7M+#ABrJy;+DL-G!0IV=}$D^8Ao^Tn#AgU;&g1Pq=R@QLp)<rlbM
zaZT@4KFXgm3vsTiv*v?_!`F{OOEsqu<}4cR_Mg`ud<A-J0HXB1ue-qb<4alxsx4P-
znw~kccX3*I2zjZY(ToGd4{CgB8f()E@}ZT^&9a6nBl_W=Y3!Di?_QpL_{NabUiJ<L
zF<Ij|+t+R;Xw^c9#rx_zO(0>|G9pYEpR(X)1^cMirjCQpNBq!^WE#~3J*C`O=D)Sf
z(O;s@AD34Yu7D+CWRy$7%axkPab3RNPq$et9$|DWm!(8P4pTln5s}jGDQMPa-%x}4
z3nNE7NN^Tc-z#VDRcdI0{{onbi&dYY8FVq*2C{8#UszmT0hA?Wa06z=mq`?m)qI{w
zB33;&DhCefA?tB7{9K{BL_H{^4TXmS0p1{s>Em_!3>KhDLlp)J<s*m1{J0ogv|(k2
z#6=;5-Jtt@5T8p8SXjSnlFU+HcRPVdu6l!NzA+A!Ri<}<!pqdS$*6VWMyMErPuN9g
z5pC`XgtAkLKM-3CzEVBmd<gZj#OFq{pMu&PLI%@1DwO1juJ8`+C^$*RU1v=H<5V9M
zQ!Sd6iAyaZu=QE`%Z9Xskvy&B9pu6Dtj=;+l+Olt{v(I{tfx7F9|kgQ6<+vQelt}c
zAHV56SN@nan%6-*sx3Xwoy+sT+8!eXbNZxAj!#=%joI0F^}Nzgd?Ee04jz1hfq_8{
z@cIGe2eL=%!L-FZoq79gy$@jV(i>sFjui=U*Y^aBXKQlfug4apX%dwlF9D!m4H7|^
z6UF<#g*wD#MFPfkMIBkfM4Qu^o=Ng0iDf%i#h*=knms$f;6_OXCPy;+ZU@G2J}eoe
z0tfyZ9vQN91Km*T<7?^j|9J2Bo)mv^#q<-sc-bK}kIBkwExeyNxjJ;CE|Ql75k1*V
zv9$2c?nC?Xt;y0{q}^uFn+Ea966M;!TAJZ)<vY1nQbsIB*)jT)?Om)!Yy+nU28I~Y
z6YYb-f*#zJ`SOJf*`c^e&07}V4Z^%S5VJaqAxUfI?f9>48@ZMVF2ZYzxl4GwoMtWg
zrKpVO*oqDVKLa=eFE7Z2926-%I@7-NNJR@Vrup^oBO+F!(q(M~7)&$QT`FPChneRj
zqjagjxXoOr4#Ak{_U7zlK<MlTaZz@HV1Lgti$-z-2n<e5{=IG$7$GoLNJYZS2ou&$
zx0-XkPBY3`FjEX4SEDOO&z61$G?bo{b2S_F>G10z*JpRm?Tt#x8wE}&7YG3|s@8Ld
z(k-_L_HMw-%GFR+nlw=SOjCBleyvB&$B6Aa6nz0*&iru8sndzT$R`l~I?lM)=C5>i
zA*ou%-@{ozzd~fHWq(3D#@GZr?eXQRAU>69_>&U?T!gZm#ow$D#nL%^S^6oW5TtxT
zAae?F`70)U>%{wts6vT1)nK%w0;|K@!Tdl9m>6#dV}2%aVfDu|R5kP>$2D;>QNVd*
z{}jawB^S2Faeg#qnqJQ?Y(^lx;&poJoz2u=XA!u|xOYYw-nEml9sU#`&JbWzhzb!2
zm$@3I^O`AmYk=#$^JQ`<r3)}Pl=~f9hm%|$tLZm$gNg9NkCB+pshru~tCC29D*`)=
zvsgw6H{8g&Rly;k2o`M=^40t`^4Kn}SR=?;(~--e@i6hT)?a{6QU4@)O~CK)+RO&8
zH}hF-!F{llQkUh=#8m>kh+8qPgIEV4smt3}@H7<#r?bD+bu*N|Ro%CA`{~W(M=lG>
zoTt?=q}$UElP^HpSwd*o4iw0nH<nOTD*|@RF_Ih2sN!j5nmq>1FGSXZ#o)4++EW!o
zMy@^=fpG!r(hNU|1bidr?6ciKEL|^23`vI?)!ajllZ5JVH&^kiA{mndAG|+>>rm1w
z&XySKUz&RCVJ{QpDp<;izi!^Nd)<x89)J}O`tm^No4&NPg^JqGb#opejyvedKf+?i
z?~|_@aNMqWUUVCc<ut*E<lpNdyoP5Re3FjbH?3p4TLkH6ua{WA={<3WyQIHh!3^<)
zJGHdDBLrLN`n1aF4lw(~w?drFDQ>CS3<AIiwnfFgdq!!~AMcWj9F>67Bd>=!RU578
zONa7kUuCUmDQD}F<T>X4NR$3j^4fE8GOh~SAzyG@-eWu!6-?bDqd6sh{ks3*j!1jP
zVw=?@QBHGD_dz}3Q*)1Ym!pMWNWDxiiO!R8I}eLvg>8CaN?X{b8u}>x+lmzqL=T+F
zqW15pg2_%sTAMWY=X<Brud<c)8-Hr$(}?{BX}m9mn}ep)aAzCs=L{hhr$2u84jPV;
z``j6cq#f&45;8YVle^Ejt>Bwvb)xGekp*Ysfjf1lP=`(?aP6A*Z%I2I?ibA_D`^f`
zoQR4|Y+-^lL)9n*epl*^bw9I8c;+GZmmMu3J&%8`+AbVRz{(q(l78@`<^|VV#b8d@
z<)wEG*zY^mqSn#9X2JqMtSb9^3+lOs(;4VniO;YGdqv1t{!6-H^u8cVakN4#+Osru
zV51ibu{wUKw^%f_6@L!kOmMFH(QWrJI*1w1yUAemKB1thheW$m4QIwV6V6M_uquWV
z4bz-m<|=MmTx{;Bm&IeQ5Qf@+Oq9P{=2h8v{$5Y-&iv`qygG>wM&|lCdaSavuHLKQ
zb@d^gUrNZ0W9kue6CDi5bPCl7F0wv$zz~(g*odt}&qLJbZo4Z=J6pkGf8A$8-S9gP
zmG3M*k+TWFF7^0bVlJg+Q^&x$vPzaVB}s5d^4YkE@?f*ibIpNi-^F{E_00pc2<F*x
z*wa-;H@J|jSjQEidh9TzHQbid3JC(eD><mWCl;c=l2FrcL#4oR`5Z@to|h(lcmO%0
z6SD=*);%?u*#!jZ<YmYb=jp13yb7|WsH(MaJ&T#<Af7C?u#SXEe{j#Zx$Er@P1{Gd
zxRH5ic^0n!vTH*^H;egFC84(9-@r`xCaiVQ5F29fUJP=~(j7B5YP?9`YN*l2$?6*<
z#IaVanKB}GVqmpmm^}Kv#J7CIMLyLPtH(wNIK76&!`!E^(<kC4n`lt@yYfmP!i4x5
z1~9hGoqpOchjj*Co*wc@?+y7iF1&2ulifg+cH+dv`@AZ-pUl%K0BGOrMZ<j2yF9I>
z5P+$zfj&H@-KXQNDsc7H7c3W8HGAiuibj!<0z=Z-HNKQBJrL{?L%Fo6J`XlCNF485
zos2n`xIyJ1jrk76v&wg){sMe=LH3|n&GrMd0-#FYewsISn`sPUTL5)ovfzU_@9^2F
zS{>2xQqLx~v8VF4*0sq+{Q2(N4m-5WBA*P(MuuMxm1QOcicRP{8Z9B*ZQ>dVbqvAR
zxLr)PUTkuT5e(&{p-+mlk9~*OtqEz}Ex$U>6)engrF=UhoA7-WR}t8T2IJNTLi==c
zZtjFQZ>4n}pS~sY#BJR^|65adnQGzrh9M~)hR^fXK_UuEF(73RKP$SdRV;D=rTwzd
zLJx>6`U^<6l2aA=d2(l3?zUvsZX-lA=;hCI)PzY{Sg56L<V}MM3Al@b5B~zBx^?lU
zWgkG1Q_$|L3}|EITor%8L4zC*V%(P?bHSmhK1{{%ciySW-73sK`Ie+@y6wWgUgM9#
z=0>gIO4V2(`On^|8@=1=WJC66z@uU5uaG-h1x+qWFi|tr^mOfa5u=z2p8Tx*uNnQB
zG5ygQCF!V4b?}mI_{Rhdn-@m7VIn)rzUlpYU@X?dwDZzX+4h2^HpMhZXGAm1``^xV
z+N5dWuIzlPp%Yv|U+3tvM^3|t7^O_S-!p8*f)gFLz9VtG9u;L-ckzijfh~BjPd`x_
zwNEeCEuXo$RAv`RVbPy`c(pPk4}&g;VT`M{RP!1@Nz!E0a7i1ERH*vnI%)|P!O77y
ze=gc{hEgG`R?`(yS?ix|G(8{u8O$unz=QgjIWpz(KP(yiPgP1rzwpSD<pvG@yJ!VL
zilXHmc0$fo2p0kbO3n&FFU64l&8oRG+lf9bG*FTi3!YcWjCjTsvRqpo(d}Msl?W(-
zGFqDEq&yJv7j#kL51M%WXFb=U4ozB~a}IfqTt2O~%1tc9OH8Hl4`Mm?Arg*kpE}Zu
z8?)_#CFrR>V>GnWCpL!FwZyFt7JRPCUp}c?hx&7lu-b`@?EGHka^Z~+yQe6c-lc2M
zpwysjmDTBkfl)+p5Du$@nzm>_{J18aAK0#SJuiDMeA++@zAlF2B&2|h`Xu_Rb*;Y#
zmpX>Bce!v{QIzzD?D*ujea9E(&W+#pAsAZ-rv<Qk2398Bw|M#U-d=y^!j}-#eob|?
zU=Q0+=Sq<>Vm`moBMAdThNoT$2bIG}g&hMv0os-XnW?f8e4<#zASMZ?%;g5cV#)63
zHeAD3|M<H4fM;dG#$$@|DurN$SSb%v@`<YGoF!y+kn?aIMryC3gZ@ka6OvqZrviSD
z7M!@sUc8|nylIF`j%K-)lMwyE<;`fksEN|&8gVN*{n#e4yY^5w=kRk+I~cSJxxp|}
z5jwQmGv7&KN#56AC}dP4$2%;1vI2m1x(>NK+9U`6zHFA)6TVVt@|HLk$&i~Em46E_
zOlvNS3F}be(6ql#RdD_g+16iGAbB7(u1+3qOnlU>;ay*WG-3s$PW)tf_QGSgST;`{
zt}RMul{YlYxIj;$opvhe)+c!cj2$!e!(F^&0`MQC5O-qGsjz&nvQ_<EDeVMF+0$+f
z%!tW+_D2r(Ag<y-8yYwlh0w=HNndf_#H*db#K$o{ZNnIbS!0`)5;Nfwq$u8`?kLWo
z)TZdt!s~GvswHZk`zXI*2+Y*^!D2SND5afI#1mJNYSGEAzn5mczQV`i<asw6X;cX|
zj|xOB<1yfwd4q+wEo6qQ5s#eFyW-BmLZ_)%T&-ou2EX-S{=3;QArP&>&O5i(W+gl?
zaTS0X_4TRW<^!iWxOd=x*af_UHL&#aN5fMWt4ChHaLDA$R7@hgNet-Mi(jyNpntb!
zUscxgx{0NB$lSvMleOah>mQgkElwv7WL%!6=v>lazCItw1p2lblTr4A=^55YcI*4@
zd&%Cx9s*O_OwLq;--SOkcU8Vk<}FKhZEg~Og?v|iK7xd!$Y41w9dC{Q=oL1@AE#Vg
zN|4k><923tYmVM^2SP=7t1DYK28ZI8lCeBhlCL410V_Pyai1P4ODLD5G^N%aoy?L<
zSwt01IVKVuy!fcdq$`gID)K``C2e44|CO12;+Odg+nJqraKJvf4%80{MSbROOUjC6
z95p=cr7!%K<@5UcG6TnFqNraXXXL9NbaN!%5%39PIlnpkoUr!u3$DU20ED|24=&&E
zNceN|5Kh0X;=N2ix?BEPWqKRpp0s_=(K)_<44_siAZaqTTQM{R3H9m;<7gi(dRI@o
zD~y)-U07Uw@o9sL;zAtq_XoWm|502fK{0khT`IMl*Lc*m?L=&d``NtwQc<cim7glX
zfMaZx++8T-UM*+AM-cF1TepBjKy)ioE*oO*p*tUDQ$_~NkxX7TL7fPD%~6zsdqe0C
zivskcJ^HzMXvnwDe4!E%=2>J)jo86>vG%PAjfjbA(<>yCHw30>CNQ^FAc*Evbuj~>
zO)7>A*Z_3k_vE`ug?%m2s=Os#r40~WhOj_&x)U4nJRBhn=LcUpI58cf61&<}0KM%6
z3w=O@*fOi-gA+yVAu)ksv8dd*?^pQgxIpf+sp!}cJi7hPKr+a0Ab6;lD}};Fmyh;H
z8kY>alqxl-q+mQ65$hqxTjuOzB#d=E?SlB41fr?DYy$D~sXGU~h^s~H=~%KSJdJJe
zUVfbo>)8Z#<tU0%BG?u*!+irh;Zfws<BD$AIBitBQ5yqktpgqo^p${nmuLzPkjY*{
z(j6Wkr4EEJTQIim_GzDqaz>fCao1dkdWtdZ2l^B7?ZPWk_e5C`H%55!gHAk)An?rf
za;tlJjG#O1m$Qw7&uOIK-wxd7=k-Xh)zN9%hj2D?zRR6d`u?<0cISzp1SY{CKsl2U
z3#HVw9Ns$L#Q4-Ur~K{FqKOnKoa^GP>KTWicP3mhmssn$@TfTc$Ya0qg*^2|$(iwy
zGv`GV)a!i9Ykxg%b!xj);p@<hPxHCbJju=uV1N8Cw6p(j6`Yt`?+087f?Wm08N9QS
zZdSE4f<j<M|MArnE>iqE08;Spf2;-1l@x|?H=OEDWMRfBd;4Breim;$C5Y$!>|VI)
z64oT+MqR*<c2xA^QjIXjPu}-OITFYCUzu-K$0iS={^=Ko`$JZqW0zOMSCnpLI`(G(
zc&|r1%(3)_(@ahBvaP+ucBRin14m@+rz~EL)-3GIKdowBZ>|pXk~$W@6)gOQX^<@F
zcA=<g+s1cn^To4?!fbMN9-_`+nD0#b&rVO`^Izw3;y#QufTb|QsXT@_E?8=Y-{$;?
zto;qtUIjUfS#D7Z+P6OMoyb1&RS-0oW_tDIwQAq5fxC)^CfK4m8?ys!atV{geQ({_
z-7&k)#<7sMLD%<4rzx(D5)TkW>q%Zl2#KhnP5PfGb@o4y!0PX=QhniT_x^l<wFt0&
zRKT)Td%zT!Wo3sa6%WDf+WdJ<iy@%$K68fE$4UBO#Y-PBqoLPCAC+(M7&Cp}$65@H
za}!WalAS9vX3@4#t6e{<W0<RafyPtR*Bi!A>oX;A^n<1vmcfQAefo@Y1lE$11iln^
zKgT{1_c8#VT7ku2h#4iZ+kSs0R3szlN$s{50Q~6b{Kx<oF*%pO7v6eddrARfjzjG%
zcqnI*JmsePRlfp5$94{F3eDNF3o>~&VcJ<Gq{>jpy1L)u)|liR73v!EZ(PFV2yzk-
zVe9%kWur>!Q8IUrq?Ml~Y(k^rlov**Nc>Q;Eq(dOy8k*23b30{xmeadd8SuRCUMSL
z5vkggO2m%^*J1<*d$L(;4^(r(KHnu35=0{pn+e|ivmro!dAHiZ43nME8<(-gb~^j!
z){m<cKOL1s@xw^^GOl5lqJQtxVd=75h$#Q$*)OV(W?K;snS!6g^IbQ>R<ys@(uy7d
zF5Qd#9ZAU=8-$$E3#`2fGMQj&VxSr-2B8!j8wL)&ta(<zg+1bC)q_`@op|oPRGo~U
z|ACiVZ;b(`O4^(9LsJ1_@w^7+eZPh~N4I`jeJpH^CJsQhS}o4sJS!09F#nUL?>o10
z1}xv5xvV#;P1EH}DLIy}J->sj1-|e6HlkNZhL4>;?T8vIOYD!bLSmrzWITT7`*;Yb
zEVs7R{bxP55_9$GwVwv})46W&&$?cU0aKN<e@t1n@*Zs>0=13*0tj38!}ZO*&{})1
z=%22%IHD>zez_SUWE3Ch^L#MO|2(#Ger=vSaP`;W{eD=M!HoVqCm)w6LGQ<wcNhF;
z^X~Isvg>7Idvr<qkMnWChS;9Em=s<9SjCj;_8L6<E3q3vcbgyFJ&u`N_!qteb!}^9
zowqh{zoV)9dW!2!{jA1?A3oULowid4@O|+yNfR-28}*axVXB0`PWsHZu=x&jdrUg3
za{r37^fU7H(<E=7^aro}O21ra;Pqw~68rdNRo|#(y^*(JzXRkM16ET}SJ5(7DZa6n
zNyJ#CS-KA;!|b_mG{oZpFpf>~q4s~JbvFzx6V_->a|#OmG5<t`v8(NG)kO+A_@f3*
z)$g)6WFCsPMuitR+(cJ*l#O~;DOX8c5-LJmOH2|wh_?S2q=~rc6VM&@HQpDrTs{wv
zc@bdr^zE3t3GYt)S8suYGudX@CF`sawZv`592cinE=Ji))3^=5zTVvlyN<Y#`3be)
zMRLs!RNJrZ=(r;I!v)PSOwnN9_&QWuzdW%)b$)8#%z5DM8N>7?WFQf&vzCqzjS0!?
z`0uF?8|DJu9zq=Y9I62lV8gv_ahBplz$#6bmknT#%P*W0KCeX|kLU4@f*GV@kgJ>S
zDU)`8c<wN6S9PKA2^BMqOhP!vs+jW4l&?8|0h@svhxPUms=!H_)S|7Z^>a@8D{+yZ
zygRKPBBe5kP7RMI;L;!9Bu4u!NL2W5LYuMt^?&}8AfWS0X$btYDJQMb0m7Vka8)-v
z{N8SR8?kM%QOT%J<A+Us(=4^}to1~mS*y9Ihk~b{f%OHn%Gqz5mKR_D(-12a=v5V1
z1I?w&2(fvMy5aP;HZ!=0!DO|&v(^~8f>p(e-flk4VbR1lznqOX>RT@Pu2(IdVh;pS
zGHP0wUFTTHU|Gb7?zkPqMRkN{BJ6FwL%zb0BZvLGLAZL>3v#HD)5a^SP`QbCu-Zpw
zzi;Nk0GhLiPbkBnE$j5@?`<1tF&OduivMQL*i>`kS%xI(!8*0O#tshEMk@f)y}y9B
z;g|HlB6CA7JvOlvaYe4i>wMmQc<!#%Uz08u*`N14e>^Sge8-B{5gxq_mM^5b5q0`M
zRCoz4^igH6?Cj!3j06GRgmV~QGtiAWD;E8NYo0eK!pJ92=C;qx<440e3X!8-X*&+)
z3H6rd=dZvGFxqi_qRn!C^{!i7=d_|EWzW>1^&y;7`mSs8h5e)j9hpH_{>NJWYY3a{
zuTY4<t0O#@lfjK!tgOb<BY<rLETi_ldF1dir&$I?36B@dm&S~0iwMF6aY3||f;y@f
z3jZTt+Upx8C|cfQ_^X5dynu3bT~q`7kW9QSbMjW+@UnM~vXnAa$tZ8ewEfC)xuHj&
z6;0jX&NY;6d?SYe<O_CJA}i_xKh@-uWl7R--;CZ&?CUe5ft{8gvSk!5{R&N_&j`2<
z7Sl|0K5{yI{?b177tm7^Ao%(8(F5pg$?MRsa87H7z#i=?Z_(Sojw)$%MMJ|Xo*rD{
zh|v!9vwHt*`*Xq&brs*YQhmey;Y@RWdS(gCpY)@>f;YmVf3&$uwht>L<<X1dsdO;y
zsm%1`Yq$E^RK>`ESb`K1Sxb)pP(G!9rGlI`QXDx9WmHX!%FCbKdnX5}z4%$yS}Cx^
zIl?#VXuOR=cG72+QUU$9bc?y6un7`u>-;`-EpGQVFkY6e%SjO`(96@s{N-nstup0o
zpgbh58(xb~n!Of%YdXGSWhjUW-bvk8@DY!Qu$oI1(jqjcb^1)@q}#=YCB#0)cbNx8
zsr`#N$bT*<yNb|`HEusT<yc7-bA%tPpnkKRYw@9K+Kh0=M@jTAiL(BlTW&J&@%%3B
zeD-EU@b7c0k673{T7PM6S?S7;_`eH-X;P7(7*gc&nZ0N4R?RzFj*tiJ*Nq0lLjv~9
z2P(E^2{Y|@!Mt@<4<=9QlWe+nqsSC<BkWAC>def&M<2tEH5-qcs4dtqIl+y%E%q+r
zX@Kj!=%0Ew$q;``+pklZjEl`CwyK_1q3Y%FURDRT$jn|*lLE1O2MX7MAk1F*XlaaS
zs7UlSGG|&^?7=mv^PUECgzMd*BY1Jv+Ri;Qz)8xr%WiP-lw}05!6?VeS^vv;DZYpJ
zrtNZEjMj)3@3^k``-@zfO7Rz8Y${0fTjHu~kDl)Dl{RUXw{&EAb+_#Y^KLRf&HX^W
zFwvlaWHH(p?S!0kv-0k9!lqZdJt(`m!z(k1)2Z!vGkwJO;FZqcFPtS%)66ogT&nPk
zMp?D+?(`E?ZXj#zq56uZ?i{&bacdnHcuygl$Qxr6UcqV&nlmq7<*5LU^B0GWuh7nR
z%Dw8YBCz#5)8+D!WksC$A?BHa=bHo%Ce_viDyDm`Dtjs}WaH-9ny3m;X^nLuR}|{D
z+{*SFDOY~n?-5VAw>X1vuX|ahx335d`ZbOEs-xl;2aB;QyA=-O+$`E*>sTE!L6i;=
zguPGF*Jswg%M8TH`%{CsbNJ|KR2I1tETof+cjbPkol$>TVO!w2AwU_Qgp4j?bs&vY
zjNtP5Q(-WVB@f#wD9PysPlZo>JnN<3wsF(>&~yRF59o_L&D{=@zQM-<p+%`2`G(VH
zMkSZXKOVKpG}-=;pOxp{v1L0WyLiqx*JSkL9h6SKCTq0^At3U}pUZs8is{d~CGpS2
zd9cUtj?I4j1*HDie=ECKCel^qg!iYxlhXeb$8BH3{{=h=(hN$z@pRj2roe^MZ`{?j
z$Z$b?UoQ<?Xb7mZ)PQr(_%WR!L7Xpu#!8vuQuc<)S3(zOzhRU!Jbtu@L##Vy!HO_1
zR>astB$O)!QFtUc_DS;o&_OqUJddoAzQEuf$tNxWR2RC|d9Q+=`7bAgjAFlUL<DLf
z&EmSSZqp9iHpPx48a#Htu$s-V&P8%K!M%+<``ldAt?<gsO|_N-^>vFoMHO~~TGqd#
zA73ltQ9z?v-LHwC8}v9haAusAq$<wb6ynl!+M1(^0$6pwJ9Oxsnz`(wgBWWsaWQ<{
zVLVVdWK$RF54_Yog^4X=gag=H6%-XNc92=xkFEgfM$9*o4hjkxp?15<i4N!T$Td~4
zvgaVk@Aq?);>$xsWa5SV_ISz--TdC-Q-jKsS*bfwgZ(jK!-3wYS2?Y?*VbpfLzJA+
zfPS3Cq~bN;?WmfLzW@h%_o>!O({}XmufKpCrs-=>^5GCM>lDTcA0p8Q@Zl(^@5M_b
zc0CIJWqi-S!<8z?55&@Y|2vwABlA|WI{fIn1|_5L;r`iEg`Wf)BX9v#>dr;b=NHhR
zq-Fgrbk9c8zf>SBnFL^Gujd<l(phmM40*MNMQ+q4%BG&AXgFwL@sd)e!|CVNE$olb
z`(2U>BVQ@haY9EW(nfT&_lJyPV1UT<KWqTeCL9TD#!BiDx%A$FUsmA8+beJUtsW++
z_%DuTPBu}iO%<@W<t#`H?Zpg;!e^(+EYLuTil2m;_ygvtR_o@+*ZP{ThZ+D_uMw(#
zjRh4ywLhQo-fos&p%LHoMq*utuox}3%%n>3(6DJ%l-`2a1)KE->3ft*(ee{leCpo#
zU`RxGn!#h0Cpl(OaxBR1H)|-=)+~`+q}mi+x2FE35Sg7%4H=!a__qAqtfBb#=#SKv
zI6;P}xwBX1(n;i0-1ZOVGX_x<<$b`c1sTjNDE^y`>Lx~%!do!rS<;xZ-%wkA<nJTd
z1XQZd?%3cwB6GfDJO1K+38lyvP@d5nc{b`Puk?r0%!*&|Hes&yJ<0pn$nGuHYE?3K
znK2uiEIfbWgYR$79agIcEyoO^nyO4KeaECapSx<wDk?kJ%#tm*r0Pl7!%?Kf@yw|Q
zN!HHBBUe6m`D`#mBEN+9P+ySXSYinq`V#4jQg6mC(=b!>Rl>`TO!poz>*i(iKPc>l
zquXLw{*?K}l-eE%`@_Eg^pr0UG<y&j8d71c_E{&u`%E;y$7#ual3AqyRqUC$nf-C4
z5|rnqe)upZC|#cU12P-PA<H9cte?{7SF3HSvTg~{JUNAW)nFCq_~Pep^Xh&K9t~30
z*H-sGt2Q`7l2Ms0D2Rq^%@%$L`99$7rJ9e1{Hf@FvTx~8@Zh0qRLhQ@kE3nima5FD
z1_IgZ!XF2~!Q4d4XvJTE-zo9?EH$ett#W?>s*hFP{IrYZbzEHegwv4<h@;6A<z!&<
z89jw$`>L;=sZUfZA1EG+2K`X|{zvgm+ia$V6SZv?s5%4r1iLA?N-SQ03spS&3n04(
zEmsGzJsq+!e_ywGExIjpKmIVO;q635{!DYqH}a$OWvqG$`kK*echS^hWL@uNgYfT(
zcKFdc)D)rYXb{h(Y)wA|Y6-)tmTd6u_=iZC`AhFE4r2bd<&feUr*|vbe(P5~RlsVm
zqtbS|SQeUAr$WmzyE76c=lcFj-FxQ8$+L7*0oH}qW!h1Dl^evn<t(TD8T$Ovq)~NL
znCd~2ryr{d{1{O*R-79nC@k`}GwPWN1Rx53@@Um|Ey{Q-udmJJD{Wu7gWnk=&3hn(
z@C<z1#qk)?7$~<~2oa4+)v*>!l_$2Ol=cbIWlb-94omfsGa?njy0A{3TSFK)&#B8B
z+!<5a1|#h2E!GP1E|FG&U>8m2Qc(7!I!C08n+F_g)eOHwCucPE6xLfwq1?>s;(25c
zI(<6ZE=mT0d3vFKadw@FF725!0ooMIn*3<oqf1L-6c~$teQls*<@HO!X*F*jzs*yf
z_i8us#@O1``~}1WWx7`UsFmD%K7>dUlAIpZJZo*EP|oOymK76B9C(?aeUkG<)&mGF
z{M3RcIme^N`2dk`Wmo(QCPiVg%GZ1vu-56=VNmL2I1|fn)w<B`J9g??g_Jpe98c>k
zRo%1nTvT39S#5iqYGwv69OoO7_S8^s+vs)9vg}ZwTjkGFO(7dg9{vb>Iwf591nJ^m
zRNYT_DbsP6-NW@q*Qy-?F0$OLoU4{wtG!%o(DaJOIq_kS$O|Xio<U)8AGZL_MGp(Y
zZyQtb#fNXpK8<PF)ZKCY=@mJ4$@Ync-wj5E{k;nslP`lY&*uQn^J2!OOr2em3tPI0
z3YyKQ$xqel^IN`HIS2Ab6%SNSY<S&?(>RAvmI9H4_;mV?D_<jD7%65nu7cg@9^gV~
znxk=O+di-CwNij9(21shd6<?s=J2|FOpCaY`$>-o;-g{4j%}mh_An{C3cMo`C^iQ7
zp12VwAWJxYAo$H3PGf^33^Na&MW=k-JFXT>8$fTBzZbRL<!|=1u?DI}`~@_J7msh&
zJ2~bE#*9hxiDJ>Zz_QV2ZImNE1u{Nu4KCBed%dW*nEO;doYrtLLp96Lv#Sgn)f+bI
z<x}hM)2t1~GgYl{Lo^ZYjay?gtdbSUjx!nWzZ9vED&u{SY*>}Z69bC^!4;ORKzpzc
zuyze|o<Uc690CKoQOK9Cet0lGobQT|9wm_4@^9;;0>%F;`f#1*5XxeEf5`u>5p6`u
zsp((vQCPsWh&1B4BA>*qGb`hfbq0t$J5zYAvr_Dh<xuZHl-3me=^DP!KIm`)7Nb4X
z{>R#%J7E^NJgQtc+cbazJpC0%!-cI2j@-X>1i#pmNjpo~ZUc5R`!FuCFP1JxgzXh2
zHbydYh%xN1Z!LGnoaRbG0xH#@{Jfv3Fq32nkM3aaYj?`p9YW;0LbpnOh4J6V5!09+
z2ep=@-CV1w)of#b|JM;$Ddci0D?QD=T|QLet;x-@SM%rArRSc0|ApxC@%HiLZLce#
z#J$5WZKj`8932Q>y!eIr^H?DUCi36x!27q_^=2tv5hXx~!VqOGqlI`syjb=2$sc}S
z6zuG)sT}#(BTK20i_;F+dx{f0JmFR=*S$?|ePvAfIdP{x@WfpRUk(mbXOy(n3D!Y^
zzpW0V_6{xEodu=}RU4iWqJT&GduzWdGETuY0!NTHwI@oshuW#nvKZWh=3k`NU)k83
zdk9~=H}o=zsWjW6x{4*Ie6sg5`U_a9dDyXTBmvHNXm&Ru6n*PP_SpM}=A8svl^2e8
zGrXM$+pQ4p1}Vg)N7lrImrsj|?^#SEHq8xAIHvwfnsz-leO%G3GkdE_@i%&T{pf?^
z9|aa)9gAz{D@%{BYJy8;&o*_{J(FeF%Fj5F=uYEL5+)X`n?42^owTnZKWZQoZxx71
z=dXzaC_JD*#jzX@1~AKbx-Ix4KR{7Dtx44bvggvz-Y#wDA|>ZhA^?(9&DlqX#csqr
zm6r1QxBdR;_7||53B7alNEE-Dr_QpE;lJkbz~d(F4d2!I>@OBVtzC!pug5oi&n)~F
zO7T~@PJZDP&4of(>OfJdU?%Rq#(%yy0@aN#msd-<qHM1e5bMS&wSD*yx{sugCa#>A
z7)X?Rf6fRMkeslxakaaK{LP4r&Mv6)ErmycZPw~CJOf-G>F{wV6x`==n-p%)$se~i
zlQM=4MQvM0wcCwob&SMha5$q!ecu?xFWj~#&NJYR-rv?R7>RcyM>d%}^fs`m^^#h)
z^?9z{(e%{P@wR`*MO0mBy6=@rTm2RQW!YAY#BEQVYQ8siZTI5@%Y9+#gU32dr)7s*
z@pnG2?SEhS<I4F3wM>+led=B#8ww@_#i);;oNSx%%=5to$>AtVHNGo3W3Zm`9p@qw
z-q5WiX?M&_$tM&0I+vyr5=cIM=3cqK@p!_;T<O!*Y!VwONmR-A$Qb>phr5Q+H2c|I
z#LQG^VcgE`Ic&q54gbxIfmNaLzkv6Lu6JLh6Mc%`FWS8^pq1g~sy=*acS2);{O*_w
z7OT$bVToMX0T;}@q-}0hZuKV@iI#GrX;arS=O3uIp1~9qztzQuMDd&M#nI!z>jT4n
zC=gYLAM5HA@_nLVBrfiCl>XicqNtPBPDl&}>MC=wvnpV9d)J!|X3JL10G*=*2}9#7
z%{u`TzXe78&!6w)<hRItnM>%KMy3V1v2EDK&2X!Z&06Axa}^}|#At^WA4fA6H1TNV
z`16}T8)j?N-sisCy^*OzqL;MbQI`&w{f+f)BdB=#yaNNPPknarel8B!QuRI8fK^`}
z1+W!*tlT3S?9h}WCRIuME|4sEcr{m9Vgqp2qS5e8P?_d!<!Agmuc?*bxAoi=n=@pS
zc7DI$p--N%!JY$klAOcoqG1^V`Xgd8WdG`|p*ee>2K7m>wCnF<MJ`D%q2OxCJjKV5
zpoFMF^IX)hjpCweL9;dT7@Zq!0OohMG7!7DK?09(y-m0^<X&}O!Dwa2#)rGKKkwUt
zp*gG0PzLL@SJnPs@7C})IRQP`&{gIN#SC}}5_F<|XzTE9#WPdZHi0Tr?<<Zig8551
zSl{ky(0p-`azM8WlDfJfk@_p_$s-*?zK@0cg(;7^aL-~+h+3JN+F1VsiZE^I(K(2-
zI%j@wBY*f*aLWOQ5js{;S)wEgRvI}GVi4FBl~kub0C+v7`~o;c35?t^F1dd~$Rtv@
z`(wPEuSZ>M>sJLiYnvvfZL(HS5_3{on0?SN5$4;lZyWWV=J1tp!!F3|$8`e-oJpct
zticoBAK$yNL(y0wO|9BK3g8X)$e>YPTxD=t`LD!Kn5=eXD6M(9TLqq%eZZd3*yHJm
zdt~n3G{<2bbsZS{Uiy!f+|ZYX$@pFyl+MtMMd^QT@x%Xur*9E6B;3Klp818@@VRQ~
z%_!?~fm(aDmpOfhR#y;-H?KWu2blfKyeA!)h`D(OD5=+FfMkQ!^kz<FZZJ+SM{T_V
zLL!1QzZ4oi1i8#-&NM@Ko2USOYgK{2fD>fg%P?l2!Xx1i+Y`S)>!&gCpwiHk&)P#P
zBbPa-hABQ%+s52?6Ej-RH@GZt&uGpR5}~YUFu%r9`p3ym`GtUfC`ygFypk2L*PQ9#
z|FoS*5~8cMw-=uOS#d=R+b11y=v#7l!7-7y`lia~=WGUMX+8jW;FTYAxbb@zMLnqW
zhgjC(@bL=SA$hmB*^1Ulr2(HohY#O~`&Rkvh5zzcoY?>5pS{V_$fiZy<{J77h%4m_
zNZri}n;;7(xK-1IlrU1}dnEPr(p3wGmN_*eu`kNL4Bzpc2FK6AU&wh2658=!A<FDW
zQxY*{lb)d~kpxL%&jm;F;C<Vv%ikUrUwX8qjK%^yWVI=g?^Rq_j4u88=i>jJuHiKJ
z+7hLgbGq2$d|^L59jgBOFW@D!OY$$kEMa>lA_7Wwnl1?~_qi2!t)??wJIcjBZ$|ZK
zpA5}+&0y0D@{V-~za0J>8@jia-;xQ%&W8ydC0}uRvW%aL^?BmKdrIZ>@zc{AP0yQ7
z&o2^P6RkjJ=;IePzNcP!EA{$yPu2OuwoT(d+>4;yRo)pkH(F!e(N#I!EY}SBw21m|
zja;j`aIu<ie=fh}`ZR5=6<8qiU%5EWb%QDZiJ_yWwh#<b`-9<&Sn2aIqh1PAKFGtj
zobEt^G9R@KP7_OSb@=#pnTPt2*J+*eYu9TtSD}v#_X%Cl&F2*BZjvBi*hi0Q6Er8=
z^m+Zo_qY}!is<*sVy58J<DzV7A@><oyQ{HF)dohSn$RD91kME-ia-?RicjC=T0M7I
zG_>vsU5XY5_%$*tT8h|0CxRv8gPLq_92>QMSHe1x2pm=$rUQ(S!%Y=8#oJtoLdFwg
zkDTQe;@BjI<@ZmRkZ-j)4UWQG3|NcB2fc@!Xh;T4Fy&*S;^(DE&it!WQIBQuCLuC;
zV2dx<La-IY@dnvVRyRNp5UrZb`_|~l<2%cj#y^6=KU^$YbX1FE?tKw^@n*;CtaH`0
zZ@Np}8<mN(YxQPr10sy&NvX$<%6kjTUV{t@sC+P%#XQ%qNa(-zuv}Dh%4x3Hx5Q^j
z&kEJyG%wxd;r<w{{$^Z+faOnvP>1Vl(T;IXzz`#!I#57aKHNK{3BckO9vR=3`Tqck
zKz6^HQS?4sw5Kp`l=(f-o;2EU>oq=9jOvL8MSMLprI#9xjg*FpZ3Q$fA=BS1q@F+l
zq2zU@gO^0PF4Z5v*)9Y#B?UjzAZ8<T^!icL6LgpBFs(ie;Cq~Q;kju0FjiqQHJyJU
zRPlI`L@N{-8m$e(_(i@4YTdFBln{_7%DD_(XH<4+>vf??qbw)3mTqGBir+~own2y^
zMW5QKy}^xxs%d^r3e2vl>&vw`@g#(dq-z_0n%4~!L^W)hhPBF72`NEHLP-;>{rS)v
zgu@mo7t$2+asYIh+#W`XEoBp|t5>t^#k3?sM1plXRt`8xAS=yxa!R={eOgRMq1+0_
zAm)&&Re)fk-Xf9!00GVfQ8l){s;u1&#U(8&6lFVU9O?&l6`EHnp5vmlwz7u^QZ)+L
zgQ?Kgwh!V8^T2Zqsy5@iXA^M<S9YSVTj+V3>Do?7Sxy1YlXW4obSbl%B7CFne)-jR
z5Oquqiy}aSl#o<LgaI+OoB0iCayCW*621via;q^CH8HW?gGD){T`q+Lq!X7hojHv)
z*X2TaA`zNlKD0=T$N@SX0E$6yBI%83u#{beEHXkuK~a)t@9ffyOoV4Z3RMZosevb$
zfS<i8EKvt{Q41zha`_sDo0TbG=n^^o^`LY6Hp-I@5zPq3F)a6wsi+Jm`Dye9pF}tS
zltT<pR!HdMD0QewN{)b#kWT0FrUx9*P~-p@<i2RB3k7IVFb10GJt}0)kP-+arSqZX
zq!p~BW-9?)<3s1K!o1ORC%Qa(`zH;y(aKq9sHr9-0!*DfW3JIe*B_Eo*agpD?;wh^
zW!x}Va$8X-ja8=K)y+nEev~AO0oSM9E?joM@1DUBx3al;%<5^tR0d-{HS4G(`=TPe
zVj<mmozhLNJvn*=`Njrv>JlZS0Xe)49-wSbFE1(&6Z=1<EdWD)pPl~zDR$lNi$M=5
zM=5bZUh>I1tDxv8T*<h%uuwM+>%d(#e)N?G$V!UHPIV?g*WEzt=SIP33JWjJJakWO
z-tIwK(1!A!^r=LIrZtsyKOR*E$6u!{hvfr|i0kwb>^mQAmJrSu)0eo7$%Fuq7pwul
zx(}Uuv2**P(em|K)xadap@xpF%}qF4v!}D1bBZo~vh_qM7Ux#mgU|bqnX65EXpEHg
z8}jSwurZk9Q1*1hGwOQe6@_T}7-Tk4-7u0-BX-aBpPer>PHuM`yhnlSb(Zm%_jUJ9
zn7y`23SS{dlB7b1T9EQI(F3WI_*|vu99~kjWl8WX7|ZMBMnhZiX|MU$;X&jz_edow
zQj_9S&Sxla4FJ<c3X(S-r0zdU#=`n-_X+w-&cBtkC5I3~icac)b+25zE6w)tN`Thp
z0z&BwI6)3R<fzGm0E+fjk_;~w9aDx{LqG=r%^EAM7&&Zo>#q$GoHG>V4k5JW(J342
zwF!1zN)XJ(AvwIY!SRbFVYua!7j~}rRNJV`HK`R%KKl*OWG*(b@GB>NB)<wab~cW2
z&u3{Y*;_WX-Ptsmhy==fy499q1yOO{`W4aeUNHJ~1{V@!9SQa;B4OCBWELD(i<mmc
zmcE9V`az~wa>vL7D?@=@%;G{5tZZv976@8&2-K^m0)m9)RQYwRSB_munyxW)RYU};
zMr{Pg)|Un$0Oq(TLYq-_L<G*-!Pn`gwAMt!kT{X>s<*U-mDs$10L(gctGGknke^gT
zZn7s4rB?XO)2)zF9F-<csht6h$CUD}_Xg;u0^~TIJkJuO-JNlj)uq#RuDBB0ij*J>
zsX^0kFDjwLaQVS-SGa9J%Wf8-;S79UGM5mbq5w*OI~wFM6tWmyBVp|UO&68a0+1k&
zD$H=b)Po6<hzrVe5xh(qAZ_A^cqdGxsBR-*Pw7XPom3DSWjMXQx52R2ukM@(LugX-
zD1r5*mY29SyRQh;=&=WEJ)~Z7*Au$yF1hS%W=kL|L##;^^iB`M#tw{;-Yb>j*uL7Q
zX4BmY3u$a;HeCrKCMTiu*w(w97g<ditfWXSFqEYDBT*Ww)Q-Dt`PE|V!s)@hlS|T+
zp<t>C!6Hn_qF|DvGzl9nFw00^wA=&*BoPJxAac~yy~p5ch8<kx%f)xAQ_0mW5E233
zUca>yKwyHGQN_dr@g*TaK||gGa?JA5rH#yPmhR+*I^Zr9zT%8UrL@}05J6JZ0MkvQ
z(t{CLVcB)&G!g>Td_96&V0MjLw%G3y0!bfQ<Z)HqS;Up1#s<L%>Mj2OiQKlsGu^g9
zT8HISiR{{3<t`v8GZw7cHWGy815N6KiFT<|n5=-qUDJ?Oyre(`z}{<oy7yfm(#b%x
zng9gJktHyFdhbF)@q#5Hw=y^s5TZ~s0myAe*&%ucld83QKU!4M17r?+#8w_WcdV~b
z_!Yl}fEqvrBt&)Af7-E)m1@#SM9P!_B|%A#Prva{95gDsZ=z*>**3*eRT3toFsIXW
zJ{3XQ3NtdWc7rf_{A*hT0B|bnjImLdL@yIxkDg+qr25xX8{Anrq0mvgH$hH72`SY;
z@AtJ+s4of40wxhQz)4Digv=cv#<Y@CM&USEQ<6X+gRtxOr9lhLd5B*$m1qbjSsHES
z>HE--b_j$`kt=r8kqbx(A_?nAA`<}zL`|}U7)s<!0kG%#P)w9&Lwy&I-4vuYrw|lX
zu;t~Yd5m#7AueeX$ygYk5Z?@THr6Y2$`gBzTz9BZ9zN`7g!uwxT67hd>c*xlQf`B(
zRj~C&BO2|4N4~zhda8+(hniE4Dpq#aGP4iU>03<)K&;g*02ETyeab=`TA-4pblY!Q
z7dGetE(StTvz&LKMhFDtJpj^{EJUM?x9hJI={A=uC@zwnqcD^7-=CEjb4QO_B^J$v
zf*{KPHJ!B%^gt?Fq9>Y<GCF?s;&TW(b@THnIYUf!>B$?iZElR{N`s&P9a=_$f24m+
zOy!)`pC5FR)|lLKynf0db$HdIe#*d8j*k+O6aqoznO=P<P48)-=RZzm0iTHP^Yj}o
zEL>7yZ!IcPOgP{fPz+2qIiETwNHhMQ!hiueW7C(J`!8<p8*L5(*ZQVoHmUPkxpj&n
z?8jX`N?OPgKi?!0`xX}JLRR{c+Qeo^@h(h4M<M4;YjfG6dfh;20F%$t_EFv&z%gzt
z{&r>BVVQzM%SMFh00ZwG_1cNdZ2_LA(_UX7v#}Vq(<Yk)yQ!1*S567RxONeTAmP@b
zr&53BU0$ve8_DE%q`IT3wj4CupO1|D`mS=OA<nBVGdgne^io@U_Ss2gd6wYtE15b7
zU(0%1Tv~FE^nORwc!g4>EZy#>lKICJfM0P<g^}V5R3T&crZj*<iSj!~Bh`=9U}o+C
zZ>UK!;+|@48!tBO<x{!@7&>|DO>B<v?v3ZKs)8WH&Bra%+go=IRNg<{IM~$#Kz<ZZ
z7-DbDEzg^@Kt<avxXx7jkp?+wvGb`1H(gm*cX4(+QreuC+D>+sH&@>}^Fw|Oj-7KJ
z$_tOiJy)r8xXMbEl|%wk2fD6eybFkjYrp5np>P1(Mbh45!I+6jlbG|JzWUdIlL$Z{
zS$bY803n%45|Rdo=SJ3@c0fpyB|WowPN4zNi5h0y%|mpA4-jP(X5G7%O}Pjyl&LFi
zLQ-e^P}F8&EimDsN-l|;h55hus_a4j%DC?l;(H52Z-HXB0n1#Cl9a7cnIw%9teCAT
zHBDv)pI;9J-tZ14%v~W(?(Z~T^X!23b9%R(N>U1l)b!G_vDC<w+2Nes%DwOt{FIKO
zOjZp^->p-g1fz+9WS?{m=m#>CNfrq=flF!vIfGAuBq5uEs}9geHjhdtLI#t{uVHTS
z3Drk%-DIvWWd8sed1X7S@`1jU++hCz@rhivF}?dJ{$*M^ms$ZLXG5T-y`ka?O&1zw
zLc6;w?Fq0GX#4O+gmpZQzZ&K^mI#S(3#7r~fdCS;Ukc(cV~Gvn_U>Gf5*k5N4LWUH
z>BCidhPG9lPAZKC=BVHYiTtA&rUi}Rs25k*Ma{bkSOIHnfKRW+f%r^CAYSH}30Q6?
zgT*_trBoMkl%=CCC6qk2lo~1_Dk1^v2jNP)MrQ*G*J#(cv=J(T{7Lqt8ffrt3v#UP
zCN44&DIdS>T_^m1hW4-iOT~tsf2EhjF@MLV7}MS>H6aQrN`Qi)y!`oBYqTy_?j)ji
z)}^E^!i>m7A9f^dKPmXq9&;E8)a(T6mkI@-uJ1OvfnKma2A~c~U8yBDbt}4jg{f&s
z*peqt*a6R#Hp~`C*G1LbI#X<bJRvicJ$d=;DjGK`ONcNR#g=U?g0mDW-boy`JNnc~
zafL7%B&Xabhg|V)I4s#gUwF7t3EN%B*a_w5Ps}K`N<bNk*!`aHO`izh%_YQw=1p|g
zYmvv|jv?i(S~RKUZeopuzlmOVHtR`2_tnUG3Zh70mnNR-mSJ{HShNFefT6tesugM%
zyUiuiM5n##R6JU9_12Sc5aqp=KU&qI6qKN+PEoG9$13O?-IqYulXb^<;+Fx!5((u{
zN?>lL6KjB=q=K@z8Ke$zx1P~n22p_<D_gUNzmSsx2ogy0+Ocuhc~>a|kzE)-mca%j
z4@$**MvApl1rbr1AzB^2Rp!Cdtx_b7Q(N^YTBz+Y1~%5bNB}}@C@)n99<8*p;)_6n
zk_BsU`?v^Ks*dDJp<cL3u}1<C0B994Gye6}i?A%1??FcFt_n~*AgJhLpFftBP3<?7
z_LN1Er1-LCA_SA?x6+bZ2UP6VGM6_?N(x~i1m=#Pf2DXrS(2UFJfti_P_wC$B2Kz#
zQb-mGE_LhXp0e=}wE~h%k~TG6?K3IDGQdw7ej7?sOb|iSpO@b{NfD}a?ul?d2Xn@J
zX@v0AvK9s1+7ROR2}Y$y-~p*~yBZFtReWuB;i)>I*l4Wp#ReeXeQAMV?Ic@RB`qUJ
z03-;@%WtTxeh5uUuBvxb_(dYjK6h&6MmDbXNXTRWHBUa9Z_c_GIxMe-K%LPmR?tWe
zFDlYZM#}0u%+efkfdf>_5@g3Tr*!(!Eq^SgAu-ECuTwmzKxuW+5JPOAv=`kWDoJoE
z3bhhR{^PLU-4s9#wCm=QUT3}6moGGJhMEWxd?8wBAZxG`5<%Ag0AJEk7Kpc6ozW)=
zWkCsesV*cHB?L~>B=U;)#3%en_;07B`B`w|_RhMNY#K|5NzA1a{IEw~?ls_DA;iZ+
zK%lcLNOr$pUQ6fiTf<vQ-0xp|He|Mx%C;Lu!l9+kvps)m3tBGd1LQwtM-`3T;ungu
z%iq57hV9yHl!8z75$_$U?K(t|Tl4&WN?XWlNqvW%&*R7`=LYs%Z|_DS#KlW}NJ^Tw
zN$`OZGkOp-sdZ-3Zc2YXy7w6vtZRst*ejn3X4cOQSGRXzcFGMYw4?;YNH9FVN~4|E
z-1F<@%;~HwI>5Q$QxFaM>*%={rP3Cb&<dJ56;Hg6?N_H-7PPm#Hs6;pd5*NOmo<(a
zJiK{?;dfT6PjQ9Aw<*yo22k3jAxEB+;2TrRpD!=Uu3GSORMVE^E*rF1J?1NNm(1qK
z1UA~b5zzIi1Tu1Kzvc$VaEZh^%n|n<e8N7%pU44m-JV@2!;Zawp30Mek^)gmLyIjE
zWQ@(YOl#BDidzszbo~!nAJSYAajxlhZwgO=Amxytbe}pd@i27>Zfjw7?ej==1u8Bq
z@<@`O+m$duuovr~mRdl)lB_D`;UtxYw1^s&4?6S#VuYB`F1?wwg8L~dcSN`pb<?Fl
zaUunX>#j--k9$Pw-QZCGcw<!5fqQC{@fxKXCAF<VW4j~6)KrH2kdrVsPwcM4OA0Wp
zIUU7#Y6@H1AcYV7M{o;$ruIRPaQjS$E>&z^v{V98@;ph2+ffxXOQ}~52FI_`vBPmg
z2Z?P*c^@Nh+Wh0}z2|K21)bAtZRS=`;5rbXbq0MYoJdF~u50U<CkJS>h61!3c^XK9
zAoQ+ct-<l@?6e<Z5u_jlOz0v(q-M%e&v|sBQjl|)GEbb-X_GfX=#3R$+7gn6T}e4Y
zzpJMI0N_@R6!($VGR2ZOy=nd`=#!T*h}+M4?r?{=7cGl0<r}!U3MxZD%xN2qHmf0%
zV5wBB8FI9j;cM`f#r>z^tZ_dOH*tk<+7=cZQgS<To`@WW{YOrdRCtAYG#LivWY*&^
zq1~o?-rj$JzeBit1K{2SvTujDM+IeWTYw5%0uuvutC{mU*DmVSF)r?H@*RBEWmi<J
zdt6J6{%5ZU2>Ngv{CS@58f~{2UZtWTKV47Km??^V;$-;s?yC$yV}Yk=+-jQfpJsS|
zJ;QI|V#zHz-K<+W!PS)!p^8;jhqxMm5jWaALbZhA)$lbtT5did-h9{NPZ`@|7F=PC
zVSGjpx7gmjZ1!`gS`<_IPW9d4=(3dth6oV43b^Boe`z}V6xP)Xd1z@NFp(-6jMEyO
zY9C;YgL0q4YJ9Yn6a{K!J87)a1;Vgg;02e3;=onDR!Eo&N1sk)M!Jr4W13sL#!^cu
z4M0{^z)E02I`rpIJH<!9)$NNYK`uJsK`N3pC!9~y=Thfr6ph>yCHqy*BAZ6QQBtzy
zKq7x_XX{4BfHM^Z#pf#3orm^cYk^_y;@38X4!8o0jeP45iQ{Lu)nbJqy0q^WtCc3*
zkuX3^3czDvW-9BBRUpBzhOFBPAOc2dJpSUVR;?<tjA))IS^zW^U7&!y=8_77AV8Ts
zrl9yEy2)u}DO3`u5On(Qw=HXZ#un%V+$RmUDwS*r5_xpxO3fOlWFJ(8<44{tl9ED4
zFg4%rrFpK@1Yx%YSlyqfhMP<fAQGw5(y}qrcPli&A`R8ofuyYgAg4p7wTS0js+Ie?
zqUu6O&;uLP12Yz~uQx;SAW+cF8tf`_0}90(nF^cj3@f;JASOsMK-K`|TG%_hE6yM?
z>Vkc+Z&swN12L5H@~*Hr<N;&5Fn);k4wZL*%}CT414unSm0G3rO#&euX|k5UQo$f;
zq2Fq#Zeds(k*Zg_lp{`kXJ5T2Gr)vlxvp18O0%TNnb%!rr?lBlKnaZ#<`AbfL=P#A
zX++M7TMZEFgheQAXbD?^An0`xdh568OJ{h&Q&^VV1#f;7@I*hwn9md35<i96l%S_#
zw+u(fDyea*xiI08uU^Xwjl7y{qTl-;YyK2_@e7MD_`tVZ_hG}8Fg#l7XP-#rw^~;N
zU?VW<{duiyB{1APh?P{?td8wjf{x(>roVsUx1VukAnRmW)ok16yt`O}f|8;@$?MaX
zomM2-peHy2>GkXKmautGFo)6{B~C+N2vXBJ{{Y%QdhujiuT|%~INz@!x;bHFP^2#9
z<Rs2!(x3FwWPHw*=TrkvpIRgqyF;eqe^R=;#1e^Vg?Aa%I*D=3bjmq%sBJ9Pb^Jdi
z4tq%3<UKcDw_|&J(q6oE%X~c~DNO}xuQjXXpy@_(Q;50x1eh*#3lqNQ@Sgtw5ox<{
zY}#$BcD8daQU3sl=T*sb%)e9f{U+oL?zi>oP#<W;v73X3VHV|XKCG$%MqqPM8v)au
zS))o$XV?#y?4hXk(ixrU`uwYZfqOc$z}Q976dk@=LYDCx4rxz8UaMC*$TaI;ZeKOe
zVzGtfmk1ob>S*pQZ)D&_hy{5(N&{Tn=`vm;ulL{P4HnTZ68^gDWYXANTf6NqT=#7~
zFq5j>JdzX8{V2l&A`SU({&U#vdnu^lQKg_vZ?N_2#3E@zu9O<NVA$I@kPAput$J&i
zk3Ll{bbMb;Ki$OG{Z&l4Zo`<3&fY`svQ@U+wOSa%85v2+tb!7x@-x&>fcmCE{COU&
z?gh;tnuh*5kJ32XDel9KttxTE%W67jjz`Xz&<jK#Be*=e*XpTMBsv|oqwcv)+A@X)
zW`?6((yo4@h)m0eUI(w7g$0()uiY;0BW&7xyQ2=2f>4n;hxaCqNw5<?B0oMKBps8c
zS*N#wT`_HadfJ_FL4>GyHSsAtr=g;YK|Wp{en=cz(*pee07!+eb8eYouN3P#l6>lW
zM-duF)AW?~Uia%{t)=U4ElEy}CtRmbg$R6@aD*?V12)U4bxJErid_VqHmQu(L1E;(
zX)kxZ;n1BFJ{yWGhQ#aclw2TzqIR$nuomi42$Bh-?u(SG#e(&<Fy3zMMMfkMtWgNm
z1s(0mGi8W2yK`@G;tCU}(Ek9vdB8cUyXnc0u^-|~vLyC>+DjZ~fm`LmvFDF^mcfSK
z=kOv=twm?{_;WgqSJ1!WJV&)*!&La2r-((kQP8%V3(8yFKn;JzbA*5(uFn!C<5ed@
zPzsF1YpDC0sPZPr0FebDbCssb!l5%0m&%TtfWIZ<avKVx?K1TZvf@h8mHz<!ML-_B
zzuL8MgS-SURxrYLSqBq1pAc~Ztg!2MF0L+K%Gw)5sYI9n06ylvfrO`)n42yuiDE#h
z17)>;4IhFld_LaSv@Y4%M}!Ah!(LZ~APoz%x&HvCmp+w4i1Aio$7f4ky5zZ<xVP7F
zWgnRPetulmthdE4c!4RvcpaqJVGJlT?b=h8QU=Y9zC5d(6yJy@t#Uv=GuQaMSx*H8
z;$O>`pW#ffydw?a>rl<BLQbktGE}Z=Cvtr1O-&ln0Cm>tql@b}z2;9{LU^oHp|Yj9
z03ElQ9W_uHbXNq#P2P)1N>(BjQBV-ups3Ms3jCh@bnxxJ4gMoB_1k4^Vr?;gQVc@W
zoTuhcPsY105meT~4BLJITKEgnWc3A6)|p0G3Y^n3m-MR@Ep@ul3G0rI<e7jMs(}(f
zod?j&ezc1coD3KVpm7QQYSK=c1rjy&`Rzp{*eJ^qS1mYh0eQ@giSVQnGVec;`q7^5
ziDVjv6X%qMk*k|*Km+U@Xlb`ItclLcV68sEdplk~iKi8~w^3!X2qt_)9S)y=TCI=7
ziY$PRogi*jr(12|_Q|rhNC6!O-=%Ucd8<&l%Ro0PQ@kG!$b)k5%(LQ?O08DVlx}Q`
zcfb&lG0*O5l+KDvIj<D3Ie-AvM>-~xC$6CeRGz9jNj#_t->$y)QUI7)bqo<1bv|Ey
zb*@Y<kN|F#4JRN-6Rw(a{dY7a#ET*g0QZVT(x5VcMra^xPbsJlJEjJ-nNz+2AcTTs
z2qX=O-hahqV@TBMty627%PXS<8CytSO38CBLe8#lWNS8xkOrLfpf&{c)T+^O38o^~
z@(PIxJg8e^GM`HBRNrXmNJ5TMKu<W^m2BX<q;+L{!<h<&c?nhHgD!*K9exqgx`w#r
zm7L}P_(yCKfZmJMCKM#V^Q!JAk}wH?j5dbzjX=|1UyW9Chzi3-WU?CzNd-a@Bu3F3
z{xLw~x;ryYuDxYpw@PHh#<V1mq>RXmO^|YvB#=)poh*<I)W|v%wa6aKtwMxq4$=Bl
zQ!?c)611P;e+d|OW;nhw>QtZNSIY%a{{W`acL%Jf{A(MIyZb{<pR4-b%a`L7Gh*3H
zf7E?R_OhdUUBwrSVoohmq+2Qy-lx0NNc-v3>34)TBM&mVMzOT1f!CUX+TE2XskCZ9
zNJ@8~%$<G}ut6G>phbdxXJCa~CgT%yly2KPWeVO;Q~S{NjcA7J&#e;;CpgLL&+v^}
zUND=K+ovmw%L-_#{XKV4*i~-yNYE*$TGq?IX4@x8xn0x!)u>Co)P*{&64~gH8lSx=
znB1+GT7G3i`_KUN+tjBFT7c?bNK!K>XC!7?yoBsDra9ycyK?)KkjNys$>+<+C(6Vy
z{OYv`O~6Pn0^tcfiR<&Fi2%9>%h?0Lk#arIhaSYZmk>@5fwn^pn0n#?LI+Xurm~Je
zYE>|TrB+jKGs~@2rNbBo8^Si(+lQHS190MpjG5ei)mEibQV82_w}qQk?yhfVY*CkS
zr+en?@Z;XvtaucW3MP5<^RG3T``aD5>zb-)v@pJ<oIYK0PQh(YHr5;wd47Tlp52zl
z`s?C5?N0zXz1<G~0I#L@wbfCZT9$7u{{UTRER5mdwjWcM%PzjNtFbvehnJ;9xw>h;
zKE3=3uTU4V8DKW+fAJDF>%1vx*E^{Iwn6v#=~5Uin?v&J_H~)4>VcPL+W2+W#dT+V
z(lc6wsgMkV{aJyG-?*;<Hu`V=kFM5<2h${Hnd?u&?M{@fNdU%d<_?Gcq@G7fqZZcl
z@^_z)j=srxb4Q2Mz>Z0y_`CP&a?=h-c#RhM9tn;A0Ph^=fXpPDeSD8N*o{*K7SbWr
zE#cP3#Sp@oZH8Q09$VJ|Ad>E?NsVL5fIBgU+pTBaClE;^FcIPRMC>o1EvFE32=LD2
z^B=VnOM&YD0KUADQkzZ2p2^dTNj}tvGLRtU5<Vi1&ev3tBf3IWZIYzAs6ykyq4|1O
zqSw>guDn;82?2X~c*UiXuCCr~g*FV5U`XZks3$0bZiS3>N9Cp^2*I)ZQydBJ2eDeV
zs7WA)TpW*(-i@HN0Z{o5--2~|6zG$Z=jajE83F$A_~kGPwIYqSyHzJ#K~4jz@T?{R
zPNQk5zWSibE&}N{$V!4ig&ilQ5Ow?zmP-2`!0;Y6!WV+$){VZyf+0gx9!dw1rjF>h
z`Vdm7Qw>+Oq+pE*R2LNXdj9}txX8A*aZlm5GHu-_#6Rgiaa_j}rP#Psr|_Sl<i4-K
zxWMB0e6<8rZoVU!P153<OgI1pe5)o&F)L;P(J;j?P}@?XVm9)p(~{&Nr)6B+c2CEh
zu40D{;mZ{@YOf2|ZzuUk8*|*pO6s_E0ZF2@Yb;(d#xVFMmJ=@IHS5h^eUttiJ1^`p
zw(kXsF^(dMcIn_1-K(gdbZ`D@<|m52xAoD}uA|+2>a|Lk*B3s`<<HNkR#I^MQ;S><
zV`}cO<is$U0e-$!PMsl0_LU5twd?SO)tg9Uqpvk2Y*}G;=(V$DEg?P_NQ#P;4MQa$
zH*%WYUafhWK{8E1XayJx>nnXwj}S;a%*mqyO_Vs=N|fQS$jty0iJBUtxKd5c*X4iX
z_Whho@ga%^-H~NuX>Q~Rg=JFU{1z*!;9ble_dj5^xO+&WObz7!0Q(=pqU{}Rs0A_<
zAb>f1BCk}qfVLXk#!B+?*E-#B!A@d93Xp!jvHmG0#Wju&gw?i|>YHddg(Mw85@V;G
z6K!&d=4=zdhM8!(7nFckIeGp4=|JZaU?~=D(p)2kVq9Ou?BUkvDngcKB!D{kRf%mH
zd6F8_Rpe~9Zvb$$w+L|6y`wFsIBXRwsr@UC##eQEmRgNyi74%by030S&I6E7P3o0G
zDYqypUS>iztcYv@r#<;q6C{}^8)TB)f<lZECwlM(Wl8W{sZ$~doew#w-oXxAO5rXP
zsDhyfK^%p8C9w#Ot2G}91!<F{L5+W3@men<P`WB?%vXg$M3jTCAP42}r~+;gl57_)
zC;6oc8WkorH3iXTqimb>6#oE%8$w_LM2Od%ip0gZxRrbWDXV)2X<!2+A~|RcXVe4{
zm##}DsRWRu475XMFd!YxAiFoJrs$N0AjDd%gb+yF@}eMvBy|bYpWalzX%gFRu66`%
zTG%oRvaK;WB~UIP`+CMnmk1}yd5Y>=Ibl(G0No$6MnIi{jFL#xNP{0bQ^A-j7~(=K
zm8-l7Uc96Yf6pqcO{|<XC3To)O2L4gdWC7d0S83QL~~p>1<<s?B=QGsKWY*-MVPl#
zM%=3+OvyUyywc6C6xhf;T_K6xk7w0HX3{qR9(3$8CHF!}n=O68n0?O-{vR+q7L>N%
zx?tUqvmffLt3%7f1bNph#9rFivzpf?dgr3$vkKf%?$#iDht~f9MVz?K(Wa4dtfoX}
zQ5vXnC)1(Vt!&_5pbM*bE&!d>Ii>?983|F{2^+^r`jcAIoJvRqraJ4A`Cix_LR@i8
z6qxTfN<sdV5AO4*YX(u&{*xT?Nr9(csFkD3x3>YCDRs_S_mApYzO<aVwIT;rQ7zW@
z`l9x$EL(?f6orZ11`-eUq;s!)MCJOgd;$oLw@Vv~+qFwQ<-N98C;FB=ys85l(cZs;
z7r0C}S=6s^>>~4sA2t@y(@lwS#E%L`Pcn7+(|`>b-F{zys?~dGX{w*#HddTC%295F
zhP~veY4?vXuOn3JReeL4{{WqCs+xVHa__(E$vS%NS3UcRbGouYmkNvq^@%?jscU9u
zUb%gej#^npr`;uD<Co7nZ-p$eg)S27t|!HCNA@4-6!J3no$~yu?r9@4?(c8O>%~g2
zgd+?}7_w}8E?H8E)xSSVTY-K0^y=ou>a}a#-xs<(yOynx6>d`cl>{v6g^w=3eCXsG
z&#zy9BX}z|4M`5L_Uo%?(YJ3d2}?w{luC+9r9cC^e{U)<$vJmBY=3?`?*$v0%5Yt8
zAJ2j)E-=w#i>2Iv;7Q4GpprLAhguBnAU5&!Y4P_5?y8z~bC!W^#@=JCeuHf9E^*{7
zw*j}YNh$;n89d{dNtz%s$f<M7@A*%wO|%FsySn<K7H=ZJcNR<pHgr-p3*{j4F+y`Y
zyzP8+_4MeZy@BFfXUA}zIdt13zihGr04T?a2mYb<Dny+&*Pow=@k{K9?z{ASzZ$O7
zeEJ+syP!7ulbH`CJ{6eISB0ZCn;yN;c5Q;@+-?)=Tcm~@Rw6r|??(vO`Tc0avJ;$K
za_hw*?9AXPUUW(^#khV~7-6?A6v@a6Q{g=K+KIJYvu(`-@D8zY0)A*^(;vl@)#njA
zkRfuzDLxeFPT$n64Gw0s#;2_jw3<@dI&ON<B3AdU%5pNd5)%SMK@@DvJJIu1UdWj@
zMO(RXOYXu-VKWExrhs)Su>cD$RfrTTxmlF~=m_%js6E?t<>-u4%q4m4O}w8F%3??~
z*4#l#a|=j>lUTCZDo$gWvpRDhf2~7I64ei;2%c%59I%cf;YXWgocA{6Hw`D4A|wxl
z{OX=Ihiy&GZl?aBYVaIa@Nw*Ok964js(#ka^BQqB*loI=c|rm}*W=Q;oIVn*cV%c_
zOvK`-;Mi(bFaoeRYqGlwWjBa%i|xF*%!_2nO!SU={5@-Sg&J6Gd(P{r`YtPo{{YBp
z;s<Ag8C%Tj*VRnk#4a0bVYoe#Y}o=kmS8M^AW7LH>*Y=U+)0vu9;fjobKRR+H6DFW
z<9@E3*x(Jbmg^E;cL|iV4~0LeK4)J_vfQ-9G)e1Dr1MqkRdq`?!|HnEEQmROr*_I9
z2?M1;1=lG-fF}9eadJrt>(kPw!5Zu#DOQ}sl6hB`u8CNwtfRY)<H#ByPRULj(Z+{%
ziI6mtNyHPAFEqK;emMRhaqsxMw_Y>Hi^sZm7<sfP>Pi|t*wCJcuH%Q(?C@+H#Qe<t
z*Fi<Sn_9uB0D8s#vY{?DIaU=0Kn6A*e;#yBveIEq?w<{|q%A5sktTGFzO=ZKoZjfN
z;?<`Mh*=o{og|YS=cP%}PNb5Ew}-uaklSk^DiIouyt(tJXbrhV0;8ZU3HW>L#?uUJ
z<9AlWyf7q=T5Zm<c%Crj$tvwSBAJG(?e}}~7;Bb*kJh=#fhpN?i=!57i)Mf@2@$95
zRqB%Rkz=Cm!3iRCPdzj`(%^5_iUdsVk}1q$K-`(3xYZGolUjyjBVz!HF%hZ}Z4zX`
zAZyM(JJ+I7g`0`U=xtD=q(|jiE^eW8O>`W<Lg8)_v*9Tkz)%|LKD(NNHeMDI7rC2S
z$<9ayVDJ7ZP7yGlOu!t}_kxrHn?e#~n5>*jNG277Qd!<tJ_eBEX%ch*$4`x9x=yPy
zzjUbsO@NY2jWmP3C8lmV>-4FUFcKJnBHYLJn3`a5aM3o9?<z~Qf)s@&0T83{)-<hL
z7seL25lF1}aI^eDVI^6nbnC5kZTKN(xxML98$~V9g5!%>N<d7jmr1J6B;7HAtq?4U
zGNLkfqeuoo6p}<Hy@qo%FQ#KD(21TvR2JP7z?JF={{T%U40Ah<Uk-I7z+Q~blAbY{
zO{vAi?HhgTNpS?gM-bG~;j?#rX>Lk~eCj|muBIvUNo6;`kUvEZ%P>~^;_DVHIDZbn
zt<;3KX>8I4bKy!*f#O$?AZgD^;VZm<BVU(4&o9#BICI|jKC^_9Po4JlA0?Rh!wy~1
zQ>_qG;?%WDLZBT%^)sOLt=ug@0Ncp@KRzq7V`IA-dG!HTZ($Bv0HT2Fi%g*@KHwzy
zPn~NvxPNqLh3x+TvFrU!?bNh8-Z-%m0whQi$aRXa@?u-5QqT#9XrD5x7SfAF5*%_?
zls08YT}kq!xz9I=>)jkTS&zCbn|57w4mjde8xT{L5QF>eP#q2K&)oqK=y2<r?56J*
zz8G#EQj29OUUogylljLgYiWQp)cGX7wnoctRO-gY%LK7)7Okl*HlG-u62z06&XV``
zg;A2?LDhF~`fqGkd2q7Ln*b=Dr04+aCX_+c+?4^sld?BbnKX<1X($&A_c(higf@?T
z-kIY?0Uug)1`tipwDLNjhJ!nveOXAY9`;rg`qEQu(Ee+2rd>5pokS8#xA*;(Ua21l
z*JHn`elaHQ7Moij6=eDTUZfRIC3KFJ;z5!>&#zv9irtZn^*$lhk*gd%+cbqZf>1RK
zohP4%q5SF2Xa-G*`5!(<$LDLBH7bXQA3k1w9^BH{hA(1-CHy_bCh4`oXnV>Z+DAWH
zT!(_fI{bTSq#&b*s7zG&PW^j+(|c?=E?z3*8$e+%e=!XOLwSJyu2O!K4sc=2M4bui
zu3Xa`?&ewsW9NQe2%6k3x!t8*+K>T5iPA?Y9V!59Uj1{o+tDO41%<aAb?%f?%UArX
z$q03N1F}{;x^kl~Iuq;p`~60R16T)rw*%%sKK^MZU3HfOt?C;9LES_9Pg;=ErsGc!
zFULk;IAwPIN+Dr+W{EGfR**u2C*N%U0Mq47VaiCg_SpG-{;H*FP9j0|{HHG|>-LnT
z46HZ+P;Yg5*M_q*^#1^U=};+<H}U%<n_E_lOGX<?!0yU6{iu8HJ$rr>k(tnSJEy5;
z*AXqPZ6zz5$veRvDecNcY*jZG(%h#=f55h!fUa}-)QM?=l16UxQ)|3fp&<8}N^}mW
zcuamqh2*$+bNu!4Rw&`b{kKgm?@imqYXu7fW2mBN*#7{(q*WQ&2p0)g@B61en4&U_
z<DO)5qBAf(KI5+hp3gAr(G9rAQ*C;bwGJqaK<1M~*B3$GuD+^&k1R8ykm2p!G|;}d
zDYv(uecdG_bfs0U)@XdW{E{+uhbR(y-7A8*hgdrEI2IfmQp%RQr8fv9?-RXKCac|H
z0IOJszNiMf^ATVtl7DT3s`b^}y5oUM5T^>DsB;6L^rkk8TX%oHeEpSYRxJQGZ=!zU
z?Xc7#h5(XaK-8KtNw7gB=3ZATxLVGq*V2w5EQE_{Qr0q)mtCvCnUaWz5S_It03=NL
zQ4&H8N)>;L+qZa|1h_NID2}>mOD@nWO`zh^_)-f85E?*AhMG^EGDr%cY?ap^adnpk
z@IE=k7mEpN48z{IB<<lrAbd;;OS4p});F$SR1Bfoyi?|5uSNKpyh`&C#IJD|+*f^d
zaHpLzPGzY@N7r6e^al>gn5H%hsHVW;UUyF|*6N%Soy359ywg6Qh=`g&Fszn>6Kl1&
z^Q9#vqC}|4A|pZb``)HGsA&g6ouQ`E+Adu%nb_^GJ+#;9OKYUvG?D}bV)j$RXyU8(
zgI3LkvjRk)EythfQHrYCEhM9)4uNY-FAulDFs7{-Ku%OggaP;dYmKi})v6L!qZ<}P
z@VjjC^1&qQuJotAAS6{gBMN{rfh2i!szT=JVBI3ID46i_An7!~L9t$iz)GN)nH-Mw
z;w@$E;U-&vNC4|PP{)e&$-3|(MJZBb4QJB5Ic&YWEXs`(l!P4WA_)=Bw1Jh;I@Z~8
z91961OhA|bN5Z^B3#pdL3)$}o2?jEfM<OTorTD^V<O-kg8Umb7Q!sML*Zr$28p9;3
z0K;Kjm=h%}B_zQb9e(_)3aBkMS@oPIQP5IB*N~{n8xpC>3AP~MHspeHYXI-1Fxn33
z)V?dKTeN6y-Q1u=5%fRiwJ-n|Le+UaoUH!#QF>IMp(j~Z-+#4rjUCmTT`umU_NX1y
zwoE~R6A?O9SGG*1u+FH8LR&}+1Rg+*{HZxfO*J`gyc!ana?YJc*`YJCEtiN%Fn~yj
z8l5U4@}v+hogvMfDS(lzorM8ji4YgqSC5J?bY*QtSFDIpfP7;^Od$UN7OS+e_CZm>
zi+T2p_w%1XN<d|>r5(d@9x^<+4rY2+30dF#m%+ZDIJciJSLV4M5Xqw1-|OM)x$;zA
zJBQh&O*+GO0Rj@FEJ#WYrNt|fi7)}JN_9?CXd~tS0OK6_uBwJ<g5YP+`2aNmKry@}
z#M^r<pdc_z5}d0_b8dXhn!ie+pX@zy^jClcW&-EyWdpr@*j=HP6Q3fKTyb9GNje(W
zqu*|0Z@N`Z>B~Mt$C@RD`zyIF)08xrJ?4`3pOty<AY?xzve`D*ntIK)C5__BZq35g
zvJPjIJ;cf8PUm`>aMtIkuUa6g;ZOS8xa-I%(>As^O`;gHYFbPe0M$!Z_kML<^-Whw
zLmEWpH%@Nu*lx|-O7+s)EPz``5LV~*fzZtmYl(q*>VGP`o*3Z3E`5-jG+l8;!Y*%-
z?DkDTV$h!sZez}3b)#_<Z8Gj^8BDNG&zhB_w`dXGDi|UF0LY{WCVK1amr=xgI<77o
zcNaiqwG=km&T%kAAA8cBmJB;l=hvUtnp+EK_l~Ei>*|zd<*YeKcMeIqN{qY;d<8y7
z^`Z<e8JT16*Dp|c1Lm>GQrx+YzC{~eJ9H9^GTlkI3y$H^W4ZEK{U~L*c{hI#&*Q+t
zrZBfP93cDod-PFEGYw}CQt>|Xy}NLD%Jd-lee<Yufv~q+`t;Q*tIa?upM@^<*uIul
zkev^Msh}-_I_ukeYJgMh#EbRU?Q-41?3xYSAgbJKuzW}xbKF;hV(rtH<MFqVQsLSg
zd|yM?_?NrHM{=2Oy=<QYfR71|bu2r#Pj0&8mrjp(?CxE4<eH-D@h+8IMay6XLPRJC
z<azp3f^=tJj}5$(zMCT5-nn(;xi{9fB?>Q>b1W3LHClD+ynnTL0&LOe%j?&=_E$I=
z5gYB-`iL`qdvu)1Qd$X_N+&YJ#=SJAIhjP0e!h|G&zh*_HKYJK@cp6|my9$+Zb(9g
zQ<&<XQ}d!}gKf4|>QZy0i<IlU7;Bk^t*clkRDX@>fw@j#tGX*R1FCO%eqRzy03;B1
zuTEnfb=Q&6q!?E=S4~~ETU4lt?;9XY554J)F{xgyPcM20niGg(O=0ek%!MF#jZZK=
z_WdA&DP$V~zMf<9KI+XnVxaGNAF=ZVIcD1w;wKt&4?u3+CtHUECn?bS>8*LyTF&#2
zU*fFnv_@B4oq{`sVYogD(gqmG#BS0G6?E>XN1&?55c-|kVh36Tih=KOHH>&7X~CVv
z9Ph8(Q^hLG3ZNk#gYV%?Z7|8r`|GJl?aLvo`gPZeEYP;KBpj+x_zsjs=_D5mq}7X+
z5|pHfFgaJUxRvaH1>z2O3yRE4YH5Pj2u<}$!755jffKb!)e2pP$04CHBE7t*av#LF
z+jtHd<;hqMDp1fo)f$-crB!rjtl=meL&HGxRfZb%_5Jd%f{GbRi>r0Rl_^Nv&q$>>
z0Na(&)fDM7AQE(iDdC>bTE}mVrWk|lcFGA3sA}n*Rp?ICLC!Ze9d!#jzYhL8Ge6=x
za#bJW`?WRj{{UsSJPBoUlKYC@3RngTZCNQ&zxOLB^VYPuEdz<f_NPJ6`rpx4!BPS4
zsTy0<>-6_uo>rDEziyY?R&_0TN&u6XlgoW$*XdntLv^Uf796EG3l@P6XUL=j;L9*a
zubm_rHclY85wdPvb=Mxcb5eCGCQ6L&Qu8JPDr^jBMzCBW^BzLkRHSPj8Q0<HDWRda
zDn2s-YM#S*2^=YcHvPkY%vc9eHO%o`UUQHwDinrU<gC;Kdvpi{gzNCEcG<U2sCzJu
zGL)qOIY<M2YOO<<-BcP(u8M+`Qk^oL{{H|<5g`~6s^!HTpoj;Y{&g`LA(%JOCA8(`
zpagTMg5V`aZP%$9%82Lz-iG?G69I4u%A}2>VZB62`6Cbw)?RTSw3TFDV4@YS@-#78
zxk!*#Lo!lH%A{sM8KZgptHxBu#VE>(lmcdT8}c0HY7LFiv~CrZz=&IEM}Vdyl<Qd7
z_kpIW<5)<(isiwyLO@pIa%&aVD>Avgk)H%ePK3syy)rzZQy1MKe1KV4h#+iv%|JP$
zt<&jQ(iJz_N&&S}fP<*swYYnG;c7U=Gb=s5lpICG=LF2@rp6#wTH7&alim`f7C|r*
zq=b<<r<eJvuS^<Snthun0PVKDH|y(3J>g{5jHktN0R~EfKsp1k{{R#-vM8`CrprnN
zS>TPJZhYumye3y_b2wORfFoW;Bd^MY0Em(TC)u5$#(P!aY&7N}+*OH6Qzs}`C-S4j
z7{R;^?ekRej_l|?=U`9KZO$)4x7dT~XdnfstpQ4bq4(B&qe12J`SEnrbwkd4zh`b=
zHG_d7l@_$lk>}t(>Z!&Wxi2okE)_ECq0kqiUr-RGtp5N=5C|TgRi#WYL$v#O^CzF}
zbQGQ=JX{F3&^PX(7tCBaZFs`al!BEw-*~7}wFJ0N_QrsJiqLC-gWx*zD)763Z<W2h
zH&vb~gQc>9_wx|3IZ2GiF%#*%ZPBa^hRABLgD2<dqFV~FUNqv^Va2g*$_a7g>J$F}
zN@L?p4Gr%+Pu(rg$TGKI6=K?3Sm5|`Sapa`bd-T0Nne>f%~yM!RLZIva~D5f6xG|t
zu=%;aoQst((o-v1qB6%qXxmJ=&^7A)Y=!lEkl$3!#?tSIo^Imx?4hKnme2Zaq>=oz
z_2sVg+|8gMYu26#Wtj=hzfycupfrni3(X}hseuVd(>#6sDzUuEl42TkKSbX0{j{W9
zUZ{UHys2lKiqyy)v>W<SwXSity=&pOf?Niiqi?5Nlgkl(bkY{5A*Pn65Zp?ZjHNkL
zdG1ffj0S@PUAK<E$W^K~J}v(M*-pj!uFvr7J(VT2fi8g|uz7i(-k_3XyRR<1Q3^ts
z&UNI9S~AWRYPJy%Te%BxEi$3!JpF1UlbN3`y7x$Q)-vlIk6n4CQ1kuQwk78rv`UI(
zYNQ?hBg&5`KLGUmgg*($=*{#g#qK?7i)57o9zZT7)THHFd3t(&^lZb`tK9&R&JWkG
zC0tX;ONqBB)2_6?Y`*Q#&Rs%~pcE1mAd~kL74YVPB%M0z?4hn<Xf5lmxv!nPw!(xm
zvgma{J8mITHlHo&P0vuxJ$l!lzucTN5A5_mj%h1ZVmB9VBISO=XrcpclPV*kk16LA
zMXX_yzbywN<LpN?4>_1J2_t{N_V(F2w`SF+R?`73q^U(nSeYkyJj9wV(Z^d)EjsGj
zr5a~0V{^?oV&zD1CCsRFC<G`E3jYA<KMg2_gggA}PX!L9B1W6@>vh|&rPsU0yl5!M
zQxHg>cmClOEChTy`29!WMnD=vzJGrrzBuE`Y&HI)X_6HlBo2gi6)glze7Pl@GXb3s
z(D^S7`!>#}yCAgggZ`g7Io-a!b4%>Y!Of^l?XPhcuFaMd$9(%><RoZNM#T9a&X`6<
zNwC|0Pr`?_fCoI->ZCUK1|Mdm-f;l-o2=P|vK1*tgi4PguR5nw7(+{G?5lU4f2_dg
z%^YIW5yb;)c=uL_8IsFM%GjMFs<il08pj^>LVbS2@~ge{=?ttF`u>rdW-!b@D~nPT
zw1_;1r8l>03=X>GqNw3gpd)3|n9FwoLf#=g29#|j#$1=#7C=aZt@S16WT*l}odBkQ
z0A3{AY?Wr%sd@Jxaupz<bF7~sl7yI!y6-emx=}K_ZMlIYlc(uKgp~CSC8njr0XplX
zR6NFr0g|ciDaKR9JVc<=r}%Y@p(`d41KwHn{GzK5{fg=Ev_=+;ABgn|JBwU9k6Wt@
z!<{yGBYM8-jzakyzwPp<49auW>%{f>SE(>kerH|&-d~j}?6VHEzrAk`!KAZql&#=A
zDvm(W)G*mp_?<^mq+M5DOACHBIQ^c`JA1_#vVAJB;pWqW+Yn?ZwoiC`ylPPY0LHrR
z4Tm&vfbM;TzkaHo4W^wS*uTVme^9BL6t2x(;uIw-l&T~GHvMDaS6{3x3p{u)u9<f2
z(4@<XMy{nmg&@oc@-j9502ScS1R-O?PEn#+)>f|Vgr`+Rfv&TxdHU2-U@ny6{H+S;
z>{EjmisCJmG`x&^>f}{Fr(Shmh~fnnLVg%ecr7~WS+cik)qs?M03;4^Txpt*%;luc
z>r?zT+_awXpk_SA^c4)*SE%4!WI;;^NE?ymp{ngOG7@6R6*yL+5(cD52k%Pu_qs4L
zfeWBu0#gEHSFIqRJf$YG2@3#g`P6tKm@C=IASz^tnh|iILzg3RNCqRGu~K`wDb&i$
zX>TF$le~#BKYG@tmR&Br;JC_MPH=M1A@Q$4UL@EjmaQO_W=}1T-kZ`NXq9G@Nj=qI
z@K`c{kVHnh#bjd17gpVtAzU~R%-Uc9;nqLJWI572);=dxZ6wBRq-=W719eP+qHlPD
zrjB9+P_&S2pGGrTQ@y4aQDo>q%B-dc(23V-+QB%rz!jzdeK}di_0#-Sa<eNXM2>p-
zZKxI1vI`|qI@w6D@gN~!j%3K4y8NjxfS^r?PqL6QWhyDy{-0Vyh&KwzBpyrV(%>Yl
zN{m2~bOZgU2?(zO_FYPpa*-sR00a?Gbc9)FyuNgVpr9>!^78u>Al*(|Nm4Gs98!CD
z;UuW6f6t_N2-8DTj05;4({}#={=sK)GdMcG{wLXPtai{k@n^Y9p~YrP2g0Yw{-vHs
z6~W|lY6#cIZ~o)<3z@?|xte2X<={MgRb7n`x8KeZ`jkn`lxq9332h^jV_kXE*x~>!
z^BQYz@%shPQHTRb@%Ts2;!x*o81G(iI;)K7Ej$8GjYe{|*yxj?`-?59-36mjBgdIq
zZFwRc01J)aTU{<yVaIqQ%fwY_WV8nsR95O%GUd?aNb;Y(t9OUg4rqBYCw)m)vk=i^
zrkuP{EE&seGQq4q)wGtwU=lZ(GD+vDGggQ%e4TpvLZ(0fk-uN!T-@5>)@!=EaxKye
zmhDf8N&_}Q)YBRZgfv|Hg;uM`aA`OD6xP9u%x>V^UQTt4(ngFlbqP<MG3B&`H~m7!
znVwsH)REC`ZqrTM5Qb5rU}_HXW74XZImTR58q+t`HpFpdwCZixExmY;b(Q<51W79O
zqo&z1Y&oTvh;P$WmLG?EQpMhG^5-n5xHT!<fzmar1;R4KN?YBK$?K9TtU=6CZCl~1
zUARQ0*T4Q6qgdo-k{fAw>NOr)q3rTzE;GyV_(U4Lw&9x<uJK3=G?H_u=>u7wv_g~W
zJGpuP0D6m{sL@;qvFoTRHaOoK$J21<4PfYQ%_Si>H%cQk{{T`_HIF}~Yg6Iuqb|fa
zPa)UsQ*~h=FcNyV=?%E!?lHn1a2zt(#A)6ol@#V3V8}lTw@<M@2E5X$(5T=u6Zl-+
zcBO^lmY&Mu-D4F~t=o%bnAJpT0n#<}r!ZoBKn2^)RCWsumCkWLH738{ON>Jcad><8
zc5W>xQWl$qC2AmSKs!(6=UL|x1z+!IB5ot^<Ky{W4a(5!E;2q{eLhHE2JvH@Erb66
z0^=ci<^8?WfL*5Cue?E2q?Ha}XlADo!YfsFY#{DxFVUaUXY#2RlTg8p3YysQcMszC
z4cTG%?Xs?v23C}EljW4^50zzAz*nSywWNI$gPP{%ZNlwXjpGbB0H#1$zpMNu(9;1*
zQkq_919Kd{wPm<Q)Nl13_TbyDyi#3XvVZmn2Sc}o*EZZ&g5s8J_jsBTr(7*0FT$ic
zCq)COI%zxUK<*z|nVMS=nAf&*Ha{UpIJ>nK@RL`U3c)XLm0;s$=`1N3LP!LXGfc+2
zYg#n8Eob*jg!${>eLhOB^04nP(`&`Lw}LHz@zw>!7(e_=!uN*u&1xZJrz(m^yp;{Y
zgw0l~gQ-RNO^E6b*!~fM+JG?s0Ed|H<`M25;oID43x4Hd+Y8U$BH?FJ43ZO6>epon
z1Al%00M2MJ6>=P)OZOhqrg(d-B`smRFv?m&0*jXm9wjCsXP4)#XM+02Gt2?i{{RY=
zN_i#qu1<r;uSFoS;pXt>RxXqlR-DRGjGWtoKg~WHOboZ{uOAgf_?K36i*?t6cJ;%8
z)ePIloW_(bX(<lM4buZ^mjtZ%j(`(Q3<AgvL+G8_+8`K8KqE<~hT7>yp-$0n8t!5>
z=|h(2b0=*#8*D_AMY00B8qYpLi^+OZi&kWy#)Eo^)Sz;V_K(Cv48q>Q?OzGGxkNg>
z`=-w4PGm?Pvq^nM&HC%vXmIQ=YVlFR!{71#EXT&3uizLWKZ4;P;t!zz0Qq*6D9ko4
zsBixOXs<DktaCI#`g#q|(RH+Nju7YCetw+1^-*pg#dzPe%wEdI=HYGItwkk<d@YWi
z5g)BvW*(I;@iKXpZlGoru5(0t{MMq!v1~i=@z`E9#rT`8i_1$DrrjzqT)0rm+6S3b
zReYwtA+(u$_43sDE-MpI@jOUi_<qA*()^M)*O-PT_5ISzj@-JpoLN+rtw%8@<6Yl&
zlLHzo7Nc93l2JuIw%Q2p)8J4{0VmU44=pKj98*I>MboS@<>7Fvg9^@)0!KYL{qmux
z{z^p<bxYy)YQ%1k$8zaX)Dl42C#PB0ezfKQ#^x$PFLW)9*&hot!+bi*oJ2h00VL@r
zIejaT;@E>$rd6#$q7=^AwOzgngykUb_sX+RbV6lU<p|1BlmL}LF$Y+Ru5MLUx=gND
z5iv4g4=NGKOr(fW8l6u~O-N}g(*=8&r62+XoptA4BJiSDG6{fYXJ3s86T0#7UWLqS
z2YCFdKtNJu!l0=mO-)G`2>unDP}p$FOb{d<zkj7@%oWj?5(40Wl}Sj<fM=ABkyA5d
z0ztloJ+)=GTq?=}iOhL=ew9|UrrRwHJ51cG6N7uR8U(~Eeb1F*;;$uKtK4e0Ff`?F
zG?19k)?1w<5U}wk@Qi~QlLTha3V;DJRXDInUWE4qiPm+mM!`Ojhbnipv=v&qV5dTK
z>G%3pt_B4_wLzLD7HhaOiYT;5%uM-opE~TC2WJa4)^~U*1{j!Vn1h(dSgOxyB_3cj
zMH(Vf;?xRu1f7Sc){yNkoZFivTOm&8N>h}lp&;w?{{VUj=9p~Q3y`H{6R;D$`s+fP
zSC6)=iqHwr@;@qA_>nk*(ak&T!w|RO-qtu<7ktZB_?^0zW;{8yGt*jTAm+f-w7{Q{
zlBwe<nzUa`9YG&43-mJ_YcuOWN}LZUq~$QXgUKNBK%MJ|t39?>iIRPMN&f)UZS>J`
zI5z=EJ4pWk_5T3=ih%LGnr*F|dB9dyp6P05KnzcI*Q5|g{{UpPknZn#fBm`o1ElNk
zxx?L^zzaph?c(nfvZNW}9_tq@J9BP?G=hS*&xY9<kA<LjQQCa|dcu*(Bpd5%pQVS{
zbgre`urtW-ZCq}n9Ak<q{{R#%*jS5eW?=vWB#<>Gd6EIGejA1~>1L>9$LKZ*E~_2V
zXUDEdqi@@y+~RL7U@($h{{XD{4?4aBhjeS#_>kviu!YVVF${YU58RIFDLGnXf>P6Q
z8IPP3^s6K`i(`GttQsG9k@wY0n=RQeEp1Z>Oi3HhGwWIJmz>A0xu-R-FV|m0#`5qj
z)mT`%j`c_(=LnwfaRblt(wj|y3338lU2FBK;?~W(aDuWyP=z>kDvg2p(;ePy{Sbqd
z#lK&Ey;G9q%C1GNs)z~_rxX1hO#WWA1)z@dfG!VRb43uQu+|aWs30H`?sY&{#=OvK
zI#8C&Oo>4o#FfRDWUZu(A%i8CG*gHBf&SiOt!y=)!)%|7{FNum&Q^IyOgM)bzPq_z
z4Z}<!DJg}yux%i0e&U}`4jMaLN!2NpLuQ>Jam%mThuz_PM~=L^I~+viU>6>^4uvEL
zf(I_OZkq#|9MNKese24OsDiMYoIi`~5sPsmTveUZPlX1hW>57Ljfffz^{w1B7O|b<
z$z<Z{7gKRyn-!q2p4PDY>qo8a-Wja(2VHc+TS(du^=Zh~WnLP`S1zgW@(R0ax`h_B
zUBy)#UE0l^l2p7R(W|tr{Ht>F`rJ{Gl{=j$pxSF#Q-KYz2qEqy)w_y~FNpDeEVo86
zjg~Mx5ho~p#TMKy0tpR->a(uEepKg*d19my$sm(O(NE&#)`_c~qw!N0w-)?6j$&4}
zHq8@kUwL_-005$M8PpPDbn=?2><tT?fPFMpTZpZc2f9^r#670tIFk=EeQ@%M!az|`
zkg%Z#HuI-HI#{CC9WA1FYu1S@3mW6RM-&)$4BkI=e|>Iqw%egy>HsEJue>=<qMUHz
z#K4QsB}w><q6*gEhF;6@Udp&)=M?Q7)dulbQ2o9VgPCQ+BQpN}b<1&{AxjZZQ^Of{
z>9h@Mq=wjYKV_gWo*&0JwX|O1Bw5%EZLQl(1g3N#ezk&VF^<hp-7>Z|o)DUJgu8Rs
zvX`@k;rMN@v$bxKmI)$tfl4LL5HwlNs^`Buic$A-p6x3kAk6itXlNQFf=$<|j_wjR
z8^+w|!;YzBN<|r+SR_Obj`VFXguu~0XDCe0;)qB>LQzfxB&$;cUS^<^61)VMPS{EA
z5U3=$ojK`V2FP67*$U!bD&c+)vsLdA<2KeUfFr$F%%kKtG%u{i9HQsJK86;yCDBYz
zvZT1v@p*z-7c4k3#mk~hdqT!p>O|~3=nX7IeX@_L-otPZ0Cjg?kW>d5cAv&vUh<W5
zh&sX+sZttIoTO}}ZbW=Fr?(4EnbKE7hr`pP*l2_|g*Y=9#x8Byv9wx)jsi}_J$0)&
zw|2>uA5M^xweMqnm*LzQYMZ=BHXd$N<IciTfH&0qb*dPQQ*;ZN;#k+$mbXqpWG}}L
zZ;bY-#cANq7RFn9hWKfDJO)#FcBH5+!KPIu5E3=rQY3BA@JtV6-{jO6I(c*T_8uyx
z7K5lZ96Qd}!;t%*$XUkH+_uU>)N+ML&VABP-^#XLR)ZN5zICIO30`2?S(1@6J4gHT
zsLQ(ZT`q*-MA=%Q2~h=61x5fH>-4B&OWc`Ih5}WY_<iAn#5mWs+%!vVLV-HTopjr#
z^sXmdVd+3#!qYFh){7}&lv=QqgrGo(9zwY9joHoCurQ5bmVM2*am0e6H6(naog$;9
zR;u|hovKtIkY{ecf98~IU?6E+C>SK^u-BCgDVRu<M3kKjc~ctROU2yMOHm8aI&~C5
zw_cG8!<BmLIs>IFwil$07n<)Au7p&bSBE9Z$e^sHCpRu}(w2FnZns(JGu?txqGMT3
zhO}I|KqSIxathR>0B3SzT}43|QL{i(%O@czZDtB*aq0eP6+w22)d*>oVQ_kagK7x_
zSsHR2wDYW7K!<3pRdI6_xq!HPouikPXFZazaU;BorV_6dgwI+BNwTXvu9CYax;q)%
zZ#CeZO!uTJd$jTY03~t0srO@g)#2y+0@eUJmDX>&A-qjMtjU-fhy?Zf_*Y|0cLc1*
z5Nad%aZ(vbAZFKYldSaT^Qx}|8BQ4<A`u3a34<k56QL3}^Q!JnBodZn$&wCV2_vBW
z>JezXN{@P^5R~RnAnYc8D)BNDhXH;`Co?Fj0!->>W2Ftniea-t6N)6-Jk{866*RDQ
z)Xc~}m1hkO2ASL+!clvJv|pqgH^dC_M+abhOu-6g6T{kDi)hL3GJvL#IY9&yTpli&
zYru8(I}$~{LKh3!_7z`Cc9Rp!P~-MMc<{yqr!Cfd#+F-9Y)D9t^w2q;YCo4MjTy{F
zyXih3{w>#eHlBLiJjHMwrnmP#dj*{=aEn%WmCLK<P_?z04cR6P6=v3Yfw!5iuMbev
zrwqT3TOAimiaDtU&5h@NzRTQy4rQb_c(f%Q(azI~+U1x8f8>&C%?D;6G}!6k%zeVD
z$HalI<B{j&N9916@3Cv9)PyY-<!TMGbP6X>eK)N*?Ae*xrG|&N!kuB(=)=?8rV5UV
zopX+H<}`|=Npp#m(qIWqF$_UVaTb;;8P=Z~!o9@LmpwG6GMh_e_0dUraXPLnEn5z#
zBn;XsGPTZ30!jJnQ10`mWXKfT0WR&*-f=c|<tuS#E<!o=qJRL7y8R_JrP5!be{XEo
z7z<g{R1yl*brN}cQi&wpF|hbi>zm80a}>J3njsd}$!Xh!M~TF$VI%(lX){|mYAvBp
zwmR&o;wlp1O{3SYxi7ef8pAMLJ#9I1(=G;%R>q14qz+qaPr^}tDz0O3(LmzdEjcQ_
zM`-rtq~Vwj6y_r9q$=U@B?ObGC#SC5_O6U!8sj8N!8odom@pJ8i@4VvPqj9TWxGT;
zqS>~!Ff{(`y2ksCbZ(^9kO`PUn>p_l7s6h}vD{g^YdfolF7AlT252&LpO2U2PHS@u
zh3he;&e2?Uc6K};g<LBYcfM}S%8*wLy>YsNmHmj)V{-zmIqhM$>VE_3vZ|NYa16Bk
z<HN-L6kh`3><fsvhq`M6YW>F0w^Fq>L4DbRU>^bmi1N}!K&s+KQ9pHI^zu`J?4z%l
zOXE&j;uvCH!rp1zNic446_5FABm|PC*iX73z>qb9M!L{|ONp3`{{S6+)t4xfV00Uw
z5}}w4<{tI$6t?~A_iS2Vw+{zhSu(t#DG8A>OM_h|YEE3;-bd^{r7F9i(<52^s2>bq
zIR5}>d_!-;cwL*fH+L&a5~k2eKnI!hfv=S*#+?zKsep;qCe2$zvhK(DQ?N@*YxP^B
zALE;!3L675EsBAJz~`>Mb;e`(wN51Chr?N$p1S*8!tnQ02CZ`p`k&Ig_#1=o%AMj~
zJ$T&W4wA6KkAa!kM=}BUO=CW@Fr>DCk~Ka)Xt9`{)HaqMy59}@`l*$^D&ke#+m#dv
z0!Jz9(w4@#-Qu(Av;lPecM_0+?^B2Z%BYj7LCb@gDL|O_x(zwf!6xYPfpo8aq6B!z
zkR*JdQvi#ExaPe;C*CJrz?wFLx=}D}oi;t(zz{wZWJJOdC3%YDxMl%lZ*i;ZYb#`X
z&bqLX<Ta(dfO6`55z=9(VWLW@_?z(*jAFwOvh4YlrPdUtJ-Xo#5@SUn2U0cAnDnb7
zht;SvRql_k>#f#}3=>%Pir4TTpU2H*ULd>2F?;)~-XOcUy}fZ@txh^ttkcWNiImwy
z<)$Hal&Ced;kqvHUI*eVY4(?8hCC3pcuIi-eQ2KMuuF_7?N}^TtHZsBwz3_>)=I$=
zl>Y!%tx<mvr%ufhmTEkXL0+66!kjU}cuKGCT4LJL#j@kq4yYxzkdZ1<lzIxKQxf{t
zJ$_aeHoKT%x}TX?r}0VnmBf2c;%7Khfw70}_(u*o20~D8-Pum6H%IoQ`t#GL;XE3h
zCJOk5_qGRb-`mwLi(N=TJ>#h!!>_W>*0v=}?+P;jLX@aG>SyCM&=&z@?4mA}yOy#h
zN^=c|PEdVjfEh=m%I^<LmoBIvnIs&!RH7qJRS%ei4FGqY_D=6G{{U?)p`YdjFCYmX
zA*@DI1bm}Wty#mfBXc=bt5mu97PIU-gHyvCFvE&yp~pa3CION)o_y<-;~1{h<$$f6
zH9V~ntjs>#-QOsj*;C7@=la%5osqXj_rqi<8A4lcAW_q()@q^e6<0BdNhloQVNs@}
zj&&kHL{|!t$c=TLhP+5ZNraI`!Y7&5nA?jlW(~4UUIG&%p)^{`@F_9?ROi=CDMXVA
zfq4XtRCF;BUIx-o%$p?Cur+{G4!(3yBh?TlY^WE3l`RB-L_~dR*&}t+35ZRd{{T%%
zNfNCDdFj1++ad=ptHxj~D5^6Uleb^itJFM|${!RJVen&$DoF((Dn^G`(z0<D1wNq6
z(5>7IB(|S3Sx&Zs+}1WG#L6%bKej|2eELwwbPq1N{Hk|JT!e;HRT>HMs03zKDb8h5
z_KuaCM?eHX(2k!f)4+UTY9IVXW}CuBDpQ&VgvdK<`&Veo(^*78M{F7h8s;*n+wY}T
zs3gjJTmwQP(Ex*%0=GV+&!0L&v`%7L8#&0Gii~Pb)Uu{+1$mh&SxOc)GD+tLok_Kq
zyh`n^^<`Q7Q@)y$_xaM!P*VYxK+!YCZB*k15ehmGN8dVa7Y2}0+&jxz{t!5n<6W0t
zaJ%<~cX%D*yOx3eXS1vW3I71jb*v6Ihm1q=iOmikI}kZu30%J!XJd+Gc!1#q?ITI@
z3f07{(d^H)a^hJ^8&X!{J==7v`VrM<nXYx$*8c#1{?IlXpY<-2`@pnL;&ng$&hQ%r
zOk+GQ!ruNngr~T1sqP>T=CTio1b=*L3D<hxqgBkNDY)xChm`U=c&(asj(oK*&zGN;
z#a0}3d>4qd!<c)hxU;)hx@uMamTl1-wVgdHR{`DzsI=;?7Pzz*gP2-*`uQdJe-3KF
zf*VtA6by(Fsz*ArQRT+SoCHIHZ;s-(Y$+C4LK5rFB4qyn>8GjvD5z7<-YIn+8}Wa=
zZjr;S(PYMBx=C?F>735Hb^OIK)eFv1*IE_qfulD*zhlD5XKs>)k#TM^$A>DmSCvLc
zH(t%0Wfx8vx5cb&+`UDey~V?c%n-K<6oI(~U*c(j)E)yIV5;sohLe%9)Xxv&Y(1;7
zXT(;o;mQzmJTo+|dMs(noKsH@dq-(b;Sj|!-NR=nrx<bdmkDEdmF1!X>%X)@SV|lQ
zR+3>rbO4=arE1}D&&5(}PJw4)F%82R-s-2ldiNf<_TD1ImF!WONnpyI*yWDBN!xnq
zDY3K~8ql!Kch)(N)dt4+pA>%87$*-}rozQ)C`%UP=Wr9DaeJuzVx`%S#C;OOB$LaZ
z*+y|?s>$?WuD#zpr2z7boVw_l*quJ&fL+iNS_G>*v+m=9Fg#O^aYxWEU1<$iGoVqE
z;8gMof`9Szr@h%5Zo1dWCZ=ky6t>^d2IAf%#<=$xwZZI~d3MWELKpz#Qu&yVbbfMA
zk|@(A?oM#0N?)RzU_2pZfN<sZ3BvbixyBwrMkR>J?%8aBdz34d`o{6nuG$P6bNejn
zl{36lt!9k}k2CgAOkV2};w9ejXAC%o@O&+^afsi9<!dWqRIP@R2otIFnvTrWe<8Yu
zRc$DH{v%<|{aqC73xjxzi!gjv?}hNj-E!{}vay?lN)pNn+;ExKOo;fOjRqqW+zUH;
zh5#e!C02M9s)o&gC)j>glkD$<IBT-&Hn?wqZCk(MJH^G`BN>Wke57*+pZnL(G5GrY
zTA`V3J-k;*Ljg{JHSrn^zbf<W{{XY*IBz~9i=S%6C%jv(34^>R=kuzrtC03|#08m-
z$2$}tS*XqJ@|;?l2#HpmH{8;x(|}1;L72MXm3JsGsVA4m>ra1l*(}SoT#LsNxa6J0
z>;BZByjluY+2M2JM~ogo=m+ak)=kRu$YqLtoT0p>LUxGf>s~yNM&UYaA+ecifxq~p
zH3I<5kl`e%N3`F?cMEXNGQI@hW|59@0L+I}7yke)XrK;@P}N3Y5S_Ztl<YnhzA?R{
zMphmF037|i)#^9`=zUXfsr)Sd*AVuB+Y5M(A;y@x*NNcwJ>auI%F{{Z2--B<$=7pT
z1soP10_?34PUls8fkFTs)64U!l<;lCmiUTUeN6^$narIxSd7W}Qz}7hl@D!!8x?KY
zaGwt>w&=rHTgpHxB{Fo4>x#$LuE!BD0_iZtrL(G$F=O2)yS8B{0Bn@RRzaw0I$mWo
z<pD`>z8qi`;y9bl+FP)W@x`cwr2uY8+9}=EfFWh#ah;GYZOK@l@nQI!9il$I&bvH$
z_BdM)c%tR>Y5YOd&cF5u&~x9VcAOi8c0>6XfqjQB6XVPBvzo^==5g<xd<P--`7GsP
z!nbuA=m_~ubT4$LfCYjktew(Ol(vmZAcMCfrvCuvdPqB{(&?Sb)E_O9T+9MQ`s+s1
z0u;I(s#eh=-K8ypTPx8!k`DTBLzKPHh`S>+Qx3{Fa_5OSuG`xJ-9t+6og{x$>FPPt
zF?CyqqLoF3&ds9PHtjWGYSp7VAsTs@t|9I(s9fc+8x4S@cm<!cTW3~jS(!CXtFt%&
ztJZ#JM<h=y6s16tOvpWHIjtd9IxZfZ#CxD?x1AG68YyZ;z;co`(?R7-%q=B*z$6Hj
zYM6-<Pd-#~RJT-%fD%Agigz1PU7}Z}EV)uneRD)d!h}RZo#k+~ke-o58fR4#7fC!l
z?filCs2q`kAyCD%0|By~AZsFdYAVRFh10pyaGE}rlnFsp&!Fd1GK$~?)Vib-nL4UQ
zgKwX$DZ)Z{yQh+#a68FRYbg>SpOLJ5SQ1s@PDOTLYe-=-2GDCQ)c5QBSh$|^k&uF=
z5UqN~^#o-R*HWp2-Lg*XC@`cWLVUcaCghFNsSsUtQud8L#P|?%1E<4E)4`HnA#2ls
z%@$$1305puFmq}T_}{0-yH;6{vYvayBi0H+k`h56Y(d<8%~gDonk+R$*-BP`r4j<R
z&~5iLmkBA&aA<;*0ckl}R1%mlG^G$usiP^?dZdJ@J_rzV9$fXPf>A(D?ORfFKq605
zK=>=o(o)Z}-XwyVR7#{BO)MBI#$9rX_EFje=VZO0S@9!axn|+^YsU4}rSI_@iab>Z
z<7j1P#@mk@M0$mrj=|H#&~+DDevzWxc)GCcZ-<%0tXH1S`INb9lVIBRS^og2*Bsy(
zP*elRauX5fBI}aFx}`d$j`)GUi5qzZUcH8Y1;cJri#|P;)g|!h)C0Oz@QC!QIfKXy
zyxXos9XTz2(AID)9pi7Y9>2AmY%FXWzPsYolq%m6xOuBwpn#NxXrK<DZyuG=ilDSn
zI)QsF_J>YS{bN%<UbRmz?md-0(QlKyaT#GG0Ixc>+Ih{=i@*?>;PxqHF5N!3Tcj5i
z5=3k@^)$z3c?_l$0zN0}<JXdPd1n4#g3`z!kOFf+Jv_SA$~X$I?*{AC`J^08G6>D~
zUg2rB2fcV@Q&QV(ufnA(sGY`|SF2!aFi9GwGZ9VXvQvCl9>whK)NUNGvbRZ&@#0E`
z@$V2RY{JrOyUsJn1?sPJnsT<@Bx&fW%z1~!#m(if7PwiuB@1MzEgDa_KT+1YEI6iO
z8+DIcv_0n;2woj$aems}xV0@<FqNp28P}xlbpvVFoofIohzk;+?`9=K@%}b?MWYsh
zrkX}Xr5Yspm^$h8qYiVdf(xB>C*V9OoIixI?mE7?4_w<>uh~|lg(bHX1V^8U4Ya7K
z+|#X;)N#z#b5*ww+b;VVwz;`UaVoh%adK2Q21)$pftD6d+CrJ})*!2f8^f^sg&Q|7
zQ<O8Vh_`7dFg(isJt!RFWR8De0`)e*CwTp#xMnK%4cxf>njZGH+FDe%TwFqd1b`!!
zgjBGXIs$D*wZI1ibvVu@&t><xr+=Bp?>m-S0EDDWsbF*8ES{pSQ)`Knvd?kNS~&?*
zoENj~XA$gs4B%`6!Mkizh#WU~z2d#*tp|-D#=5`|c@<GtsxZtBeuw=ZKevj@rq^O|
zuBuOUq5$#TSe=|(U2x79YuRT7vZT3hbQ#3%^8Wy=w^9nFT@xuE3c=#d{#{<mr@{pK
z^ZD$x@NK7uVaC5*yta=Ms?;0_z!)zES_QNN*UB*K<Z625>8){fYZ`>HnjpnupNKu{
z4oXLRbqWOTXKqw2rUlg;#nKR4hf=2$QrILNHQUVm=;qV1mVz}&zP8zAPG%uW0w?zP
zSDahP5DszhO>9u@!>dz>DNH~cl4@GQ0y>UsU;>HQq%z{%*(3r$Ite>|R6(X?R(q$q
zo_lF<2AE{HV8m=Zrh&k@HjM{6yraFOV0ex<!q;|8;@39C#<G&avK;}^eE$GiNoxa!
zaXxEbhtj6n(&&|gZn#?C0ms&>w5rDWr`6ow2`%O`0nz=Z`@VJ5;cNEP@{I?~Eu3Z>
zu`)XSsg;BH&Jm2Ui>D0?UyQ831{=CZJlu*%Iw<WU&TR%bjI*V|>t&4a+KermDV8F`
z&0D7D32i~AV(!v3D3~fw=clbK5a4HYno*h`>-H+z;Kf{GMTZ$gDdvW6Bc{Jeu3L;z
z2J3GG_Og*_Iw^+{@dpTYWrQ9e<IHi3J9M^GmNO3Z)6ps4Q>Vtc`c%zYos|~mapb*H
zyX)GB({rF$Pq*L22N!m~eyk%4b^I5G8Y&D}vZybOKvSv*#7>%QE4ksE2A&WKxQ_Gw
zgUj-><T7&KncwskDQ#w_URskR5&)7n1APbIoo_hh5D_tju_&8OhMYr0p=ePWbK9*e
zG^QB3aP!G#+$pA#R0vd)5H-`%K-bQ^JH;rrM3gPUw+b?$Aw@@)r2g89VX%efT**({
zwGJ)2eCSSS*Ix>H$4|bLR9ijbhM|!GXkNp(Z8&ACxSHAmbrLl(pg$VO;&t;JfU6Xn
zmdfJ5-*XnkTVhEKnNiEnXskM{?AS?GyHOIXX4?%QBm)6Fzt6(59CuX<vm2z!#)*Ps
zX*$hJ5p@Ge3yjJuAe}l*5-hWI;)f_2odi^aX$m8nZltGqf{_Exm?w24-6j$asZk`I
zz}uZOMH*dlw80W%l>jhQfg%zP34l465!Q?a0P{$!FEJq{L!ZjLIinFUsAVl7B<@cm
z%Aca@h?5DMkd(r;8y#Xg*Nn;_1R?io?$Qi^0n!gHwKj4fNGfaD>$$QMn8+V4o?2E`
zIk76xeqrU;y1n>)$Z07^@T7d}9nmnd@i#ZrqoAijsnkf;eLnh708E3Tr+Ah1+?G_G
zz!5RED<}{`brLfwhqP1$T0E1!QgeQywJ@F6g|SX@7+HS$Rg9@9R)FYa4t;C1r~d$q
zO3Qp^MsVd7BRW7iKq61j&&I2{r$lY>M%zJCNivd{&}pq#E`pvK4bH2qt4E0`1jrCK
z`g~|hNw7xO4cBQ=NB|WlHjz;Zd<uJS2}~?NN!0oB{V7g4f;NELB4M-KlA)B44xU5r
z=Sq!{ILWq%CO2x5*>PYHnKCujO+O6d+E}Ex0Lcqu{uOTB;ts|w?Xfkf(_wh^s}3m6
zM1YbKXO^*8d{Ub!SATc9O!*Q8{(7!Ejpn0{4rbsIIoyw$JIDA<yPPeF;n&ZGTYVu8
zxUDj#d_;YI&16xkXjKI2E%H5U;G2SbpH;49&fhC_qRaTB&0+;M?Jcxh+a)Zp5Oe`4
ziTK3&&2?CMa3$tR*RPjBbuw5XqCeiF<bv6o+pI*q_jrbwSP9Jp6Siv9$|<(zRaO1r
z0C}Q!7t4JH(!hl{;$)IE)6eNeN?YG6&KZtVaF(^gA8Ib~YlkzGgr%ga17n=WtpLVl
zc3OJ#MBFfV?~8k;58^m;_{qaD3kHi#+ZTKAvT`UY29u_zdeRuILurSHPok$+4~GXJ
z1bUTNc8iSM++CvA55=FjwJAN|PmWVO^L+rVoE!Ub-fh-iBAf8cA*M%)fQ~0?4}ZH`
zXedHTEr64eMs)!Gb)k?uMNzedfl^#Y7DM<IyA3)LU2U@FL#l?p5`93^pdD&MOj#kr
zJ;JVWY%1ZU25xQ8$`nvTlOa<P<azw)+91h5W<)904BObo9edg1N`P$3k)~YAQZkdK
z@&MnR5vE*k%kB`nD@b|Q^rE~(%D71{@T)E4HyzU5bb=H@6i5I71m@@E6<(nrl*adn
zcO(^yx7l`1r8+1RKBJs-+LYJ0ZkR}m6kYB+$8DPKJKJ?FDFi7^A_{cVZe!DWYb#X-
z0rp9B8>wFjH;r*`4qICbduFXImvX0<-J~{**?dF+>LW>-d$C=BmmX>xMAfKV(Q^vU
z?DG2^y~jgnw7a=x#|mV+TXQN`kwrO|<Ot2{PO2GFgK9nuUi|JBb!QwQ?B)xJA3jS%
zc5{JTV7ARAcrqAv;o*05`rxhIibmTFK2^u@Omj_A8tEfQ=hleW4Q9!h)62<O2)Vm;
zWPvT9NF$lnxz^Ila*CmAKyK-tC5taQkcC0oW=TF&aV8K_rMf}4ZX9G!yrVJG*Qufa
zfvS=ln!$XfjQLzzR_N9zkRRrNHY|!QJ1*?qc~?HqXp*(4%E<Rqw&tACmghtThNuuc
zl$P5GN?Gq8S9qxs2!K9xvsY%OGJt9CYMwQ05TdN1BtZwE)|Lg;lIuWS-rKWxY*O<n
zAPs!!Rb8-NrZT&_vFC3*D9wf}tD7_>J>e)b?y7kcPQc=wN~D8j-cqJ9m_eK33X-tn
zRp%TZk6pYFpc95Zl4X@a{zA@$NHgJ7_)L5|7BD%TqXoC{Jja3hYPjmu%^Ii2Ub*|L
z8?!DUeXE=95x-l@4NcXWmofss)IsU}z<<@{Q1%Nwq9@%~txgDhtE&dY@9-QM`<y9x
zTnRnekMxg2(g^rhKgB5ut%qo@U`}_6ZW22Edn|4EfZ|+VALAz;zr|j=S`ZTATyr);
zc_ec5tsVu2r$&T^!RO6g$Hg)lG~_f2wrP2eRKkD|O8J`Ic9&UgX(bl7xAs)%p_M{l
zYw`T5qs*C4)Bv7$3R267LRJps$Aq8D_7(30Cz2P5Ityw;U<{HZLF#<^Q8BlaB$<+v
zvhGWAN`XL_-&3LeE6y@u8)hV_CkJ7UV)&{X8Hss8IbaY6QPX2jaqMZN03Ky(d@{kj
z4*_D)g%b@80pG21wO`s*B&%Q&r#u5`+>dH;xbHO{wL=#3pxdvyhuOJQ-Aj;mjezp3
z*+_$;K}pDxdhI;wL=;8D*?5zzNFIEuZf=Mq<0_>}F~6;N9KflW3xx#c18FqY_$UK)
z%ECfCGp>i$ywKooypSNtNe9j+&b%EkWe|j$sX0i>XGnpyNOsG?peD|OR8(RIPG+T?
z%0B?84Cz@)%Y#k9SDXzh@zr#<0V4X)q!#i-4v;pVl+ZxbqG>V+LvNc_KuicScZz^7
zAu};`f|>Sq7YWXws37T7aikL^KAnY?@x!_{o>~DuwTR}(?{zAMB!X<DO_CH6NX_R}
z{)&+s?321ujk?C!fg9_uN}Q$I6#7w`RZZF|RxF$#Xhi6pR5h&}ASL1!vk2_U%ovk-
zF=r4AFEX_vH3!e*@~+C8qL`JOd+(5r;mS(cT2ugtfH~~~lH#SJ2u2VRph-$ZgUdoH
zu{_m=hyW!@a{#Xih$SOQK3^&jK`64tl3}p81p{FO>GkD80Zg5f`*bBFCVW!|q<#KW
zw-q3m(HCMKOd+{2b)HnM4beNi5bR3aEvFQaW<2NaE7YA11$oTdlGJ~LJWAQ#0>!Wn
z@Owp-@p)*SN*0mg{{Z9ktiCcLv3GzzV@CzZf5_>$Vky;&5gwq=-68m_;^(X^EVxe5
zY8N-CE?g0@Y%5Qh6Y#1WGY)H3?H_R6`SMo3<J3TFu^xlNn$DINZX(oK6vBq8DiN4-
zKb>_n$!*r<VAm6L`@OiiXj)k`qNSvgw2)GPH1QLi%DtR2^i#`IZNoTomwnlIHjed6
z21w<#1D@<bx67`Gm0&P3&i1nE`yRK=;JXNCAzIug!>kxH%8Hg9z{wDHK=+3-HJ-Yg
zDi5{3Bg8PyC~e#q5NUR|4H1!r60J{)Pu|tiV6d#KOc(6A{6;RLDi(eee*WtFhIoAp
z-MX`NiY-o+EM`(rn1D&zXX#plyJlHtz3!^w=b2FU!kx&qB}xi}r9f_UJ9VZ929%dD
z>ZY7Ge%1C7{2@y2?^;@%WXT!95JBoRKMAIYBo4GfE=W2qxS_*};I_+cIWBD6l{Qlu
z(geVcQVA92@+e%}#H4RA3`2(a&kx3|P+TJqV(H{((R|82V0=W=>5w2s!2$lte>FYr
zOAFy{A;5TZjc>0V!tOCdEgk1~DNzSdp`=6;OR6c6C$6O@2<K*XJ#v*waS|=CyOU{W
ziQD1~B{CjoGDo2Y{O&5IR-c5ch4zvW?#a6|$2(WY#k&PfVb;pcdv<g~DCs>+QgN8N
zcp7Ez*I=TXO;?7re%718`!fFkh;LWHTp-e#z*q=X&FLp9vU|k!oqX#X`GT!3+O>@J
z>a`xh!-y`_h=I*nO<))g2x69)P8nvV>~HM-iPww;6?chIQTc7>S8zC|aU3g~9}U3k
zt(QHH6)9E~Y8%hW(I2&Ow3b}FO`;Y(-{qcJL~Z4@axbRlyyn!X&U-AuDT-XNXKFj8
z6%`$UfizNGqE$L>d#<65zVr8KSt?d-wCn!#z`_d90jy~V-+0y)WM8{`RfCihB>D;$
zJ*={-#y=A9+F=c_w|4UA-MCzZ00MUKbfmhl7GPT~z+_}qDsh9_CfH<Ypp?N90o3}?
z7Z({Stx(p08jah9EtLX+s<w|hmd=W^;igwjTIMA{=yw~`haE!n#;MELYLt^GAdx0C
zp>t#?WoR~8!|@Hn?wmcx+W@5m=@Y$Ira*kI?}As(%)6`~+6ybP#*mUBD?lkKp9;6G
z^M*aODZ<9$)Xh4Xh_O>{3gWkpA%bI<FXwp|Ew^|{+!9cIWE1l=*D!{;gKMe=n0p{~
z(OTKOJ*!*~5WCD&+7h=CWSIpro%(B7c*cj8h}|y>She6v!5mqMuNB8H?{2|b)o{5|
zl^O#P9{_822~D(VHKUTVjC-n7C&deCwMb4tgA)<yOnH!&(GHYVj{*Sh)R6=vE0lve
z{Qfk7syAhk3EIOATX%&b28CIpHo8Qeb+1}d?n;in`EaNOfE05S6=^U=-#Tcpgdj>#
z4(+5e+JXzBNr^hZ<@2eg3*9KH9Ib_Tb^*dFcHvl?sPH7GaXWpAqs4I<8;~fb-O9aJ
zYH=I(?OU9nZ5u|>(z({U8zoqEud<igsaSI@u+jht5J9R{2&iPB03z&SEV!JC5TH40
zq*4tdAcQdn6M(h~0)o@0It;KNp)!()l_9|ZPW2`MgknvXsa~XLBpHFQuMhxJ0vFBz
z6POdz<x<UTplXm(w;~Ch4C%Ev5?u?z07-=$r^I~^I`OeYR}N@|#A~55tq3Ep73nuk
zE&zh8uyo#vnKLCg1)qXKTM*|nCv#TAk0sJL0AvJ<j)h8O1F6z^%}Lcr1U6#Hh1$}T
zWeVP4Ntz)$C~3JWW!dDm;!@!t{{U*YAGK#=oii%U7WZT;<A<`Xq=_1Dtzo}QDma@P
zDHC826~4#TlnfO}otKZ3-7Q5r5htB0Bu6jOI(Bp_m$Vft*<J%t9LSCN16tT2-vMj2
z*=a~wn-pbA#ughu)_g#1uC>}Vr?UlSW(DZ36vE4J7tBtQK0g|$_L)`*1S9P>geM|`
zU>VqLALfwgO$|DwR2oWhrVJ#FJ`pqof{CEzl!+=T$^kQ=({cCtSDIlSTgo%TR+xL&
z{q{Jw4XX(*DGZ+zk^KXt_31Q<&n#&a#GC8aUJ70+7DY1!7sPJSiDFM*F=W-NYw$I0
z(1f;x=o2S@UV737X#T?|tp_2pDpbWb3T?R>ld19b<P$e7i;2oqq@>J1<xl~VWi-0b
z6#MY$#tiTWXsok%qMHn2EiM7r6(0%s5-2!>MOq@T)tdPoep;+vGlYIK3|ilaTzY<P
z6qE5uVR(+w((A-2hiscuBy0dCYNh}ROf3ddzvHzTR{$eW;;Hu#yYN}C0k_c-NPq^C
zYg(IwM}I}G<{1%vQJgB#77Z%K*$2FPHfNPT&GMfuDBR;zj$K%#00fh-E?y`v8e3T{
zJ;E_-rdoNdjxf^liO`iEb$<%xvEK}kbx6e1d)pc9<fxt_#n^4N;W$P2@fS<V2~&Ye
zC`cp224`saS4B#ZsosblOP{L$0OQMZPp>5s#WCk^?i#VVYTcw-_*PnIO4X+14P=j{
zT%${~1cN12eO%@Mgln}0F7Jw4wYO!?<*QaZu3!Zwe=|(6J|Cq~hFAeS(AN=ZYSK|=
zrrkx8MN4)Lt2~Fy3X3?VhiDTke)iR$YiPP22l;yYsy$=KeSE4!N*NI)5_bONy=Ij-
z1>2zx0Hc>N5d&Ul^{3M@s)$w|A;Y*PD~DV;omRNh)<V?`C_oBBs4B`%+8>eHo&-1#
zPYqRa4T;kK08o&;;qD>Fdkno|_SGHl3StO#rMln)xm!mvK_^f(rB$X_TpexxpOlQ^
zmMk=X+<ii-I0J$4p3^vqoC649UL!6#bxTc-XW{2mu{G)7sT#Ekw7}}l$`;t*{sghZ
zFuQKc_zF<T0OB{GL41#SN<Z2U>0DFmyB$;cRrJ^$w)y)mhLt98%3ZBbi`&2}y9MFf
zJR1f$P6`5T+k};XGd`eoQ9U&kRn>oz>*=>#)=hfuH9K0vync#5#F%$?bA-Eck(69`
zr0Jm?t9yeJNw3SSEY2fQwV|a=IAYbe@13}|B}o9JB}PgIIIQR5U5IE87gcJ~IA&x9
z#UqYnX7yIBC<M2eN5l@N&XOIKS;Nbjn4nj9rLCz8ZLamx83*coqzVUA$QFhd15*^@
z1&7f$v~K49?N``>%H2o-FnlOaKsi+>IOtbG%so6MFv@CMfZL&2RHZ<Suxc97VzcpX
zB4J8wQd$WLRAuMoP5_I_%c~CA5@iY_Eb@>?I`Go!tD!rzLUoa-H7y{R2pmWOK5aT~
zOb?ww0HEILs_mZzP4)$FR@f#C2-sC;45n9Az$*q+0e*4zzlMa|t<^CpWok%)2bFbP
z60BKkaq1!T$!^LS!58j5dHgZe<!<U*IfTI?Bp+C=iR}P~70c783qsvpm16f8=VUhc
zh3fOH;qF`9Y5xGM#HB?1r{i4aIh~bJ8z0I}l}mhm;bOikuxig8#BEy*veKVg+i}6L
zCQ=V5GCx|}qD4kD_$OB{rssM75XO}DRCkM%sl2h8Ku9B;pD&$3Y&gO>%-iaowQd6B
zq~@49>_)$p4D(PV#Av+6oDH`I0#yW_vORUEW!#`y1hoge1$}&upXQC`0*0krZFl&S
z7MA&Q$Vi<vnEkw|)CNZ8C?9t~TNAS!34A-kOd-VNaI^s`8rLbrYWB5@LbpT+&8nVo
zej1lnyTy%Hyq=qWm6=|qR)N;aYgocPd2F(>thy5h2QB$h8t6&{5d|=D1u7(%F{YIE
zx^9YBKGNe#(Ry#T_2Ah$FHDQ4D8v+!RH#tjG<i~uAZ(x|8pRoNFj9c?J4JZXJE^o;
zJVWVq6Q4G1`WhC3fQU9+Ex?f}UjG0ZI44Es=?N7m1L4s-&>bwA44b5sxd+RBu^U%|
zVHmMZ-f=1lDN3hGFyID>t!Z`kS@*qJNQum355K*t&=R^g2$@ZsApopQjmSLWB7QX_
zf)|=e?v%pm3PMVPfdoJ!{CsL#BuevRG!--K=^;fq)KsYkPd;E(40VJ6pGe+S`NKdd
zyrCNnXY;Ib+_zLQL<J^pKpJz~dZ`4Ma?f&3>?tiMi0i!rT`_o1qZyS;+AJo;^#u~B
z+nDvOd?SW%R;vLt%;>X4`rH_+o-DGx1nM>a0DA1{xOQtj&F|=q+AR(tSzy43jcT<`
zQ7~l^iy&nR)X4n)wOPQ;m4?9*Q-rnvSb?Y@Pc!%V(ulmKgFVsLUuDD$*+3-6P<hQv
z4MHY^H$^a~eVXMi6s5rjGE^iP(vba%ILye|5Nvk~3oWTeAdn<SEhz-ef?yYyE|q%1
zKr3O`oh2NiYBD(6?xD{D;PXn@vfbEs5YBCywH@M|d}PZSf+%WL6pT1)YhPWLvxoqF
z6qAhmQBP<XZVhzkE;)zWn-^bF2vXJ~DOB$u$E{Vv;VNOATKxu|Q_sOsz~QN3%|_AD
z&Y0WCb)sd1VT@W^xZCSNeShl}oe0|~j+Lp0!_>t)EitE8R<RWuNC&%5WS$|3TH*FC
zFS>QsP)<^f7b9b*I@~-lv`2XQEHlKzoedtVJ@J1RV%$lNVivY9uFl@sg}->V!IFfD
z$|q?A3e~{y);1jbs#xA4;6*lBN4O6V7dU?rUAKoJ$LuZp)?PAPY$-tr1APHjZn^<m
zgiMI*MS}PL0AoNpl@nePrY-HATcF%sC2ys$B|)%A1i;*pr^Br*MKfg9kX}@(*Av7z
zy9>6%teIPQy}CudfRAZl0(?a5QYTZ$`BVnDo9GnUm?vb@immMM3u|l*C8r;4W7=G5
z1g<^Me1VO(I?~CD1vK0L0A$+-wO%L0czzQe610Z`bcBLQpM^1^Y<E*s<zXw^<o^H{
zxBfS1hh9@x59dl#qhJ*GU>`Y(mV#t+pRf9&+65xExyE>l2I5?8*U*P-t<!L%p8##;
z0NFxk`jiq34wTmuGUNXKz(@`h%URFthW0nbi#M3J1!AH5oIi;zm2RfNDhPOL+T)ZN
z6aN5FrI#^|6&=b7O<HB|W815Jw+l%2YrvRqXP6rtA;QkLe~)5n9@}!!laTTUkjtl`
zj<v*b8ufA5lQv^?+I&|_ful<eN4Kk_Tdy^DU|2=J3R(LFu2XQb4daP3ooD(%{?R`Z
zSrzMc#4*1J`t`CBf0BE8o`aD5l{~<nL-uYKfRg~A{{Tty`BBhgfx5uQIvyoPJ4(YZ
z9<Xlj3m~bl2tYgLaU`8Qf%(?n0;pkgPX7RzR2wdE&DDyMTVFAOVdS)so2SB#UW2Vr
zsqq-`Obm7;iO@obJAHL~c(+iHz0Ud%GuErQ(PplP3&Z7uJ%`mM#j>1Il<>^q(5uT$
zX$7ZKb+j^4Xk{@0NG;h)GQxB`=UN92N~?(|wjO(ukQ4w^5j>)Vb=Ngku+1t@Zlb+&
zc@TD{wPd(Pp+0T&B#|-|15R30X3(U$gr}@LCsU`FS|DL1!4PF>)M|Cor_n5eqg;Q7
zqY=TbT0oWLCL(mC)Dd;3!s{AUn=A9rwyqy<+V9yQ0EtilZTfHd)}IQimEm`|;o9Nk
zZWeQC!E1Vw!~%y0D1+1*?o2tWfoRI;D{uZ8Z=1isG28`94l<`j>H#J|xM&rPw#+Bv
zT;~(B!-t3AI<O$M=crk8wHs&J;+w&9qt@&;%32^C!9D^{{z)g}T39DdCa2c{&!0c3
zK^V)G8RP@~BoQ9H43DKa$Tms4n{@FE5>o11DL^`A-9H*zyi@{5!iC}&CC8S-f^_7b
zpAXiJjmo5)#>poC0Oi?Q^Mw?T52Z)MKvU+XU5#+V+(pFAU%cqcY<t2ANhhSAjTSB4
zjTq*Z!v{sJUdkC}$*&0sN^~(5#pZLKT;-zHjJ8v33fVT62>}pFb~Q?~vpUMHNiH&-
z6@nno%4h>^WCgLRNjB}iqF3+$Q3sajfa?h*VX{0hBTyrr^kSr55lm{CyJ(Vf9rV}Z
zL?0R>B5sDf+lWy}1_^;08na^5qD+<cb+VNAYf?gvy6h{>0I3dff=cLOZ?-kdxzN|0
zOhg365N=YazG-oqQ_%7sy(hCe6w+Hdrwuq1JJO++bUW!lT0vg$DK`jE0CVRQ5J9rE
z(l=S?ufUO<=w@SoxT~Z|T@}HUijbvFU__p<BXLsunO<itVKuvLLB8!uF(*mquC*;H
zND@d>4$agM_{<0Zc(wDYc+%32kU2~%_lK6U%1WbPBC)C-@dan%8UeDCG}?k=l<m^0
zI^Z6+RLQtp-N0<=sRvowmgCJbn1?Edv}B~&y`VBQpCMW}UyNOC&~z}Y&xnG&SweTs
z5P6fJuHKlML1sD7_(pK`1nD6}9Y~qmN<;NV4W%4yA;g~$*K~u|k*cY{F3O0|Afyl=
zk_?@y905kd_g^7OJ{Tzp(3s`rOD%yZjCJJ_vI$(FU3Y>!s<lpOtQkd-c0$vZRA(-t
zKPs;hY@H+z1Z#!3cKeGsg2#t&@`OKn=xqyGgr;{Uq5y2Xz?k`@V(}vjMc9HQ0WgAg
z$Hn{&*?tR+aMSPF@jf75X|!9UDJ7>6uM*YOAjs2mPvMkt82mtW31fFI1L=KvPRkz=
zj4!6z^+9Y68g&Ps-qt{SHSOxhj@fgwws-&q-M1}V0-3f5g-9_wkBw<m{{WBUXw(&r
zS!vXB{3`9o;LS$XV@q7$k@M#gtUPxI#dt2+yRIO$e%ZI%Q`YKqMs(>a2jVxaEJiM#
z3Yf#;u6I7^ct?NrnvSUR-D!wbA81{m+TnO1!*Ius@k~M%h3<r;?XQqCN#WQ><1q%M
zO#-=#s?042rwX^lSzik9E-JUyr|+?qH)WiFpr>Rl*gW#2r9PzBY+4!v7%ivEUzLL5
zpH<bX=62UUwjVuG{gGh{!?-_-c$Vd$?V>DInX@viiwot-5=X|3$079ggZfCSf3lbw
z$@W#%ir09rYq`4am2m#xNeKihBao6lRa3NrWod@qROZ)<nzFTi&k4c@c>4rDa<DTx
zfIZkxx{`N~)`Zl1gduZ5B1(kay>p3NuI<*FLQn>SK#>qY+tcAfB^-lfcLXony?>3{
z*|_4)8u}Y?1HzRlIWuPR1fH@e`_7J6{Cgm9E`dAyC%iJlwtNA^1;U?dbs=rGr0Rg$
zo0WNc<KZ=Fq5+<wKPgYm+ca(dq1f&rV}@}48Gt!*>eLz-h09E*{d<RCr#h!#keJh&
zy3(Ph3%ve+t8`Ep%wM^;r|heXvCaWwf;f2b-Zy3yj^mAlVHRaG-34jhM0tKgsIFU!
zaTAEG{CXw;)bd*VI|d$mN`k{*O_rbR)3fyOW(F><!kpp^RVByNqpiDY{*lo~@~(Fo
zi!VKk4w|30<wa_(uTZ#JnA61m0+i#nEn!v-DNT&eXe9i8{VKgNm|Z50Al9fr&?7t)
z+pb~iT9K2yCOrK<wSA0>m6yca-0;=+8RHli31KG^$1f7g4g0A`%(oT3RHSO7uEM=i
zsAqMePhEI!t6^wW#Xlt>C)@C|zA@W}6Jwa8j$3f+*lrS%aw+7?&WO;eG)O%GuL=%u
znupMR`L5H4@VXdb{hjB12a+d-_RWH@hS7*Gxhp;tl*h;AP-r;lv>iwlJK^3m;oNMF
z;_bY|%w`&jQ<&zS@Kx&3djyNAy}Da*km6L8Bnc2?eCoNfqD&R=a3Njdk_bqVuhy3&
zTq4UN0zHM@XDRWL4xrDKLtSN`h^H1$*Km|95Ot9gr%GmNg-xxQl=j-^In!C&O)J@q
z$VzhpDQj^Fl??y_q&gB@%h>?q4k^O$ygl)Ga*!022+SmDN~-+UYQKTP)TvMw?7uyK
z5L{hm_BC*fCn}KWR&{k6f<HRk;TU4$o!c(Y5s2)l20K-pU2`SM)Fw&RMu7E$=UtT}
zATB<$d-AoX;Rg~a<3});mV&GN4G*>q4O?)906FLqde%P_VC+MN)=`OZ$RkNr_itEg
zaK1XeON^22a9LR%5#y2!Ywvn*M}T{sOdW>5C1v5RYfkW>S4S$6*-2=$fdwNnR+Hx>
zZf9?mT@Y?nIB+n#xJ!1nJ?DK2Ab1K%2YLAE9}k5jo4`gp$3-4Pg>ESS0H{>}PQ3LV
zT68q=V7yy-US1UUO*GgE%`@tLF-J*~a}+g6i!CGA9}YKRgN#5mk;evNI_X&4UbOcU
z=(6&5R@M-~zQyxpFpWNSfm8a}Wm<8xso+<10zlb0Ycj;oszDN0CD5piI&z9BEf9k$
z@egHC-0LSw4-ldcH02j5P>>0Oq3KK#(ohzr_b^9zAdX}joYHQIwz3}M4Lu3~gBqG+
zUR$b%Hd8mO)IkGSQ9X30HRFE2)C8HbY;4sER1rIvs{oS`*HF9&l!K`5loDW(py|C#
z8S8Xm;ui=2qCj20xOKFT=9%@c76)jFuW;3NF;%iaSefS(lZPVe$gI~`syt;{NJC%_
zUw?bkM8fI`8Hrsw*b+j46DkK`_cSKL=o;g-kn8slgqfKJ0(qIKq(~{R8H5EW?Ab~V
zf`o&p+-tp4$C(M#pn?j}TsBIGNlb{)jr{8lp#(@&F#^_7gcT$yBWVO_Riwq$5&;0O
zZd01wM=$_xCcFsKV2Yibsy@*WrC7WanUG>c0DS895D`!<icT3UvmN44F-KCf;w0sd
zbk}i7(M&ArgTHiV4@fCgEO@jbCQ18)RjLw5gw}UrLN?e9G6I#Hk_dw&Yq36mwN-JQ
z6PhI5cuR;RHl+X}MFigIfua{JtxG~Xz*CrO%z66IIwdemWe~J{xBSGRK}qIDrjqNJ
zL<F@+Fh*X)?%TAt(P}!9WF`i`r2~Ly%<CyN16oPARwf^W-EiH_z9oiSsW*)r;n1IS
z$1f_UT=t_W(Nk-iU8R*YHdP02y^?W{7V%aSh+w=v-*b%HGKF5rQ16a!e8-3PGh6%z
z8BU!79{o1tH2W@p6;X|IsIXj5%Ug5zQBK3SM~Ztm;{0K}e#5zL%?U$KIG^OYu)T!!
z>0K5-6HcZS)uiiyerH8b4^FL0t;5w8BzeL&+aDcc_gIc2fN?(&IO7Rv%ZoJ^Qs6=X
z5ReH31p)s6#<}hl!|?6?>LPjh_^sScafWCB29vF$LFIi_WyAJq;{0yVHD=>>_U!-y
zhx&ynCv(a~A1-y=U~tZ&B<fc+kHodik)msjVc6FlaV3@tU1(TZxT|&+li&$brN=~b
zQ8}kxT!mZ>4HGudb>pg{TG|XRi<_Rj6px0ug9*6eEMKz=E1ze>?r@8oGdiRs+-a3W
zd1a4MXe$us4p$z@6_|1|q+A(3T7A`5!uV2=jf_6(*-tvic_~J426T>u8PsY#sRr6B
zq>~U)8!T?t`y98mxNX#|T(pMW&JzuZNl8q2gb}Iys6%rJK;{tQTcS_23?*DOioIgd
zF?6KdAxRl>pw6Cfsrd?1gcV|$4s4<PFOJ@D<|f_vaH`qg<+_Zy!kaJ%i4&y9ogF&Y
zoz&E(au`zVPZZ&%@aqfgA=ej%A*;5rW(wu>7swN@yq^jn&fo)16+waqlOxaVqNoK-
z?lm=$9HKwew_&^tzR<X_&L`p~gM2@NCAD0*q=J>?03oqD6X6?mj&+g6_=oXm<Zs4o
z70fmq)~Ew|>s7S)ABAl(JWu}ssCccQHjJb(f?BvV8Fo~EXx_NTRyb-z4~WnE=(I7F
z1+bKkpAj8ut)3mioOW(5lBH%PN+*7`R*f;b#>Zkqd#phCjTboo01%?pq@QPJKsFH?
z{rT0pYy^^v4B>{LUhPWvjd=e6hPy1o8@9T658{tEHr7Z`3Lu|-T6j}D{!~?K-Wjho
zUjxJO9Ac@9H*@&rRUvoBZE+Sa{7;Fo2A*{Ltr7wlPehN`omG+qh4f4}4x@mh*-{bi
zeAn0gr0{i~F@|AR{?1y(7u<oCN=#^@<)nI%PNvtsnW)ljud;{J4FpZ*-sm@I*f(d_
zS4zWQdA5`-*K)9v3QAMu_q81g^`kQ`rIecX2RT)L@NPAR_ZQd={l&R>0ECw$odJkF
zHJ?h*HGwfuDC{!NW>vG<e`&mJhQ5q5iB_AIR6<g<0t^EibgEdIG~+cggy4-^kp*6i
z<Bi<}ggu!hG6Zi~<*+WOe;X{wQd|b)I%T2E7zf4AY7h*{p^K-KT^xN2ge`HRx^kwC
zrDrlEfSO_$?XC(t_taWS5>#^?Hl;WdV4F`4YKvV_ymR=1<0ZVTKZGm;EvZF5((r_n
z<SNBH5qEmCpe<T_I)gqTB~zHc5OE(6;;L^S<K&@X;Dt1Y1Q7tAp(Ok(MU2DHX@F0P
zw#sh=2H8Y7w+G;|>*L#=zI83gaHzqV*QdkIij{iAflNSG4Ju%NVUx*HSgsrF4k2ht
zKy;~T%z0*y-nzUi^9!z58qu0n>-bH&Q$4KUF1nS=_7_a1HV{%r=k=<*Oims=Ra%2J
zBXn2sPh^KNRAMS-S8Ao9(lmgjf(ics$N}-Hye;9f)oH+%H)Tz*@?FF2))_7r5Vn+~
zFbYUkhtWe#t3kr&Wn3McnPW>zGM3y*6_+r9v4N#}oRYlpAr49k)EAh5N>vHlZ%ET>
zHyc4x(Hf_g_Jb9@ZH7EcDo7ynK3_ell;MI(fD4EVUT~%!FisY?x5$(%BuS0Ua@e=$
zt>ms#1}(aq@O7ANgLt7OeMdUU#Z;c?L_}Fgo^>i#Vy%Yfb5z4}i?0TxGXSDG9)7fP
zfU?rKQi&n~>7>_%poQW!mFsFJuf*<t%@%moDa;GEluB}wzO*IxUJZ+;%J9Zf0!P3{
z-jrd*);)7jTgiF~Gis<aprdTaw_QR9S#{llkMzcyZBJw5>VSzFCRaAdDoPHKqywhh
z>Dh=;svUJ~wvhx#CS+=U{{U)hNG8a09ri))f~9U09XaWxI5#kadArJ<7fC__l7$7Q
zSjq=JRaWx5GGv+EaOK#9$Wo;9^cqx_sRlwBiQXV1GLlI;t1jH)I&Ji#V=fnqu2iqG
z+pwn!BQy~QT|WN+YNNzjTXkxSgPVO;jp2e+kWys85$9a>LNruyHq}cJ8fFq>rBWsg
zEc0PxmFxx=0z`c2t%g}0G2T@_Xf734ypmG|F_ew!{uRW$6}3gM*$Xb>?;$v{!ZRgZ
z;VMuutev&4(w(UYR0t-a1R~ZeakP?@6-X1H>No!YYOdpZCgqU@9%1Iph#;itJ0CyJ
zsyLNlkZ%b!JebW9Fp^_VyyyTYRNDj1A#rwwK`Jt&>ACRv4pd^EV*x;Q;HyKi&dae*
zJz((z%%k{cel1W`sP7&;x{xPYI<;{4CYM!kk+)qHi^VvBqTxoI$rI!{3c%tl7X#sb
zC3A*wT&|+Uv>S(Vi7zWs2b5*g&ai*_rA{Eu(1>Z%=dPZfh`4PEhKR3J-P7{wQjXm;
z#gV$abqzAyW?J9~_}8hpz8Ezs*`^xeLa#ef?SmTN;fJFDUB$sd#!F&lE^c6sLvyTY
zTRcC3Q>sheZ_kp?tBYikSPb}m)@|*hwfswramKE&%jcVxvMrXDd$hVp_hUn-+(wnx
z@ZJ{2GUD9M>n9VBdl~~x!t&RIzv0{m_`e_G3;rRCG?g)A;sc9u3IL>#K{Kd4i1Mw*
z(W8eMK+|Bc4Oio;=W~e--g#=J&f-`u3xq3!E!{S_&M3lz#kBx!5K$qbIVn<P4YsE_
z;m(aZ>V8RWc6W#W0Mu#Y<LR<>+5P~1w#w5fN^rYZFQ0K+B_I%#iQ7$o@~M1e0QsoK
zRfc(x0;e!n8ebXWSB)$cDBfjrG?G-6<xtmBOnj=Vh$0S`_D``eRFi`m82<npVR*n=
z5auaxTDWI8l)R*?#0K!A2iAP6&<Pj3uU2+ScF-#J<(s=3#ksF|%GB8fUg-usccn4G
zu`0nCq$^j4+`xNO;nwg>YUkK-+%YRGT;}k&jr9cTb%@Zwp0wa8xMeD%vrv4Cf~)*z
zhw*+LxKb~zgO-KBhVI(&wBdq85v0MGI@LO~oZj%$n$V)~@d!p8X^G<)vp6mY9D45k
z&t*ae%0jdtkFUawuWc%3tB#2;lUFL-otXAtV{2)K_EUv;E$kXbBahvr=%*%155rF_
zxmOQ~#GFM}Vk%e-I_q_;$BYIT)FNDL(6828x4C&OTd~~QTaN14y@DD@(0%i)U`<z-
zk*c8Spur|d*Ue2z6={bhmXef}BUt6iv|7x8bMAj_QdLFU7i*YDWB6kIm9}p9n*FkD
zZAg^1BmHLwB#uK#Bi4eOYF2huSZ;ZK`F(jEd<F&lM24B{#=brS?y$EMcA3ODo-K2V
zV%M(SVpo#m?>M8LN!mFLAOR3G6}Ll&vA_YRS6zE+Qo%4&rXmz#?}{;t#*&+x_Z=t-
z$`z@DzppC1%pE5DAysxNqmHQzDXeRVaSL|sQv1&-MJ%pVPGBSeM?FW+m012O8q**J
zS@@Sha3sQ-_L11<Y8)AC*AQbi_pT-OLX~h7RzgSwgXA^m@`^<U(rZIQL@Lzyfy9zp
z=^-!KKWmG(#qDseEKjyF8}@r=RH!VK9cQeKB>7cbcMi(Z`d+JR1&+>gy2r!rv=Fwm
zL234~DJvnst%(s_&U;GfDV*XVOt4GUHlFPyL~1u8ccF2WPPHq^R(}K>>H#E9kUeM{
zb7jwQF%7z~9<fEeqTaYvHrjKNqW}sg7O|j(&Kk1oEMeRC;)e=m{^y4{MQFKl(M6@)
z5&WdA9#ijZe5+H3aGKbY+CI(tt;%&7gJ*l=J1qFTd$dl_Z&<ZO?c0cc>$+_%f`*df
z&wvs%ld#vyx6ciyL}tr7C}udg5?~E_@=^XK;r=1uyi2&p+H&2(vkH<zwd?k1=>}8~
z0xsB=hl04b#8#1*JRE6B@j%zmR6dY!u(~QZhcu8)kPK?!c!J!!S@5WYr%?$=<^E!=
z;ee;zRIxJc70LK*yIr4YoFACU$$KiD###Cl(s-5d?>;FZxv3fI;aMMvi+gtQoJz^|
z0)oPBNC2xa_h(Ia0Q$veV5cx49V0Xc%kHz|4LNUxAbZJb>A;o7q!69Q!)fJO&Lc4?
zQ4S~t`~B_V2?PL6@=oXce5zO=DK-n{LtvGXQ<YKxFaYV+bo<teR4y@fE9`d#yT!Qi
zr6nY?g=bL*;Zcrwqd|I$OO4jMxw9@Ut27|x(Idhq<Ucy&vy(0g^H>^0sg;GgZ0#Fp
z8PliIvnsngj3Al1`PU9u%P|{NN1`^}Bpo4OCL^J#b8`!?MVFwV#le7MNIFe=2(VM4
z^$IFFWuILrjG%LDyjzJNh)nrZWi25<22x=p$o|qbG);nn`Yu-PUlyPZV0EW7NGVPb
zWUo!YN=l>=6FYOKWP}?)L+&n6qEtjjAsYVxohg7BQGHW4FAz>uD3T0m&YaefbTKK7
z%YjoTQX_4Asm+mapvkdRyRCqN+yDeX=5-wEvrJsB(2KxLpKT~?sKg21P5h{vq%TPj
zcR;Z@Y!xYF5(-C<r#2=6S#WifyRs)zUL>TIZVBJvS=>#eE4XtZY2FhdEw(o>2g13U
zt&wjfOBJb7)F6@o(nj5Cyo06s>*}+Mh!<X7Hh{vCQ<y{v)0GoBluRU@RXf@Mh8;#?
zButaJio1vS*FlH77G}h4)-jg~wMkU?rfagM@9Ge#7!D+(xN9Lyg_IeX_jdg@s<j;!
zPKknw8(7LSZlS2@=T*B)$xbaT(R`ayMnuY%4uhnRuHuM@@Inc3oxch{#TWQ~0OOYT
zcTJ0=BQRqyD;~Wn&K{eqI2LG=QxwKFNmkF{zqWj0$Fl5TVYq0-@9<1XyOd$XmZhhB
zB%yHx&&x_KC&7h!&ZjY$1193y?jdsc+(5+FYoY-JNb`|DRe0e&nqnMVV0f1b!mjZA
zO5k_5IAz-NxP@+16g}ag*08ElZ8Q9G1cCnmTedm)dZy6heUnFSWt{Z%gZ5OXZv1<I
z@B?k|*Ak)UZr1Z|y=KUjB>_@Gj>(Zb?-hH3U~1NLt5F(SPc@}qA49VaF0uNo+uDz7
z&+)!ImEf3vvDhNjOf<^LDwRyBL=mr+qsqHJ7sB6%r4^knoAUBl*t~mcICf&eA%S3+
zUkKqX;+Vy-y2jSve$vn<GEg$;we=v0gVUbXyP6JGEMZL4oZ55yByDjFRqKTDmNRm1
zu~{g$?|evLg>FIJLogt6i8UDuTWx>TMWBw(A*oyshOhA+&>6g!E{)shP`GeNQk;%_
z$Rzx!%xDdPq6d*ph39R&mB)!%KX8sUc@H*}S>djRTVZfYRg?|6fD~uXY8t>e#-xI&
z=E>NDx%~asXG)Z%y6Xg>g9TftD^a04Zgi?|@meitCPH<B-rVs201#o9jpj=1-D%k{
zd4sHcMS5j~6*U+tH!0jB-KSdN$BOSx2=i)g_0Me?J=7)0R!H(CQ$Xi5n<B%93PV1s
zFKo3Xr(6n`8$^N$26@ld;Yx7{#Aa|@vyEa6*e?lT(xf=7%RyFTnA=Z<HjpH$^#G>q
z;H!hM+zQhHLw%%O@Z!bF39-YFrI>o*T4w=MwCf&qo5kujy)lMkvYq_5S1^6|XK=Qp
z_0Ov<k-+$JxL<~j7@Rud>m0<~7nq~V8A+2VK_{0w<neS#cV(CcwM9%*F;#nVd!o$)
z-|VdH2Mb!;ZTss)vJf>$R$zR+HlU?QGV?1J7l|%8T21+({ib%6hHxepZd^iN#O`G_
zHlX|G`;<8(ZcoCY{{Y(Tt^WW#`oGP4hTtk=pOAbzpT~;Eyj{awNyV;Q<M(&&Tw-{F
zik@{u5((KOkVw!0<rQL!*-XIDeOJ+_VH<{|Dbo=Oj>h;-`-k|F*_>%U7nK3R4yH^9
z*0<>5TT+qi)fZu<^7E>naUTX)+WS5_j5T)_R~BN{>88=+VDeZ4QYm;k*}-YlDww7^
zkpVXByR&>xig7Dm72tH=I_1stR}Np2w$Wyh?;VDubMmb~*HxEQ00_TbU1j2{Q^B#%
zaoWS0{Vm0KUk1c55ryLY-OEX~_GJ~M85tm-jdRuOiYK|E=Wyby$aY)ItSQ8OmSG$@
z#~98RVTZJ=FA)k|v$6h*z~&HX6*z;PNK^;HJQvh37+mz)_qO|@xMjuv0C2##Z(C3j
z<m)6D`qpkxOcJ)h$UD2K&I@wu!62B-bvyn40KF;Ai3hHsF02K6_GO2c-$H^yighMG
zrlF0x<9O9@*2gp_@mt0Ch6TaxaMlX%adnHRvQ(3=b_a{odO9?_YMGs&S)2<FE7f&Z
zTsPlkfVhXUr*Pa#?!y#(w7aAw`zxiUQoPfc6V`cGYey1WO|EW=)piHGx_9|0e`9<(
z#6us$xJQT7tCn56v%JLI?!iL=g@uKMawY)lPA+vux$m%#qN!L>q|E0~2p+0u__D%q
z$C_p0!)S0Q%!v5b6&mjq<Y{%Wfy00C2tErZHv8<U4JDuw5e5k|NjjZ$t(gSoN$ki3
z9TE<@(~YSPAxaAXqbj2*ohL&+pIWs{OO+agofXB{$_0;Vy`P~-5aVmiL`1q=NRkIg
zs@SII!oSQZ&HZkV6?6V0*=epVvQwm#Vpgs+vP7Bg^C$lR+<q}xd_GHa0jJ%1l~3p_
zG4Xy@bH>~D3rjY9Nh(vTQOl@Tg&_Sk_|~AgC^RKQid452>VTC3CowVd)EaHYmy4#$
z+t8-gmY#A7POy=+9VnCz(pt0^;lluJ7H;DqkdUb&M!HC>eluLgK&)Zglm&ZX&93JW
z4i?D>*HOK5jyWmvR-WM|6q&^hL6ILyq(GY`w33i{X;M;=GIx(EFavIS=B94~$qec+
zWD_J0KZSY@WKsiHsU|>#rUywC=q(mgW2*UDpcJY`{+%YKV!?RozRi^Apg{P3b?=7g
zU^rbQ<HfO<0!G3Q(usf*9Rv;*NI2q@Q{ys3!P}Sls|*7~mmm8C-s0*IGY}E_^rzDh
zWi8Fkq8o8^5`sXO<tAytk+K-P0*8m6d3jrDOHkSb#XCZlNDW4Cz7xeUCI0|0lqEw^
z6q=a2blW?nmX%5=l&BP;S&BrA$5BZFbY0t}rb=Oc5{7~S%nE03f&0>ln&^acDm#k0
zg`lLAr<hdfA8}S`p>rYMWh?A~X;sNagIP$D2J$OEiWO@P&;eS9g~#&JL6aXE<{oSU
zsfsX4nJ_b?2t9SG*>bo}i!sm_S8Wi&&fXEfDwe$35mPeYsqWDj0hQ(&gc1Qf>iq-W
z61VWDxJX&H{3PPeCn(LB5=fuYy2c;s5RmJ>Pg*0`b6F5G5(e=bj-TeK)FNc3wg`r!
zL6(q^B`}nY2h;D)ljfSyCIC==+HNuI4gMa(xLr>t_@*8%UUicMz221N1Z)xlekQc|
zJqkFsI;COonCq`~g^tD7r%}||r1IJU`>9uD{e*i(t|g21fpKpBc9QbjbwIh8s&mfZ
z>SjK%T8_rkqD49_@Q%FfvuZM<i%6UA{`I1}cq-$8_*o|gvcawG?XKA^xtU32FaYrt
ztCoPwZYr)Nn2_OExIo*_zyeiAif*SYoa4Zg^tb5;?N9NWjBq9tz6k7Z*!`&uB{+^c
z`ZIv6pcJ%M8Gt$i5zk%fwhR6}Qx;3>II^7R1QYH@(5&2D24ZS<wLvb}NP*@C{;MZo
ztG?||5yf!sD8|tKHI2NBi+kIb3ywPaPrI1)1_1H`ySyeB4~3*C(h$!Mf4_99^&Zik
z+6#FjSSJPWj|gM!VfVOBGmr5Adn0zCuHlfO%#$SR&uX=1NMi{;DK2}<a|Zz4dZ^!O
z994*a#7<#YO9-+o0@cxA5ES&80Y_2>-efDSBstR)@=d39ha36wM7UPfR(Nj>fchUr
z^Y@<9m<1&(Kx`vZwyNLGm<TNdb3bG+s6*YDX$numm*`I#TjBR=DtisMOWoFB6O@io
zxPnabGffQvv$|d+=c3@<)r)6ghv3JJuh#Low!61&t7g(XMIg4?z#GYhAB{yzxE79t
z52#e?XQ(KR#m~s93$#uVYlc`iw@n*1?{1g;I@}T7JlJ22)u(VG03Cj`D$~m2<ELG2
zwJBE>WvtX|=Nc$7)pEO)T|1Z~yq$_unEHL`RfvUjIu1~t`*M<9bxBIr;(M^A?gzta
z6QVY@1f(t$&6^7y(g|@SCMG>3X{erEH54;0LJ2Me8z()SaGoQ_oM&T!SRlgH{MR=P
zG(F`{rry6AoK7eBbPYqU$t<QTJ1)y~c2UDvCM(2;5pvZBhWIfFZpo~G2kr;;d6Gxa
zR~YO^aMgdr?t;|f3^-aX!qc<guZQ?QO7FmM#a>?AUc8bVx^S(1H9LGOKATI;_gNUa
z;+-)~ngEjRU$p!evpgLo!iVu2ujScUg+iTB(5Uo4=6)4r?k+hQ(Cg>zM}~0Pyi&GN
z@a}ndd93Ab{x!uHuVeWA(Yn66RF$jUN+(1le@Gmt8rZXZ{QP>;$$dW$f~A3`DN_~-
zL4{$$)#nmh1u+Q&aRx#88KH@|J!+d#*_tH`;+_P<G4uxwqe{3!fI%ZrXL_+lyXgo9
z5**O$yF@D63%=pEg@dW~)}AFx52r@k)51CY>EjSV%}m0VQDt^TQ9ep-z#X6r0>R7d
zKZcQL09jjY1m;*tB6W@6(`whm)o=y(^N+V)3kw&)u+=1)nbd-(_<wB+;&iVLcE;}3
z*jpjxy9rKYsKEe<>NcbtIdnd$x1ZpB)erud%qa$)-8QlPD1R1k?hNIkUT+mzl7~Cw
zuo4WPGra5h)q0JkBvS_e04332vAB%UQGj@;64~~<lH)1LL4^`N<o@)Q(>DaI;PBRf
zis6b#yJ#q;3DghYl|Z;rP(uj|N%k{xg_JY`M5bU3I#JRRSI@uXY#>UD{v&uE&x-LT
zh4vuzu(oWer8XuE@A9h@%P2cB1djxt`2HfLI%HD-lg(0>cpevLhC6AF+>BL=bi-ZZ
zWpFqAs`V^*r2hcv8thi{uwuJf=ZvSA=qDIwX&gDgcn#99J{xhRhDw%}ZIdd32J$uM
z=T<9YaX5%$hqNsEoF0>^XD%ny&$6KVQsdlvwAU1DtX9GyB$t2$AnFQ0@-&=16Gi={
zQ}SCK+H^%KB2{sY;MUkx!wn%_;ZjGAH9lwSSMc@wS(R1P4K|=Q{lmuK1S>glDF-Y9
zAn!c(iq~lX4<&^5Ij)_Rk-?5C*R@U#ZEc`;Ce^d9vJ^r3(sJg)zImw=Fg1d-U*c}c
zaQqX9yP^L8F3WE#pgBk<%R%+5ZW`km5K#j)M);n-t1b3`u#1ISEUidO4XLCiBr7Z#
zG1Sk-wP=|#Q!?ce6eu?0+-b71r7c@4r=)WIspi)RTXKq9Va?*$&9)q;+z49I+l2`V
zPz3TxjYpXi9~uCACgxsryqM+JHLW{6!IQ(BD{pFBP&rf2eJh&A)a`2Z*NU}Gv7)hf
zZrNyH+$d^HNjjggS#_K=Axq?#L=<!>Q8~Re6<Q?9@J-ZLl%IIXF+8eT0SJz(hLr^=
zb3>b$G{*qbWep|Gl<MWy99v3fIbL7p5+D_MSDYF^N~Rpra|>*dZNNYQM>jG~l@4w0
zjmFkVI<k;RStD&WHRv*pqy)+9m3ML{c+1L|*29n!Au@XKC}mk0$b+p}V<FI%<08qj
z9&yP+QdF{fPuPliU^hu66~cHf{{Rzk8-~go=r=W5wmp<Ix`IabRt68iwsxsW?o+1X
zKKfQQZX)O2Qe*)ENo_EzTU7uW8dW1*&oZEySaRm^EqF?m{iY0g*H{`R;ddu7GK1gW
z=n#LTX`mvkHKt@F35zKHFL+vGDnL3&@qH<j+k2@bmr9iOFLt+Yl!pdY6C{H(6+??M
z1(m!btp#fi6<_jFB2I^Wx_-6H)BxOSs^Yb}n_J09JjaGNilX+M#P#5_2}@khaIS+`
z<aDB#x+;GXsCz+z!?}U?PTrMfk?#f2VJ9htn6V&LjV!FFW<UIA{C#V#q+*aj>yjFe
zVMN3Uh%hs1YOO@Z0tM042MR)EPz33>&a3yOSYcpOE)KlHRcg(iKWx}dvWtw}EtIMo
zKJrZN2@*WPtJro|Yssgf@zC=gf3=Cks8gu!&}uaVpSFa3L@qeHw0sW=ZTrjv4{F&!
z6e8)?`^Ozo&?N~zy*k#u9))_OQE@TIepW?#ZS3>Bli?%}p%dz;mzm-WV(s1`;(u+k
zw`><n_XR<2B!Y4xd3g^y=^KP@9l1kcV!FR*=?2<B{3`E^aff(=5o_5&Ln}^1rZVME
z{ksG4*GZ>SrUPZjNi8-;u%6GchcUv8AgvEru-k}nUL3AyN~f2Kb*rplk_L*qi#sr1
zp;tZMXzk!GVVHjr;fcg?<=Z8+-ZIcq-U?KS+6f%`5j0}449lolqX=$kp6@P7rR{@=
zZPSXgg)xU(+pU!;;u<HsD^P=&#=6W8TCY;0-eBk!h8?+EndW5;;U=*=t{+|=!wxv*
zfOh4z0!VC-oXG@p&`-vVq6wW3=`p}G$=zAJCuGNHse2gV!quk{F>0Gj=AJo1Qb?7i
zKkYt~=QUtlK`=+uEb5h8LIq6*pR{)h;^kl$zwq85rg2qRTdi*;hJuu}NJ<+{{xYn9
z{7+f}=V-%jgfCU3DmObVC+WFWe{4x|--+$t;~PtcvHOcOI^zu7N^L<u%R!JrPEev!
z1Zq0geL!2a_rF_0wSaXe)Bdl9OnCVC`Kr(tQJrc@+!ZPSKd=>9(oL48g>`QZC2hcz
z%9E(pCry1S14#;8?4dWrnz(TZ1m=}<k;~~#Wh=>5omc|_X&%M+K=yUOLlJh|oO_B#
zcFF>LO<SElvSZZru1AYv&NmU*Q}|oddad3Sg=m`9G#>u|rL6cDgIU3NZo>#=ypA+`
z>!L*Gc#T2y(0a{dRhPaePkyYkv3R`oU0Cm7<@?o0`1g)DZ?UcnxZ=EZVQ#GVc9zIc
z&vN-57Sr-1o<dDAq0T*>A%4D`{#uZ*snV&$u>y-dd;-UV7svZT$KB&TDR@75aG+A!
zXCo;7me4sQ54~uemY4On=goarhTv)7X$o}2Tm4ox1kzh=yv>3H2m&&QFbyq+(iNK8
z!kMvZ+lhoFIj2&0>0XlQ0IcT{(<$qi3LMI{6PZR*MxA5yp>!K_Nf?6JO|Cdv=}zW(
zC?RPH%s@I+v^E5lEyg$gtLq*L8k~rPj}mgz8e$Bk*2gs%w7@LvQrk_0PF$dAl_R01
zc9V5Y)l07kZZyTcm5Yw03GZFdbIJ)nEvQ{k69HJF9aZ^GfkG|pLk%hAqzvb*$tINN
z_2##;NexU!WVjau6zBqaeg0G}BV}=*XtYOTmn1Ecn3W+uDd;)HSf>OMzJ31yBNHJ@
zyGz5_y?80)<_d2^=SJunu5X3abu-;mMnA*$t95BxIS7#?2t6qzk!9ZDF()V?LGg?z
zrN^1dkcB5HG0U&5Ky$2RYOpcwkS?Gv@V%w0%2>@PY&Dt*@TBRl-qgmu?`#znD2Bu;
zue4hRt?yYr5)y@kn2CV{SgkA!nekL{11l`6oG#QC3JBCZwVic=&*@zObYH=9uO8}a
z!uM!zw5}9!PL(V@Y!&fzPW$dYv`jzzN2=~=4~XWq*Ww!4Z+2ndku9-c=p?3Kg=zFA
zuy6w{T%(ywrcZ2qW7%TPDRf+7R!x^ft9H?XqCMgYau9m#5BaT{W*SO%p#Z~QZM(y8
zmSi%R)aD1nM_=I$32l-lRFksIIm~a4Esuzy3o9dC2Tv`|(M!cYvY?qr5=mP4vX%EX
zsGX9S^ZT0R3#6A$%FynC3U6$J#j9;)0tUo>zZ%bY1o(B=_?I%`LgCK}lvZ<QFm>41
zrbU#AP01x%t9|vN0&WzO3#`-QOu~%lE5wpap&3AgkRvfdR8RfCm3ROksU(%*bs&iZ
zpR@Z>wX<XnFeNu}<pNZt4R-7DqRDhXh|w~6U?=&6KqpP3%AHSCr@#_5OdA(h*D1HO
zXeq@g0p+*Son{Gkh#Xt0v-mr+#?hAI^eIjd44y~Iv9Y{LMn-6nQmNHX?eLpx7Qjjp
z0F8xURjyxjut_pkYsv?P2aup^uL@ysMr8>fIw?}WJ<ZE1Wo1Rew80)B5jy^r^bt(z
zy9d-cfEpoAzLlk5W-ug@udmLS8g)=kgsA>7>2b1i6P8JZPX7RLPNvdI7dW*{`xjAN
z=vi3>B*5S0%4<7|G{U!nbQ`U0!f64dq^3v!89b|#t74Ujad9eY!2vqx0H1|aHZpqV
zv$acIALJ=Sz#?SxpkTBDrkMrMsy@(4y_M5Bd@3D&m3Iz1!dCVe+5*fNtC_Kdl9dn@
zxZM54b+pIzgcc=8a7He#oDEx{MPz^izb$<z1uXB0fK>K^l`PIv{4<B}rcf1*V@Yl8
z5|(Y#on-W#g<7Rc1x$eQTzL=4RVw0ZyiE#r=IebmMxM9eD@0A}7tdQ;0P5A80DRzn
zT31CxGY-k2L?2mP-D>!}OQNMf-%rYdahGmZ0~NQzI6r}G-BqJ$NWQ*kp$RfhgH5M%
zsXVJk2y3yVz-0XY081AYLbX$tqsbhGin8q!v`!%6%Y$c#zS3E20_qUhLupp<5<FT?
z<ov1EC%k0_9)oB$!2rOphHmfJeam#Ai$_DZFXe=UCvp@|SQOSY>9TvDm862LjvQ|j
zyH+KM;rMvCUMlh%w{1fz6oIKx9FUO{)<szjCQn|zOFp}r+@Z$J9eSpmXMKcreA^hs
z+lai!E*fzRypfqGAemOXd%`x;QB~?yftH#&MB*e74I6d!S>qQ~_9KZsiQZf#+o#u^
zXOez<e~PSM8Y{UiFr=Ip#+auI;vsg+%WS#tn;<MG5wDjzb1KMyg0lm)R%RcGa4W92
zag1idt}b5-wYqGV5a)<Ml#l5;6rDtKr#}%%qcg;hDbuahXVZDo>BceJrWL@LtN2zI
z!&W%HJdG2Kx`5Ft1eBbFc!-?{j#Q@Oom_Vhcb@9CP9FNsYaB>v{{XM={X`ep{f`px
zqg-i?zF)>KR9?S&;Y5`<Nh%&gpydL&oJKr~otte7p~GRDNMtRx%7@1rx3b1=+qEtx
z-9!0EUYbV!h6(hoMoX!O9Z*#<Qz+34(V|LLK^g*JdQU-3rV?D~3TfEq1uu`d=E~0N
zDzLj}1<mV(5R|r^WWdsYed!!e5-?a|?aCSy%}Rn6#q8?}R}^vLvFBPN4#JyBv}h;5
zBf`>tB+2wO#5ejW8i!r{&V$i!<LZhSVTW#}-;>vZ&~2*<;k+8}9>*`*wy?vRUDf5o
ziUA-2n38^VS+L)PT=n?%Tz)RQp5WGvYy$l8?K8G~Q@5_u7m0+p#tC4hF@#zvP!QDn
z<Q+4rB>V>|=mrz`G$r2|*TciDPlcCRz;Lag**7PCeQc~w8M7?eut0(ay8eA@pL@Y8
zx?odWB!rx@0DuVVAMa4tYKEhC3TKBo8Bid`ia+L}V8L0{Te_6lp)R(J+oVbf+Jus_
z>i1kxMKBi97v1LrQk8U`Mu>PSQwB6&D%GTd8CXP(BT@0G%oJyK;U>14Wt__ik~cb&
zy-BHP3U2cOL~-N?RJc}jnJ3Dix=i)g>1$y|P$fn$ZQD)0Kti(Yb~}HHlaz=(bqh|D
ziEwfN>Hq>3K!ch+K>|J$6DHkt3rU0nb#-<pbfa+FM8Z@xJkFx6Qgju?f63S~=2quu
z4d=ts`cnlc5hI-)T`ste9DlI2QkdCI+Et-SftlW8%ByB4RodX&kcd_ODwQGS1xkj}
zbl#v0&`RlOfJKyQ^^~m(Qbwde1La2U=(4c(fnuo+*F$aIFvu;WsYFg_IvL;LTKp(x
z1e>f}cXU}+cuNRdX;f<U%2AXJ#%)BNx_MUpU1OKwbIfs>o}~~&>a*<w0eM6dZ1tGS
z15x25brf_2;hza_KiC`Qw_j=2XCCbC?+0yP%ySQU<OtW(<ZGG3zq7BKVp0o0aCe9W
zeth2EAmY}`dDN*b+J*{pfd&s>`n;>6Xoep&@-6~w+WV^|xUx!?thz{u*m}{p=5kJ4
zvK80(Y`~j-;^!A}0EDU$;TsS0S$tZqP#9IJO&~~GHwm^k7^+Hyr2{vSHO{@nHp#95
ztx~tajI*Q(*T~gCB<4D*?Y4=k(n?fRkajW3DD2aeA`Y@d>Les24NUa&_?m8pLK0<o
z6qqU^A~XhQNcpc^XpmaSDjNbnr221C0C2kTBpFC8eiEgEWJu>tXav~^a%pg-HlGLt
z4SLamFi%~3uLl4i8zJghdBD?YQ91wxHLVO1<OSKR6{WyD7>j0+d2)$yV=*VKVQ~z8
zXJu}IA?7Ts+jKO;VF*YDupd(~)glQOUOnR{%YA4w0x#f<LTI+i)B)Cwf^<`w0&v}$
zlym|jtg?~SCG`MbnU7rpWgx^s0A+zc=Dv&>W!LArY`2|k6{Rprb=PW<PFK4?L;{0i
zmk3jGpqPR;``77DV`0}yE}aUTb|~ODq`^7$IZVdCon-NwfCALv<G5D4;YBG8p(;@a
zK{59=$=0U_$tx4yx|uZkLNkygfu~xg;TBoM8GyUEc$U;uJi(q^tHK&l(*PA!@$z$9
zz6p{+nb<(`HD-Z_!CTmGg3B;siweh9WhAFTn8fSL=Usgk9?HR0s$jy9;YHhIpsBSs
z79}c(3iLd+)`qJK24XB!2O5@@Bd~lRrC^^75h~~R`PD$@6AcRESR5u(Tl^D=c+(uc
z_Cz~nhTB^syu4cSASzFVC!F&=E4tyBM^mCJVlD6JxSlnPp@(p!(<JPpn5B~mzWxP;
z;y=Z2%$uvm0Pa{qec+R<t3oHOX+7;NIVa6!Ve?h*R2f^#bOQT=>@lo<<u+Gd&xT>n
zDa*Tu$jX&(;$Fo0diqe&5Hmki>eX3Ifuiz+aZeGj{g?bd!uCpU3TeV_A2FKXr^U!<
zJTo3uYMY!)k!3-xaeim&to|3`OKZ-~8N0z&<+^b9)o*@~Kyk*7x#yISbR4Lj1DZ+O
z>N>ij@PCk6>)J=6r+AU2*e4O;ry5%BEbmm|Tc&3!a-e}S0nH@Nu$bpm>Wq#o0s_>b
z-y!_RU!@Ul-DS1iT}p@}Fy-P0Uc8M~HY(AQ)y`&{O45>H#7{C{jeh?CI*{w2jKvqX
za}-w(zU`h>;nqP0<wSsh;aSS00w**Px8x`c!+|>V5C;t5r&KqIRc(u7_PCpFDZ5*=
zA?FqoDhh~JoX%;g_%c~V%sP#g>g*4w!!bLpSHhT{64oDs;JEHzVZ^S`9eAMR1xZd>
zJb@rjkv(eyvrRTT5gK*$S1MC=K;}}^56Y!K5Z#<{7Y1=-_>0#4?j3%z;vdT)u0awf
zEC}<hZWoGfCY(*izH2tP0toB<RQ~|ATrDmku_eMa9KfHwYg7OXl9B+aV6|ss+%~=k
z?Bdx92^hB$4*A^3@uJ*DQPfQSb;j{bZ}Txlpq#Dw9={8FhhXxK(2W+w?6-s0f$*)4
z9&MuL;0xQ5Mxn(gz@J2<kF8LyONeg6-E-VW8Y<R(S+KD38vM%3AC4~DMb+zlhVaGu
zjlHvpdm43_{&mEHhGcG(=tzUC4Z*Fx2gAWX%6@`l&vWUZ_3%`%z_|9#7dm(k-?y62
z-Ji0Hd|$a=i@RAsGvXS?o>gOsyE6<f<ApSUGc6T^s40eu6POJOdF(Z=Nyoi))-y#U
zu|PtBV4TV`1NwI5L2Wssb^a|BqQ%#8At+Y<B30{N_@sqOs|M;%g<q+tY$TFM1oEIH
zm6=|MHzi4JE`r<C5K<;SpPd^_4!Y~fW>u#ILQ?I-t-kO8gO(MPdTUXdWh$EpFos_~
zQiGLBGM&lW?kPpqvb9N<5)?-mx>{8O!~v47lx$kGX@m~u^SowuGD?B#_Grn1t~HQU
zc)#9U_=JJC*I&+{8IDC>h-m>@os?f9#{S)FUXll(=M`y!4VN*;sk*f?&=vc}<Jvf7
z%ZZ$*&F2+nt-|@v2f2xbLgEfKl$C=ssWBjQszK9b-cSa>sD><pv=xD(i~}2;KYEse
zw=nO@>!_{rvSv{c@z{g@^%X9CR)d{wR&ecW5^wmzi8I|NDkU;XkN6)-=(s&D<(E0d
zs=+6aP^>GwH#ThdYB>sX5y+i+`qs5lGPsqCPQkLf;+wALj*Ed_7Oqf0<+$nareMZw
zIUWUg#&Ik35#%uSmIHFNm9+hXjlmP5&<~5`Ym|G7d(G4pTz_L8-mJeoxYG-B0^>YO
z4Y*}r$-Q-y5vGC3&~p&3Rn}1%sR9b~-!7ha`L3~clB<PxMFTp6nkPU{N?jmGlD#tU
z-fK|yAAx@Z;QMzJLRRu*>C{R4^sZNlRqZQ6(GAOGbMT#l9=3ZBF18N76`v6TAP%|{
z@;+0aRKNmy>)5Keii8}I)zh1w<|vS;k_ORL+n_7JWk{@z1jwJgX~S43VKrZcPyzn{
zwCzSD*%`gUM7f#(k+Cpophl=9!cA`gr2-5Q6B^VIN`c)n5=vTv2q+MB8)+L;8)IZH
z(G0z~j|t1_51lj#5EKs;A?)jh-Ni5cz4XgrUIIqdM~Gs(CgpCb9zbL(&d%ApTX2w=
z^yOT0>K7GWB(8xOfSLejPOiK~lBhv(LInELSkh9QLv>FX!^9OTt+JWjRdr#qbXsj2
z2-2<7gohGW<$I|BlLaW=1c>_A&{%v|Z0lV&xKa?=N?arajSTp?(?Eor#F<gdUDXzd
z&kEOda-T|bVpM1)Pdf^E4&M}{1uHR?4Y~bm6OD)gYw*v6otD7iQl++n6*I9(n&c|O
ziY!I7Qq>Zqr0R4Z4wYTP46OLsD{w-sR1%2H2hOWL_e`QPzUr>yuu*LOktrnUS13Vr
zmAi*0C|O$@abLzCav<iNCqPcWXUe;LD}Z2?PNPO>3e~s5j}~y=5pjgwwgsYlo2H2Y
zP0V=Xaw4p=v&1x0d51S{W5e*X8uwtUInEu|TpzLZQi~_JPXT#0SY5j~rT(FJcV-%F
z$MmOjSE$lu3)5~`+=)JcQ^eNAVuyLzNB*tX)T(o~9w6fGCgXd49kj)jYlp40Aq@rh
zOsz^#0F<YpHKl}WT+Z65k~yr$V3|majf2lq^HQ5uuucNNf8e_$hp{Wv_jgyR{{Zyu
zBSpA6>!2LXS|rtQb9C#VsJY>;%<n<ss}423#c%Aa_;U(mTHx-uuVrPoQl~Cl@Q(T7
zlQXY91d+(qnoSRMowOZ!D$D>lxS4k5{{SG1{{X|bwmcm3YIL-$7Rkcn=|uPUk0~k2
z4wID=uRto}Lt0?yJ<s7FRH!R7f9!rh56ZK+Lj<+6;cG4qu(V2_y~A93?Z7-rc}Xh<
zI)JF(l^evvPMRN8pW2aB*Lk*R9$G4kwPsm)oDYp0x@iw$HfGlNHbGFixA2f)%#oDV
zQ}hFIW9YVUXDM|k_)WZx$6gA)#9u<}-c_<lZEZCQ*Tg{7>+ALSRbppVafiDFM{QSk
zadyHI5>&M$%G3tlW~M+HiuOWXlq*kyI7<$`;alewh@`mL4zAhL1fl^XCt^1FRxc35
z)TLW2d3vo}E*6zS2^02Q@Rtaqi7~ewZw^?rZz#1=!3_lhGm>^Orh~0nVKmqr^Ao8=
z{IuR$1d*Uxn-J{p1;@J%xx2#e6L9kkxI?WSd*mpB3~Y4U(z&|W!2Dp!JEG8j<HuAK
zp8PH&B~OXk_yRWa_mx20cD-$m_6v;g=M$})i?-c{i{Po!`lnIoQVHc(sqpiL;z865
zHr5&`tmf2csPW!{52lt?2V^`eamU<uhhT3hNwW?IuGS9CB+7~WzBReTu`R*jolxpl
zZWWGup{sHBf5WZupJ*11HEI`!SfGTU4HCm<5)PVAPdei%w1yXv%%8X5Ev#*Gfx;0m
zOb=46Kg6GJ7<XX&2<9NcY2G5mGcko)<`P#Lx}p7uk?LS`(D1lwxaysoe97hG`0?fe
zTtzBF5d5d%8vZ?ZUzWD_*Vxw+rxC?26!qQx?|pFVgq1kr*D56QB%OV0wJmKL85ke{
zw;0KAR!$Vl);v#kol=hZNy@D?CPY_1igs#XF1r8#*<KtunPDkP&c+P=`BymeB+pX1
zHrb%5WwU`=wkI)x)P2Pyqm5-qu;-PZFEAvNvC@bG8miTRQVU1h@DOw)kWQ5zN`*!c
zN;PSSmR4GEWTc3b@YaMzs*OrnfGtkbb{s}ktSdJ@U++<x=_QwuvS)Vobg4-aGRX01
zJ5aj%Co!=Sp*%q7QOXqn6Em$y?)_G-97W2Ht@0aK1j&#<=S_*XS}S3qK|)mQJ_=?4
z1Or2*)sdkJ#_Z<pD7-_is$`A%YgVbcEei{aFu9NxqHUDpd?M_Dm2DIcm0B7CSIX*>
zhsFA=;d<mGBfH9^=0OC`pv6#vHD5xa0ldnK;zZ?~(E!Juw8oig*`=+NM;*FNt*YEq
z6##TTx_VF<F3J_B5Z1|AKaTMQ;v7ixO|3+QlD`k0)9GEu4Wrr64k2+|TDE$*8=_kT
zZMVCdfK-Jg#jZcQDAV#Zyh(sUT@j)U#_DBUX5xYm^Ghla03ehCN%)$xfFRL=hN#N$
zLf*VBaB-dm;fuoJf?=kYtVU!M50N6dij8P{f#>gJ4-Tg1G;;R8*<+sGEtP57vaL|r
zD0&}Ulc`V>Kl?|@x*Q9q4Lx-#yWKAwlw$(4R}k?YA83||ZEx$O7zCbE_cYp$>}a}E
zDEI1Sm9+4SAz_4C*`wYKf#onFxN45iS20?kKqXIX5$x7Xv^fZovD5deRb3@gaJeNW
z`>0ES8Ff~mOpl#;wla(~ks%_moU!4OPLmYoI`&J5x^AR{;sD1yw9rA-K_mp&q!3hR
zef;U7CQv!V2uQ0iUSM}0F{euMlY1tMaYQRo8cCS*rncAXuiA%Rz$R>4JBeSnYT8sY
zt61elQT>~9@?K~TkX84=xD!}j9@<iX2pXE=vABm-s7$K$97(c}ICC7S6`cm*cw1G|
z45`(GgTL0A+Gcf2sQjT9wzErdm{x-r8nfzDlAb6eHd2wbSrZVerfO|v&CC-tOav6k
zmHBY{E6bH}kj9h0&b!vTb=?sq4!BAi3Lz>|j^!s_W9JmXQ%Oqf<UmmzXgDRu5d|<c
z2VHjh{c6o80$?Dh%%H-Yb_Ayti8yk|Dpae>r2MNNj!a6{;e=$56|=ZN6<asd05q;W
z<bepWQJATlLK6T+hkeCYa0JXO<H;)G6YT1l20GPq2<hF*t?dOP*_}Yk8)|9zcK6oq
z5ZPs%PR{Q4h?i|;Xtzq7<btEUceqL}sZ0<R8t%&C358-|TsC-a(VLuS5L-@|DYR*1
zEa^WDDcLDd_{_VP<x~|NSf0#Vnk|Q7uOqy5cC4uylocaXZ=h9N80xR22sR~Ee-EZ=
zo52Eq(5hT&^*H|k9vn*dC@j5}(IZsK1j@7{be+0Z<{hPs4GSL<M37vMG|k8G3*IBg
zQde;MfvZG+Q;p~FXmtd{pDk+V{xJ(J<Ql!3Hc;!lO*nD8zDrEKe(*vaaUc}5l0Xf%
zkue4}^Q#o<3%K>*5EhLIu<B8MKEy6~ZJr+BR&G+K9cfC$mZatd=dzMN@dQETHQ-4m
z`cKtV!^KkS=W}l%`BsMjJaFFA+`=DsI945O;{fR+C<+75DcX+^MqJ%lXJT78M!0i6
z>YL*{6&ILy8*tdnZn%FF7`4BIgWZ$eygeappM_F;WzG@f_CIB^9sR6+&mUb!-B)&a
zaYG2YzgV`lA{;T9P8r!Fkb%GZRZ5KjNmm+37DKLOi@S2&x>;u6lp*H<D$62NblQQh
znF+)ex=OhCQwh4p@ReU2dj_$#!*J!HN^#`0<-?#WAn|HKkcbCZKDCpM#nNG5t8!pK
z*PQ*2C1(u7Nzl=`@`)Siy!k2j4RId`W4sY*fpE4yY;SA=opGCsPVp;n$WcO(CIAC?
zn3~1J(8WI!HJakhpwG;0=X)(mRjAQ>pAB=2USN+4*xqzi9xd8MzYO4acqb3>4mOMH
zi-juarQ*X2)al)hTJzpDt(tf$bt(#vrY)y6mx!)kP`IC_o~pFN?Xe7Y?$?Jf#)G%`
zy~-MC0P0kwKpv(~!nH$M&|Y)_RH;yglI_;L;EuqtUd%A}?(oKudy3v#2Cf`wUUIOJ
z8$lpPO60hfC}W-&UELlLD*ghaD6l@GdikrfvOGf*;mijUHhezqt|;<|a_Z;=Te5*U
zbvmB0)C#4FrsfQ}z;8Lf$SRypvoVz$CP3I~Pq0{n@ju5Gym{Ky-SgP$u^(eYc5Edm
zPj-gVk)k0+WR)ITlU+v$qRJR<<ll4jN&YwS+5|@b05xCm+cU&iX;xBwwV+c3k_iVx
z5d&$SVy@P4G+cZYkN|WmZxpvxpBKLn1Ir3*1IP%S{HvR)b2PV->Tm`a9Bx&i!zggu
zGzl`e(ORFg(y*WLS#%6G<fZnm9}I~GVEIx^%4i1QBX%T`KbZ-TN_h<p6I=>iK?B7b
zws{K~OoO6Q2Qd`{&Z?8!8YkB3Q4&ZX81WeNuLxD2Ya$K4N=hS5{{9p*K5DsW22*T7
z(cG0IFizS=l_U*OQyNNuaeeESmf=ZdQni%pzWNF*x4P8Av^~)&3?kWUwHFSk5}~O)
z^r^72u}}a*SC`m7cFA=rln5krs3am~T+W3e;9ItreA*jPf<RWWA7+@xfvTg#DW1+s
z);tvZLxmi+b<v$EBu`4Q+P5ZM*U9*;BmBJW7Fn|zxKYNj6gLH=-aG^iee=$%$;@M!
zUH%D!u%=GAN3x7#Hz263Aix=a$KRb8Btq4q$g-?EO~;zTIDX~#l`xZ%3@J+1J{4;N
zMAxbs5^>dq7Rj&+D<R`|e7l#Hr56cYk>~ksUCat>$QKazn$=B0rTji-$pz&Cu!2(n
z4NilWr}M15OcxL|SLhgMBU_aj;>4-kZIuM)D0DVdJ>o`P{`pm$5z5HshOily*z6w>
zUOm|+9{F(QwtF-aFi^D~erX>%z{W5#tC~g9>b#o3>{S!^slqMoxSrb?w@4YSRGjCk
zOr<+WFr|GfM}*WarWln~xj{RQzbZ5Mbiq@OaT487%q>f90he85ABMk`H;mNmsX*N`
z1tdvY`Kwf}>4uX!tU&$ih-<^7>a`pVHo}s;sL?4t5vHPm4A(0^!7_P79d|nrM#hgU
zm_!bxB37XV1Zg57YIGJ}7Z+YQw5-C`03hm-AA8eoLR<#ulOx5H$(SZa-bRhXC>;9h
z<b+=3HdqmvDoRucjr9<GsD|s#GV1`nKtjKdR4Vn-+E!rBlLt?YI0G@)TcUxgm-b(Q
zdsXkYyoE+%9zwGCwj;A(U_(~GtF0(YETsqlK-Ws-Uion)RRMC8W?Up0KNzW|*f3PM
z!ZBrThLRMdioZ#)C1+N2=$yLYf&ki@N!cNyOqJpZSDEKerX>T4=|FE9ZKYTZ*r5(9
z^1bKQqK8Nsw;E|8d23ymfWC+r41k$j1SzsqQYK+B%>H%YZl|(~sQvAd?iyMMkgXu|
z*J$fjSp2t1c$H;#8-SJ;7H35hrrOp|6{*^oS~xcLZOm4!;ieSBVIyp#;as&)0YP2C
z*HX5`z){rnq>+@uqIsu8A7>&Ak=Cn`B@;d+Sn={fONDC844IyKPvutdq;`WjTUbzX
zSS-(tW7vh3Fy+1$`mMs{D^f@bUcAor+)=C@NM+^CQmsN>OW>#2dzUvW@9viCicpfJ
z8Br#A)hD<%z$a20DJrgREbv>Up^&hKR%Fhe6U=kx`_`@iW?(Pas#xI<?rLMMzG}3!
zvO`$wH_sG@jhe0&fUgP(A_RZrXGyM`4^W*~If`pq*0^e<xc)zY{{X?3$xY^a#~oOB
zsAWnB0#cdiIs7QY-1>#F1F2Lg(+nl#-0Y(rh+yLr$1y%W$L!Lq63GR&8+?d$@IRKG
zh6oB#^y^n-(*TWj>%nH@YB|wDnb%(}{{To=79s8@vb*Bz{{ZB;aTeQ7<zW(g#gXcE
z9XzUOwgCsOYR7elv0%`26|I6iQ^dS8#E&!*;kIF6Wayw9B}2|)n(VKqkm^O10}i12
zUMJlc;w%!~j^3KQvb1aXUmRf1Hn5@LQk-jJKlOyho0_8IEMw1+^-62W!8OO?rr|z^
z@UpeLn0>xF?hTA7X>Qu(_8m$|IS4TzeB;uoRgl?ey69=aIZ>`5;Y@oJ;VV8T!*Ip9
zgW=0tUeZ7r^Eg1BQa+t)K8_)jD|S^3IK`Ek%r6;Rc=l1-3}uUg))kH<A&JPBSx=3z
ztaH~>w)LjkO`OgWH&mGL0fMd@t1cPrx3ZIR)zg-oXNfwr+q{*3`a_h36qBTh)~Z(y
zeREDbhk3XOlw8`i3&HNRe9!4q*LE1DAp4is>UQ?!^#Y=hR<$X6Om)_XWoXFXs%1>>
z@3?%Gr}$jpm(kjtrx@`~lCAA9l&#iM_yD^31qlQG*(c#t__isO@V%8IB=mmiPQ%r&
zXo>df-mCNv26u<=SZM;`q$*Bitz&2ad^gg#lUQaU+n*EH_=>G8MJXU#sabdNbNGk3
zz%Ty*`ftG4lMWRnE??cU;#J-1r1v5=R)C&kO{;H(@W$dlx!QGZxAI=X=Rer}Ou#;u
z_p--k-tEh;YrJv7r4Y3#eCMB^I_YFJu-hlds&8_O;0=?+*jkyD4{T%rq6kc>I!DHV
z{{Z-0p8{ibc4HW8Y2vo?0iA8;2Pgy*RAbZgu45ADYz5PBtJ0I`r&t19Wv0+Tonx=x
z`K&jYHr;ehZL<|7wNjKaty+UR{!{_Z(o;wSL~hAMp(z<gZOPc5u|x@pDK8h4YTSg9
zB>18g8$kOXI+He3ouYPypsOkhLXt=IL<*2)A;9XNG^ELe%C`6liP$Rc1$}aWrkn*J
zsv<r#I}`xiC|?y}p3`Vn5~cTQ&IHDy1vZ%`R+bszujHcqLiRgzfjMo$uOiz0UgFk}
zLOQ@a^`+8l4QZ}>z6#}L)XV*PsOApWYItrKSB>HfUpN5;DnJk?X#-ldS(sAs*pdg&
zbebKo2elG>6qAN=tF&AtX4Q7Cg@mmj%<G{YX%3|Mwe-<gbDLF=<)<)?CcbBb(&|#<
z54_wqRv>}Q(K&^H17f~)i^Ef?i!Bg9))iTZB`iGRjI0^)btKNUEf!rJ4}=98#U9Qw
z_keh0>_iG9X2Q^H2_!7N+kX-{i{pa>v~-p&K+gx>S>^Kl>#E>*QA(d`>q_Q0&L{r>
z?SiX|Ch|Jy2$I`+>*fak02<wUpap`+bBrlvow}LAl2Vm|<BhhWl5~X<bof>!M;BBe
zm9){8m~xNf?1kdD$qI!bW$<VFbssvhhkP}tYJy2CQ~nI`ae2UamKaZp&G$@izN5&0
zSI($$k&?JP)f%7?J!(`p@jYhZ_;(A$)Y^N*yrS$Y`&3Xt>-|4Uo)P~5kg*kV2p|qc
zJp3_mn|N)F)-9BgaAgZKB?JiHpZTghe;1hL<gQ_8hEo7}tpkQPH_CDkg(e{Lu6CW6
zM#<QMEED^MDE|OYpc+wvA_}7eWYNWEkTV2;cIQW6j039V6{z@tiRLMpV?;Tc1SFhN
zlt2n2nILW`garULQVVfuPEZbp2U>y#fp|a$QZE@vNjj0PkUG(@omY!*WG3+?#{)^w
z6=e`P^s5bq%Zh<}1$Opzh6`LVsSyAVIIcg6SM48{WHq2UO%{-&@%h$Bl5UU;3n$h#
zunMDUw?>?qRcq9f3Ga458Fc4Ysj}*eon)hJ1(FGpdDDYsDb6djwiC1nrig9Q%$3WK
zRh1;`L>(r|K!y28>ie*S=0;*nOwY^@I_#i0FQW&X#NBY}8f~*GN|d5}K|AmAuQo)K
z$;^gZt%j~r#LAZh&o8*AABI9z-03<i*RqQgGNIvsr2{dbn#smo$mFe3dF<8ugM^{9
zkLeoo>0I?-HA{SwQM+(dQ{o_>tx_&21R`h(OA62gk*rePr-xm7p%Ix@e0YQ1yi%Yf
z5#?4W&S+aWQZk8ISBQdtkF2R**UaxczE#;_K{S9>@eTpy7sE5c0(p_Fjr9@vQrz3A
zq~H~WhhTrjuqWTd-A$#7ESOn{C(G8ZVau52ILvbA*H%^WZfrO=;wwCG)3}Ow#}XG;
zJ?cn#Axj|48Pv{@IdZPfl`#V<<Z%ulmh6jJ@FpwA*EY<T5ov`f<vVq7Rp4!~RHcx4
zllqElSlVsv9;#w13N0~nph<Dp8MYj?;T{%Px4>+2wt*okbOQxSJmiX7NvLzU`Xy3n
zV9enzI;TzCSz;H7X8lQ3v-Zw630MBP1O*YW)j*&2t88%Be!nZ#C4;-q=&XD;+YfgT
z!;sC$xHv7k5ZV@@B;+wYB!WIv#yB*<S<cKTnYLo2TrZ3#7r=1q++_D};CS2Ecu>`C
zw&;}W&?xEYNT}So+2ihpumSI51)R|DlA`-!;47RLw41zI#h`7mHL1mA1HiK(dQPTf
z)hewnZe^{2shzEP)GH^lz9+-@f3kb-65>25i>~F>x$Nsu3Xv<3%0VFc$CjLb7r|Dm
zi*0%a50{;_`7VzRLxx8Z2bSMWd@i%ajtgglV+!I7X)1Qc-SFtPT7XmQBQQdQ=qG<5
zYpthKD+30rp2V@`?r_lW*6PvWeh|fbX0Uq~#~g7;V&EtM-a`lf07(kh!T=g|s(6a8
z!nn3(efR$W6`D+@=7xsFzt7oP6SL05JLgj7EYnTekTVblWh87>(jW=*tV~WRtQT~Y
z+Ss<yWH5cyYlv}-7Z~ESVB8vpEbN(eR+ft%^XD`z@_FVW2bQ&-1FH_wv4Ql1`QMPT
z)WOny8d<7IcBjL_JQVYf_|p&kIrd2V&b-aX8*xH=tU0%q7OPgs)#3@$FD|OeIT}1I
z2V$#=G>kNSL~{J>K6@^68DIYZsp4dbV}7TVw(E6*{{V+Obm6~#<yQ`^WlL6Mtx7Yg
zI>|fNVCJ@)a<ao^W}C=$(c7<Xy~ELN`FTifSxh1%K!9U?wCNRD#LOe3PMaQH&=W2l
zw^Lk6hv@fp?My9bQV9kW2D9l>_K`u*tU2A`F)I7wCR}?RV&Mr<Kv4oy14JOl&VF^v
zVp|O>q~Q+{*EKG}nk#K8NFpHV_oZUJkXKB{*dt6O&_M~1WD+-}K?D=BVJ#vh6tiu@
zjlmj;jZE{R0D)vLa7Ej6qy&}t#-B*22W3_5n}qJ!MZ=V3)ce!%(wO0@uHhFbnlk57
zrzuwEE5`R#oyj>?QjrRg1I72sh7yqLrkQmF1kWV{_s*nqM%NH^KyR>i98y+<0HGid
zB8ZldGYMDd;tMoVP8{seW7Zb|@~BH@4D*dBSjOhCvd!WgY~daV=B6E+aDESCZ25l+
zVQ(}{EocQ=A3D2EyV!EF%b(+T%9V>qd4h`ZfJ-*XAtfn~2pS5m`;bbl!wzQ^RN_yS
zXO9+H3MZv70t)IWuz(eH$J|2K4e<TuD{`*yBWEBw=27=Y&Yy>&{F<#`KjJJ-AW&nR
zc3BSb_wO$kh&u0h>&q@UNrF!EUF|wzn?qZmTs=z0tBHQ4FN4~x^|(kdhRW7vN@6;7
zG&P6-FHjQrQ=4Qm-VuW`u#~3d#X6v^(q}~tw5%t(YCUWBgFzj6sE#RWm)yL4TDY)=
z(n`JKoJ{-y`PHg23qti{6AJA76ylxEKaOB(@TTb~T0*&vL64myj<>qU&r%gCrdeU3
zMtgL#xV^y<g{dlqi`=7eDRm})_SIYiyE>WtQ^0Lg2axvsskdb~FZ?~hHWq3HD`~LW
zi95&Hu78Qv?Q55Ktr{#10i#7>;fV-k*8quBYx~tEgJ7#-4riqnQ~@f0K=*|5rvVDK
zYd}q;6qBZGyu}<5a*D*+BdHz%^XE)yyr6e@E?iuUvPlCrrlu^sHM&V?@Mtz04rZhh
zek3jcXqq~pl0r#I=xBs5M2Sr>wvFB@!*W5*CVyI*$0G?xPWLNAaO(k#HME4~g!8T&
z7f?E)Oa3Ho)w1G&%ch2clVqyZ92nGLw0CIeO=vQ~XSvc>GyNmyP7V_REQu19Y~|RI
zB8jFF+&5jpP}6dBig6i?l&u$tXaW>XSf<$3dCrpy@<neWI(11SL9ERD{>64VO8PTM
z5|j3ogeV9T;spA0sLLf8bPJ}IO{L4!uQ=0kM~8npYoVeN^LLB|pnEC01%xCvQgaOe
zn#;vB%%;;l(+c{+6iZ?TyNT&s-XIp6FA@oqag>!SoKDeHZV3rlpdv{HOcbdxxS8il
ze6|l=Xo07^t6o1x{JXkp0n$kFr{T|fLfOLHLdo1x;T%G?(x8}`>Cam1@RDeRn&5VX
zsb2!%ZsS)+yo6a>j`HE<of44~toqf4QIp<FtBDjCBT}YVt}xyyV|VPy?r_{Wf|eOq
z_eZ?0rU5l;4O2EDtYXivO~RIU>U#MqKZLNa;`iRwe)1S@=nyj`C2uKe9u$G8(@EDu
zU26bnT=jC+g7BYq$Hf;c-`Q}74&66vh1%Kw0L&qub!t478|W!S8irg|95ZAZju$ea
zmsmBW*-hPv?#;kUscBJ}2}(dRM01$iNT#u*2;c0XrOj`C@Qd3a>$KgazY3al7Yrzm
z3yIJu1LSg_op`$`FpNPl;G|q1jW997m%t5Pq@~3ZB?L(cp1I)9K@`&QXKnWC>b+)%
zQnsV7WLvY$cF9=IA;a8DcBZi#*2)TYLe>{8tRL>yLFNwh$B+Q>iSX*+rB-3?xw;Q!
zIOFaa#JJ_wo3douVpex{?l=^m4nqlXUSs<HHAcC0COPMn_3ozt_ELruAnDi9Q~j~=
zb*2Z#_?HfFt>aFyh6d2#LctF&C<_1$$R<7pvGA2DW2ttI5y^A~y^dD8?u+<z6FwO1
zn-ssXPA81}LzqR`OXy15J?cpj;*GcKtWi4@S$cYf=Fz54e|4)nA+uQFn+yul!7SNY
zI+t4kGP1IFQThBUBN0*cU!CNnSEox3_dTNIMEEI3ZX9uG!5lPrPYY9H8pSQoe&Tnv
zw<ZdVY^5C&=1JvQM>SVu8g*{Ao^q@3tTD#c?Vs=iVa)!ODZy5l9}eNy-KlZ16vq!>
z8FH~QyO)XnTMdJ`D&L@zdex@~7^2I#+Bu)lx$s*2Qxs{mP@;Rz8uA;H_VHQcj`-h+
z`)1>uPmD2_RO{{nw%AYlOfsK!w29CG^D=ie(Bbg(xOEWCN!0T_Y2gbq2}8S)njj9e
z%3dg8(+fh3Dh^W;e=|nsIwY&K+B4fkYXrA1T0Gb(3rI;Mq-a4@jkTRLs?`ox2~7<J
z14_N06|^n{W^MEph|@(6lxbGxSm;95K>)1}i(JbpyKzYiVfKgtQ3+94Fnpv}J6)on
zBa+qOjx^i`$MmH5Bk6s#lq^D%6X*dxRe?}Nmtji!g(GMoKouk?tHrmiAb}w=2(U!0
z0=vDuL=IZV%gj*$B?I9RP*Q-{=2XGu>+`9YvP=uY`MZRrM<F60jd{g*-oXiBfhdbN
z!28Aw5fnpMRbNkZ;furtAq$WokMUl*O-5SD68coIprHyN5O$&$5`eIPLUn4xZm1Ck
zNsT5wDoEWRz0I*#Cuf#yqX&5*vJ|o)NA$$gX)^J;<M`EA8o<tpUK_J{tK2}Y)V9GS
z=3j@N`qK?JFp}#J6s%=dzLhvKd=z)IR|_^>@`zGVDH%?bjIwOBI7pX~p;YzFz;zH8
zs>mwWKt9b_4V$i{15IXM#8($4^A@+^YiEv2REM8PI_4w755WHb^75{ag5g6NYn|*C
z4;RFj9>{sBiAY&!JmYecoC6!hZ<8hh!4MH_4YHOTLI6{bBqb#?5KlgQx>Z`_5(zph
z6a}oM_gN5(Ikw5mZvaTtfHfa4sjN^5B%RjDjGzS(#R+!IsYp{`thlW?l@O8glkgR8
znD1PmsQCsI>+qj;n;z1M4nm7N9&)6E^^ctw7-@DF#b@dZ4uxJ_quDO!iY#re6)lWb
z?%0q&rEO+{KK86?Z;Ebs^ZCMl8M4vjJ=DVpWh~*XS*1E95ulB0m8mtV9~HDnq}<9#
z&{7yeBng!gdehnmHIV0KafQQ!`gV~N@ZbfKfI6niQb{S!m;wR)DB4b?OaPPck>V2?
z8fI8F>u=fvcu3?aIiTeyO*!dO4d5vtkhuhbsqt!L2-3VqG$Xxa%IVcM4nz`SB4#3?
zz3%{uAuYklHyHbR0UDoOKg}x~a#ASSa7xh_Yf)<2QaMJ|!?+i_)m3r1B_6T22uLbT
zT%z2oHoNm^oUTuVX&Y0)NU$r#AS6s{On?FzT_7oIl<EaOkj!N%<}92kFqll~(ybB6
zAQ{zs0n&EqOlFr-SL1t^rTdQXB}pWK1c~@pc4@$XyXMs7p0fIjO3s{#8fl^XicuL#
zYe;p%>krQL*#QS6Oi7v-lM<RN75Uj4E)>GsjKmN|$4-@(izEbWaDucR3ffeZgq>qq
z8XD&@5inB8AfxQEpmfj;2AWM#Bt??51oV&@%Bj<Sl!F04_?2ba8p3VeQGiJ6Pop5p
z-N1`1t%%`w`2PSJrwYT^Q@0lmWlp=t`)X^wz*Cw4l~)x}wBF~E019o6-m$~jb-x5*
zZY66$&wA<%_m2MnZ&C#nQeqlaY&A1o{k1`Dkqm1De**016U6ZaWpU=mbb_clr0RYj
zDW>rHc`FWSIQ&Oz4Q|SS;k;Jw2)<t!;!St9*gHiQtmn#=x=a8%#-@CSTI(b=ur*w*
zcAAaI4!Wgyp6?CEaofya2oq@YNOLR|DY$|{wTR#6LLtV<LRi5%=$qfad0}?l*eG>H
zkfkJeiAtq9kB**n`f^+n+}UlFiNJUp*zX5i;tjIejg{E$#1C^J3rW*m0Y3_Bm;fO4
z%~y4CPPk#*B=K$<O|ZDS!x<+jheA%M*v_6*B6m)l#^_Qk8{)Q_!(4GTyhVn<wRO!q
z^h|^upor7uQUPyvZPutmgG}sIi^JSujBw^7X=TP2&U<y;fd2qhA`k??Qo2Ap`ShrD
zHe?My;-glZYBMthfl+P}?4yIY&$K5vs>2>;!w<K7zjtW(2l=EEEv$R#CbMzxZ8|2M
zGY;~%p$lUM$F`uWQb_0d618Vxm=)FASBS+LYZ1fJ=XBbODG6``1H%$I89ghVtJ%{3
z0QzT==)Z@b+x<tyu?~DS?aDU)0950&ylaJf7vWd$tZ>G~)x*SEFqG=^>YSs<10?hU
zvFlW;iG1zX`}<UIRA0m^Hjy^m@(U~B7(Wtro5vxS?v;0Ydic1$eEX6#%dUw+0NcyT
znN7W&IrsNneQK0AZXRL))2|g)ekD6fYl%3GuFp6!<)gzKDB)o%LbSfT&^vH>7$BuR
z0MP4O{3{LFv-vO7>E+MO+WA1)b78Km<5H+Oopa&HdV8w-fUnbp;`df=wuc4Hvf3(M
z*@!U*<4odNs#9x$(5+k+T4ad23Krrn;rY(e)Y{T_f+8vIGAz8-!IdZB_YrPVTM+A_
zL;wKyL7hM9HA<-_<vajF0gbjTc!}m01xb83HQXIXruAxzfurc8jIWJ~x-Tz3lZabe
zI-*d^4gz$EZ3M@htdm%^8+kjcI9FvYC&%4MxHkCQTC_)q9Y8WUYCe^LifLgjU7jAG
zb3>=Dil193D%`sxKu)F)r{`3jZ?9cSc_MPBHn$2$%cv#+^5;HOAe|Jr0|>RT%rdx;
zB=XnFn$jJruJIZrQELh-Du6*C{$7+Wc^h@IQG5=)R1+BO6<BU4<)ZN0#WKm(;R%%U
z<+-Oal}e250w|`_l#8c$e`$O_aHOrvys8>P+bA=qT7ue)vzmm_FA&=&=Z|p3HeGB7
zf+a+OzokHRO(96Zksz2&-tB#xX7Ylz$y5xiABQT8l^t>n_4h(BG&2BC)e^xwSH&Dt
zs%G`{q>l*%r(TgzX|<ZQH1NDVVRnQ=i@SKoE!$$<BKrJ*0*iVCiQJRruR61br1$(S
z)13Vlbsi6d!x=3CP>fHst}Dkdrf};^7ZTmVfGc>J9+cM8EOuwvL$J7ZRW(>NUgP++
zzX<T1&N+!X0b!LbQmD+XNe9g7Rw%UM9w~)S5m&RhIxJU<Vs|+9D*h#SuJP-&sl^gB
z8H|8BM@sH#(-bL&4VN8J=DkNe?!IxtrHfq@8&o9$T+9Qf%U>$+b)^Sq4)I4Y#QQy)
z_avrDklRNv5@Z9ZJh%Mnl|z}pE0o)m7*eDF>+CS{6b-orO4DBgBzf*@Db9=dtpH<1
z7PwOJU*cAcr7BZRC1)<7F|M9k#aU<#Epbru0s?#Ze!Lh@Y4}Tyf)eA3Wk-=8?g6X#
z;hzdZ&x@^Z#F%^6{9N_RiT+zROg@rEvZhpn`h4q=#5*MmZy$oL;6QW_Kco<ihB6^R
z3Dq(T=_6X_setN+d96C9`q8|lDAW)U5>E410NgA`I7}w1&Y>UxcGu;tFc1{XChr9j
zNjk&<6z2D!D43Pwi|{0<=m69W=82-xlt=~=PQ-<bq67|8H7$sOrbyi)qnK$Kb=YV{
zdH2y14>ZQ~_h6j!^{HS|<8(u_c9i}&RwGCQtyJQV45b{AkAhZ@!ELiNpG_jU7PC91
z7Iq=|N<5bPw(<=$gIXCwMb=q%V=ILKl2mo_itqqvre%Aok~E2?x0+dil|oWE9$QtG
z2uXP|mLRD)h?&=Fbn{9UvgaUyCL>>3h=fvC;`?O+0*ok~3b}gM(cU8Kv!qEx7*sY!
zXawz+V^5~_RrV_L41`yOie9@~vIVIHKukd!essE`0+*6R0<Z4N)Y=u1DcMjA&h?Rv
zbjemJ2V@ejoC(03gX>(zAQPhXQF5e>4F=#9L<y=y?Xs(xIC!KmLS#saQ*Q-JNiMpq
zxcbiJ+a<WuE-WoYAwe<(?={hI&KXj_d}tPx9BnEjHRJ_J@fJ0Jc4=*L#u}vEaW*0p
zhoAod`DWG0Jr4ENNozYM>AzlTi?ibEXLrCfA9NqHEEV1&$3^w=D{Z6SI_id!HP_@#
zLus8#vtGEPPbft@NaAMkd>Zkm+*?+}DJ`I#atX=?yOKx7YUT`0Qbx-^6u`=0xZJ9B
zz7o8|cxM&F2vat=Gi<Vwu4{14f?(;XJq2$T<udNN)pM_?8&Fa@nffR_rYCgT{{V;K
zYf))yOAUnRT$!2cGtaF{8=B}|1WSUSs|^kDGgw>dL|s~@$!a1(9W8|qj%=o_v$*g*
zK8Xg@gZkB5orGbec0-TiH&(=4rxaUF1qdVgSx5ua$HtDcp}-D*g^`GP{&->1KI#d>
zoJMaRy0*m>yH{-;C@uu$B#DV0ntTl~N5bWz{KD-=aduo~#_?vYE#J2&Q_bD9GiM@T
zX{P#8ULHk^h3a)0@f-3$8NPpxo=x8sI2*-no?s#3*d67*fVM}WI`z_mhzxKB;>Yx-
zE?Q(V!<UM?yFK8HBZV-#t2S(s9BrhixUFQ3367di#<@@VXsg-HClLnlx<B~KsaL24
zK{KTFs<wX**v=z|aYiS6TS>thv|4W6U%1-PGXv0WeznZt={>CNCM|z0Rj>K0s5*lw
zAN-Tu1IEg<<IW+*yLaOR937>cF@m(%<^}=OcfTP6tsAO04BYj4-a6SQh2WdR=}V2y
zzl9s^dyOzI!@ECMXS@}NHt!Vi3jw>!wqre`1bE6-xGJ2Z%1vJ3be+X2=cplrUmip5
zM<@qXmBcDP5mz(xX|U^;zmmx;u-|q{Wy7zCPTqYruCletngq06A!zrqVj=aUXkcro
zG9dkF6<Qp~Pop8krx!{ny%z*$ZA#3b4uL~S`1Pezms84Bhro7Wx-7v?WGRpnl}S<w
zJBZZ(0JSL05RD_m?G@szT&x&%2tgxVN5k$Zm}3;nLKm2YJZAp@+ODpY+mMB_$2i@*
zyZ-?GKb>a03t2vxaA=hw;EYWx$e`MinUH5(r*EmOjCCxgS5bkkT+E|oWZK`7+Jx?q
z0nO*P(AF`hIxTF%Wk0vM11u^hN%)$UwMlf8UfS&{QbUFb5+L%aZnNfr;>3h`E+z01
zktB%PIeyVlVA)b@NW7q!t`Te$uHmHRP$bM5uLrtpt<!vt@{KP9!c^c=teZoJ#hWY*
z=*3sX)%tE=8cZj4c2;d5CgRBjB$5b%580z*pu@CQ9Zj_-v(-$nE)w9&)|xn?3QD0_
zn?TTc)%HD&7im7L3mkDQBvD}XQj9-@`z^z+LathHrA>uQX`7gzK}{9e{{Z;bTk7#w
zu!=wkKSaxp?07MTZS6RA*$PvNGDs88e=pjPv?pjq!<~x(&&BMc?O3yKW*l2+mi@ud
z_4<7)KB>&^?_G0V?Ixji%QOBXdqZ9?iYJ4t9v;tTpsS3hMLWqpa1YGaN5HUQlZbz(
z-E;g`6(CX`WmEQ<U_L@b6sN>G&(622J}j~5uo;!jn}N%~rKAl)r0X(t)+j2}hQc~*
zmr6Zs@}9(Pu!mbpJC#97WP+k({$N!n*^a5rUSQA#Hg$!yiQf>EtJz+3d;r(ssI1*U
zX;#<-2RQOk?jB>j#V-olLJi|?v=gF$IW<ruYz%+3TdL>{jgl%0%%J=NS8K+2d&x*o
zcW|YJCvKqqD@Lf#LBMiV01bEqt>u4a1@n(0NP5YrJyewgKPuqy_ND3fm2-!_Or2-!
zLg`Jz&ZSy-fR9isHlO}S6>kvl>ue$m1zRhj>rQM1m6-0EskJ2u%m^g!PX;Uy<^?9S
z1tg&$c!xe!A<=c`9%;IoQH-il$_dl*rUw{7Vs4UkXHX2smpWiFZoC@-aIlo9Av3nR
zZRJpR>%kj-6ekjL5>#VRuTVbu(-;MUjdW6O$Qm~on#qF;gCI?1@rwlGYErbm8Ef6!
zk0|+81rQ=u4khyB;b8ByM>?}IRZ*hwx0^`cofBI&QJNQF8bR8e){P2TB;9rrl$~jS
zhM+P^<xYTdgXK_afncOCktroyrZiO2ornWO(M-zxT<;t=3do@5f(nzD>0ecQc`lxl
z<Vi|<TWM-@kW7=N$59nnvg+`vNP?xD2WqRAU33AFC*A{{RK_^A!8(}-Rd#k~aIt*m
zWE8@Hi9TBE@vK~Hph#EfGr6k2@C%UPLURe*L0tWIo05X7VpPeX0#lZKDucCxv-K%g
z3GNn7fR4L;=}}4HuCgH6a;<pp627*uxn|no#39dk1EG&9*rSSdgI1m!4Njyv;22o%
ziq==euBp_Q98!ptbOeg)_<M8G1g};8w?J1Ti))2A9}2-R;FR3sY>SJRlcI`eK|LfN
zr8(r~p0!zYk8NGfKlRa7U8>_&tXbIb^C3m`DK5OJFq1sv<61l}i@qlXPl#e#_xDbg
zO7R-Mg8m+?+C$6!A&BB-*9lZ9NeKWDdH_JH?{IVStOm8m824-%6>Gs3O=3J(WW(w2
zE$xzDaapAJH61nO_od1}2HkrQ>t!0F?Qug+aYf>9LYue0x^Cr_tbe4m5tCj*C+Sb3
zbGlB4RRk8WG2EeO%tH#q_-nAc1>xX(WB%8SI?H;gMNR~^Pmqv)6(_#(*K$8zip8e(
z)yKS_29J>?MVR4iABZs<J~*|vC}$mHE#}9%9!P~xJ$KukG@Tt63BtRZOwuOp_Sr-D
zLjM32z%j4*am+dU>?Y#*O%`&3q%KZZ5>Ai`dFijE18KON!+)>gS*{w^_JdHYyh8=T
zY#D_irv>tyQ@EQc5X#iGsXh^~1#zcNl$!O8CJdrL*PI>F@P*i#gqw12%kZSQ2OrsD
z+&_gT?S!#-_1pMr-{iC*Do7wl^<_$jtzzP^&#eCc0K)0>xG=Wx5B@8=y0Y=k;ZOJ<
z4|D$jqL|&Im#b}@a^u+>Es0a5XDLXH$r*t4u0pV88HT6?k@UZ{x7*~jxSP&9jniQk
zXrH|N<8&{M_{)XA4&9wA5n!~ua}fSU5o(|c)(SGN;EqUz6sOBy>eC|!hO5T0VWMMF
zc@N9EY%Q@xjIW%UXW<(8&6+)K@6y6J-Zy*1n7!sZim7hg-#T4!!q|X+v}vHw2<R*6
zw5e0WQxut?ScJNv%u*KVZ!91gQ5jT}fHgjG<*g>GfGXW45}W3?a}aSUWoXdE!H-k%
z72-f>Dj3%iT1xGL%gR@JwRdCyC1AnVNcq$_K#(q)97}*Gi)E(L87^k-;l`y>GRTza
zv7S{`+Q=Shzz{CH##Y1WY2+nYn<Pkx5M=2dwKNV=LMMZk>P=yKo6^ck#J_4#LSr<c
zTYNz^R;@A&_@iMVfF(Fr5>=ysHWdx5g#vVewx2JZQ^wMkt)3rNU6onZII3J}E(bxK
zRE>>u)mgD!6(<N%8yn;jLVe_zGJ5|2nWdJ5V3$HaX!1*FB^rY|s)QJ@QbCe=qZaQd
z$w?q5LCas$YCNzcr5!*{A5eL?Q3R<w()&4bfZz~&t8};}NtxJz_vcXN8I@s=14Px!
zd!d;Ypq*nXwyzduIwm&1Wpce^6U1#HgJ`p<J`iB1%AUtnZ^D@DQyp@MClbf82Lc$w
zl$4MmOFMPf=T<vPgx(^_Kgpv=6lt3;VqrHpgWc=u1ZB{rC!nuqacnfKiuK)!epZNT
zgm$aPgN5+xOIB2qdx$(O?b2t$OlDaf06#J+aJY9?GZq&mQK<H?m5%Xy=dSTv+vRxF
z`{i1I4yWor&3BX-Dbj0s1<7Jxo~b99UfTy2!Vnn=Y`L9l*I+vQY8*_;^)`SacTZll
z_I0GGy&TH?PN6^2J#`gb$1sjb>~luwpA6gkcNbbRVFu*pNr{qG8vH@3wdb)RTcqr=
z?bNxp-E!|2aU=PUCgo>5fCy54dd*UMjg^-Sph_2nsXy^Gy3&xQTUpAH)k!}o8+<)!
zjwCWrQ~<Pu1BTmOrxfAKRzQ(@l=zh;L%btVK6}=+H)f>oB|@;u<-XlRi?p&?00-=p
zsh)WRep6fyI2(`u03q}$-UN)sHX$RKE?l}&B&JpLkH1Q(OhG1k>QQ2e4FNbgvjoPG
zq@Beu0($u>0N&{|rT~ykkT=)oPRq-!7l~gMl(I&^>91cezEnC1-AOW2cN<a_rl*<S
zoY5dkOPv}fu8gV%OrI}WF)?*Hi8`jPDSE<yk<yw#b(A&HbRQOdV63Qua-9J>RIpeC
zXIWED!4{j0S=5koB}DD})>j+ZHmkp(YBpNSZj(CYtY$O@1<pOv^pcT2p0q<$1j1FO
z#>N2js|*k>fyBz?)g`S#6E!b>Qz1iINV;VG%ZpY}HtAIzQO+sNXlg}Bd3uu-0j1ia
zmVssHwprFq5TkV=`!B`Byp=05Pykk*5CHjC*d2Ag*>0=C94g8d404G&RCaP@8LJIe
z{{Uuoh+_bRO3Kb<2qRr}u74j;nvgVF^cV=tMd4aJ6omJ#EDaK_dUMvYF;2DCl@|AH
z)s@l0(iVcF;V~79UriG0L=dMfsD!~HdQ}$yZnI1!RH9f=8jv=x1G*uss@IQJ1*?RB
zJTo)*(ycNx1+#;1C6PG2q<_RkXp*I<^4neJyN(?Ev_z!hL{u=Whw(OXyblOBD^g#x
zY+Ir_36IWVuY%V#z6af7G`frG04{Ix{{R(ZcV}gb;|XH*C}!QIs5(g=B_~NI%$nDw
zG=$2?uLak-701^Xjoa8^3vo_2V{YQmkaPuW-{1m%bW9nq)~cKa7ao6vAG3CXuJL=-
z1m<SdM1#ETx5}-$&=qnsI7(w^P9td2MY0zA3n~auFs*m|>GV6Ugu>p@q^)6(ant99
z_+e!zVb$Pvs&T-XN&$UYf|7It!a)`4KiCN;mHum=qle1(nEwE?y@Kb2)rZ+Ne}%Tn
z8L_|r0GhQ>US`?2Aoqz$<dqFz^QSsbc<-v3;FmU_*F*LyH;>t47PvLVwi?N8+l9-|
z$Bbn@B!kLh<0hjkoNlf$%ymg6C&D*q$9Pv7!U{W~Wo)*>)Tmkl$suR{)g%qMj+IA=
z2MT1e#9llBnENdr6HSL4##PbgJOS$K+fM%gf$(k>!Y^)pvflR;AUfwDP*#B_%!%@v
zuZG2(RWVVvy0OHtAN@NR`c5-pe>J1~IqegIxMQ&FM;*rStAsaztl!)q1gJVmgoeq0
z3W)>CX1J~`LlujAs4!j8aBOeAzJ4Di7?*Zf*3=G=K>}t)r`8q^?T57Nd$o=;dy6rr
zJ)Aw@v|%J=X515z0BxY=H?EU}aO!+6hhozwQha*R9cPNULj{JPpE9AU4dqT(j%4^w
z@#`~J$&!Vl1;Tk^g(}q!6*v%=0&~o3%z9Nigh^MJG#jSY>sy$T;lUBK>~*F)yGSK9
zvhxd^<lCufaYaZo2cbH^>$Q6^4uYAJHNtUec&Cz5=3uxP2~pI1Int_H;S)4~ow)CN
zVCoRER-i#l$<%6oVA2~Q>cfCAzQV3vX_PH46u8NOGd>|7=Dko$qhu}kVL!3CSjJsy
z*=q=WG7OM4jsE~DuUJhWNYPlsJF}@WrF=WZjjH5YT&+ocwPaqpD^K2Q9}$KiX4!N!
zD}!OGuyCAVhY*#a(W%grKU&RuNSRtRo({@uhTJCQ4Fs(+43Rt1W?Y^`0*$b}PNXR9
zzK6@{L=2m%?wRmU8f&}+YXC=`6i$h5c>?L>rWBi%q>})N(`c_HzP47vBWZyphx@g(
zkQ8+%mz{eo-67bFz`;@$Fbfvi@wAa50Z`oi=}=vk!$n2dhd9|Za}DlPpoUYRAoBCl
zywK^oYq0>e1-@)8!nK_l9d`1jIOSvxxhc=tvfHe2+CLaS#a*V~T(*TS%LZ-cZNVf6
zLP%1_s<j8wx_lNFu)+z|#C*0{73&w(%gf)ZD%bs2i>f9QtVC!Ga{AXn5End6k$W3#
ztd+b{lz^j@oeGqlHTeB1ty2a9eIQC!<*>JlE%?Q&WlkwaD2R|X*aKC`x0<rn-ce4?
zZIf}vSXz`NEf^&r?v+pKDOkcAM1jp&r<j6#6vd_-_Pj?fSx9vmPMQ~z51%txq!S*B
z<IaHxuxj7i&B{PYXHc$?llxJ;cXE~D3DHLjUDhzg=#Xx17`SMSCRP-8<*jQ_Gfl(6
zQmQ5iU!d%^*~9Rx$HW*D2S73?N7A@lYe}gD@A*r?x*Fm-(FwyczLgT7qUy=?NZaqu
ztF#uh6nMAy<C1!ynF%6Em^8)--BcvXK#+#X3L2d?8&kk(gc4U7)Kmaa@eM#c_OE4u
zDTT*H!=g%Zg&oNwY9aJV*6Ew%Crt>{ljWwKROX2YOOqE?Adv!Klgr^o0J@3Y0mc-v
za|4=0)2X&?2+N^ZzlR$~ZZT`e;HfDf1LxMU_~U0N3)QMc7?r7zoTx}3?de#t4TXYC
zxiwPKg-mD<T86q2WswV#>WYXFtr2sHQW_F&Hc!1V>&m2nybmSBG=a)$0T8Dtl#y^J
zK$tW+h&D%*5V>8#fb!a)xQnJXm@DyFzUc~3c%<p!GhbqkOI(wvNw%O=q-M@evF@Mq
zM_{0sf>pJ^c(GlYEv?pD2uVb9B6-(0j-(p-D|Zc2S>&!R2)8H;eZ_;BQMRX*VB*PI
z^kB9X$-=41l;%5$HIr14qE08lO%k~wCqo>CQF~;PR%}2^!0y%2LIj>vFypEw%&OnC
z1jVZ63{3R<<yI(8V79Q43m@@i!V$!(QBS(zIt{h!UG4>h&<c(&t3${oAH^|s;CvX~
zCKTds93WXDVpaW1AdRC>GgmOpE`CxhvN2T}B<`ymIs43B?VDS6$?tEQTct7xQCBn5
z@|x%v&=^)FYKBXOszus^)|Y%<-PMDMa@poPgd}W`+Op}^a?h<Ule4yYB{q|(v=<<p
zKFaXBj7|a+-NQLE0iyFNbd5BRr98M8g&8usN&|;tXACy?2yep8!h@M$NF)t^I<rRZ
zKwS$-@t+M0U$gdZu;saxSOZFB0O;ULid^}7^$`bMLe8aCrx6EtAE*kn?AsW{@P~!K
zyZ-={xI%-By{a5q4ylerjgO^1nU41A&LWU_0PF0p7ICXgUg4EoxXq(&p$K+U32-h7
zPH%>v5NVpW{dM$NZl>x$#meox0Pw~3D|*Hnl-S~S{?6)(flBj2ff2b8@|p_m?Er8$
z37AY%T=wQS7ft(1z!0tp!>+}Op29GPyT!Z&y>6u>1T6$<6Q`wft)OUChIreUK0bSR
zuBrI?Sm!v_7a(8D!BzZM#XMPU!fL{;F$<*d_9<s-)+o~20V*vSZ!GOGsRv$qRa!I$
zZeB-xY2rUhqw>5p?u$+NPv=EZ;+LPqFU{X}+Csoe8*gUN1SKMRL~He}Rxs12mvoU(
zJ@c||@`-dUloE;2AcF+?%?m+`r?|8WBKUQ??pURQ7Epq>GKJ`!1pZ$^R4X{O+AS(U
zq-Na=!kY`kT`O#*L=|YAHY9$O+TGR&NTzc*gq@l|R%Io5R7w}5&WDuwQB)E<R50EW
z0jFAVXi7;aP$Fa#>G#UK>x-#tfYA{{h1O-TLV~iC>p4!5_tvX9kYQP6P11o1ZE9s>
zC|X8E6QPZX_;RmCV1=%kfSiXzcXm&R&I~NiBca#f^`-V?u!MQwt~iR$;hTYo+pP&w
zj4vsOQ2J}FDuzdn&C21Z_Cwl<@Xs3DTV=MoQlv(@ACMYvRIyw*I_z3lOmHL@D~pBr
zvd_5*dg&=rb=(q1FVe88&~-ONEv8}_QL+^03&(735)|9*l!63>58u*)F9l18Fl9*a
z>`vKIkosbBl2i`AW{85=Ro|7vx{qP^p|FyLAehoRea#M_m09%W&QgZ1nY{1>q$w#G
zy3hO6o9eU69ZZs!xb9Gd6)iAg1bpap2wGf9LjL;LTPX=ja}gz8TYmIIyo6JBZB=K-
z7|XbK4PU!ztgpC*kf5)0oxfT#*?f5Q*OIpxssMB!Wr%RKJM8!F1gN=id$j;&LX{`-
zuJqEEF}nrJRje8w^S|7#)n<^;Kqd^5GilDPK$%%xrhyT|SuO{gP=J<;ra^%TARnAn
z98HLiFJ+-X$TEi{Tp<ssML^z#HlxY}6EWrm0dAfO$a7q!y_K~bQEu^Y4(Vk?XlG;T
zze=f&Brp#pVW4Di3Q+fWm+>{^1x^(u5P$yV2X04ytx*IJ0ajlGHV;sQw`f&ooHT)(
zy#$l6-%p)-Z*;+TSx0euRVADdsil?oEg%q~Aoqjw*0r#P@4r8~rBuKRf1$?4AB3gN
z2()QRJ!LX$ip02@&_?N4Rz)|EqqcaBwX(aVI+C~`5A755pft$?DvIVxdgb-Ii6JWA
z&OLs#Ol9XpjIISDm3Tl=9w~s4PYps{d#@H^3P|65YDn2EOs^KWOw57PPg$YM$xM-|
zVQ}p3014$Y{`BC`0uoN?gNp=e69mZCjyx0#i3koZ=}H!mBS_zBYa4h90h4uk{u%JX
z-W>Jfk)y6@JmR_jH&$zg@=L`Srwc(`l%WGJA@r=5{5DxMfiAih0Z}CKq%@GMy1_1h
zk*w90x^+q*q+fax0E!nG_))Qkbiv1BRHZ=VCX*`DY0MzFuN2{!I#j#cw%bZXlBEH)
zL3_4VX<*-4%?hLAuf=y~d?<$-{w~|^CO~bYn9stm;rMnl7y)Am`URlg8ro)SI0gBr
z-J7XNIZPdsn`6}diu&81vab{7m@U^3=4tVR;Z&HW0D<sD)bq2Oz{=9<)CcsRKl508
zO6DPKVGOoHyL&svRdt9u!)j8(NIIRh(z)z)JfcF|!#HJ!6`=TOWlgpu5;}AJs|uu%
z*EGC9%1Khex>P4|KAmczBxtB5lIT-vOae}mwEz$$6G0A@SN4;1v|2g=C2&9<Q>9zN
zQ#D>1(RHzhA+5}GRbK^m6=RAU-qt%;#6}OocxcX?@)vThNNqpVRmctNy%>gY`VFK+
zz1j|ae#+$dt~tjM*<t(7_VFpB{87W)RmM2=+PGDmCk^53CFg9dA9Xp#ROM)q{Z17w
zOmiS?Ca$&BX;Wr$Gdq@pU<W@l=V4_{#jT*$<}M`M`}qh9JMcZ-)*r<z+oiyRc1jSW
zkady<gPw-A>OrO;=&93q%xsC`47{87?c6fkYf|m?1yetJQW_%RSesokx%R-eFw1hY
zahtt;GpR8n<T`C9&X_D^0Rj|Z%<5(4f<a1@qC|)~gR!fabC#efC9^AI@CDVQ-JWp9
z6^^n39m3OQwUMe&wJ9LT>EWMRC&*;-T=S{Dm0sqZ4E&Wt$9y!`3oj7B?W`SSvf|!t
z=ScoyBXrk;gI%Nrvqqq--qL^6V}*Fn2F7?6`oZwxu}f=G8%lgx$RZUypwIs5mN@pA
zK(a+@ZWWsCrs`h8_=5}J%p;2N(uFF~0^JsBUPU^S1dutHI#rei)9wS_+plGxEva49
zspxM%Wn<l6j7x%Azv25~b8M!8?i6D=BRWF2h#(JzQ+r~jV-xKtXje4q8g&YW;CxlU
zU9Ag_&+&W*_$D`bWDps5WjZuT1dRwkIIP;NEvcTUji>Uos<y5ffy{Ph?mRy0J9eqr
zKNI##h#@$=lj^m&{{TkeDj_Nz4?|YNg-e7~YPG|<eu^61$9S0T`R4OJhsu=Z!oI_r
z04if-h7*9g@J>_gi!L2K<EJl5!l-7j9xHYTVCJIyFr}*M^~5%%C97u%3Nr!-pDMkJ
z9oCN!v#|GZpA^_T1SurWZPhUvd?}=CSA>g%quShs6sRR>*Y0{60r0{ycU)VPv=jg!
zAc!2u<-e^<hHX(ySr`wYC`<j+t-leJ&YpEz2#|<7K8u_CkdzF`NKyz=d@~@Ama|a9
z$k`lT5zG?dtX9Of^J-aA17Su0N|HAweJei@O*hC|IC35`lxqU)-58s}=bcJh1c_|`
zow*asVN0ovEf7Mo%r1L^rr394)&>p6BXpD}a8(oV0;)e8$%55sm{))7rI=@BcqO}M
zxx`&+1dfyC^{S^AN!KAU)L%@145<zu!%f?O(l1t}4MLT!qpy_EI=w1@NJ8AyPLt|X
zqX)A<ak8tY07%TZK-_<tSbGCay7?ol=Vh?^l^|g(+bBFP94a7_15R;E&Nd%aSk!an
zq$lpVWpsq0%a<D(6Q;EQv`mFqJ?u6Bq#fbWi8dIp#fl~YQql;TV+|l~2t!jDQIbnX
z%}4m}u&yiOJ{q~S!Lb`>-gPP=3h-tz08=Q8J8=S|ou@JQR3FCsHkM>EcNhJvg~lC*
z_KDf+q+|Rwa)tpUyvhoj)2SSVcQ|}aI^#18`4!C^NN~yz=jx%QOr^<2W2u>qN0&}@
zXvr2r$H@eh-KE1R7f4Z0^I9ky4RqIENUF8(3rdXqNs^S8oh&pIM|GG0Hs?EZA4-g-
zGZf7C4c$$9H*}*Iuu&j|qr^w|XViX2<5}3r%0cF?(lF9OmfWQ(y1p5FO}d~6ObuNS
z1as1<fJqXVO@twq#eT%|Xi|JEIS40~Pzm{pihu$FeKC8WjobS}_*Jus0cd%Yqo|h>
zL`IRKs{R~?hmobyu>im&ZO$RQO@)F~l}Wd;wrrpJ&rhXsk8yq=`44$Z!!juOxT<>R
z8oN@_c!eqyr6BYNF^akx3!o=9kpk$IrxULvslrr|tnEHtwE?iyE~DO%iZ{g|DFZkP
zBUu|oIjxmV^dwypXNj0`Af?2_>(KQ2(3T}+1627p_RpXcJTn-dDu#d!!c&;xp-4LV
zRwXJEzueI<7yuz~gLF3S#i#kRpfUjcsj&$|MH|GOTdt)bm1bAgp5Ew8ZQQljV)!V+
zxL(OBOdjkhT5e9Y#bc`WxR*GpxWoSdP^WiSa^^sGtn*S#BvYjVQ*hzRU}%%`-if!-
zOkN7%cLa5)FL2Q@tP+CbIO|w@N^qUI(J&f?S*1rkmU``{@g9x{w{TjZt>_^lbeh${
z@M@U1fC|{d;ptNusw`Q@-M(@E03N>MS2(lmu%e^fvhH8YU53@&;J5}C1_5xB<IO6r
zJ;S*~Kv29t1jO+sOYWBxCsKL*>q*#(bWT>G6dzZ;P^&u|?86hm+FnM2(Unr52vk7R
z=T!zHE~p#X)zGT<7r-tp`_B1=8JJLmuDyOWZk8dgu|-moh_Z2jqxf41b!uFd9_=a;
zH52*OTwGLi0Ip%0TFa{svfe67SiBiZoG?sn^!Qdc5ukEP)xo%Cg{*ic=-jY{g%Sv^
zPNjmkif&R=-!h}a$~B6wJDrwj14O%B>&a71q?Hk%fM&ePRVz4T3JaM`=5bN{a|z-6
z9ZzDMWLBhGqr7g(tz3Ot!cX?6t!m-k%o&FFpY$GQ>=&JguZw0(AhFb)0PyBkSnW@=
zzA^1bi`%fhD@GHB<~V*B!m?Z2gn~lKM&tlVQP#Sy8H8g&uTaa*r;y}14|SgGBQTB1
z!LFq0eE$F%D9;w)tafeLUE1-rxHzkd9&D!FTB_E_c%bInF^@Xfr&qVd3Tz$L>-f=Q
zyyu#eAV?l3^dxzzV+Fom8I0NA07zkBMhH<5e)-m;q0B7_G}?1rSQzNJ#PK^j{4U*3
zTimL9#Geuf5<xt)>&~k*Kp?AcATmM|!kERa&lK6*t=VZ;psblt%2fm&W<>nWIw6td
zl<-{B2#*$UqHx?&@s<HYBQuC08hDP=q0%Ur?7ihBvLtS&eU|ospW}^oXT*RdDs3&W
zr&pp$NbpY}WJg04Yd%q%Ws`|ye{&SGk1nvgye0exk6nJ%O|QDcu_l`(TA1-b+(aI=
z4eY^(PG4lEQ*#}jjlt9|`y%Y`g>bvoTj3m4XMBr>7N>zg?+a&5XJI4DdTXlE0$AfI
zSi1EaPcxczO?dZ<j}+tS!#H`MtP=-lvd|;JcAYaRCuz_@@-^yGf3WYO_7e_iQkS0d
zujHTb<^9SnRc&<r%lIYQd#ve{Ef6FH5AGl5oqDY{yi89pdh1kf{<nuR1A<|K@Rl*f
zJaEm!*od{d!k=sSedOd_!ot8xTtD3r3hD=1r(TO0LBa0Y)3=}HT<yg+0MTP};pO4r
ztUl3rpNGGWud~iScHa93y?6L~_d(q1uy7&}>dyId@6&!pv#_;0AYD%F8jJkLzgI<E
zEkj6R7!H11$6sZWxbK3mdpqMdxMKOya)c1=yXb<4nN;LhBXB|A)~(cYUd+JiuJH5Q
zLxOhY;T$b?u*g6wKme);8tL?`Y@yheu8rN=M(9TfCC8k^K~_=hj}?TSNQ0sI&z)Sx
zmbWDH3pWieCJ?nP0KGs$zo5&CNC^dSopurT^{36(q0(1Ofcq{b)Tv5nh?&#nN+dL+
zZNVXOg*1UGM4xoYfjvO@(RnHV0JYH!JgL;Um7yw0_e$aj`O<0(w?xwx3+GzS+hsth
zBf}A(PKJJT0s$$GlLZ*yms%H3+o>rhHm9EPI(#aoF{RK|+%vLWUfd$m5n|hr6b7V|
zsE^23H(bfExLqYO8qj4*i^b;T4GhRTk<is#(PFGb2~I7ZAmmUW@;lLFodQ{D5M>l?
zDQv=|Dr9T6rl62CN^5fxQ5#!=+D>&IducQ}?7a3^6r%6kROKWO>DTwEzJw&2Kno>p
z*5i%=n2GY*ppgg&hTTrMb%T+!m&T~_*ixSC%M%!2m{uMe;AkX>jR#uv+7~-kW>E*N
zZ10#=t@WcfEUdzi>H?B}bad*zk<7ydRj9#I&I*$4C-8sS*Bh5_FeX!hVk#wBnMm%`
zPf=UAUO!fytBD-<Ni<y1Ei>=){H%A{zv0icuF2hU=KBTq+%OmycIhfkUaB0cp~K^7
z;{>qJzssPk(#1ruoAT>bOFxLT%gz+rBSKOnPLOo<tD@~zvl8nSWAFv@NoYUZB}KPV
zw172}1zULleif08?^$b7X#!<RaR-BZL5QWWl2LJ(Ya&XLL64nR7XbCTC?$X)c8?*p
z?mN<ueVHhjjmaNB-h!dH^H!;evge1C-XX-84Vh{kcKw8`fdC>(llc?yt6=1y@;NH?
zfiGI$kK9v=yR~CwJR1X~45R8RjicVI;+sTepxM{+{-|m&OMHlFY>0IvFTx;7iQD5=
z-B8T(Lf6Owc_G&r3Ab55J|^c_(33Uh)te_~xhQ4Do!z+1gQjgH5v5san-vn$5ar%o
zTM!mhk`)me{3!E9(#;U<60C7W!#cX65&#3kBz(U0sSO1w)GZ0}c*#u!D8HN$F{et9
z(m;T#K8zC~E}kn*!g3`!qoCLm=gy}r9`Z@UkSvFeAhdTAVTG+JS#>BArlk4P@067k
z=#c4Kn}IG{96xK_5I|@EK+?W%h;&sdt|FN(f{FKvanesSuccOJeMxRmmjq=19gSNS
z7gfq1j9d$Qa_UwFP-dVvISKT^E`qa<ZXLehybElrSKdq4D+ekPWc2+jbB5q6V%-c2
zVvZe+Zg<&XZZqQSf3zHNcW$LgWlNN%b{>02I`6QUc3>Ieyz|?4TcYy;;f4#z&e6;_
z(lz?mu^6ITWOQ)AYNpLtFk3~lK&2o6r6nVw^7O3C=i(~!nF0dQPGQ#f$#J02P#@Aq
zm0HU-Tv)8?cU8|Bc50G^sk?XvNd+Y9@Y|&XmKj?3Y-1{ja;kWbhQ*DNQeb2RjrG=R
z&8sh3jBz3mPR?JPbtoXD=Kv2rW{Zflb~6gb2)NV&R@Us~6Jpe$g#>~ibgmksPGz%<
zD#C2608XQyom3}owppe$Dbo(WZdBt-%A?PkYr>(*TGMX2{{Rp=n`$^nRsR5JZ>j57
zLCmG9Pn@1~>?2Fw8?w{Gv@wK@m1}RncAO80;h3)ygm;+MD1@vjJ}+WxE04tQB}hjp
z@mF=)e@m#-xdX46_FU#7xx_uuu=<$;*!fvzj@<ao?$CQt;vOMeecKOTEjG;^n`Isp
zBo9Q2+u`&-kB4q;P0y;tsoVmP(V!2{)mN%@wiIOrDo=(_^qRcbaZuP2LcjYm;c({*
zT{(c_*7%sevT?TU)U2+vaG(aqr;AZi<_EvHes)W!{H+<e%7k!tVqKxJjs`I-JNSK*
z3M+o;*G5DnAA8SAd+Ca8CGH<IBECb<?x&npjqvU77#Eo;dkwWpVPQI4tt3ugB1jWe
zz&T|xje98NI{PZY{0kW3zR+Dx6=+d@{n35U+KEdDI_gJ3y;x{-T63j>);9V=xUl{|
zxVpt{xEB+`?f8YTO{<p~VdA-fb8M*e_|#G_u?EVuY&&T%)oFvTf?F8JICp?;Z<k}5
z>l=RER*6F{4(`dd1C*XhT#`r~Doce^3>t2gk@$xU)@Z+p{V4YaVoc%ew}j$pO7P2{
z^q+uDtEbPJ37tP`wIEz+%kC7`X`JjgR(=VDT_=ca6>Q3GEZ<3D>6wJMH%iAv14DNA
zx6vZ8528%Ng~#C=y1-F}uH{xOi<P1svvEc<WQC{ES_-X<9i=kRH3WVau$9_g(Ne>H
zxhltv@f!}*@N3+2gl-y77GWtDc$JzM%DcvqGC(@!M3AA*v+$XuHmD$r1I|9<>K2iB
zz|`!G>75TR4_&@ViWtLtUF^N&VAdh5bB0T|cI}cB;+P2q<^cc_0VTwZ<1qf3^+0LA
zBfb-H=eYG39;#`)Vd@H_M_b73eRMuBs%P$h{5~xh9{Tf{BUsHEdYY=*Mc9JnxmK`k
z07~<MEr|XurL2tBqy;2_5}*mwaRk(3!R}jiUkK@#D01zP7;q>7<53W)h#J+AHX%ca
zm|t0pkG&8=j0q<~H5zl;rR~hnN?Tq-i&LCJ&6sU%845ru3Nli!*w8SMWf_c>^^kGG
zoQg^A)BzKy2TzYG2Y?I|_M1vLZ4+~aIJ}`Mvson}BnaH==~UeC+JJLc8pD*7&xTtc
z#!~=*w5faa5@*Y5JWw5!p`zoMtLulQcDa)Y>6A$LS1XBVW9+(&8{GB@Qkzh>WiD$2
zQ>;NXQUK9jh}Ar8MP)6tkQF02ov6qD$3&;NgOR$UcDChWS0_Rao|L0<N}E$^U12Sw
zNH8Sp&VSqILosz95rxwPJo!?!01kW6lY6DTxkLne3$`aJl#xASpI^?FTq4SiXF{Cd
zg|_kpIA%7bI7-3A0_h|vOHaZQLiHm`4K-P1l2i6>l!oKH*LXGHVp2;aqKvv00R(A9
znCzF9HBOwiv&3x|Wq)kd!ww9pLx~CmdKzsiuBPDT7%3I0wxov(EPeQw{1Dh;*4JER
z*;@kM=?PPhVd)+f^CcY*m37=VjfcfL_Hoece+THQHSfc}zGb}s06&$Fuq)fX9>guM
zOhJQg>Mlz!wzL$i2nisLyz5I5N3;%eO6jom!>NTY#xL7ELwF0?D7Iis><K^oMN(^J
zjU`wHzyO$AxRu&G@?2R_N(4j#bC?o;DpSXP4^~#`*g`kiQ)$LKSHN)6a-|oo9HUK}
zS)Z*~t=+-6^Hu8-(>#`{#MZ0aVX%TSt-$iLb>6u86(ARs>dnhcH*k=4(FH)n5;=7u
zogu?TQti<*y0$JVaz>Cq8^to15WMGdOdhakiCT2$8p->ba2%Ajp_`!B_$y^aUDTPG
z=ePKyYmv63YNNQ152i{`4sVesN@GYU#amrRF+48ihR1efNh;9w*mbK6AYBB9xk`9v
z1#R0G99b$+8Noe2O)DcAi^|~8u2aLyR5KUD?jPd|3tJY{7PpcjbQ;!%9=m^x=ev^g
zsFu10i}W*qES$FCizZhgL6rVg^Xy0VRB>GXCBw8Zq?Y#KDk@g{iW*}j)oPE;WR1xU
zrAjK>UE++H(Rrdm%l`m~FT`U!3f0CJYy9iQg(b8D&+LAcvBJ1jY<)mlU@httDA1-W
zR9L3+^B(O>9CwIul&GW<LQKF1ko)Cb<6BRL)9l%*Ak$yKBPqjeZIYXI*+9rL=0XRa
zl#bNA=2nF>U=hm<93e6R35nZbwO6T75{{b-TPIcWz-_~B8<0qXQe<d1sA=4$0h@Jt
zaK{i>-MUe1`dmOdtIo8@=D14Kh!Rw~^2Mx5*=tLA^yW4+vffIiI<BPP3a2|$;KIfp
ztC9;xES^v*r^4+QPl3f}C8~wsX2X19=xj+!fC(qhQ&%zWoIEXj5X)9hi*5F9SL{s_
zs)!qpjc}NQ1ckGTh`O@7uL@vKpwL!)oYJ!7>Q||3rKQ3Q?Ht7@#fp$bsFllBi{eZ$
z;zBL`si5G?Ag4C6Io78Sc&214@62$uGHVCfLjM2}cNjMo_M?nps>j!cuZOTzKWPUe
zD{ZF5!;#fWDM*2?-7Bub24U!jx=wxkg@@1Txf~dEEIUXVoBF#i(q&-loMl+i&3$e&
z<|S)P2+(WmU2Jw@6@2ZeWa^gwABLAupK4NbkVq#@2n6jE0r4df0mT}|EgZDM*lP=Y
zY`bWz?sqF8N05{C_|&z`B<B`F=J#c&#rGTC3?|nOYaYLS3Tz?9)aeOQ`HkfCplvee
zND4+!N!>QPMk!z|-^G%bnjkHfo>3kX%oLeB3a}~`Y?ffiPVmmtF-3=PJ{-cVu;(v9
zWUYqJdb2vpi6>oZ9$ioj=G=l%rq+;6)9%9YTnmTzmk@V|9#XLa+l|_8GCXt!IT4y<
z)rSxo+@q}(d~SNo4cbKcAq%s(!tv|e8;A<?%aH2K_o<Hxl6;8Y%8jtg1j6Fum?<|2
zJ!-^ZSFa^_ed6-AvohO;AnVI%rvoBFRZvHG1!eGtEs5dS`#2sV;*=Mn2;4x31o}^<
z3#>F%>QiZ9dsUR~CY%!9@#4a69AJmo2V$g+QhH_@Pn9O7YK<)mIMVG1i%!3vMN`>u
z<^KQy_SI$DKMXk1Fno2`xUyLpi!P8{NJ;mg5Un~@d{aAYK32LO42%5My(q;~EUkDD
ze8!3A6|aQ5D&xCu)Ob0?F9XK$CLAmwGSe#|LhXagRFfV?sb{H-!y1LK_TSaFK8J4v
z*0i~f!c;c{UuSi=RL5=H9(WUv@qQd_ab%}`s>xYKRa-mbY>7P;%9}t6o%ZrpS&0~o
zI|&#2iyx{D!U#Y(n~lF9TKKopR-de&r7Ii($PTmlR&Zs~<KUV+&}S;$eJRYfDq>{7
z);>Q<mKOEujpUsNR!KA5D(r+R6qSW&-n;esQ(h&4RdyE#7a|ywK~3AOF67LTqDX*1
z0Bas#)p~a(Q=Q#`3%m`hHy3i1Jc2`MDbVUd(s_AJ4k6J5CQxh0GOP{=!bSccbf;6C
zD6BafoxvyJ6@$cT205_hzk{cqd#b-}w=iBaO{jEe@|!6j`=k-K%C+QI!)6C%o0Zh6
z<&D;X;TA&pe%12oXCYA|PwLz2T&^|+NL@D%G6;>-fiK)$p$yohCohG^Hi6U3)mE@G
zy!C1CE_q`VgA24pszMS<!Hml@uQ{M`pCo0L@lTma3eTG=XP=b;E$hKSGBUzZX(Sf>
zL?po=#GaHhIw2Oid1G#ZLdh}=YJU1umrmVv?v+sL0+LxJDQ`6Gr=>46tlG1pIb`r{
zX(>5~k1ll+v03$5m=tk~!jM7!nSe(AbQ7|m>R{-Kvv!!wvaG@Z1X7HR0<39F!ZB*`
zQj(#t+AG1^D(+|q#jBoi5NWI?VOMz76JX{55C|t(t4#o^uM!qi{9pbTnBrSC_MgC*
zb7L06{{WwRY}zB*P&ZHm`hc3~cwZ54{{Z7w-$VBE<h_KhaP<QT?#;YEO9<jv>K(uD
zl+H&UWCci2P*6!pPW@|PjD|rPE|d(=LDd|zx?vVJtrR60;lixu1OjK~YODLsbCsq7
z1Syx{zR8>3+LGcxTXrqF=4t-Mqw}AgPZg*s;F}tg_f=)iE}t)8w6a_;--p6yD>+Pj
zYm%Yfq$OF!jI{_(Uxek75>v?i%{7jasJM`t5|CC10LX*%qXb2Q@C2EZi>M0&LCzrS
zO%A=(0T&6I%{CICw33so&px!ski0BVx9t*h0-4PxH0@0W4U|bC3BIsx<OC%K2$MZT
z>*=jDm=J}JCDNbaOgPoDkdzdp13rIR=5f)U>vsz7>Q}S=4o)rF9izR`T3IDzk@@`U
zD&q*lWagiVcVk7)m9;RtZ)UP-w2cBl9|2fbi3^CT>2iAzGY~Yd0|+%L0on%>BLu_l
z9#fGCGp!3+=ecR%sP@ha^INsci|#z_4eYKdY&7Hnn@F1aj|ynP;N<F7wOV<c*6b0>
z3_Ywe-MbVROdUsBt5N2oi`=d@m}@e%I<dkH<?28(gc;1Qr30!KH83+Zw?{D>R_z!F
zLy0O_69Z6ZZ@H@MCGK8#b+-r|rK;Y#Q^wp7*f38s)~u5P5CIn|DcH{+F5dK6-#lg2
z_;lRt1$1?(ZZ=%CW@lxV(BQzE%q6GNb9b;z{{Tqdvug;DS2<SIAfSDwVII+D@>GJL
zP)54}AAdTbb*F-@l!c1$MYo6ciF0gJ5}y2}CpMd%&1qs=p9^)@VBZyiTZglN1|4n!
zgb)wXxEw`^Cz{;FXjPZtQa~mQL5j~KE{i8+(!?;Nz>bE3z|O18J>>_+?wiB$8+=0H
zqT^QYq2;C|<w}7g<yNroa3>(|T0IuKDfYA-N@77DFthjKBM7v`FR>hN4t)(^_g2`I
z<%QGEWOC)CtpmGE@2`Y)6UuAom<p_OT3u;29Ik&e=vN->%x`Ay^TY>u7}aF^a;4k2
z;!vQ2q#n8-(APrYd#v`UCktWL_n3{dn1Zs{*`PmgwHO2fd?TqOfl4sYN$dSgbdv*A
zk;GSfeQ@fbJ^P0|C&HBU0CN2~ROAFs=v?<Q;^8;2v})%TvOtA2x6m?y$dRD=)7X2Z
z8(Iy*wL48m@ZKij+&#vFmaAvPl%sN_f$-%5h1Xz&hCCLZHB`NJ?g7N@Uo_H?8o5Qn
zMw0~1d8f2tX-%n2Nh(jpcDBu9tns!2p7Ra6eJ(gb&D|^dka>=D>Tm86c1V3QmP(Z3
z?J>mI%h)a3({{n{tS(3Y0JUHAkrcoNXgU-P05Pr`rSSe9yS~HF@)I}K?qqS2WJnv2
zQP0;(Yh*jFu7&Rnw#rSySiQrzwi{)QwB@z_8kHqQ%?gqNfKZ;ANuqmgl~!=d*JZdj
zRt5pY7>(tcxSJ42ag{B`i)b3HbCiB!lE#)4y408erprVrM;KvPLtF!4jvG{ab{H0x
z1Edf6g5FpjV=*4JM;6jarVMq^L&Iy9;)@@4y8e>0zht~ybH&^*#QleHCK~O+ubx&Z
zgs33qwZBA?Jd&h{fz!;?j62y}RA!D4M~D_aqCr{}i0%IXkZlGJk^CE}592oleBd3C
zacQ<ddlTU{ZC+GCQkY6&eBo7{!(<0jojUv>!_*n-gR{@q_6nl7G51PwM34Y+fESeV
z?-EbYQR9Kk!g>9cwhrueROb+HyJFqNHlUYWbwWYV0suSt3SB1|G2pFK0Bfok!ijyw
z7Sa+|s);>M->qDk02NRI(n>pxG!yKtt;D*QEy~-}q-uHnny*Up3SLc$V}z|Xcb8$c
z2NGMz2_!)vepI|j%mTB88HLsN*}adl@c322QkP#znT<&jex&^TtCHe1ORAp*)?leM
ztPrX`(aTnxeQxRwV7D4lg!r^nZS$?}7Uw?<LdW7Q45=#S;Lz>f5YtY&P}6`CkYuYe
zhJf<XKU&4dkw~=aR=*4mcyJycbz<7I(-uPAv>_RkbWY}LD8D<dw9PiK%R+Z<uIvVh
zIYxlYPnXu9!%P%Kvkp%Z5~Q7Aldm}Y)`XczAhpRvpd~?IPEk7Y6)k#$q$k$07b`Gg
zPn|=fbcftPMeJP(A{Lyx#6>KCs#R%-Ar`e!Ny-kxQZ%SCVN!e(bY|V~ys~6~1k6-;
zsudZP7q(b}Ry+ViP`DH3syuSl9J5&oM~g_>b)Ys>-31!6Qiw33qE3gMF@ObKz#`Vp
zC=>&|TVPdcXo|3w?i*810HmoT5UzS{Pq`i{omQ{S563rQ!?P|lx8n{Uup<P=9b1YG
zrV_)$#G&YQKRW7oRxkN%Eq0@?+SlROjP%1DtA3#9di$*U)#^g9&@LNNa;rFl;MZjn
zxq&)q@sKR!EzGww7xzg0tDEqI+Fs&*CC3|V=4RDsY>h;?r~~C${{Zp_Wu;D-E7Zia
zk~Mc;%R%8`$5N*Pv<lRofS9gckPTo6@no8W#;MYY3Dj?~Gt!JInP$Z$nItTd48Y&d
zdN#O{pvy{c-X;=4W)I4q(Bvmeq+B6VkO2db9<<T4sOFhmB_X{DFr827Olg#|4EQ0g
z<Um$v&9H&CzqJ)d+Q{j*F|sRyGVSwWt5$Ou)<?p*Y<MD}anWy4%F1F@pV=n|-eLIr
zxRu?qkdly;ljo_d>h&|Q0k>aeONio{>RADmpt2-1+7dPzniJx=JxW65VJT48ZRsv{
zOQx_&$^QU~UO00PWZ|}MORfTgmz37W1jBzOpmVleM+~RgQZFkn;Pyh@)!*DCm8?n4
zsm(mJuGXzU@sX<7q(RP6>pLedP+n7Ht;KWXD!a&Rgl#0Ftftcow$AbnbtL$INUF|z
zs=5MbU>B4L+vjmRg(W31J`vKM)&^ND%oDPF#k)4mgr*XxCqwUbrm%LJrB-on>o;&q
ziDwtLd7_z1iBU*9K?Zfu>0NVxa9qn=M1sFWdnvs|-w)dd0#a1ajG{L5@~j&Am|XrP
zkx-|7qW3J}FPw!-2qhz_ss?AlI|xo_U!Rt4cipEtZj?L2c%!0VZ=jF8>t_(q+!eVl
zy8uhE04?X)$BxF^F8$hM^!wJnZC%jk8C@nK!phJoZ@LNQbRx6=0PSUwBx<`tKa`+?
zBuME|n&^S=T|hYD2{x|@*C_%9wER5hli;?nl0wd1zFI2>;3J0dEyM3(7HVeG2|^5_
z-Is}d(tOB(2c3N*g|VivG{uMnpG~~UTxSrh3*7N(Cfk#s^nvtQtyZ$@cza-}(+9#j
z>^*CvFzbb$0caA6zV~v2VV+b%l;MM^13?3znoEhBrZ92{YXuGm64Ia~88CE>W_+fK
z<5dr7Dnr@60C<Ou@XRXSRF%G!Dh$8|XVZQ{tTlkLPeCrFZpadJQoqDy@+|vDwDvy}
zc6QCQ6TD?n*Ye(%IhtA$u#?z=?aG94b&@eIB(!mdkhEXrDavFd7%}GtepH%HF)HJM
zgztxOYrY>=CYD-l>tMAh>t&Lptq04OF;)Zf5JF4clz>WnoPNh2#;}{VtyN~(Z`l-5
zzjj7c@2QO^(wf&31<E5JAbG1BgRfnIaPpFFTPnk@fK(DfflA}9pDCx@wNt7E+v>dH
zMZSz#yUX?p3jxN8(K8d6Pf$c_)YP%NAz={#S)GbpG;jsEbUW5N;c(iPp8^R4=K2q%
zMNG|j%Bo{K#K)3(+Kv*(7j{u}#i4zd-?>sS+~lOV_N&k26lEixp9-N-pj3j}9=@t@
zrPOgAm+;%^x}ZA(#s$A@oEjHyrmt6sveoj{GV-(K0z9@oXx@LTHzF3bcL!lA1FRoq
zXMR3-hRNHW4B*@~(4^oNmkYQ;24K)}X~`p4&`oCG84r88{nmdEaj3^V-}XMk@>Y1@
z+d?p0ZtvO<5*dudL5NbLZe$9Kdx5P@y==N103w@@f-S@>uyFhl4Jf76w6f?Ub0bmt
z>(-Hmv!1NhnG&O{g4=+H8&Oi^={Z3nK0DRtJH=CLGinpee7c3(suZMzA+n;ba3oTw
z0@j)4jm{2sQOP;LY@5V!78~wD1FIVosuQUvUFx<fu11no>?I;Z60f`|3k@-Ag`r*K
z49=@$nEimRHl(@5?p<{jhA=d$tF^lkYsB^mJ|$&9DkfxtetXZtxA;4Wpy4+CEN&*>
z>;^9?;ox?ZZT*=^9u*`7B=SfDPp{6gc!iuLYVflyB~BEHT2g|)0;UCKw#90V2}DxT
zRHXNln0dqx_oyW(6aN5IuX&MVe|VoNg5wZ?w>P3$3rdL0shxJxybQYOP6TL(A@!E?
z2}wHWWS=AQ`q7e2g05O6KD1C!9wHMPf0_p#NfiPoY~qOkNhH7rYLX#TsNGS!S0H61
zlQXB(SB<PzbwRo_Xtb$AGKfI=n(-D?ssaIxQJZBS2@?eF4)g`43ZnA`NGz0<88fXh
zjl8O^lx2dS06LC!VV&hw@&Y4lyr(LU&YsY#yvnb?5*?P>_Pf~@HNyp@s_-&yES5&7
zeI6u`c}z#forJIaOh9nZ^gjx4wR;N9dDBDX`q$BZINhr5&ga<fm{U$L<BY8;1RTJ@
zA2D5|2aL_#byJnu4xwrP0KvV#vvAHain<5$?+}2ffe1+?NB%;&kNGW9F%4)p0b9c~
zK7@Iz(+qF9wIGAJ0LLz02qLi_Ac7TouagN?r3uN9%#D0s3XP=(X|YHzDh65Kc#$#w
z^yat|Wd*w?uBajaR-EK*<-J*KrN|;eVjf93(xL}gf%(zx3Qf~Xr@%_mW(c1xX`YEX
zi>6j~u3}ehSu~<l@q!1hAU3MliiNGrv@o>9l6G1XfqOPa9ca_nEJ}b1JxTMfTNR0Q
zV<9fSF_2o#6_bMD%rc;sz#c-VwBE}v5aSY5fk^@fN@Ij9=G{g3zZz=?uzKOu0hAcm
zYO3b~;MJvuqH4GRut#b<K<5>4UBm92&9tJF37)#wZ^AI+4L}{r>>Ef^U})J#ZP^z}
zO}atKgo3C%=CresbtSh_TMI0nEs_SG_SIUI4uKp4bQ2xEQ_d-rs1Sn&PSs+CI1*B7
zIL=m;&KGEw(q1F_RR>ebe_y2=jJN~<fYkA<?>MC@G9y9eHP_E-xk;ooXV-X{SxW<2
zlZe}`3KA9!%ySjfjTS3T#eRqO9dNte9kTBr6rnM$@&#hzNNFn%8X@EbFYOJ0tRdtn
z1N}8bZYwHe%8WSy!G3w%wB?U!_YIW-eXweGiQ2Ym9N0ovWq=>t+pXo<aYC@$cm#rg
zXReyp&9Ptk4}>m{5DrjEwB;cQ%1MnXfD%f_Aj(h(Z9ykeH|0R!WJ2>S<pJYRqRWJw
z#0_+xT5c2<zRPz8;02aQ{7hn)o;Srd7ED|PTDxe&j<ymtbPTd|+yun*n);^!VE!<9
z8$#l^g&-?9a&h#!sP3F^3tP`OE?pI6(@>e-3G}UlE^I2qf>5=o)h$aaC;4&I^4>h>
z&OK;m@QuCVxp@z`*|oPy)~kgHR1-Y_KM$=rjGpn)Dd%9XKFu(!E3(qfwk?wDim|s@
zw_@42Ce@`V5=rE!rq!)1$xnaEp!S;1E}rP0QlMS3VsGO7VR3$&Ug@x>8$zHS@)x*2
zwO6BYC0KwM*37~c!|XiiYY}%(;mIpWDbVO+PFwvbUNVRY^x?=g#v=Pkw!1=7Gv>|-
zj}SX+@uFk7sdHNCB`*77*9b-=l|gMvCINzE5%=XyX_*Kj2^uNR8;xQX7uIIcq&w|T
z+uk4_4|$knfMPZzYqV90Mb954TBrmU9#E(Krr?;SC3R<i!;QKCK}G9m@pokYW0$2h
zjBs`J3Z)8-$u9I$-pFv3VB8^fgItpFcJCo7AJUK^ARbbFl^Ben@>N>o)OdK=AL5m{
za@HS*a6UZ1#5jKKtBb5T3rS0;pY+xa#Ej9V=Bj2d%o=aB+vdGOm=7knfZ=1-%kC2F
z*4odHF;3I*o))sPvBF$U)t%A_X+_fBWtFFI36npadcGlyU}adJujBTQ6IsTPp-I`Z
z2tPRbs(ZBV);lQTt`Xv%AHlHfPZZ+5B)?=ebo)SeNNq_8N=(c^+sw^X?VZ{V&AC~;
z#nb3v>k6&RKx;t|Ih9XgJ@yU5mzL_u-dtR*q5%YxmJAs`wNk7_d_!C|61rLqG-x;;
zwoBp<ckHd_T=84zl!Gubr&#qgG=v<y(<)vEB*n%XQ`YHVhR<}8LF7OtN1Ze}0hF1R
z=_xkW<BMBGr7Jvuj)d%fe@bItk+)FlVebShAG3}YMfNBYa8k6jAV7}@-|P8TJ;d=r
zjF7q>9fu^rS9=z$*)l>~36N6}w;{E2M93?nH*i#sX??~c+8z~Zk`>)6F^+Ms{{ZT1
zq~SfxEBf$Q99BcYD%RkkmfbIEyqXyEtUP(|Eq)x*X_@d-h6-E?3j}5m2s-ncrd>8F
z*_PZVVG=V(rkm+NT_zMYa|9{~1aI-E4w#kVb%dj7C?Q8!J9Mei#Q`~mkpwMd>;|wX
ziB(HLPc76E0ZN8hk59cT#sRloSt0k=R9e|VI(yJgooaq1PM}2X-6jB5i5e5@UIH{#
z9@*3**2@aXkVqhsPtu|Y)n`-@GLBiQKtgrP`PYEeXH~M0SgeIgfFe0l7%d@Fd7C3l
zIp9o>drfzzv_h==r_4A28gk|->{Z?_N+8OTw##eOK@=66nYK%CkiQ^*8k_{@XT85;
zj4%o;v2rmxWXFaaobl+Oes$S!YQqtR1e>kO6^p5{{t$e{y`cK5cks<*aQ@6N<f#N3
z%a>nPu{wm$(z#wb^89pih0@`zhYlb5``uh=%8OfdnbjFqXHZi$M=jxIlP)P0sb&Uc
zZ^-LLJi7k?PzXr8=+Dnt2cDnrM#iraEh(aaEr3ZW`q6<mDha#<#o3i5K}jcQI%_>C
z&7Dve17t1N3v!SN*Xk*yz$gvOrag^epT&5|r(Hl&T9ugkRxcE*m5>$spV5XZTe8Kw
z7C;1nrC~g^t(D8?bDwmDlSuD#r_zwon96lm5EHwnP}^jg>ow}fEW%AD=CaQHzHx%s
zvU<kV$yxK~t$T;jHERNPU5^REfHS#d%j<W7)b3H4WXh*aYqzHDhJkE3fCRn@!;UzV
zEg+Q%DFdASXsWzI@N8(0Vi#(&VL>51;7-|g`BG^&Ikt#g?(Nh~4Jz*JC@7w~>*-or
zHUg$?a*VDm+RLB;I#0~h(`1<{tyjQ=HvazIh87wpJBP!rQMWVmtDs3#U7FIe)*Pan
z*5qZ%M0smnAkk&C!Mgne{65~db;Fjhw982XL6EIC`SYwyS%(#ki)=o5t2d1;mi89$
ziSU^-wPiTnDutZCKRCe%Yqfil(@01Uf(hDs{SLLPB;i+O!_RqzZJx;#rC}DKT#z*Q
z3i;MB%|bj^QHW>^60J1_tOYi+JpAg2$OJenX9!#+tAJEg@qi!+rbPybGL#GE!9zHu
z4+N>SNiH0tHltJaD$Wk0T~IU*UvIM4q9KLOIxMH#`Y_vD`)f-#vRts;!k%yq){+WR
zJfQDiP~q<Wn2QU2S1pYX?F)(4>WXkXb8x3zXqCGv0P8wW@8?<%(iIz#C3?zHmB$~_
z5(rQ*N6M98bWQR`Fzimw&j?#qwhgNkecZ`)Vsa-<lOAR|YvoOI+-(*~I^RV90D~{C
zEI7@KMf;h(NO3{s_=*+~Ksx#UmFEyCz_N^>*xV&J>C1bEt;M`4O*W*sXI1H;8uc@^
zEt<hZ;VsM%%V*rf5Y7yhrDEaGx0Nc)c?8UDtkk?uc&KU1arQy3Ezrqzr(DYps!=9l
zdI`|!%5|e@8iYg><cKV@ae&*jd&IQm!Apq)-bPWCQ_2tLPN!l|TOlT0*Q%27t&y;6
z2jSEZ<=SxG@sg7YR=Ojpm?ol~;iG<`D=-Zs#T@KMiE(#vgf)9`=(l)fT2`r_=^N~I
z)?%(Tpf@)qQxw^4hKocTV-K^xzPzz`dp;6SyPy%NaHRM^{{Y*s*GgOe0J3LQp4Oa#
znbpd)<LB|t9aYyD@V$y|E|qGVuJ9blxnP0bPh5(F9(7gOqyZitTaQm=sYfkZVU9i?
zNA?p;1Mx@14RDKCrX|C6*S2<-E!o}KcgqQMtt7VLnf}EH+iI;*)g12VZegXlrT+i{
ztt4hQxch_~673hUOiAZBhVy|ga128h?^w6?1tr4MWMwZ#fEkpJiRG%hXW|cMRk9m$
zMZG^h9%|!o=7U3nr_b^dBY=B4#x8KKAL0Hz7Ot&w6?)kMNs?4z2B7X}9O@vttdKm9
zmdenpRg~e)k}qV#8{js$d8_Neh_l2$^DAX)usNDSiGiJ9^apN~mtF-krvCuydn+2Z
zaEa%y$v_I0i?ypN6dOrwDrAV~^!m}kElsd67hFANyPM|S%bm1<yrWqsZ@(&DDfw9&
zt2kDNK0>~`H^RN0DtSu;4dS^DAyc#=tE$1%%F^XN4XI6)m<Lh^zzC{YNETNmvkHX9
zQk+k<H9m&{OIe5mVf_FNdFx#^6n0n<<NmI97<)`cQ?j~vO4PMr9%(5`Ny{;~u6Gzo
zsjA+=H!V0SQiL4HAZCSZ2hZ}V&5%J>3#>sz8zCrGWRRi&B<n(MQpTYmr0BAfs2>5Z
z*LsVc5$UQ)rxm2Ao^m?WW;-c!K~GsJRE>N(4nk^Rh$_3~KeZu4D~2Gzqt{hg;yx5s
z-OU1ZDk%ay=zuU4Hwh?{4`pxwqCNsDCT^-ZwnlB<SjrN)lM0RMTN;%{qd^5o@b}P+
zsSseFjX)%olU1eHN9>dbygmk-OhhVAvNLYsQc^%VY%0JT1z3bdg^aQJ9Vmvdl;+(&
zWxx+X9Vpx^WhG&s{?pzB7kEDmc8hM%&1rC~I^koI92t{8`6fO!vHt)YtQ%F-UDp2q
zm460FW9jmP_CI7Fu{#gp{hsjsvXYd=t1ceCGnoBNVQ~j`xaUdTc1}H>8r;2tvJnqi
zsj`v?Pk0FD*Xj9C2Y1#pi6(YT*PQrDr_Mb80Lh~O5=dSofu@POiZY;$$)8{GMFKC^
zQlfWU=s?uv@}h4g=V@fh<p(OlQlhQI#P7<iG=XHjZiP9W!gPRlgVUW&Qer|nF)G*W
z4$;5k4!&R(&=cYUb=UQ-Z;4bSU#->bc!~fG)`-7zExHdPD-Nrzb<WXjxTSEQRE*jf
z6HTHB@<WI{<SUEubm6#j&lL{}N!F_39hi_6tQ7-M;4F8?80zt?Y0~nFlbGm!KU(N8
z6b(9axn1=tEu_FXD$f!iD5xwY0a}kPRkuu95j=oogr*(fQeG!1f=;`Q^{J@gqFY*G
zK~1sDR1@8$P&&@1%hH`ek*Y;QAfzycipPAgV5E_odF58MRceym5|>vaybKbwskLTN
z1|&w6X@UZyQ@kYueU)A%Y9}bnLI*gBkCj=c0^uR#g8^q`w5xX#vd&mg=1<DH7L}49
zm9+l=3|NSFhnZ!y4+JM~J<r0i@uD17ZaiESeepR`@V5avcV}be{%ak=9V&$>E?7H{
zu+_2JbIz#>@t97K0M<bI{{XdWQ*iz~b)xL}e3v(p*FBOuI9-_lNkA|<MSS-gYKyGI
z0$8oq%pd{;#<9|~NOp@E(n?S)kfRd-m>m473r^j2_dp<(3gUp<w@e{<lG2|}V>NS!
z$7l)Itx8~uE{$PjU&MD0E$%V4wQOg4?A)xN4{;hOACOndzL~=-ij?GOWzS-1hP9zk
zH;?6Mh7=Q-In|Xr#-IXu`?`A8yF{BT$3HEPG~)-uF$__X-G#c{d1Mg+KuDcu<3$0w
zsFGyDIeTq|@Y+3{SL|M15OW5JhQH~Zsb%?$H3(qKB@W^BzHZISW)g`jGZVZBrn)lS
z05a$sr#IIO=23aDtAVOYd_gh*1oHm?eQ9kDlt<xAQq9&L;JI4VRF!H<LCqvV^BTzX
zrUvH)s2=R57raYkxA7Z$rY*;Fh+Buyl&W<e6#_?^XW}XvAOeYpFo2(7I8!&+h85q+
zFxym-a^M~m6zZuxb{=|DSqyBH4|&nLsY8~i<Aq$QPANE*g1x5=aSi~k?Err+JperQ
znrmUBA<*0;yk(9`QQ4CU?F74V!z|jT8EwLg>^;TzVF@Eg(m9FLk6o(MTI#lt502xX
zpMs@`#Z$un0OXh&9%{?BV-af!_N+?fn`}cfuNATgW%gS=+>&~zoeb?l?&L|HMO7~a
z`C2XYoqdoV4&%ntjJd(s))L!^dpKycw3M9FGC!n{41i$GCZiov9N3<<S87wrJ3v$`
ziu*0Oz-%~&48U!iyTb96+1z2pDDfbdzzO9fW>SA@r&fccy`y3GR@sOZGQ5}~XX*Z`
zzY@T)91o0Mz<8R_F?oe0v<8%*aza5uXOw~uKT5ArhK(W{snuPjQMk9U?K0Tw>X&Zq
z*D+rCNlY}-#Dfz)6oNJfTC7@IOD{EKhE#m=PcZ%`#dvD@YQrxTkvWp^J|w&dAe955
zI+NCyQi#MhU9Z$5vtf{dVwWBD&w*-Abc3MNT?ig}pOrnL8!7=Lz*BAq!qkQvTF@nH
zl&EY>Y4NOVeR(BqU}*~guRa~M_C`xVut3^*{p(!SQ=P=Fm4H)dYBPynrpFF>{LoN^
zD_&+MfJH|JgttpZVyNB-?=emw#4&ZJG97dwCU?pR_;2*CrxM=AizyCEo@4u3u78TZ
zuzOWCV$HflWkP4;T%At)$t$O&6xb28w3fhvkO&&i=TF*#bW%>KT!ASHbth2(iU$a}
zUTKpJNxrl=6_-tB0g3Xc4jYvrq-c-`DIf?iooD4!pt_QGDP*{ks7~J^dQfI?Foz(C
zPwlx0f>a<5W{rgEt5g<5trSqOb_YOYYA1R!V(Ohh2q6=;bu%iGHIwCD2b!l<mPMF;
zGL#uG2HFo=6;1821s%g*N=y<$wBKrtO_ptDl_s-!BuONcfDJm8g3G7~DBY`>RGg<y
zoT}I=skpi%%9SIW>rysKBUJG!8AQyT%`(?YxK&5uyMT{rJ%({E0@5bwn{REl(_ZzH
zoDYsz_|q^oe~XK2_A1T{{{ZqDIos!_))si|`GJRUrW_ss25s0uo<R+P`GZ-{cz!6m
znJc)*0?Jubm7G%1`)1b5$p;{qG0F(5A-B51Ep+%VkO|ca5(Z!aI*FQ?lXc?a0_AK$
zD=7e<=^U%gx`#UHBGe?L4rlC9gR1d1ls@e;lj1sQsN1g8;4YTaDF&?+r2hb>NhS%6
zLF-Dc_y!fMJ4qm^PXuGGaIPXBN;5P_3WKio&0`p9454h*q}ufIlCJv>Kd{CFEVAZe
z>?I?eVL7!7lCd3vbr~gC7-;V7vz_1yw%+R&HDj8htb1d{O{NI;RS;GRVyjX)>VOvi
z00yC+pp}tv3*a1He9#FwzBSm<WB?kwH-JxhMe$3(^818|SBRZ=gZ^tqlMlqHRnjFl
zxVji^i5b$D5;T*dO&F$L=-DjP-3{U9ZgG2syLN#EQU@-7PIYde6u=6ro(M3HzWQv?
zQr>|ahxL7$ibHgouA3o^KD&T+B}8+GOu(yylB7+fucfP2*K(!82C<+d(?JlD`6d=;
zTF|FcDbKN1n-0BepkcbpAi~yvg?F1y847fl6i5h8!(Hn)8}TgsdrShf-Ysu><`%LM
zp>6_Zu^*H|%co;~7BB5tvUu<x5Gf!KL`a?Ht+C(ILhU$CjfJE8Aa!5DEp<!;4SxPL
z!ecE|`Tmz-hyy5B6K664N`$ASXBi6>>2!r<Fb7|a491}YU>HztHJ0s``$81i%nzkn
z!qmx71+j)^X2DtOw%hTD@pc!ATDIEDcw2=)gR7x22i6bF*U-2?EyF?Px!hRn-dc7m
zGUCmloASXZQqY8g49Fx7ajxWi>!o9iO2()FA*iBpj9t7v7Cq{jw<!q9fdxQvk-yHC
zMq?)H#N`%40q^b<9YOI09i)>IH>LqPCBWNMYYVkDtv1VnKg>_GJeZFPPKiFJ@~LyA
z*-Jo_z8cFo#wuNLNM$4yEW{38T={y67fTx@0eqMVjwy+)hu^TfKykFF^3du5{Qk87
z{{Yw~+0KV1c$N9Lvqhbv5`?8H0ZSe@R-_J^)UsUZDgXd?QM)_zVf+ft5Rg5m8+@rs
z=7b_3`4t%XQylW*Qrh3_%;Tav*!~&^6{6o1ebygnE4kM$Vn&1Zs{)%y0y^tNoLN1Q
zgufqfmDdSz7{9T(a?Sg)tDAS)R!?YXl9wBugNRtu%T7Xqsc8^z%g>jl$SD@$28mwH
zyH&+3apv$ICn~+d3Vo5#^Jl(kr3fWGbR_!JI-z4H=#h!T2Mo-!h5b@5*;>2Wy6re`
z6j!sj>0OKMteFr(WRW1sqK=z{0xl2XSq_>bv>RPtTqW8|*d7as+i_M4XM1;nS}Ok5
z@hX<o>Jpytj-Dt~bxGP{k%_NUVj%mEy3enHFD(pl0oFcSPo<VkyT)(0hZMxPvlw-?
z-QT|D<HUoiluQB7Nz$lPb;APbu+#+_U=6fQY#u{RI$mgZuC4$EK}g(4J$g{plHtfH
zrhA3cs%>$1-32$7BZ?#e<r-9hbXxbhr?_q$_26wuK!h$74uEUF=SrzlEt9CQ>$<wQ
z2MQ@{I$Qo&00A8O*Da2%CO2J14wMm@S@>`%AQ2%VHPSS!sS>o_Kx`;qYurRIejYY$
zJQDrU$dGp)m8HTc3`KE!1)s!g_B2U1CdsE`{62l1fLh91M|$p&DpvFL`qhpti0>S}
zN~aE^-IA_bWQOu1%moNNYoBY0)o(jQ`M&er01?O@TGWzeLAncSoQ+xtP@QBN2$2dV
z4rG9BGnDHz4xJN8w5IN%6XA~$k`LcX@SO_uKwhIFRt{eh1Z}zLUW>_4;z;vPm{gp=
zgC|`gnVD5^Famzm1q`vVNY<jl>a&D|^`(@NBzUxu(^`?uS9p;D6}A~lWx``ot$2_$
z3XAV3?VZSPAv56`K-PvVv#L|fY^0cT+D>3blh9KskThA9gjpZ6bt)k_j?e{LVJd^c
z2-T@1Y5?;z;cZe~boBs{;?_kGx=Dy#Ickfx9kzJ^O}K)B4#W{bQd$Fs%hLuz!u_pc
zZFYHcdBN?1hgo&xr!L_dl+VD5Mjs05n1?@a@ps0vakN=jZU^mFSZ`=+MZK~1gp%Tv
z3R13-{%c+Iq0kjKP}He*6WSAM2wTqpHj;NgVv=b1CH77VS%>kZoz9ANGIu=usb-fX
zhf~Y4Cf+q-`(aHi3GnKz2G#6_V5;SXw_VFuG8$S`R0tz|%}E3qLeT{hvBQdynbyEE
z2`60DnTV|(i%yWrENqzHziiry6tO3!lUb&qbEXQ`U?f0O4#+U4Zt<p^2~wMGR7}X_
z5!0Pk#N;iARQQcT%48F&(#uk9aOB8{6`ftdjD^WC7u72@cJ;)PRb<-1=f5gG8BesV
zUb~J9Ln||tnDNYV*^}LnR8(V5XO`95;pjQxY1XJ3WE-KDP9@N**Fi{$0O`nb=e1mU
zEja?Im=P!y&FRH&jj};4NJt=TC)d;GR#{K85|a0ms+L-^oF?2hljBedfHj!<@};<E
zRr6Zuh5C!HB_JOXyh_Y8^4q0ZV6j!)?8Pi?4VxK?h+6g?KJ=rRGOM_P6jzHewKHlh
zn$!^>kp@ox03Xhr)=Q8L$<<LVGV&IYm2Mq?0tIe@&^1|v8L(P^@P%--;#W&tW<Ux;
zc_hy%=e1Dc9|!|=OCLR$m9p+z?{LMbLS;E*^WLx?OzN@&MrDk@5Exjr;;cU4&+`_f
zE;+#w`PI4(IST7IJM%PnE1R*^6=62OC*42?;k|Kq*2PyY-n*udD(bcIHV#n{C-fDV
zd$tP|`lrnTr6>hPk);Eqiy#CjUmPtq_E#4Vm}$1uwR#Qc=(qbo0c>F$2w8iI?peld
zaLjciAuqn<1quFG5Da<q@~^01SZPoc&ZAY&W1cEkeqOayHae8O#u%Hq5|){LYEcI$
z$~h0db+vI!EN5P&(CeGia^bmNPZInoNhSv&^8BmJX%=32nT-*wBFNgd-Ya?n8&+V`
zf7Ij+ej5ICPjvS}294Lad+yxZVpqy=X9-A|Aju{p{B2T15CRC2NejFbptAF;K+2r3
zxbvTn<xyJTDWcPL)-Pmk9=UyP0KDXmr9|`Ty(~x)6Rb)FY|3)Hi-xj<sAox35wHi-
zS~JWc6Bk6R?rrdQmvM+%D(ODX<5tb(Ia1+lrL`YIW|+s8JG<lfNvho72AI?3`%`|;
zIOgsAD&K~&R?u-q+)AvSaAjMKkLk_*!Ze<-SLr;vxDAe<g;C6do@`a)iQt$QX*@9Q
z7mqdFtq3<ZH-RvlXW|@baj;Q>3E0fgxug<e+xQ>BS>evZRcqRO2<OO!Qer)o<JOq-
z_87w`a?=iF0juN)Q_QXcQm^h3Vt=IhQeM_ZR~<#P>L=yowWwAV7#`jJiDX%D{{Uw9
z_MB&Dg{vNAmP(vJb0N2UB<0QonF>E4RUcNXBe4QUG}qG@hMG<}ezsNJw;f||;MZI_
z<H%L5`cHa708k20Sx7sHfITS{GY<6IlCs8!kb2~!*USdOY#DeEq5`xs4w5$4{7^RT
z&YtJM%NnHaE>MS((g_GcLSTJQFW*|0=`KP<h~$t+L+VHplbgahbefkyY^F34<zsMu
z5Vu2+(aNPF5>GSFZF$xnHn?epv4f+TUEDol#g&syz$HRR0Bh%5y?ULYl2=PgnWi8o
z_g8FT){fsk=tF2pQp}wO`qK3wp)k78s4JXi>$ILfMaxMlu(NmhbFfT-(rdAyMZ7l)
z2jX(&u{Dk|wo&kpsai9GuvFoga#N6k<Q;cCK9$JhYl@Xl;4X&+MAN0-)kx5V0+bC3
zcRgym3<)aX1628?ttbGL{J&q7dB`9VlyODY(vU%dNj_e*BT^KA8tGpwEiDZ|AnuXR
zl>uls3&4rGZt8o(BomZs71p4T;FvqDl!440APosR{Oi}4DmIkqmr7HeS}8+ac}~?n
z1tHCtjT81(QlKP31LNu_poE8jMU(a&QUDv1<-a=iY^tl+9Ew{!l;u$*b*Y6)qfNpy
zZtyTb@-^Wk=%`d@H6g;?P)BxjDg&S8Ml}mF5YSA8B*UCZP~Lp1;|PV9R6;v!<fO^l
z;ZAHSt_X`um=PpVMyW)?c*2BfI#fNf*bB#1h<_VAE^yw{aGoFx6K{*!7RlrtLDqf*
zRjdoMQat|vAE;e72CQF)G|&A{(BJZ?M|gd=*kyS~@|p<{H79eZ=dD{6wIyl95)(Ht
z>$^sjTPqtWBQ)!-y#CD)a~y6ImbmVly~H@Zioj4QDbSF18xOdmZ5F?Dw}3rYOm?94
zjD@<WPO9{se_Cn68M>)Z2L&eKuG;PU{_f@Dl&Be3^$GO-dD5$43}}^<6CmAQoFT{7
zSjcL|(D&}#Xq2Q*zE#WPXuYOl0=rI#b90lTnBtrQ<5pkAF-8iU0GJvCk50Op!Z^b@
z8`ociRB;S-Osz1ij>WJP*xRl1?yQIeY6sb*)u<ljM~YQ0?y1)u<7mRLmt0AVs4=Jp
zv+LB)P&6ud3_oi4D+cz(+8=v;aDez(3L!>zuD^ot;u<WwlIG#502MQ1iam{7msXGE
zwy-29YIPr#bw-h(AS!Nns7#b<;}KiUoIc65h=lV#q#9Fc5_360aBER+AHh?G*(&Pc
z04@rI?=$zU8_r^?m)&~p>R))c=na)_0T3ip1AeJ4CM>$KZ@zf<iO>&CHU9t<K;13C
zLQ@yH?$Y5@Wk7_<ks5DK02NwoWl`hzp3`;~homI#qwfxTRf=MDL@la5#{gQ}GLrG{
z-6VpssQZdX@~S!9f?%e>vbDPk!W`l3ZAw7V#{yIg?;dnj-fA<&V{stYGexj164Tgh
zsA(HkO-B{ZXl$}~;!6r~+;Y<JC154wr63K3TEo0S61q+d-~=hhWC~EjSw?~cLF8h&
zJZU|vfnDWD?3zNm?9vMW@2ASK-z3>%R5wp-P@)zjY-x1}BtipXtG?GAaXdM6(g;ef
z0ALySb7}caU*W(%6vA|ssfTxT-$j`_L9%VW&v3-sC;9g3xVV51xv2wAU`2f^21#}L
zE1twasPZ=|f^B}<?Z<Ya7jU$sNr^fcRP}?UY@0zVHPB>)@7ZwcJ4Co#4_szB8z5y)
zplU|`p0pXH_f!EN66K56%g8sbscB&NdGgQ!&MIs)P-W0pR%=U6IMePGwC-TI07=$8
zKJ}vjYJ?8)vL$4JX=QJR1qCYcS=5==E}Vy!pBe+-GNcF+7k4&_0^th^IZKF02_rUG
zfuWzVUieRfA*zpF-74rHETJeGDgX*ton+L8#nQ{CRJD?p(Eby60+DiIhgA@QdGxOx
za}QKt3BKv&_7W}FwYv*&U9~85CqkDJcO3>;GepO`K%lS@1zTN-_P=$9-unj>r7qhz
zk7qBtsuq=P-VUNQBWk<a5e9nug_n%M_KksKsQoL09O0GYoFMJT54zuW+JexI^E#VJ
z_s{|M90}u|s6Q=eh^Ac@lX&s)+7H!Ip@@A7pj6QHe-#0=!LWQ%#}u@;V6cy7Pko37
z;0F;ThZ3j+0iZkS2U@3z6$L=y8F%JCBf$Hurqp9VFE`jM-E5O)mt0g8D3IA3&fcHz
zRO)x21$vvH5_zN&^US1{mz;u6i6G4BvHRA%K8j1PE=aiXb>iM|GmT*)3G#uz`KgdZ
zl??<42<Hr7$-lcubtk%K#7UiFlvO-dATgHItt>SX=Sf#z17OXRhZ2wzGCVo~x9wcE
zI=tC*m^vU_g<!VYTR~cs5|kh>F&lk@Sq>#?7YkWZovQYNt|GZ#3vkMm;u=v)#jpKB
z4#SxP^zt>+aE=?<{{Zr9k0sA>OnHyv(l<J(hhtm<oG#55_w40$W>q^ARd~k{?H*Xu
zWbPe+$k6A7bJ~E0%A;LU2av9E=gn@Bcuw0vT1xc_-{bM31Os#~v;?3MN^==H^cvTR
z-AY-A3qnXFZzu1iOz8?9EN4`&gry^xI_b338};);Fj6k00hpO3FhCTd2I$&m!8coH
zEGX~Sa7L9R$+=PwCDKAx5S?^7!QP{~gv(_v!>SGh59#oeMRJnxAj%}g%EFL$1V9|C
z#&lH;F$kkh00|0{@S<oEB~*AM!YN|1N<rM6JgQtE-BYU26o$^_vf@*)NQ13QNgAx$
zw8?C#E*Rj-7YAQCt2E7)MP}X<g3ZDqC)d)futK2pQI&+j*v7}5Fkj6ir>wc5J5IGE
zNJ0hGA^61MG-JJ&e;h&rp1|%=bv(mo!oQ&h;X{LWXH>JA)!`LOF&RJh1T1@lx{H<o
z02$o$iqLyv%c7j7>3h2dR^DvB@sdc_pFe=5wa{*kOj$-TOdXeu5h_wi*J&PAYMY})
z4tWw36NoS;0+zN%hIS)Qr(RX5Mx+=jlf<^_4R+ntqsbvlO3^+E*!uiO*0h)zP%0I3
zH1~8{JMb-GX^S;+e~N;q*-=YnT7W#hzdGPQ<@NgqicPRu4{N`O9yeN}v|{6Sw)VJt
zMN4?Xj7S6SE9cbSYCp*b4`XwZ{gk7F7`MW3hLY-_r8$&Nn(s`jR^+O<f@;3Xko-?}
z&xUZu5cQS4$`^E`ke26qyTSNd@%Vsax)#R`q1d$6et}@@R~x(HJVDo7StwaEnL~YJ
z;a^k3;n{_zEUZ<m>aNO)TRO%b-*T46dmij-v5$;WoI6KO$cvy^Ncd9*xOv}exKg1<
zk%N|Y(!Ef(;Rz+si{sd`El081sHrI$$<}^9dYTrpZc;NzQS?5$f)d(_ltz#|{QjP_
z*aJlc#EYqh4`LBytEa(8i9Rhs>GiJxc}l4BIYNtZLY#OO8c<16phmDd(^>|pTPoW2
z#470xB!#3vfxoR-Y(gn5Fs(inEMtu};K~H5I%rJQH?u3OylU91Z-CmhvA$^%JHoX5
zdj3@|lG`jyan9LVBF5nevxIA>TBTGI<gg+Q)_MFyv@TMWArhpzg#b0!kBvne2we{c
zbX1a`_C!FpY?3z<Jo(o(jR008ub@5ou;LZxWTghs4*SJpxJX$KgQ6pB078h|j&)w7
z!dWnGs*c{4>wFV^a>OOea)*M5=&?UZt$qg9jB8r2vA@=1aDA3-?Sk*vcx5iyDJ7&b
z8$zd1oDFN~7#7Qn^Xu7Q;$J=O;ZW?QFLx~kB&m6ppppP4bodZDb**T+&CFmBm1^15
zDTWjRL+Uwam>*>Ps8c5CYX;QS?o`fHtt7}ZlnImf)}h7%7eTb7FPGh1I@QB)vZ7KK
z_v_1@8*U*Btl~mB!x$^qvvR}P+)~kQ(`QrODOo~bjdcAgOGTOx7k5cI1ihu3mz+}V
zo7tAzcM8pwGE_)9!1U$PrOk#R50RNL<19HCZZz^eoHWJDV6>^wLSX%9T4w0vKu<Vp
z3$ey{V(mDa-OHBHhTbE>+QF2S9zgzMT9*LBW$CyDcV%aFeTUuQs!?|S)gIK!Qoj?Z
zL<bQAUvS9(0Jf#AgKhNd$$9PrUb!c@VlA$4W|(c@F;qAnwRR3ynt)b=<_E`qRN&S)
zo?8?F&d(%SS@;ech~b<OamCyph`MfU?wNk(*$!n&5|pSp0O^-fW6C*KoYpj(LD!dD
z)he*+ot;5q6lb&^DZ_Z*0J^oY!(YR(Tp887coO6$;3_i^k*2yHdUV#S)-G{5#+@Hk
zV-1Hit9Q(UqNf((9awBBDuNOqkDsQrts5%yoLyv%)1eNjDFRAzl&6#r@lY=kynCz6
zA*P&qTPhAHjH4`xoqY%2oi4M$5-guZj(3W-cvpu5UDIG>36;2_jr_H)cNd8lGd!0?
zgrMUdDt4YO;f@bwf5b5+n=PP}Hic$c>i~M6D#rdjY*V6}NuQF}eR@<I-*tknc%QVM
zDC6R+4}>twi(5sKha6BTTZ2iSKu0ZWZwta`;D>FDGDgcI5ydLw9oXRn4r)Q!_hk)X
z4kr5fA=k(m$pnCUYgM?16*Y!Rb_&J^g^EWtTa|X<>?M}a%U~oT07>4tw>vSDs^4gU
zi(AMhNYsKRf_W%^H0`AzHj~gv9&=FF5Fjr*y=1CVy%v$6R>N{AfrI1tLg=_FroyuW
zoawA}sWu8t#))Mltbp1`j;1yqv@>`>A)u1IaXHcyL6I@9TJwf&0*0KnNV>^V3i25n
z$EMW;?h%IoR}G^fLP+FJzkAUT8i11J;8`Uq$q;0pDgx^Oy_O|EWx`f6Di2a?(Xs04
zvw;B+wsux!TJoNBLP=Gg*cL`@9R&$efI6Kh<ZH6esMsj2lZAu@XuQHd%}YkXRjS;?
zsU{nCqO|9Yhsr6`<OPpima>xA+{TmB<5rs!D=wpMj$67E1o}ld5~{c->D2`yes$*p
zLLAU#Fyh<}--&or62PvK6y5EsjSzg(1M5h4a-ec$DyEyoL9t(&c5Od{VwZSJz7^R%
z;|fU<d@3ORRjfpbU6aTrMu`6aw1u>gL@1CBQ>m)uux`CFEKu8~CgDhM01OHA>+?T4
zdr1gfcNbCIR|*PYAsI+nB#*vTZHDkt+)K1kyRHjv_0sTdX%bA%q<Ynni8RnQn_g}u
zX%E6S7Uma<I)uEg>1qI^?iKcHlm7sc5r~3rLbZr#rG<bN#>OqI?W`4dbmDvoook4w
zz}o|Li$%_R;4JIfhvF*FhM9W}!|u|jLUJGj5x)H^M~3i9xX5#~T?ITPI%7ReWn$ht
z;*493@xys^^4xJ`4OB=IppA4JSJOCt4vq$%RtqK8d#VUctZ?*Lwcch0Zpu<1%$=#V
zU!1_v4In`AQcfDcu5X_gH!X#Q{{VMM`_tBv_W@v-=VjGQubyKIu~SUB0V$KF$DhM*
zohhu7bca+X$`1YFFRv7|h*GCQG~RaSpsRUcLRdW1mxeHM`@z>GCIX>8y3H(*yyrkt
zOjYA+Y^!Tz=z%JMy&DRyV4Tj~SNuzSn?*RJxe6cy8<`LwQ8T<?uMIAuz1eA}FI{iF
zQj|{cQ?9;sXIm(BpcLbPxRU1$N-b9LPGX=5S6{zMiqwHJm76nVT$~q;2QhZk>*Z=Y
zYGA?p`p^c$6&zC~u(eMQ+_vT%g?q%L6FSyaU}npm{{XesIoq9zZrWO#2@6k;<x6RR
zWp40;mEb1bl&GP!AgT$2<bL(8b07Zzl*;-eVc2mB`NOqoAc6C&mrdbhH~>*bl7lIj
zkran!BUGb0g<STtV%{afn6;9;K};$^+5no;;bhXrHl#(uzer6mu&*9*Gx){{hGEM|
z%Hz9^K?5v&qk8(b8k`d4%;Lx;!9whk<8t$M$}KdZ<IAE!8cB^R%ZV0L#26c*I9Lwd
zu;XDx453~SBonT@xr%}zF{Uh1Z(6Keyz>C0CR|D8AjI^U*RGR90m}+q6J-AYjP2EJ
z#7bq|8%?t>w>n5t0*M`UCW-*jC5JGSbAS}`Z*Z1dN<tdMTe@15L_$1VwE|NW;s`S+
zYnh_qzKM<jc-{9NUM<H^k#Mz^&RqiFo_xP?=}u!qm?ZTGoHp55eWUQ6AAiH|;w>fO
ztAF{ltph|T02Vy~gRfc#G7Nx`My;~FSKXZ<7x<mkl81eVUbdS{ptOOJN=YrMI%W|g
z`@HHZvnzA**U2|Kj=GOz*8sZ2`#$58VU99YiedK<1E;|72mLdys9ItVQ_xKoQd<o%
z%gkx$Qk*+>mYoirb5c$v!R@SZ6l0t)r;~=>ysL{=6__cqq@McSU-ctc9KkWQGMViR
zM*4C)kHRJr;g#Bre?F?*?DrACu&e<%mG!zG!f`uAuMun~R~rW+)(26dkC8NWh<iZ;
zya&v0`BZDQ)hrKq8+)p=v_2eb0maTc!?%syU^s=-OAAbxLXt!h1eB5YrBi+GuhM>Y
zfPN@dJ*yW5$6jjPYs^SULPYs;({ZQPmgcyKPVE{uUMVawm%Iu?sPU*NCQR-+dTmN^
zBE%=t6Rzpr82#gKX2WdMwfnii*z~HE17H6Dk;?r!VE(qsl-t<xwlvsn%uL$0AtWY1
zSU!Mx)dN!lhcX0}pvpMv&H`X54hh*+z00NCO;<Oi2*^^k!bgzP<MG<7)#C8nw8RBs
zhXnz}^<5{g6=`6+8HZuar7f}Cqe)6Y-^*&kuZlHYE-QA80LH^WvXxrd+o2uPK)@qX
znx<X|x_lPhK5AMSL@P0!QUQ-%l(KChOlBaI^4Y;ENR@d3`u*=fAlR=u$;(O(As{6r
zl*yU={<Yx(;3*)3bg^|gawL<XOn@|~6E{;6bh~-bm>^D)Pc1y?wbXUh{8IHcOEguK
zgBhnRPV^zNVGHbKIT@9>8j0VX5pCz1RfU2<&lX~XAaD2UUT^?PAYegAyxO3tASW-v
zhGxY`IxiA{QZpkgz=_;YXlxM@Z*-$Xp(+0WrBkOPtrJ9uN_e^>Zcbd%H0EkWl}Cv%
zid!i;LbH$jsiRd*;POT+Udn`$MqS5Ro#j)i*(MZ*&nYs6Xh+ziWv*6LQg>1dH&l`Y
zfwWbIIxMp4v>T)LZ-de~)rOTt;TK_LX)vR-$4Y1-E|B2`IY|mYNLTGhuF~d^pcVP+
z_>ST4_&>IMTr|jOj6f#&sL&kREB^qO=UNzJ+R_DeSSp>S8Kn7qze*=%b)6_t%b*$`
zKeI;Wz`Aa2f+&k*JW{lX8BZz^-3W;(v(^RY14=;3g#iReA75IqBwVG<yQ%6h7ShZX
zfRnODqnGVft5?cMJ#$wmG!-T6-yL5AVxsF%+TlbeQ#F~6XYxReLeX^*QjuentF+I=
z7Bh%pM-IZzcBS}Bk+AZt{1*hw@am?@jVvuJGmC}F&UZ}W7>mm<upM#YWosmoKQ6lY
z*I3fZLKq+gBpR1-OjU$8WS;R^LWvoU+KnP;jdwjXQ3B<6g;=W-y9K~<X4z8&9)BO!
zn_v=MEf)%So11(Z#Yg~mqr{ODw)$_+?kPkQqN?hdo#EHvKyj>f+lPwOg(<j=WCPPq
zvrVMkiYGKjB!>#&PGYyg(h5+LNsWhJ%AHl&TN|ipgJo^uSbG-DFDgn-P!A}i#pPG1
z^P&;N52D=;uSiabk`LIXhS?}PHI++?T$e9P?|`xnV1u`()9X!ciKKEvF+4@W(QUL9
z70R;2$ou@M)SD*iDi9MpdzPDJ4wlAXtf^Fi8l7X~P9jMPt7Iz|v;1b}<A`kSf`YRs
zpb)6iH>h)AgoLWP8DF5>1;Z$F0JgY%$9T|CPm~C*a}ii(T;tkv6$kCVf<ss{*qx-S
zBWf#2JgT)i&CFU>j}38cP!8lO$FnAog|?EZFb>{BO2^_xYA>YFGl!LX;l(1|D$r>a
zj9n&HbwEjkS+4A61yQLQonnE>H<e9x`-|hacMm;nfLI5Yb_;89M1Yj@h~`Ar=L5nF
zMj$!v01Ku%siey+Gk<bQ8nwH(PkotbNY}xb&V!!Z%zjn$>V45WE`Jal_v;2_2O-Nu
zl)2s^#6Oj2A^?B~FHz@A_>Gcc1=HLd3ueO8nZE+SB%czdARjNCdDcb*m`@mK+q}W#
zsaeoa4>d`jMQ`S4gP?>l0#caTlZ<eq7{Z**b%n*9$R<y8r5uOgM0}{gj_BLi^$NI#
zytA(rAneNxy1L=cCdGs0w(PA`lqiq=MZidopp)~jJ&l?0_p+Lg8JSO+Q7#K%*Lc4R
z%IH1q;Aj<s2^qP;JcT|6L{5+ltMi8x)%O`=+!KhSJ)S3Qi-wY|M|h@^R-cMYk4l=P
z7iJoMzUq}wTS=9hsQjvBtUW!K_K)nCg~Tw26wA_*pjk7QPJE#9Bg%q9np>~oSq?95
zc7$`b%LXx<j6aAlrwT6@haqWGWXs8J61}%Em0Rp-6s5Lx$3Y7k3ky!f{!@+vy|d#U
z7&rzgbZss#R7*FCSNd1&fLmD{vkwgVO?l1?e4Q*0*!`1gf*L9TrH_(xz+7jEU>A41
zHN+Ml&ail;)2w*N3h<r5IdqLlHE6xs?vm;`#$c1<>ug@q<X~7`vo7H`1NnWyl-sGn
znKGSnc%by(tyikYJNrI<yvIRJ7chuAs)45v%AH}yW4uOHXBoFv>C$;`r#`h^@L;P!
zg~Kq^Czg0%bHi@Wc&W^l4N3F#Kc!HwTr+jAgu~{7;H>Tw;a7YsxN%vO0Vw77{wtov
zW2C?(bXZ&%14ve04}#k;khK7{5C*%Cg=1F4x!M(`%sT_28)Dry>d2IkkYH#a@~Yyd
z>G?!i7HJ3o9D}KyI@A{eSAZ=LQ-qe#fW6FUI?$KSh@mbJryNK*iO>Q?ERwtc7fLV^
z(o`Z=4ul__Ou$lP-(>MC3JFRQ2_r&zpW1}DI73th<+)0?4Ja&VL=)%bL>y&9hIWva
zLyA(tFaQAUuG&zECd<$RVJVp=R6&!bqKq4Opl~`TK#vGI$c;4V_wb^LNsddfhzl^1
zcZBmIq=+{{d>6q3x^NW8COr?>pde_V{6Z3b&*Kf{1eEoNp~`b9FM%thGm!|+l3?vc
zv=k0>n-u8{!lNlZ7?1Np*##(>yr-7tVU=h$_<h9`ja6!ssxxIdL=&%-FgkQpDi8gU
zyAndcD?Sl0K6J*3y3Vh0V2)Wjp)Kbm2#+ddGP5f-ZjabFR)naijJwsQ*=N)jM{OS|
z26@vJX9V@96`CNBbo8$|vJz$%O#F6m+o}Hmhj_V!fD-Dgo>V}C;!eK<R(N4O>T7d^
z)Brx2^B;e*&Uiz}P&tx9Ov;jjA5CP{x9GGDwNjfmnk@w)NIOblT{b^@((;l@^N2PD
z7qzr)NDdUiJ0B?j0D1?$5mN-4C0|E|JF(%_N&|j%nNj9*Exa`_8wriuMQy=c4!g#h
z{<Y>h46Bex%LqHzYqx6&Ls_Ry&ed&|Lqvj-`XX+fxr4Q5Y9%8&e4zdQ^uFBGb+l3_
zHG)cq-`Klxa+D!CK~`c&ky=!)E~{05OsAI2qYGtE%1Xd9r^0os4QX=Ct5g9BFNxyU
z*DrS^YA|3Zh|u)>jSv!`3(9I5a{0tIqzuJKfV7ZcgD2BruTdLOveHRV>)3d!CxUoo
zRyN2|n}e20RGz;NI!me-6fZGlA;s=lvb9qTxJXJ8qM|bF1de~zAaxP78)St`Tex2R
ze3e(m81Pz4AwfPZQVx;v^&dKICYKb@13SvTa^c59pHkGUr1;`UJcpLGXGP%YP1v-(
z#NJCb?stlEQcm)8(s^%C>YbRLuAItUtKg<AyZof6A`)~O>UBT0SvJvUvf)g-I>g1N
z8rZDrL%|w@)9>X*_RS-7FA~@S%k>|H-wMGj9d0t4R?J8JBDlf<8mtPV`wyB0+GFj1
z!+42&N`0N*Kk2Hq1UxG^E7fdsS?jYz5~j+c4uDMUy;R~>e08GwP8`hwLcDOW9JNYP
zbxhCG_pCQIPHmMM($b1FH8ZF?ij1WyZmCbi1~q+yGlz?GB|_~^wh0poC@_4q9IK=M
z0FO}>Dmyn?b?UuVrdm#(VPU=_e7SJ$Ahi&uF4ho;_fi!*k0L(BeIk&sYQw7R((boR
zTUw41{wDk>DtIWQlLV8uSl_3uNHB8vB-8-3^G9th*LLr-CDpl+#+0C_1NnffDCi`O
zxy=#o+$pEsGa8~eVl0trkn=f|>WmOJJ=u?}P&kvKd`P<D+TGUi>x?GZq?>GCA{}gO
zw5Wx1+7;<m7z@ZV(N)~g4s)`Y95s9g*&$limAk|k>xfbkBo-JMO#cAncJipI={;>_
zR+;TFP6z&@>VL%z;CpuL_|DM^AUxgrTab`)gQ!sWDvj>$$6Z}qds<rK;H5auD*d-;
z+(64W4mA5nvwqpsm?$Y_2s?Vs6PycS+7PSJ6G$-We{}P;OfKKFtQ8%h;MS<Oys{$S
z5@}m15)NQbkvo3XG=a?rP?JC$IqV(g6MiFS4sWr18yP8D9&g8Lr2EKmwd7vDX;M6;
zG?MJD%eUMZUTK=nojQ-Ygz&yCY3-LxUfcUWwWUgN4H*SP#FZyc3DECBRj1<@SDJH3
zOJn!=m7Xq~R_SSdYf5b2GYWaL1q7a>^i3T%+BqeT?S{&Ahw<RFw!%1`{?V^wd<-t(
zzV9(vK_wua^-7|4k;<Cq{{UH?MY{AzGy|Mi)204@;)r&S*}e;Je{qj+ldDaN6olMc
zx_}D{Sj?QgQhs8y>bwAL5wEV1;ICi<syG9w=%-vc!y?59CCPN7G(aL^Nc`)U#bOJ|
z3$epdXaE&s;B6%>t17bQ(g69-!YdZ3y4PR@N^IF|r3pzYQZ?6oz}~7G>Z}0=u1K0%
zO8)@%gY}>!G~Gb(=AJN>1gR*MB=zM$1lbFS5i7K%F)G#s>7{wb429-`Y!ieioT+U-
z=#$G{ze<5Rb=8rG)TI^)IgWx3-1eb&=j@Gy841%p+RP=rh$CIA!ZsapP(z!kUaXY5
zftxUx=e>I2cmU><<qroG2}#mCGr0STU=t=1%Lo=qrUA~amE|=t210`*Ku*#^d~gn5
zxu};)Nfuvb@gWW93Dj~Xbgx7Up%(;{q{4xnLb(khpy;74p)$781c=t7Q)HpZ%Yxov
zD2?I<ntIob#Hh`&P8uZyLP3uY$L=a%n}ni4kW<99-MAD$n4LXi^r-~wkX@KSMJ<$~
zm`MQdwx4=a8rf8;#G)21mdwdI!99NFj5bMBt27%UxNEv)DI|e2G;JAHZXvLw7D@pi
z$urOMr?AAV$G2o^)$pM*Ow7-%SPH9}i8Q|inB}LH7!!1yyDH1^J;JEszQ}P~aRvKD
zBITm3f|8+L!IIofv?})wBw|BG;Dv;3EHAKirKg-Nt8<Y+gF45jm2BduzMF|FYC$<j
zMey6jy6QW@mOLRq>ochxDy)`^qH{&zOEA}$bqz8BDG3UlGLJ8nQ?7E1%GMY`0Hbc<
z{o4s71rrnLSr4t5#BI=9^eNg<<A&!_b3&4I18J!hOxak;0#SA_Cav33>w<J3MwMOl
z$vHwc<sxB3xU%^TCnm(e01t=fS~w==GLeWOpn=yxLLSB%uw02MDKV!%zsk4hw7M20
zcUa0C)z!u(@gYGe8Yrt!d5u0Iua@PrR%gd`)z!ClLgy-ybWr6QeTqp0=$QgYDAxwy
zY`XJh#1$*vjM{qr{OJySItp>SWm-sOn_E<b2+PcMAMHwQ?x|IA&vjPu*Aphi#kHA!
zBNNQV)pnCk$!)lmOk-HX_ivE;h$|o`DckhvR~pQS!Ofyu1GIkW<QsGl5<!x$^Swi@
oaHb`&?G>NH+$z<zs%5m7L6IOGdH!{Wimr1+t?U*bFwDRI*=NV59smFU

literal 0
HcmV?d00001


From ce1b0d606092cc6ae4413ab43c2b0c17fef85b7c Mon Sep 17 00:00:00 2001
From: 5000user5000 <ck10600760@gmail.com>
Date: Fri, 21 Nov 2025 15:12:45 +0800
Subject: [PATCH 11/11] =?UTF-8?q?fix:=20=E4=BF=AE=E6=AD=A3=20BitStream=20b?=
 =?UTF-8?q?yte=20stuffing=20=E5=92=8C=20RST=20marker=20=E8=99=95=E7=90=86?=
 =?UTF-8?q?=E9=8C=AF=E8=AA=A4=20=20=20-=20=E4=BF=AE=E6=AD=A3=200xFF=200x00?=
 =?UTF-8?q?=20byte=20stuffing=20=E6=9C=AA=E8=B7=B3=E9=81=8E=200x00=20?=
 =?UTF-8?q?=E7=9A=84=E5=9A=B4=E9=87=8D=20bug=20=20=20-=20=E4=BF=AE?=
 =?UTF-8?q?=E6=AD=A3=20RST=20marker=20(0xFF=200xD0-0xD7)=20=E6=9C=AA?=
 =?UTF-8?q?=E6=AD=A3=E7=A2=BA=E8=B7=B3=E9=81=8E=E7=9A=84=E5=95=8F=E9=A1=8C?=
 =?UTF-8?q?=20=20=20-=20=E9=87=8D=E6=A7=8B=20BitStream=EF=BC=9A=E5=BC=95?=
 =?UTF-8?q?=E5=85=A5=2032-bit=20=E7=B7=A9=E8=A1=9D=E5=8D=80=E6=A9=9F?=
 =?UTF-8?q?=E5=88=B6=E6=8F=90=E5=8D=87=E6=95=88=E8=83=BD=20=20=20-=20?=
 =?UTF-8?q?=E6=96=B0=E5=A2=9E=20precision=20=E9=A9=97=E8=AD=89=E5=92=8C?=
 =?UTF-8?q?=E6=B8=85=E7=90=86=E6=9C=AA=E4=BD=BF=E7=94=A8=E8=AE=8A=E6=95=B8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/cpp/bitstream.cpp | 145 +++++++++++++++++++++---------------------
 src/cpp/bitstream.h   |   9 +--
 src/cpp/decoder.cpp   |  16 +++--
 3 files changed, 89 insertions(+), 81 deletions(-)

diff --git a/src/cpp/bitstream.cpp b/src/cpp/bitstream.cpp
index d3085e6..d7de4ee 100644
--- a/src/cpp/bitstream.cpp
+++ b/src/cpp/bitstream.cpp
@@ -5,114 +5,117 @@
 namespace jpeg {
 
 BitStream::BitStream(const uint8_t* data, size_t size)
-    : data_(data), size_(size), byte_pos_(0), bit_pos_(0) {
+    : data_(data), size_(size), byte_pos_(0), bit_buffer_(0), bits_in_buffer_(0) {
     if (!data || size == 0) {
         throw std::invalid_argument("BitStream: invalid data or size");
     }
 }
 
-uint16_t BitStream::readBits(int n_bits) {
-    if (n_bits <= 0 || n_bits > 16) {
-        throw std::invalid_argument("BitStream: n_bits must be between 1 and 16");
-    }
-    
-    uint16_t result = 0;
-    
-    for (int i = 0; i < n_bits; ++i) {
-        // update byte and bit positions
-        if (bit_pos_ == 8) {
-            byte_pos_++;
-            bit_pos_ = 0;
-        }
-        
-        // 檢查是否超出範圍
-        if (byte_pos_ >= size_) {
-            throw std::runtime_error("BitStream: unexpected end of data");
-        }
-        
-        // 處理 byte stuffing: 如果當前 byte 是 0xFF
-        uint8_t current_byte = data_[byte_pos_];
-        if (current_byte == 0xFF && bit_pos_ == 0) {
-            // 檢查下一個 byte
-            if (byte_pos_ + 1 < size_) {
-                uint8_t next_byte = data_[byte_pos_ + 1];
+void BitStream::fillBuffer() {
+    while (bits_in_buffer_ <= 24 && byte_pos_ < size_) {
+        uint8_t byte = data_[byte_pos_++];
+
+        // 處理 byte stuffing: 如果是 0xFF，檢查下一個 byte
+        if (byte == 0xFF) {
+            if (byte_pos_ < size_) {
+                uint8_t next_byte = data_[byte_pos_];
                 if (next_byte == 0x00) {
-                    // 這是 byte stuffing，跳過 0x00
-                    // 繼續使用 0xFF
+                    // 是 byte stuffing (FF 00)，跳過 00
+                    byte_pos_++;
                 } else if (next_byte >= 0xD0 && next_byte <= 0xD7) {
-                    // RST marker，這裡簡單處理，繼續讀取
-                    // 更完整的實作應該處理 restart interval
+                    // 是 RST marker (FF Dx)，跳過整個 marker
+                    byte_pos_++;
+                    continue;  // 不要將 0xFF 放入緩衝區，繼續讀取下一個 byte
                 } else {
-                    // 其他 marker，可能是資料結束
-                    // 目前先簡單拋出異常
-                    throw std::runtime_error("BitStream: unexpected marker");
+                    // 其他 marker，可能是錯誤或資料結束
+                    // 根據 JPEG 規範，這裡應該是資料結束，但我們保守地放入 0xFF
                 }
             }
         }
-        
-        // 讀取一個 bit (MSB first)
-        int bit = (current_byte >> (7 - bit_pos_)) & 1;
-        result = (result << 1) | bit;
-        bit_pos_++;
+
+        bit_buffer_ = (bit_buffer_ << 8) | byte;
+        bits_in_buffer_ += 8;
     }
-    
-    return result;
 }
 
-uint16_t BitStream::peekBits(int n_bits) {
-    // 保存當前狀態
-    size_t saved_byte_pos = byte_pos_;
-    int saved_bit_pos = bit_pos_;
+uint16_t BitStream::readBits(int n_bits) {
+    if (n_bits <= 0 || n_bits > 16) {
+        throw std::invalid_argument("BitStream: n_bits must be between 1 and 16");
+    }
+    
+    if (bits_in_buffer_ < n_bits) {
+        fillBuffer();
+    }
+    
+    if (bits_in_buffer_ < n_bits) {
+        throw std::runtime_error("BitStream: unexpected end of data");
+    }
     
-    uint16_t result = readBits(n_bits);
+    uint16_t result = bit_buffer_ >> (bits_in_buffer_ - n_bits);
     
-    // 恢復狀態
-    byte_pos_ = saved_byte_pos;
-    bit_pos_ = saved_bit_pos;
+    bits_in_buffer_ -= n_bits;
+    bit_buffer_ &= (1U << bits_in_buffer_) - 1;
     
     return result;
 }
 
+uint16_t BitStream::peekBits(int n_bits) {
+    if (n_bits <= 0 || n_bits > 16) {
+        throw std::invalid_argument("BitStream: n_bits must be between 1 and 16");
+    }
+
+    if (bits_in_buffer_ < n_bits) {
+        fillBuffer();
+    }
+
+    if (bits_in_buffer_ < n_bits) {
+        throw std::runtime_error("BitStream: unexpected end of data");
+    }
+
+    return bit_buffer_ >> (bits_in_buffer_ - n_bits);
+}
+
 void BitStream::skipBits(int n_bits) {
-    readBits(n_bits);
+    if (bits_in_buffer_ >= n_bits) {
+        bits_in_buffer_ -= n_bits;
+        bit_buffer_ &= (1U << bits_in_buffer_) - 1;
+    } else {
+        n_bits -= bits_in_buffer_;
+        bits_in_buffer_ = 0;
+        bit_buffer_ = 0;
+        
+        // 這裡可以優化，但為了簡單起見，先這樣
+        size_t bytes_to_skip = n_bits / 8;
+        byte_pos_ += bytes_to_skip;
+        n_bits %= 8;
+        
+        if (n_bits > 0) {
+            readBits(n_bits);
+        }
+    }
 }
 
 bool BitStream::hasMoreData() const {
-    return byte_pos_ < size_;
+    return bits_in_buffer_ > 0 || byte_pos_ < size_;
 }
 
 size_t BitStream::getBitPosition() const {
-    return byte_pos_ * 8 + bit_pos_;
+    return byte_pos_ * 8 - bits_in_buffer_;
 }
 
 void BitStream::reset(size_t byte_pos, int bit_pos) {
-    if (byte_pos >= size_) {
+    if (byte_pos > size_) { // allow reset to end
         throw std::out_of_range("BitStream: byte_pos out of range");
     }
     if (bit_pos < 0 || bit_pos >= 8) {
         throw std::out_of_range("BitStream: bit_pos must be 0-7");
     }
     byte_pos_ = byte_pos;
-    bit_pos_ = bit_pos;
-}
-
-uint8_t BitStream::getNextByte() {
-    if (byte_pos_ >= size_) {
-        throw std::runtime_error("BitStream: unexpected end of data");
-    }
-    
-    uint8_t byte = data_[byte_pos_++];
-    
-    // 處理 byte stuffing
-    if (byte == 0xFF && byte_pos_ < size_) {
-        uint8_t next = data_[byte_pos_];
-        if (next == 0x00) {
-            // Byte stuffing: 跳過 0x00
-            byte_pos_++;
-        }
+    bits_in_buffer_ = 0;
+    bit_buffer_ = 0;
+    if (bit_pos > 0) {
+        readBits(bit_pos); // 讀取並丟棄，以對齊 bit 位置
     }
-    
-    return byte;
 }
 
 } // namespace jpeg
diff --git a/src/cpp/bitstream.h b/src/cpp/bitstream.h
index 8b0b3ea..e6458cd 100644
--- a/src/cpp/bitstream.h
+++ b/src/cpp/bitstream.h
@@ -60,13 +60,14 @@ class BitStream {
     const uint8_t* data_;      // 原始資料指標
     size_t size_;              // 資料大小
     size_t byte_pos_;          // 當前位元組位置
-    int bit_pos_;              // 當前 bit 位置 (0-7, 0 = MSB)
+
+    uint32_t bit_buffer_;      // 位元緩衝區
+    int bits_in_buffer_;       // 緩衝區中剩餘的 bit 數量
     
     /**
-     * 讀取下一個 byte，處理 byte stuffing
-     * @return 下一個有效的 byte
+     * 填充緩衝區，處理 byte stuffing
      */
-    uint8_t getNextByte();
+    void fillBuffer();
 };
 
 } // namespace jpeg
diff --git a/src/cpp/decoder.cpp b/src/cpp/decoder.cpp
index 440b428..3d27949 100644
--- a/src/cpp/decoder.cpp
+++ b/src/cpp/decoder.cpp
@@ -153,9 +153,13 @@ bool JPEGDecoder::processDQT() {
 }
 
 bool JPEGDecoder::processSOF0() {
-    uint16_t length = readWord();
-    
-    uint8_t precision = readByte();  // 通常是 8
+    readWord(); // length
+
+    uint8_t precision = readByte();  // precision (通常是 8)
+    if (precision != 8) {
+        throw std::runtime_error("Only 8-bit precision is supported");
+    }
+
     height_ = readWord();
     width_ = readWord();
     num_components_ = readByte();
@@ -206,13 +210,13 @@ bool JPEGDecoder::processDHT() {
 }
 
 bool JPEGDecoder::processDRI() {
-    uint16_t length = readWord();
+    readWord(); // length
     restart_interval_ = readWord();
     return true;
 }
 
 bool JPEGDecoder::processSOS() {
-    uint16_t length = readWord();
+    readWord(); // length
     
     int num_components = readByte();
     
@@ -412,4 +416,4 @@ void JPEGDecoder::upsample(const std::vector<std::vector<uint8_t>>& y_blocks,
     }
 }
 
-} // namespace jpeg
+} // namespace jpeg
\ No newline at end of file