前回の記事

今回の目標

前回の記事で，オセロAIの速度を保ったままある程度強くすることが出来ました．
しかし，ある程度強くなっただけで，劇的に強くなったとは言えません．
強さに制限がかかっている理由の一つとして，「シミュレーションでは一手先までしか考えていない」というのがあると思います．
解決のため，何手か先までシミュレーションできるようにすることを考えてみます．

…つもりだったのですが，計画変更．
ふと疑問に思ったのは，LLMへの盤面情報の渡し方です．
現在，盤面情報は以下の形式で渡しています．

  a b c d e f g h
1 . . W . . . . . 
2 . . . W . . . . 
3 W W W B W B B B 
4 . . . B B W . . 
5 . . B B B . . . 
6 . . . . . B . . 
7 . . . . . . B . 
8 . . . . . . . B

うん，見やすくてわかりやすいですね．
…人間はね．

LLMからはこう見えています．

  a b c d e f g h\n1 . . W . . . . . \n2 . . . W . . . . \n3 W W W B W B B B \n4 . . . B B W . . \n5 . . B B B . . . \n6 . . . . . B . . \n7 . . . . . . B . \n8 . . . . . . . B

さすがにこれは…．
かなり分かりにくいのではないか？
ということで，LLMへの盤面情報の渡し方のみを変更してみることを考えました．
盤面表現方法以外は一切変えずに対戦してもらって，その状態で勝率が最も高いものが「LLMにとって分かりやすい盤面表現方法」と言えるはずです．

ここから本題

盤面の表現方法を変更して対戦

前回と同様の流れです．
盤面の表現方法を変えたオセロAIを総当たりで戦わせて，最も勝率が高いものが何であるかを確認します．
表現方法は以下の四つ．

改行区切りで表現(現行のもの．比較用)
FEN風に一行で表示する(黒石: c4,d4,e4,d5 / 白石: e5みたいな感じ)
黒と白がおかれている位置を座標で表現．一覧で教える(8/8/8/3WB3/3BW3/8/8/8みたいな感じ)
盤面情報は渡さない(そもそも盤面情報は判断材料として使用されていないのではないか？という確認)

という事で，対戦させてみた結果がこちら．

[F1_ascii vs F2_fen] 完了 黒 2勝8敗0分20 (8%) | 経過 2m36s 残り約 28m36s   
[F1_ascii vs F3_list] 完了 黒 3勝4敗3分20 (16%) | 経過 5m05s 残り約 25m25s   
[F1_ascii vs F4_omit] 完了 黒 3勝6敗1分20 (25%) | 経過 7m29s 残り約 22m27s   
[F2_fen vs F1_ascii] 完了 黒 4勝6敗0分20 (33%) | 経過 9m55s 残り約 19m50s   
[F2_fen vs F3_list] 完了 黒 5勝5敗0分20 (41%) | 経過 12m20s 残り約 17m16s   
[F2_fen vs F4_omit] 完了 黒 4勝5敗1分20 (50%) | 経過 14m48s 残り約 14m48s   
[F3_list vs F1_ascii] 完了 黒 4勝6敗0分20 (58%) | 経過 17m16s 残り約 12m20s   
[F3_list vs F2_fen] 完了 黒 5勝4敗1分20 (66%) | 経過 19m43s 残り約 9m51s   
[F3_list vs F4_omit] 完了 黒 5勝5敗0分20 (75%) | 経過 22m09s 残り約 7m23s   
[F4_omit vs F1_ascii] 完了 黒 4勝6敗0分120 (83%) | 経過 24m34s 残り約 4m54s   
[F4_omit vs F2_fen] 完了 黒 4勝6敗0分120 (91%) | 経過 27m00s 残り約 2m27s   
[F4_omit vs F3_list] 完了 黒 8勝1敗1分120 (100%) | 経過 29m27s 残り約 0m00s

それなりに勝敗が分かれていそうですね．
では前回と同様にグラフ化していきましょう．

各渡し方ごとの勝率は以下．

トップとなったのはF4_omitですが，その差は圧倒的というほどではありません．
一方で一番勝率が低かったのはF3_listで，こちらは有意な差がついていると言えるのではないでしょうか．
リストで渡してしまうと石同士の位置関係がつかみにくく，そのくせ(特に終盤で)トークンを食うので余計な情報を与えてしまいノイズになってしまった可能性がありますね．

一方でヒートマップの方は判断が難しいグラフになりました．
安定して勝っている，または安定して負けている渡し方ははっきりせず，このグラフを見ると正直誤差の範囲内のように思います．

ただ，盤面情報の渡し方を変えても明確に商率に差が出ないというのは，「LLMは盤面情報を特に参考にしていない」ことの証左ではないでしょうか．

二手先の情報も付与してみよう

つまるところ，LLMに与える入力としてはもっと短くしても勝率は変わらない，むしろ強くなるという事です．
これは逆の仮説も出てきます．
「盤面情報を減らした分他の情報を足すことで，もっと強くなる可能性があるのではないか？」
ここで追加する「ほかの情報」とは，もちろん二手先の情報のことです．

LLMに渡す情報として，現在は以下を渡しています．

今の盤面で置ける位置の一覧(ただしすべてではなく，弱い手は削っています)
上記一覧について，実際にそこに置いた時のそれぞれ以下の情報
- 自分の石の数
- 相手の石の数
- 相手が次のターンで取れる手一覧
- 増える安定石の数

上記リストで，「それぞれ以下の情報」と言っているのが「一手先の情報」ですね．
この「それぞれ以下の情報」について，「相手が次のターンで取れる手」の中で最もスコアが高い位置に相手が置いた場合の以下の情報も加えます．

自分の石の数
相手の石の数
自分が次のターンで取れる手数
増える相手の安定石の数

一手先の情報しか与えていないものをdepth1，二手先までの情報を与えたものをdepth2と呼びます．
その対戦結果がこちら．

[depth2 vs depth1] 完了 黒 20勝27敗3分 (50%) | 経過 13m50s 残り約 13m50s   
[depth1 vs depth2] 完了 黒 20勝28敗2分0 (100%) | 経過 28m10s 残り約 0m00s

ん－，なんか，単に黒側をやるのが苦手ってだけに見えますね．
あと，120試合やっていた時と比べて100試合しかやっていないのに時間が同じくらいかかっています．
プロンプトが長くなった分，出力を作ることに時間がかかっているのかもしれません．

これだけだと分かりにくいので，グラフ化してみましょう．

まずは二手先までの情報を得たAIについて，黒と白それぞれでどの程度の勝率だったのか．
また，wilson法を用いて95%信頼区間を表示しています．
Claudeに教えてもらったのですが，95%の確率でこのバーの範囲内に真の値があるという理解で概ね合っているそうです．細かいことはよく分かっていません．

合計で見ると負け越してはいますが，信頼区間を見る感じ誤差の範囲と言えます．このグラフを見る感じだと，一手だけ与えようが二手まで与えようが勝率は大差ないことになりますね．

勝敗の内訳をみるとこんな感じになっています．

はいまあ上のグラフと似たような感じです．

次に，試合回数を重ねるごとに勝率が収束していくグラフも作ってもらいました．
横軸が試合回数，縦軸がその時点での勝率です．一回目の試合ではどちらも勝利しているため左端の勝率は100%になっていますが，その後勝ったり負けたりして収束していく様子が見えると思います．
ちなみに50試合以降の信頼区間はあくまで予測です．

見た感じはそんなに変なグラフではなく，順当に勝率が収束しているように見えます．

いくつかグラフを作りましたが，どれを見ても「二手先まで読んだ方が強い」とする根拠にはならなそうな気がしますね．
二手先まで情報を与える分入力が長くなるので，小さいモデルにとってはそれが致命的になるのか．あるいは，「二手先まで情報を与えたら強くなるはず」という予想がそもそも間違いだったのか．

そういえばよく考えたら，「盤面情報を消しても強さが大して変わらなかった」というのも変な話ですよね．
これらの結果から考えられるのは，LLMは与えられた情報からランダムに手を選んでいるだけで，盤面情報や与えられたスコア情報は参考にしていなかった，ということでしょうか．
なぜAIが強くなったかというと，スコアの上位半分に絞り込んだり，X位置やC位置を取らないようにしたことの方が理由としては支配的で，AIによる手の選択には実はたいした意味はなかった…ということでしょうか．
何それ．今までの実験全否定じゃん．

本質的な部分が揺らいできた，かつ今回の話題から変わりそうなので，ここから先は次回の記事に引き継ぎたいと思います．

フルバージョン

Osero.java

Osero.java

import java.io.*;
import java.net.URI;
import java.net.http.*;
import java.util.*;
import java.util.function.BiConsumer;
import java.util.regex.*;

/**
 * オセロAIクラス．
 * ほぼ Qiita 記事の実装に準拠 (https://qiita.com/tt_and_tk/items/22641b036d3b1e5fdbca)
 * 記事と異なる点: DataGen 用に thinkAndGetMove() メソッドを追加している．
 */
public class Osero extends OseroBase {
    /** 思考方法の識別子． */
    public enum PlayMethod {
        /** ランダムに置く */
        RANDOM,
        /** n手先で，自分の石数が最大になる位置に置く */
        N_HAND,
        /** n手先で，相手の取れる手数が最小になる位置に置く */
        N_LEAST,
        /** n手先で，自分の取れる手数が最大になる位置に置く */
        N_MOST,
        /** n手先で，自分の安定石増加数が最大になる位置に置く */
        N_STABLE,
        /** 経過手数に応じてスコア関数を切り替えるハイブリッド戦略 */
        N_HYBRID,
        /** 人間が手を選ぶ */
        HUMAN,
        /** ツールを利用した LLM(Ollama 経由)が手を選ぶ */
        LLM,
    }

    /** LLM に渡す盤面テキストの表示形式識別子． */
    public enum BoardFormat {
        /** 2D ASCII グリッド(現行) */
        ASCII_GRID,
        /** FEN 風圧縮 1 行表記(連続する空きマスを数字で圧縮) */
        COMPACT_FEN,
        /** 黒石・白石の座標リスト */
        COORD_LIST,
        /** 盤面そのものは省略(手番と置ける位置のみ) */
        OMIT,
    }

    /** 探索深さ．[0]=黒, [1]=白 */
    protected int[] readGoal = {3, 3};

    /** 黒と白の思考方法 */
    protected ArrayList<BiConsumer<long[], Boolean>> playMethod = new ArrayList<>();

    /** LLM プレイヤーが使用する Ollama モデル名 */
    private static String llmModel = "gemma4-osero-e2b";
    /** setLlmModel で設定可能なモデル名の一覧 */
    private static final Set<String> ALLOWED_LLM_MODELS = Set.of(
        "gemma4-osero-e2b",
        "qwen3.5-osero-0.8b"
    );
    /** Ollama API の URL */
    protected static final String OLLAMA_URL = "http://localhost:11434";
    /** 人間プレイヤー入力用 */
    protected static final Scanner scanner   = new Scanner(System.in);
    /** LLM の API 往復ログの出力先．null の場合はログを出力しない */
    private PrintWriter logWriter = null;

    /** X 位置・C 位置の座標セット（row * 8 + col）．MoveFilter の戦略的除外に使用する． */
    protected static final Set<Integer> X_C_POS = new HashSet<>(Arrays.asList(
            1 * 8 + 1, 1 * 8 + 6, 6 * 8 + 1, 6 * 8 + 6,   // X: b2,g2,b7,g7
            1 * 8 + 0, 0 * 8 + 1, 1 * 8 + 7, 0 * 8 + 6,   // C: a2,b1,h2,g1
            6 * 8 + 0, 7 * 8 + 1, 6 * 8 + 7, 7 * 8 + 6)); // C: a7,b8,h7,g8
    /** 角の座標セット（row * 8 + col）．MoveFilter の強制追加に使用する． */
    protected static final Set<Integer> CORNER_POS = new HashSet<>(Arrays.asList(
            0 * 8 + 0, 0 * 8 + 7, 7 * 8 + 0, 7 * 8 + 7)); // 角: a1,h1,a8,h8

    /** LLM に渡す盤面テキストの表示形式(デフォルト: OMIT，Stage 4 実験で決定)． */
    private BoardFormat currentBoardFormat = BoardFormat.OMIT;

    /** 2手先シミュレーション情報を buildSimResults に含めるかどうか． */
    private boolean depth2Enabled = true;

    /**
     * LLM プレイヤーが使用するモデル名を返す．
     * @return 現在設定されているモデル名
     */
    public static String getLlmModel() { return llmModel; }

    /**
     * LLM プレイヤーが使用するモデル名を設定する．
     * 設定できるモデルは {@code ALLOWED_LLM_MODELS} に含まれるものに限る．
     * @param model 設定するモデル名
     * @throws IllegalArgumentException 許可されていないモデル名の場合
     */
    public static void setLlmModel(String model) {
        if (!ALLOWED_LLM_MODELS.contains(model)) {
            throw new IllegalArgumentException("許可されていないモデル名: " + model
                    + "  使用可能: " + ALLOWED_LLM_MODELS);
        }
        llmModel = model;
    }

    /**
     * LLM の API 往復ログの出力先を設定する．
     * @param w ログの出力先
     */
    public void setLogWriter(PrintWriter w) { this.logWriter = w; }

    /**
     * LLM の API 往復ログの出力先をリセットする(null に戻す)．
     */
    public void resetLogWriter() { this.logWriter = null; }

    /**
     * LLM に渡す盤面テキストの表示形式を設定する．
     * @param fmt 表示形式
     */
    public void setBoardFormat(BoardFormat fmt) { this.currentBoardFormat = fmt; }

    /**
     * 2手先シミュレーション情報を buildSimResults に含めるかどうかを設定する．
     * @param enabled true のとき2手先情報を含める
     */
    public void setDepth2Enabled(boolean enabled) { this.depth2Enabled = enabled; }

    /**
     * 候補手の選別戦略（デフォルト: M3a_strategic — X/C 除外 → 上位半分 → 角強制追加）．
     * 実験で最も強いと確認された設定．
     */
    private MoveFilter currentMoveFilter = sorted -> {
        // X/C 位置を除外した安全な手のリストを作成（全手が X/C の場合は全合法手にフォールバック）
        List<ScoredMove> safe = new ArrayList<>();
        for (ScoredMove m : sorted)
            if (!X_C_POS.contains(m.row * 8 + m.col)) safe.add(m);
        List<ScoredMove> base = safe.isEmpty() ? sorted : safe;
        // 安全な手の上位半分を選択
        int k = (base.size() + 1) / 2;
        Set<Integer> added = new HashSet<>();
        List<int[]> r = new ArrayList<>();
        for (int i = 0; i < k; i++) {
            r.add(new int[]{base.get(i).row, base.get(i).col});
            added.add(base.get(i).row * 8 + base.get(i).col);
        }
        // 合法手に角があれば強制追加
        for (ScoredMove m : sorted) {
            int pos = m.row * 8 + m.col;
            if (CORNER_POS.contains(pos) && !added.contains(pos))
                r.add(new int[]{m.row, m.col});
        }
        return r;
    };

    /**
     * 候補手の選別戦略を設定する．
     * @param filter 選別戦略
     */
    public void setMoveFilter(MoveFilter filter) { this.currentMoveFilter = filter; }

    /**
     * 探索深さを設定する．
     * @param black 黒番の探索手数
     * @param white 白番の探索手数
     */
    public void setReadGoal(int black, int white) {
        this.readGoal[0] = black;
        this.readGoal[1] = white;
    }

    /**
     * 黒・白それぞれの思考方法を設定する．
     * @param black 黒番の思考方法
     * @param white 白番の思考方法
     */
    public void setPlayMethod(PlayMethod black, PlayMethod white) {
        this.playMethod.clear();
        this.playMethod.add(this.resolvePlayMethod(black));
        this.playMethod.add(this.resolvePlayMethod(white));
    }

    /**
     * PlayMethod enum を実際の思考メソッドに紐づく関数参照へ変換する．
     * setPlayMethod から呼ばれ，playMethod フィールドに格納する関数を作る．
     * @param algo 変換対象の思考方法
     * @return 指定した思考方法に対応する関数
     */
    protected BiConsumer<long[], Boolean> resolvePlayMethod(PlayMethod algo) {
        switch (algo) {
            case RANDOM:  return this::random;
            case N_HAND:  return this::nHand;
            case N_LEAST: return this::nLeast;
            case N_MOST:   return this::nMost;
            case N_STABLE:  return this::nStable;
            case N_HYBRID:  return this::nHybrid;
            case HUMAN:     return this::human;
            case LLM:     return this::llm;
            default: throw new IllegalArgumentException("unknown algorithm: " + algo);
        }
    }

    // ── 盤面テキスト変換 ──────────────────────────────────────

    /**
     * 座標を "d3" 形式の文字列に変換する．
     * @param row 行インデックス(0〜7)
     * @param col 列インデックス(0〜7)
     * @return "a1"〜"h8" 形式の文字列
     */
    public String coordToStr(int row, int col) {
        return String.valueOf("abcdefgh".charAt(col)) + (row + 1);
    }

    /**
     * ビットボードをテキスト形式に変換する．
     * 盤面形式は {@code currentBoardFormat} に従い，手番と置ける位置は全形式で共通付加する．
     * @param board ビットボード
     * @param turn  手番(false=黒, true=白)
     * @return 盤面テキスト
     */
    public String boardToText(long[] board, boolean turn) {
        StringBuilder sb = new StringBuilder();
        // 盤面テキスト部分を形式ごとに生成して付加
        switch (this.currentBoardFormat) {
            case ASCII_GRID:  sb.append(this.boardBodyAscii(board));  break;
            case COMPACT_FEN: sb.append(this.boardBodyFen(board));    break;
            case COORD_LIST:  sb.append(this.boardBodyList(board));   break;
            case OMIT:                                                 break;
        }
        // 手番と置ける位置を全形式で共通付加
        sb.append(this.boardFooter(board, turn));
        return sb.toString();
    }

    /**
     * 盤面テキストの末尾共通部分(手番 + 置ける位置)を返す．
     * @param board ビットボード
     * @param turn  手番(false=黒, true=白)
     * @return 手番と置ける位置のテキスト
     */
    private String boardFooter(long[] board, boolean turn) {
        StringBuilder sb = new StringBuilder();
        sb.append(turn ? "白" : "黒").append("の手番\n");
        List<String> validMoves = new ArrayList<>();
        for (int row = 0; row < SIZE; row++)
            for (int col = 0; col < SIZE; col++)
                if (this.canPlace(row, col, board, turn)) validMoves.add(this.coordToStr(row, col));
        sb.append("置ける位置: ").append(String.join(", ", validMoves));
        return sb.toString();
    }

    /**
     * 盤面を 2D ASCII グリッド形式で返す(手番・置ける位置は含まない)．
     * @param board ビットボード
     * @return ASCII グリッド文字列
     */
    private String boardBodyAscii(long[] board) {
        StringBuilder sb = new StringBuilder();
        sb.append("  a b c d e f g h\n");
        for (int row = 0; row < SIZE; row++) {
            sb.append(row + 1).append(" ");
            for (int col = 0; col < SIZE; col++) {
                long bit = 1L << ((row << ROW_SHIFT) + col);
                if      ((board[0] & bit) != 0) sb.append("B ");
                else if ((board[1] & bit) != 0) sb.append("W ");
                else                             sb.append(". ");
            }
            sb.append("\n");
        }
        return sb.toString();
    }

    /**
     * 盤面を FEN 風圧縮 1 行表記で返す(連続する空きマスを数字で圧縮)．
     * 例: {@code 8/8/8/3WB3/3BW3/8/8/8}
     * @param board ビットボード
     * @return FEN 風文字列
     */
    private String boardBodyFen(long[] board) {
        StringBuilder sb = new StringBuilder();
        for (int row = 0; row < SIZE; row++) {
            if (row > 0) sb.append("/");
            int empty = 0;
            for (int col = 0; col < SIZE; col++) {
                long bit = 1L << ((row << ROW_SHIFT) + col);
                if      ((board[0] & bit) != 0) { if (empty > 0) { sb.append(empty); empty = 0; } sb.append("B"); }
                else if ((board[1] & bit) != 0) { if (empty > 0) { sb.append(empty); empty = 0; } sb.append("W"); }
                else                             { empty++; }
            }
            if (empty > 0) sb.append(empty);
        }
        sb.append("\n");
        return sb.toString();
    }

    /**
     * 盤面を黒石・白石の座標リスト形式で返す．
     * 例: {@code 黒石: d5,e4 / 白石: d4,e5 / 空き: 60マス}
     * @param board ビットボード
     * @return 座標リスト文字列
     */
    private String boardBodyList(long[] board) {
        List<String> black = new ArrayList<>();
        List<String> white = new ArrayList<>();
        int empty = 0;
        for (int row = 0; row < SIZE; row++) {
            for (int col = 0; col < SIZE; col++) {
                long bit = 1L << ((row << ROW_SHIFT) + col);
                if      ((board[0] & bit) != 0) black.add(this.coordToStr(row, col));
                else if ((board[1] & bit) != 0) white.add(this.coordToStr(row, col));
                else                             empty++;
            }
        }
        return "黒石: " + String.join(",", black)
             + " / 白石: " + String.join(",", white)
             + " / 空き: " + empty + "マス\n";
    }

    // ── AI 戦略メソッド ────────────────────────────────────────

    /**
     * ランダムに有効な手を選ぶ．
     * @param board 今の盤面
     * @param turn  手番(false=黒, true=白)
     */
    public void random(long[] board, boolean turn) {
        int row, col;
        do {
            row = OseroBase.rand.nextInt(SIZE);
            col = OseroBase.rand.nextInt(SIZE);
        } while (!canPlace(row, col, board, turn));
        place(row, col, board, turn);
    }

    /**
     * n手先の自分の石数が最大になる手を選ぶ．
     * @param board 今の盤面
     * @param turn  手番(false=黒, true=白)
     *
     */
    public void nHand(long[] board, boolean turn) {
        this.exploreAssist(board, turn, this::exploreNHand);
    }

    /**
     * n手先の相手の手数が最小になる手を選ぶ．
     * @param board 今の盤面
     * @param turn  手番(false=黒, true=白)
     */
    public void nLeast(long[] board, boolean turn) {
        this.exploreAssist(board, turn, this::exploreNLeast);
    }

    /**
     * n手先の自分の手数が最大になる手を選ぶ．
     * @param board 今の盤面
     * @param turn  手番(false=黒, true=白)
     */
    public void nMost(long[] board, boolean turn) {
        this.exploreAssist(board, turn, this::exploreNMost);
    }

    /**
     * n手先の自分の安定石数が最大になる手を選ぶ．
     * @param board 今の盤面
     * @param turn  手番(false=黒, true=白)
     */
    public void nStable(long[] board, boolean turn) {
        this.exploreAssist(board, turn, this::exploreNStable);
    }

    /**
     * 経過手数に応じてスコア関数を切り替えるハイブリッド戦略．
     * 序盤(20手未満): N_LEAST，中盤(20〜49手): N_STABLE，終盤(50手以上): N_HAND．
     * @param board 今の盤面
     * @param turn  手番(false=黒, true=白)
     */
    public void nHybrid(long[] board, boolean turn) {
        // llm() の絞り込みと同じフェーズ判定でスコア関数を選択
        int elapsed = this.countStones(board, false) + this.countStones(board, true) - 4;
        ScoreFunction func;
        if      (elapsed < 20) func = this::exploreNLeast;
        else if (elapsed < 50) func = this::exploreNStable;
        else                   func = this::exploreNHand;
        this.exploreAssist(board, turn, func);
    }

    // ── 人間・LLM プレイヤー ──────────────────────────────────

    /**
     * 人間が手を選ぶ．盤面を表示して標準入力から "d3" 形式で受け付ける．
     * 無効な入力は再入力を促す．
     * @param board 今の盤面
     * @param turn  手番(false=黒, true=白)
     */
    public void human(long[] board, boolean turn) {
        while (true) {
            System.out.print("手を入力してください (例: d3): ");
            String input = scanner.nextLine().trim().toLowerCase();
            if (input.length() == 2) {
                int col = "abcdefgh".indexOf(input.charAt(0));
                int row = "12345678".indexOf(input.charAt(1));
                if (col >= 0 && row >= 0 && canPlace(row, col, board, turn)) {
                    place(row, col, board, turn);
                    return;
                }
            }
            System.out.println("無効な手です．有効な手を選んでください．");
        }
    }

    /**
     * Ollama 経由で LLM に手を問い合わせる．
     * 全合法手のシミュレーション結果を事前計算して初回メッセージに含め，
     * ツール呼び出しなしで 1 往復の API コールで着手を得る．
     * 最大 3 回リトライし，全失敗時はランダムにフォールバックする．
     * @param board 今の盤面
     * @param turn  手番(false=黒, true=白)
     */
    public void llm(long[] board, boolean turn) {
        // 経過手数でフェーズを判定し，対応するスコア関数で上位半分の候補手に絞る
        int elapsed = this.countStones(board, false) + this.countStones(board, true) - 4;
        ScoreFunction scoreFunc;
        if      (elapsed < 20) scoreFunc = this::exploreNLeast;
        else if (elapsed < 50) scoreFunc = this::exploreNStable;
        else                   scoreFunc = this::exploreNHand;
        List<int[]> moveCandidates = this.topHalfMoves(board, turn, scoreFunc);

        // 絞り込んだ候補手のシミュレーション結果を事前計算してメッセージに含める
        String boardAndResults = this.boardToText(board, turn) + "\n\n"
                + this.buildSimResults(board, turn, moveCandidates, scoreFunc);
        final String initialMsg = "{\"role\":\"user\",\"content\":\""
                + this.escapeForJson(boardAndResults) + "\"}";
        HttpClient client = HttpClient.newHttpClient();

        // 最大三回チャレンジする(1 attempt = 1 HTTP 往復)
        for (int attempt = 0; attempt < 3; attempt++) {
            try {
                // リクエスト body 組み立て(ツール定義なし)
                String reqBody = "{\"model\":\"" + llmModel
                        + "\",\"stream\":false,\"think\":false"
                        + ",\"messages\":[" + initialMsg + "]}";

                // リクエスト送信
                HttpRequest req = HttpRequest.newBuilder()
                        .uri(URI.create(OLLAMA_URL + "/api/chat"))
                        .header("Content-Type", "application/json")
                        .POST(HttpRequest.BodyPublishers.ofString(reqBody))
                        .build();
                HttpResponse<String> resp = client.send(req, HttpResponse.BodyHandlers.ofString());

                if (resp.statusCode() != 200) {
                    System.err.println("Ollama HTTP エラー: " + resp.statusCode());
                    continue;
                }

                String body = resp.body();
                if (logWriter != null) {
                    logWriter.println("{\"request\":" + reqBody + ",\"response\":" + body + "}");
                }

                // レスポンスの message オブジェクトを抽出
                String assistantMsg = null;
                int msgKeyIdx = body.indexOf("\"message\":");
                if (msgKeyIdx >= 0) {
                    int braceIdx = body.indexOf("{", msgKeyIdx + 10);
                    if (braceIdx >= 0) assistantMsg = extractJsonObject(body, braceIdx);
                }
                if (assistantMsg == null) {
                    System.err.println("Ollama レスポンスに message フィールドがありません");
                    continue;
                }

                // content から座標を抽出して着手
                String content = extractStringField(assistantMsg, "\"content\"");
                int thinkEnd = content.indexOf("</think>");
                String moveArea = thinkEnd >= 0 ? content.substring(thinkEnd + 8) : content;

                Matcher mv = Pattern.compile("[a-h][1-8]").matcher(moveArea);
                List<String> candidates = new ArrayList<>();
                while (mv.find()) candidates.add(mv.group());
                for (int i = candidates.size() - 1; i >= 0; i--) {
                    int col = "abcdefgh".indexOf(candidates.get(i).charAt(0));
                    int row = "12345678".indexOf(candidates.get(i).charAt(1));
                    if (canPlace(row, col, board, turn)) {
                        place(row, col, board, turn);
                        return;
                    }
                }

            } catch (Exception e) {
                System.err.println("Ollama リクエストエラー: " + e.getMessage());
            }
        }

        // フォールバック: ランダムに打つ
        System.err.println("LLM から有効な手を取得できなかったため，ランダムに打ちます");
        random(board, turn);
    }

    /**
     * 候補手のシミュレーション結果を「全合法手」として LLM に提示するテキストを返す．
     * LLM への初回メッセージに含め，ツール呼び出しなしで判断できるようにする．
     * @param board      ビットボード
     * @param turn       手番(false=黒, true=白)
     * @param candidates 候補手のリスト（各要素は {row, col}）
     * @return 候補手のシミュレーション結果テキスト
     */
    private String buildSimResults(long[] board, boolean turn, List<int[]> candidates, ScoreFunction scoreFunc) {
        StringBuilder sb = new StringBuilder();
        sb.append("## 全合法手のシミュレーション結果\n");
        for (int[] rc : candidates) {
            String coord = this.coordToStr(rc[0], rc[1]);
            SimulateResult res = this.simulateMove(board, turn, coord);
            // 1手先: 自石数・相石数・相手次手・安定石増加数(反転リストは除外)
            sb.append("- ").append(coord).append(": ")
              .append("自石").append(res.myStones)
              .append(", 相石").append(res.opponentStones)
              .append(", 相手の次の手[").append(String.join(",", res.opponentValidMoves))
              .append("](").append(res.opponentValidMoves.size()).append("手)")
              .append(", 安定石+").append(res.stableGained);
            // 2手先: 有効な場合のみ相手の最善応手後の状態を追加
            if (this.depth2Enabled) {
                int[] oppBest = this.bestOpponentMove(res.boardAfter, !turn, scoreFunc);
                if (oppBest != null) {
                    String oppCoord = this.coordToStr(oppBest[0], oppBest[1]);
                    SimulateResult res2 = this.simulateMove(res.boardAfter, !turn, oppCoord);
                    sb.append(" → 相手最善[").append(oppCoord).append("]後: ")
                      .append("自石").append(res2.myStones)
                      .append(", 相石").append(res2.opponentStones)
                      .append(", 自分の次の手[").append(String.join(",", res2.opponentValidMoves))
                      .append("](").append(res2.opponentValidMoves.size()).append("手)")
                      .append(", 相手安定石+").append(res2.stableGained);
                } else {
                    sb.append(" → 相手パス(手なし)");
                }
            }
            sb.append("\n");
        }
        return sb.toString();
    }

    /** JSON 文字列内の特殊文字をエスケープする(llm() のリクエスト組み立て用)． */
    private String escapeForJson(String s) {
        return s.replace("\\", "\\\\")
                .replace("\"", "\\\"")
                .replace("\n", "\\n")
                .replace("\r", "\\r")
                .replace("\t", "\\t");
    }

    /**
     * 指定位置を開始点とする JSON オブジェクト文字列を抽出する．
     * 文字列リテラル内の括弧を読み飛ばし，対応する '}' を正確に判定する．
     * @param s     検索対象の文字列
     * @param start '{' の位置
     * @return '{' から対応する '}' までの部分文字列
     */
    private String extractJsonObject(String s, int start) {
        int depth = 0;
        boolean inStr = false;
        for (int i = start; i < s.length(); i++) {
            char c = s.charAt(i);
            if (inStr) {
                if      (c == '\\') i++;
                else if (c == '"')  inStr = false;
            } else {
                if      (c == '"') inStr = true;
                else if (c == '{') depth++;
                else if (c == '}' && --depth == 0) return s.substring(start, i + 1);
            }
        }
        return s.substring(start);
    }

    /**
     * 文字列中の指定キーに対応する JSON 文字列フィールドの値を返す．
     * エスケープシーケンス(\n, \r, \t, \\, \")をデコードして返す．
     * @param s   検索対象の文字列(エスケープ済み)
     * @param key 検索キー(例: "\"content\"")
     * @return フィールドの値(デコード済み)，キーが存在しない場合は空文字列
     */
    private String extractStringField(String s, String key) {
        int keyIdx = s.indexOf(key);
        if (keyIdx < 0) return "";
        int colonIdx = s.indexOf(":", keyIdx + key.length());
        if (colonIdx < 0) return "";
        int quoteIdx = s.indexOf("\"", colonIdx + 1);
        if (quoteIdx < 0) return "";
        StringBuilder sb = new StringBuilder();
        for (int i = quoteIdx + 1; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '\\' && i + 1 < s.length()) {
                char esc = s.charAt(++i);
                if      (esc == 'n') sb.append('\n');
                else if (esc == 'r') sb.append('\r');
                else if (esc == 't') sb.append('\t');
                else                 sb.append(esc);
            } else if (c == '"') {
                break;
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }

    /**
     * SimulateResult を LLM に返す JSON 文字列に変換する．
     * @param res シミュレーション結果
     * @return JSON 文字列
     */
    private String buildSimulateResultJson(SimulateResult res) {
        StringBuilder sb = new StringBuilder();
        sb.append("{\"board\":\"").append(escapeForJson(res.boardText)).append("\"");
        sb.append(",\"my_stones\":").append(res.myStones);
        sb.append(",\"opponent_stones\":").append(res.opponentStones);
        sb.append(",\"stable_gained\":").append(res.stableGained);
        sb.append(",\"flipped\":[");
        for (int i = 0; i < res.flipped.size(); i++) {
            if (i > 0) sb.append(",");
            sb.append("\"").append(res.flipped.get(i)).append("\"");
        }
        sb.append("],\"opponent_valid_moves\":[");
        for (int i = 0; i < res.opponentValidMoves.size(); i++) {
            if (i > 0) sb.append(",");
            sb.append("\"").append(res.opponentValidMoves.get(i)).append("\"");
        }
        sb.append("]}");
        return sb.toString();
    }

    // ── LLM ツールサポート ────────────────────────────────────

    /**
     * simulate_move ツールの戻り値を格納するデータクラス．
     */
    protected static class SimulateResult {
        /** 着手後のビットボード(2手先計算に使用) */
        long[] boardAfter;
        /** 着手後の盤面テキスト */
        String boardText;
        /** 着手側の石数 */
        int myStones;
        /** 相手の石数 */
        int opponentStones;
        /** ひっくり返した石の座標リスト("d4" 形式) */
        List<String> flipped;
        /** 着手後に相手が置ける位置一覧 */
        List<String> opponentValidMoves;
        /** この着手で増えた自分の安定石の数 */
        int stableGained;
    }

    /**
     * 指定座標に石を置いた場合の結果をシミュレートする(実際の盤面は変更しない)．
     * 座標は "d3" 形式(列 a〜h + 行 1〜8)で受け取り，内部で行・列インデックスに変換する．
     * @param board ビットボード(board[0]=黒, board[1]=白)
     * @param turn  手番(false=黒, true=白)
     * @param coord 座標文字列(例: "d3")
     * @return シミュレーション結果
     * @throws IllegalArgumentException 座標が不正または石を置けない場合
     */
    protected SimulateResult simulateMove(long[] board, boolean turn, String coord) {
        if (coord == null || coord.length() < 2)
            throw new IllegalArgumentException("無効な座標形式: " + coord);
        int col = "abcdefgh".indexOf(coord.charAt(0));
        int row = "12345678".indexOf(coord.charAt(1));
        if (col < 0 || row < 0)
            throw new IllegalArgumentException("無効な座標: " + coord);
        if (!canPlace(row, col, board, turn))
            throw new IllegalArgumentException("置けない位置が指定されました: " + coord);

        int my  = turn ? 1 : 0;
        int opp = turn ? 0 : 1;
        int before = countStableStones(board, turn);

        long[] boardCopy = {board[0], board[1]};
        place(row, col, boardCopy, turn);

        SimulateResult res = new SimulateResult();
        res.boardAfter     = boardCopy;
        res.myStones       = countStones(boardCopy, turn);
        res.opponentStones = countStones(boardCopy, !turn);
        res.boardText      = boardToText(boardCopy, !turn);
        res.stableGained   = countStableStones(boardCopy, turn) - before;

        // 着手前に相手の石だったもので，着手後に自分の石になったもの = ひっくり返した石
        long flippedBits = board[opp] & boardCopy[my];
        res.flipped = new ArrayList<>();
        for (int r = 0; r < SIZE; r++)
            for (int c = 0; c < SIZE; c++)
                if ((flippedBits & (1L << ((r << ROW_SHIFT) + c))) != 0)
                    res.flipped.add(coordToStr(r, c));

        // 着手後に相手が置ける位置
        res.opponentValidMoves = new ArrayList<>();
        for (int r = 0; r < SIZE; r++)
            for (int c = 0; c < SIZE; c++)
                if (canPlace(r, c, boardCopy, !turn))
                    res.opponentValidMoves.add(coordToStr(r, c));

        return res;
    }

    /**
     * 指定盤面でスコア関数と X/C フィルタを用いて相手の最善応手を 1 手返す．
     * 角があれば最優先，なければ X/C 除外後のスコア最高手，全手 X/C の場合はスコア最高手を返す．
     * @param board     仮着手後のビットボード
     * @param oppTurn   相手の手番
     * @param scoreFunc フェーズに応じたスコア関数
     * @return 最善応手の {row, col}，合法手なし(パス)の場合は null
     */
    private int[] bestOpponentMove(long[] board, boolean oppTurn, ScoreFunction scoreFunc) {
        List<ScoredMove> scored = new ArrayList<>();
        long[] tmp = new long[2];
        for (int r = 0; r < SIZE; r++) {
            for (int c = 0; c < SIZE; c++) {
                if (!this.canPlace(r, c, board, oppTurn)) continue;
                tmp[0] = board[0]; tmp[1] = board[1];
                this.place(r, c, tmp, oppTurn);
                double score = scoreFunc.getScore(tmp, oppTurn, !oppTurn, 1);
                scored.add(new ScoredMove(score, r, c));
            }
        }
        if (scored.isEmpty()) return null;
        // 角があれば最優先で選択
        for (ScoredMove m : scored)
            if (CORNER_POS.contains(m.row * 8 + m.col)) return new int[]{m.row, m.col};
        // X/C 除外後のスコア最高手を選択
        scored.sort((a, b) -> Double.compare(b.score, a.score));
        for (ScoredMove m : scored)
            if (!X_C_POS.contains(m.row * 8 + m.col)) return new int[]{m.row, m.col};
        // 全手が X/C の場合はスコア最高手
        return new int[]{scored.get(0).row, scored.get(0).col};
    }

    // ── 探索フレームワーク ────────────────────────────────────

    /** 盤面評価用インターフェース */
    @FunctionalInterface
    interface ScoreFunction {
        /**
         * ある盤面のスコアを計算するメソッド
         * @param board   今の盤面
         * @param nowTurn 評価時の手番(false=黒, true=白)
         * @param turn    盤面の手番(false=黒, true=白)
         * @param num     今評価している盤面が何手先のものか
         * @return        その盤面のスコア
         */
        double getScore(long[] board, boolean nowTurn, boolean turn, int num);
    }

    /**
     * 全候補手を評価し，最高スコアの手をランダムに選んで実際に置く．
     * DataGen ではこのメソッドを拡張した thinkAndGetMove() を使う．
     * @param board 今の盤面
     * @param turn  手番(false=黒, true=白)
     * @param func  ある盤面のスコアを計算するメソッド
     */
    public void exploreAssist(long[] board, boolean turn, ScoreFunction func) {
        double maxScore = -Double.MAX_VALUE;
        int[] rowAns = new int[SIZE * 2];
        int[] colAns = new int[SIZE * 2];
        int placeNum = 0;
        long[] boardLeaf = new long[2];

        // 全てのマスでループ
        for (int row = 0; row < SIZE; row++) {
            for (int col = 0; col < SIZE; col++) {
                // 石を置けないマスは飛ばす
                if (!canPlace(row, col, board, turn)) continue;

                // 局面をコピーしてそこに石を置き，スコア計算
                boardLeaf[0] = board[0]; boardLeaf[1] = board[1];
                place(row, col, boardLeaf, turn);
                double score = func.getScore(boardLeaf, turn, !turn, 1);

                // 最大スコアとなる位置を記録しておく
                if (score > maxScore) {
                    maxScore  = score;
                    placeNum  = 0;
                    rowAns[0] = row; colAns[0] = col;
                } else if (score == maxScore) {
                    placeNum++;
                    rowAns[placeNum] = row; colAns[placeNum] = col;
                }
            }
        }

        // 同スコアの手が複数あればランダムに選ぶ
        if (placeNum > 0) {
            int idx = rand.nextInt(placeNum + 1);
            rowAns[0] = rowAns[idx]; colAns[0] = colAns[idx];
        }

        // 選んだ場所に実際に置く
        place(rowAns[0], colAns[0], board, turn);
    }

    /** topHalfMoves での手とスコアの対応を保持する内部クラス． */
    protected static class ScoredMove {
        final double score;
        final int row, col;
        ScoredMove(double score, int row, int col) {
            this.score = score; this.row = row; this.col = col;
        }
    }

    /** 候補手の選別戦略を定義する関数型インタフェース． */
    @FunctionalInterface
    protected interface MoveFilter {
        /**
         * スコア降順にソート済みの全合法手リストから，LLM に提示する候補手を選別して返す．
         * @param sorted スコア降順にソートされた全合法手
         * @return LLM に提示する候補手（各要素は {row, col}）
         */
        List<int[]> select(List<ScoredMove> sorted);
    }

    /**
     * 全合法手をスコア関数で評価し，上位半分（⌈n/2⌉ 件）を返す．
     * スコアが同値の手は出現順を維持する．
     * @param board 今の盤面
     * @param turn  手番(false=黒, true=白)
     * @param func  スコア関数
     * @return 上位半分の手（各要素は {row, col}）
     */
    protected List<int[]> topHalfMoves(long[] board, boolean turn, ScoreFunction func) {
        List<ScoredMove> scoredMoves = new ArrayList<>();
        long[] boardLeaf = new long[2];

        // 全てのマスでループ
        for (int row = 0; row < SIZE; row++) {
            for (int col = 0; col < SIZE; col++) {
                if (!this.canPlace(row, col, board, turn)) continue;

                // 合法手全てにおいてスコアを計算し記録
                boardLeaf[0] = board[0]; boardLeaf[1] = board[1];
                this.place(row, col, boardLeaf, turn);
                double score = func.getScore(boardLeaf, turn, !turn, 1);
                scoredMoves.add(new ScoredMove(score, row, col));
            }
        }

        // スコア降順にソートして currentMoveFilter で候補手を選別して返す
        scoredMoves.sort((a, b) -> Double.compare(b.score, a.score));
        return this.currentMoveFilter.select(scoredMoves);
    }

    // ── 再帰探索メソッド ──────────────────────────────────────

    /**
     * n手先の nowTurn の石数の平均を計算する(再帰)．
     * @param board   今の盤面
     * @param nowTurn 評価基準となるプレイヤー(変化しない)
     * @param turn    現在手を打つプレイヤー
     * @param num     現在の探索手数
     * @return        nowTurn の石数の平均
     */
    public double exploreNHand(long[] board, boolean nowTurn, boolean turn, int num) {
        // 探索し切ったなら今の意思の数を返す
        if (num >= this.readGoal[nowTurn ? 1 : 0]) return countStones(board, nowTurn);

        double total = 0.0;
        int placeNum = 0;
        long[] boardLeaf = new long[2];

        // 全てのマスをループ
        for (int row = 0; row < SIZE; row++) {
            for (int col = 0; col < SIZE; col++) {
                // 置けないならスキップ
                if (!canPlace(row, col, board, turn)) continue;

                // ボード状態をコピーしてコピー先に石を置く
                boardLeaf[0] = board[0]; boardLeaf[1] = board[1];
                place(row, col, boardLeaf, turn);

                // 置いた先を探索
                total += this.exploreNHand(boardLeaf, nowTurn, !turn, num + 1);
                placeNum++;
            }
        }

        // 現在の手番がパス。相手も置けなければゲーム終了(両者パス)
        if (placeNum == 0) {
            if (canPlaceAny(board, !turn)) return this.exploreNHand(board, nowTurn, !turn, num);
            return countStones(board, nowTurn);
        }

        // 全手の平均スコアを返す
        return total / placeNum;
    }

    /**
     * n手先(nowTurn の手番基準)の相手の手数を最小化する(再帰)．
     * nowTurn の手番のときだけ depth をインクリメントする．
     * 符号を反転しながら平均を取ることで最大化を最小化に変換する．
     * @param board   今の盤面
     * @param nowTurn 評価基準となるプレイヤー(変化しない)
     * @param turn    現在手を打つプレイヤー
     * @param num     現在の探索手数
     * @return        nowTurn にとっての評価値
     */
    public double exploreNLeast(long[] board, boolean nowTurn, boolean turn, int num) {
        // 探索し切ったなら今の手数を返す
        if (num >= this.readGoal[nowTurn ? 1 : 0]) {
            // 相手(-nowTurn)の手数を負値で返す(相手の手数が多いほど評価としては低い)
            int mobility = 0;
            for (int row = 0; row < SIZE; row++)
                for (int col = 0; col < SIZE; col++)
                    if (canPlace(row, col, board, !nowTurn)) mobility++;
            return -(double) mobility;
        }

        double total = 0.0;
        int placeNum = 0;
        long[] boardLeaf = new long[2];
        // nowTurn の手番のときだけ depth を進める
        int nextNum = (nowTurn == turn) ? num + 1 : num;

        // 全てのマスをループ
        for (int row = 0; row < SIZE; row++) {
            for (int col = 0; col < SIZE; col++) {
                // 置けないならスキップ
                if (!canPlace(row, col, board, turn)) continue;

                // ボード状態をコピーして石を置く
                boardLeaf[0] = board[0]; boardLeaf[1] = board[1];
                place(row, col, boardLeaf, turn);

                // 置いた先を探索
                total += this.exploreNLeast(boardLeaf, nowTurn, !turn, nextNum);
                placeNum++;
            }
        }

        // 現在の手番がパス。相手も置けなければゲーム終了(両者パス)
        if (placeNum == 0) {
            if (canPlaceAny(board, !turn)) return this.exploreNLeast(board, nowTurn, !turn, nextNum);
            return 0.0;
        }

        // 符号を反転して平均(相手のおける手数が多いほど評価は低い)
        return -total / placeNum;
    }

    /**
     * n手先(相手の手番基準)の nowTurn の手数を最大化する(再帰)．
     * 相手の手番のときだけ depth をインクリメントする．
     * @param board   今の盤面
     * @param nowTurn 評価基準となるプレイヤー(変化しない)
     * @param turn    現在手を打つプレイヤー
     * @param num     現在の探索手数
     * @return        nowTurn にとっての評価値
     */
    public double exploreNMost(long[] board, boolean nowTurn, boolean turn, int num) {
        // 探索し切ったなら今の手数を返す
        if (nowTurn == turn && num >= this.readGoal[nowTurn ? 1 : 0]) {
            int mobility = 0;
            for (int row = 0; row < SIZE; row++)
                for (int col = 0; col < SIZE; col++)
                    if (canPlace(row, col, board, nowTurn)) mobility++;
            return (double) mobility;
        }

        double total = 0.0;
        int placeNum = 0;
        long[] boardLeaf = new long[2];
        // 相手の手番のときだけ depth を進める
        int nextNum = (nowTurn != turn) ? num + 1 : num;

        // 全てのマスをループ
        for (int row = 0; row < SIZE; row++) {
            for (int col = 0; col < SIZE; col++) {
                // 置けないならスキップ
                if (!canPlace(row, col, board, turn)) continue;

                // ボード状態をコピーして石を置く
                boardLeaf[0] = board[0]; boardLeaf[1] = board[1];
                place(row, col, boardLeaf, turn);

                // 置いた先を探索
                total += this.exploreNMost(boardLeaf, nowTurn, !turn, nextNum);
                placeNum++;
            }
        }

        // 現在の手番がパス。相手も置けなければゲーム終了(両者パス)
        if (placeNum == 0) {
            if (canPlaceAny(board, !turn)) return this.exploreNMost(board, nowTurn, !turn, nextNum);
            return 0.0;
        }

        return total / placeNum;
    }

    /**
     * n手先の nowTurn の安定石数の平均を計算する(再帰)．
     * @param board   今の盤面
     * @param nowTurn 評価基準となるプレイヤー(変化しない)
     * @param turn    現在手を打つプレイヤー
     * @param num     現在の探索手数
     * @return        nowTurn の安定石数の平均
     */
    public double exploreNStable(long[] board, boolean nowTurn, boolean turn, int num) {
        if (num >= this.readGoal[nowTurn ? 1 : 0]) return this.countStableStones(board, nowTurn);

        double total = 0.0;
        int placeNum = 0;
        long[] boardLeaf = new long[2];

        // 全てのマスでループ
        for (int row = 0; row < SIZE; row++) {
            for (int col = 0; col < SIZE; col++) {
                if (!this.canPlace(row, col, board, turn)) continue;
                boardLeaf[0] = board[0]; boardLeaf[1] = board[1];
                this.place(row, col, boardLeaf, turn);
                total += this.exploreNStable(boardLeaf, nowTurn, !turn, num + 1);
                placeNum++;
            }
        }

        if (placeNum == 0) {
            if (this.canPlaceAny(board, !turn)) return this.exploreNStable(board, nowTurn, !turn, num);
            return this.countStableStones(board, nowTurn);
        }

        return total / placeNum;
    }
}

Evaluator.java

Evaluator.java

import java.io.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.function.BiConsumer;

/**
 * 決定設定 (V2_noFlip + M3_strategic) の LLM を各盤面表現形式で総当たりさせ，勝率を比較するクラス．
 *
 * 使い方:
 *   javac *.java
 *   java Evaluator
 */
public class Evaluator extends Osero {

    private static final int GAMES_PER_MATCHUP = 50;
    private static final int READ_GOAL         = 3;

    /** 決定設定: M3_strategic (X/C 除外 → 上位半分 → 角強制追加)． */
    private static final MoveFilter MOVE_FILTER = sorted -> {
        // X/C 位置を除外した安全な手のリストを作成（全手が X/C の場合は全合法手にフォールバック）
        List<ScoredMove> safe = new ArrayList<>();
        for (ScoredMove m : sorted)
            if (!X_C_POS.contains(m.row * 8 + m.col)) safe.add(m);
        List<ScoredMove> base = safe.isEmpty() ? sorted : safe;
        // 安全な手の上位半分を選択
        int k = (base.size() + 1) / 2;
        Set<Integer> added = new HashSet<>();
        List<int[]> r = new ArrayList<>();
        for (int i = 0; i < k; i++) {
            r.add(new int[]{base.get(i).row, base.get(i).col});
            added.add(base.get(i).row * 8 + base.get(i).col);
        }
        // 合法手に角があれば強制追加
        for (ScoredMove m : sorted) {
            int pos = m.row * 8 + m.col;
            if (CORNER_POS.contains(pos) && !added.contains(pos))
                r.add(new int[]{m.row, m.col});
        }
        return r;
    };

    /** 盤面テキストの表示形式と識別名を保持する設定クラス． */
    private static class BoardFormatConfig {
        final String name;
        final BoardFormat format;
        /**
         * @param name   設定識別子(CSV・ログ出力に使用)
         * @param format 盤面テキストの表示形式
         */
        BoardFormatConfig(String name, BoardFormat format) {
            this.name = name; this.format = format;
        }
    }

    /** Stage 4: 比較対象の盤面表現形式一覧 */
    private static final BoardFormatConfig[] BOARD_FORMAT_CONFIGS = {
        new BoardFormatConfig("F1_ascii", BoardFormat.ASCII_GRID),
        new BoardFormatConfig("F2_fen",   BoardFormat.COMPACT_FEN),
        new BoardFormatConfig("F3_list",  BoardFormat.COORD_LIST),
        new BoardFormatConfig("F4_omit",  BoardFormat.OMIT),
    };

    /** 2手先シミュレーション情報の有無を表す設定クラス． */
    private static class SimDepthConfig {
        final String name;
        final boolean depth2;
        /**
         * @param name   設定識別子(CSV・ログ出力に使用)
         * @param depth2 true のとき2手先情報を含める
         */
        SimDepthConfig(String name, boolean depth2) {
            this.name = name; this.depth2 = depth2;
        }
    }

    /** Stage 5: 比較対象の2手先あり/なし設定一覧 */
    private static final SimDepthConfig[] SIM_DEPTH_CONFIGS = {
        new SimDepthConfig("depth2", true),
        new SimDepthConfig("depth1", false),
    };

    /**
     * 1ゲームを実行し，勝者を返す．
     * @param black 黒番の思考関数
     * @param white 白番の思考関数
     * @return 1=黒勝ち, -1=白勝ち, 0=引き分け
     */
    public int runGame(BiConsumer<long[], Boolean> black, BiConsumer<long[], Boolean> white) {
        this.initBoard();
        boolean turn          = false;
        boolean prevCouldPlay = true;

        while (true) {
            if (!this.canPlaceAny(this.board, turn)) {
                if (!prevCouldPlay) break; // 両者置けない → 終了
                prevCouldPlay = false;
                turn = !turn;
                continue;
            }
            prevCouldPlay = true;
            (turn ? white : black).accept(this.board, turn);
            turn = !turn;
        }

        int blackStones = this.countStones(this.board, false);
        int whiteStones = this.countStones(this.board, true);
        if      (blackStones > whiteStones) return  1;
        else if (whiteStones > blackStones) return -1;
        else                                return  0;
    }

    /**
     * 1ゲームを実行し，勝者を返す(PlayMethod 指定版)．
     * @param black 黒番の思考方法
     * @param white 白番の思考方法
     * @return 1=黒勝ち, -1=白勝ち, 0=引き分け
     */
    public int runGame(PlayMethod black, PlayMethod white) {
        return this.runGame(this.resolvePlayMethod(black), this.resolvePlayMethod(white));
    }

    /**
     * 秒数を "Xm Ys" 形式にフォーマットする．
     * @param seconds 秒数
     * @return フォーマットされた時間文字列
     */
    private static String formatTime(long seconds) {
        return String.format("%dm%02ds", seconds / 60, seconds % 60);
    }

    /**
     * 進捗行を標準出力に上書き表示する．
     * @param blackLabel 黒番のラベル
     * @param whiteLabel 白番のラベル
     * @param gameDone   現在のマッチアップでの完了ゲーム数
     * @param done       全体完了ゲーム数
     * @param total      全体ゲーム数
     * @param startMs    開始時刻(ミリ秒)
     */
    private static void printProgress(String blackLabel, String whiteLabel,
                                      int gameDone, int done, int total, long startMs) {
        long elapsed   = (System.currentTimeMillis() - startMs) / 1000;
        long remaining = done > 0 ? elapsed * (total - done) / done : 0;
        System.out.printf("\r[%s vs %s] %d/%d | 全体 %d/%d (%d%%) | 経過 %s 残り約 %s   ",
                blackLabel, whiteLabel, gameDone, GAMES_PER_MATCHUP,
                done, total, done * 100 / total,
                formatTime(elapsed), formatTime(remaining));
    }

    /**
     * 評価のエントリーポイント．
     * SIM_DEPTH_CONFIGS の各設定同士を総当たりで対戦させ（自分同士はスキップ），結果を CSV に保存する．
     * 盤面表現は OMIT 固定，候補手フィルタは M3_strategic 固定．
     * @param args 未使用
     * @throws IOException CSV ファイルの書き込みに失敗した場合
     */
    public static void main(String[] args) throws IOException {
        Evaluator ev = new Evaluator();
        ev.setReadGoal(READ_GOAL, READ_GOAL);

        LocalDateTime now = LocalDateTime.now();
        String startTs   = now.format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
        String date      = now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        String filename  = "../csv/compare_" + startTs + ".csv";

        // 自分同士を除いた総当たり: 2 × 1 × GAMES_PER_MATCHUP ゲーム
        int n          = SIM_DEPTH_CONFIGS.length;
        int totalGames = n * (n - 1) * GAMES_PER_MATCHUP;
        int doneGames  = 0;
        long startMs   = System.currentTimeMillis();

        try (PrintWriter csv = new PrintWriter(new FileWriter(filename))) {
            csv.println("black_depth,white_depth,model,date,games_per_matchup,black_win,black_lose,black_draw");

            // 外ループ = 黒設定，内ループ = 白設定（自分同士はスキップ）
            for (SimDepthConfig blackCfg : SIM_DEPTH_CONFIGS) {
                for (SimDepthConfig whiteCfg : SIM_DEPTH_CONFIGS) {
                    if (blackCfg == whiteCfg) continue;

                    int blackWin = 0, blackLose = 0, blackDraw = 0;

                    // 各手番前に depth2 / moveFilter を設定するラムダで対戦
                    BiConsumer<long[], Boolean> blackPlayer = (board, turn) -> {
                        ev.setMoveFilter(MOVE_FILTER);
                        ev.setDepth2Enabled(blackCfg.depth2);
                        ev.llm(board, turn);
                    };
                    BiConsumer<long[], Boolean> whitePlayer = (board, turn) -> {
                        ev.setMoveFilter(MOVE_FILTER);
                        ev.setDepth2Enabled(whiteCfg.depth2);
                        ev.llm(board, turn);
                    };

                    for (int i = 0; i < GAMES_PER_MATCHUP; i++) {
                        String ts = LocalDateTime.now()
                                .format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
                        String logBase = "../log/eval_" + blackCfg.name + "_vs_" + whiteCfg.name
                                + "_" + (i + 1) + "_" + ts + ".jsonl";
                        try (PrintWriter lw = new PrintWriter(new FileWriter(logBase))) {
                            ev.setLogWriter(lw);
                            int r = ev.runGame(blackPlayer, whitePlayer);
                            if      (r ==  1) blackWin++;
                            else if (r == -1) blackLose++;
                            else              blackDraw++;
                        }
                        ev.resetLogWriter();
                        doneGames++;
                        printProgress(blackCfg.name, whiteCfg.name, i + 1,
                                doneGames, totalGames, startMs);
                    }

                    System.out.printf("\r[%s vs %s] 完了 黒 %d勝%d敗%d分%n",
                            blackCfg.name, whiteCfg.name, blackWin, blackLose, blackDraw);

                    csv.printf("%s,%s,%s,%s,%d,%d,%d,%d%n",
                            blackCfg.name, whiteCfg.name, getLlmModel(), date,
                            GAMES_PER_MATCHUP, blackWin, blackLose, blackDraw);
                }
            }
        }

        System.out.println("結果を保存しました: " + filename);
    }
}

analysis.ipynb

analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5e8b3d52",
   "metadata": {},
   "source": [
    "# import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3f33f96d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import glob\n",
    "import json\n",
    "import re\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3fcb138d",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set()\n",
    "# 日本語フォントの設定(Windows: Meiryo)\n",
    "plt.rcParams['font.family'] = 'Meiryo'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13abf2f6",
   "metadata": {},
   "source": [
    "# LLMへの盤面情報の渡し方を変更して対戦させてみる"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d452dd9",
   "metadata": {},
   "source": [
    "## 盤面情報の渡し方のバリエーション\n",
    "\n",
    "4種類の渡し方を総当たり（自分同士を除く全12マッチアップ × 10試合）で比較した．\n",
    "\n",
    "| 渡し方名 | 渡し方 | 変更の意図 |\n",
    "|--------|----------|------------|\n",
    "| **F1_ascii** | 今までと同じ．盤面を圧縮せずに一行ずつ改行区切りで送信する | 比較用ベースライン |\n",
    "| **F2_fen** | チェスのFENと同様に一行ずつ`/`区切りで送信する | 情報を圧縮できる |\n",
    "| **F3_list** | 黒い石と白い石の位置をリストで渡す | 最終回答などと同じ形式なので分かりやすいかも |\n",
    "| **F4_omit** | 盤面情報は渡さない | 他に渡している情報で判断している可能性があるので，それを確かめる |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44621d8d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>black_format</th>\n",
       "      <th>white_format</th>\n",
       "      <th>model</th>\n",
       "      <th>date</th>\n",
       "      <th>games_per_matchup</th>\n",
       "      <th>black_win</th>\n",
       "      <th>black_lose</th>\n",
       "      <th>black_draw</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>F1_ascii</td>\n",
       "      <td>F2_fen</td>\n",
       "      <td>gemma4-osero-e2b</td>\n",
       "      <td>2026-05-06</td>\n",
       "      <td>10</td>\n",
       "      <td>2</td>\n",
       "      <td>8</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>F1_ascii</td>\n",
       "      <td>F3_list</td>\n",
       "      <td>gemma4-osero-e2b</td>\n",
       "      <td>2026-05-06</td>\n",
       "      <td>10</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>F1_ascii</td>\n",
       "      <td>F4_omit</td>\n",
       "      <td>gemma4-osero-e2b</td>\n",
       "      <td>2026-05-06</td>\n",
       "      <td>10</td>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>F2_fen</td>\n",
       "      <td>F1_ascii</td>\n",
       "      <td>gemma4-osero-e2b</td>\n",
       "      <td>2026-05-06</td>\n",
       "      <td>10</td>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>F2_fen</td>\n",
       "      <td>F3_list</td>\n",
       "      <td>gemma4-osero-e2b</td>\n",
       "      <td>2026-05-06</td>\n",
       "      <td>10</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>F2_fen</td>\n",
       "      <td>F4_omit</td>\n",
       "      <td>gemma4-osero-e2b</td>\n",
       "      <td>2026-05-06</td>\n",
       "      <td>10</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>F3_list</td>\n",
       "      <td>F1_ascii</td>\n",
       "      <td>gemma4-osero-e2b</td>\n",
       "      <td>2026-05-06</td>\n",
       "      <td>10</td>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>F3_list</td>\n",
       "      <td>F2_fen</td>\n",
       "      <td>gemma4-osero-e2b</td>\n",
       "      <td>2026-05-06</td>\n",
       "      <td>10</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>F3_list</td>\n",
       "      <td>F4_omit</td>\n",
       "      <td>gemma4-osero-e2b</td>\n",
       "      <td>2026-05-06</td>\n",
       "      <td>10</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>F4_omit</td>\n",
       "      <td>F1_ascii</td>\n",
       "      <td>gemma4-osero-e2b</td>\n",
       "      <td>2026-05-06</td>\n",
       "      <td>10</td>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>F4_omit</td>\n",
       "      <td>F2_fen</td>\n",
       "      <td>gemma4-osero-e2b</td>\n",
       "      <td>2026-05-06</td>\n",
       "      <td>10</td>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>F4_omit</td>\n",
       "      <td>F3_list</td>\n",
       "      <td>gemma4-osero-e2b</td>\n",
       "      <td>2026-05-06</td>\n",
       "      <td>10</td>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   black_format white_format             model        date  games_per_matchup  \\\n",
       "0      F1_ascii       F2_fen  gemma4-osero-e2b  2026-05-06                 10   \n",
       "1      F1_ascii      F3_list  gemma4-osero-e2b  2026-05-06                 10   \n",
       "2      F1_ascii      F4_omit  gemma4-osero-e2b  2026-05-06                 10   \n",
       "3        F2_fen     F1_ascii  gemma4-osero-e2b  2026-05-06                 10   \n",
       "4        F2_fen      F3_list  gemma4-osero-e2b  2026-05-06                 10   \n",
       "5        F2_fen      F4_omit  gemma4-osero-e2b  2026-05-06                 10   \n",
       "6       F3_list     F1_ascii  gemma4-osero-e2b  2026-05-06                 10   \n",
       "7       F3_list       F2_fen  gemma4-osero-e2b  2026-05-06                 10   \n",
       "8       F3_list      F4_omit  gemma4-osero-e2b  2026-05-06                 10   \n",
       "9       F4_omit     F1_ascii  gemma4-osero-e2b  2026-05-06                 10   \n",
       "10      F4_omit       F2_fen  gemma4-osero-e2b  2026-05-06                 10   \n",
       "11      F4_omit      F3_list  gemma4-osero-e2b  2026-05-06                 10   \n",
       "\n",
       "    black_win  black_lose  black_draw  \n",
       "0           2           8           0  \n",
       "1           3           4           3  \n",
       "2           3           6           1  \n",
       "3           4           6           0  \n",
       "4           5           5           0  \n",
       "5           4           5           1  \n",
       "6           4           6           0  \n",
       "7           5           4           1  \n",
       "8           5           5           0  \n",
       "9           4           6           0  \n",
       "10          4           6           0  \n",
       "11          8           1           1  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv(\"../csv/compare_20260506_081301.csv\")\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24b05a77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>config</th>\n",
       "      <th>wins</th>\n",
       "      <th>losses</th>\n",
       "      <th>draws</th>\n",
       "      <th>total</th>\n",
       "      <th>win_rate</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>F4_omit</td>\n",
       "      <td>32</td>\n",
       "      <td>25</td>\n",
       "      <td>3</td>\n",
       "      <td>60</td>\n",
       "      <td>0.533333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>F2_fen</td>\n",
       "      <td>31</td>\n",
       "      <td>27</td>\n",
       "      <td>2</td>\n",
       "      <td>60</td>\n",
       "      <td>0.516667</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>F1_ascii</td>\n",
       "      <td>26</td>\n",
       "      <td>30</td>\n",
       "      <td>4</td>\n",
       "      <td>60</td>\n",
       "      <td>0.433333</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>F3_list</td>\n",
       "      <td>24</td>\n",
       "      <td>31</td>\n",
       "      <td>5</td>\n",
       "      <td>60</td>\n",
       "      <td>0.400000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     config  wins  losses  draws  total  win_rate\n",
       "0   F4_omit    32      25      3     60  0.533333\n",
       "1    F2_fen    31      27      2     60  0.516667\n",
       "2  F1_ascii    26      30      4     60  0.433333\n",
       "3   F3_list    24      31      5     60  0.400000"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 各設定の総合勝率を集計（黒として + 白として）\n",
    "formats = df['black_format'].unique()\n",
    "records = []\n",
    "for format in formats:\n",
    "    b = df[df['black_format'] == format]   # この設定が黒の試合\n",
    "    w = df[df['white_format'] == format]   # この設定が白の試合\n",
    "    wins   = b['black_win'].sum()  + w['black_lose'].sum()\n",
    "    losses = b['black_lose'].sum() + w['black_win'].sum()\n",
    "    draws  = b['black_draw'].sum() + w['black_draw'].sum()\n",
    "    total  = wins + losses + draws\n",
    "    records.append({'config': format, 'wins': wins, 'losses': losses,\n",
    "                    'draws': draws, 'total': total, 'win_rate': wins / total})\n",
    "\n",
    "summary = pd.DataFrame(records).sort_values('win_rate', ascending=False).reset_index(drop=True)\n",
    "summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5b100662",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 総合勝率の棒グラフ\n",
    "fig, ax = plt.subplots(figsize=(8, 5))\n",
    "\n",
    "colors = ['#4CAF50' if r > 0.5 else '#EF5350' if r < 0.5 else '#9E9E9E'\n",
    "          for r in summary['win_rate']]\n",
    "bars = ax.bar(summary['config'], summary['win_rate'], color=colors, alpha=0.85, width=0.6)\n",
    "\n",
    "ax.axhline(0.5, color='gray', linestyle='--', linewidth=1, label='50%')\n",
    "ax.set_ylim(0, 0.75)\n",
    "ax.set_ylabel('勝率')\n",
    "ax.set_title('盤面情報の渡し方ごとの総合勝率(黒白合算，60試合)')\n",
    "\n",
    "# 値ラベル\n",
    "for bar, row in zip(bars, summary.itertuples()):\n",
    "    ax.text(bar.get_x() + bar.get_width() / 2,\n",
    "            bar.get_height() + 0.012,\n",
    "            f'{row.win_rate:.1%}\\n({row.wins}勝{row.losses}敗{row.draws}分)',\n",
    "            ha='center', va='bottom', fontsize=9)\n",
    "\n",
    "ax.legend()\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"../img/winning_rate_board_format.png\")\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7498ea5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 対戦カードごとの黒勝率をピボットしてヒートマップ化\n",
    "df['black_win_rate'] = df['black_win'] / df['games_per_matchup']\n",
    "\n",
    "pivot = df.pivot(index='black_format', columns='white_format', values='black_win_rate')\n",
    "\n",
    "# 行・列を設定名の定義順に並べる\n",
    "order = ['F1_ascii', 'F2_fen', 'F3_list', 'F4_omit']\n",
    "pivot = pivot.reindex(index=order, columns=order)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(7, 6))\n",
    "sns.heatmap(pivot, annot=True, fmt='.0%', cmap='RdYlGn',\n",
    "            vmin=0, vmax=1, center=0.5,\n",
    "            linewidths=0.5, ax=ax,\n",
    "            annot_kws={'size': 12})\n",
    "\n",
    "ax.set_title('対戦カードごとの黒勝率\\n(行=黒, 列=白, 対角はスキップ)')\n",
    "ax.set_xlabel('白設定')\n",
    "ax.set_ylabel('黒設定')\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"../img/heatmap_board_format.png\")\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "200c9388",
   "metadata": {},
   "source": [
    "# 二手先の情報も渡してみる"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdce1e9d",
   "metadata": {},
   "source": [
    "先ほどの実験で，盤面情報を渡さなくても問題ない(LLMは渡された盤面情報を判断に使用していない)ことが判明した．  \n",
    "ということで盤面情報を削った分，二手先の情報も追加してみて，それで強くなるかどうか確かめてみる．  \n",
    "二手先の情報とは，自分の合法手一覧に対して自分がそこに置いた場合，相手が反撃として最もスコアが高い位置に置き返してくると想定し，その場合の盤面がどうなっているかの情報である．  \n",
    "具体的には以下の情報を返す．\n",
    "- 自分の石の数\n",
    "- 相手の石の数\n",
    "- 自分が次のターンで取れる手数\n",
    "- 増える相手の安定石の数\n",
    "\n",
    "この「二手先の情報」があるものとないもの(ないものは従来のもの)を，それぞれ黒・白を反転させて50戦ずつ計100戦戦わせて，その勝率を確認する．"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "27f2cd91",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>black_depth</th>\n",
       "      <th>white_depth</th>\n",
       "      <th>model</th>\n",
       "      <th>date</th>\n",
       "      <th>games_per_matchup</th>\n",
       "      <th>black_win</th>\n",
       "      <th>black_lose</th>\n",
       "      <th>black_draw</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>depth2</td>\n",
       "      <td>depth1</td>\n",
       "      <td>gemma4-osero-e2b</td>\n",
       "      <td>2026-05-06</td>\n",
       "      <td>50</td>\n",
       "      <td>20</td>\n",
       "      <td>27</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>depth1</td>\n",
       "      <td>depth2</td>\n",
       "      <td>gemma4-osero-e2b</td>\n",
       "      <td>2026-05-06</td>\n",
       "      <td>50</td>\n",
       "      <td>20</td>\n",
       "      <td>28</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  black_depth white_depth             model        date  games_per_matchup  \\\n",
       "0      depth2      depth1  gemma4-osero-e2b  2026-05-06                 50   \n",
       "1      depth1      depth2  gemma4-osero-e2b  2026-05-06                 50   \n",
       "\n",
       "   black_win  black_lose  black_draw  \n",
       "0         20          27           3  \n",
       "1         20          28           2  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_raw = pd.read_csv(\"../csv/compare_20260506_200359.csv\")\n",
    "df_raw"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "42dc4995",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "黒番: 20勝 27敗 3分 → 勝率 40.0%\n",
      "白番: 28勝 20敗 2分 → 勝率 56.0%\n",
      "合計: 48勝 47敗 5分 → 勝率 48.0%\n"
     ]
    }
   ],
   "source": [
    "def wilson_ci(k, n, z=1.96):\n",
    "    \"\"\"\n",
    "    n 試合して k 回勝ったとき，真の勝率の 95% 信頼区間を Wilson スコア法で返す．\n",
    "\n",
    "    ── 背景 ──────────────────────────────────────────────────────────────\n",
    "    【問題設定】\n",
    "    n 試合して k 回勝った(観測勝率 p = k/n)．\n",
    "    p はあくまで「観測値」であり，真の勝率 π は不明．\n",
    "    「真の値 π がどの範囲にあるか」を推定したい．\n",
    "\n",
    "    【二項分布と標準偏差の導出】\n",
    "    勝ち(1)/負け(0)の試行を繰り返す確率モデルを「二項分布」という．\n",
    "    1 試合の結果 X(勝ち=1，負け=0)の分散を定義通り計算すると：\n",
    "      Var(X) = (1-π)²×π + (0-π)²×(1-π) = π(1-π)\n",
    "    n 試合の勝率(= X を n 回平均)の標準偏差は，独立な試行を n 個平均するため\n",
    "    1 試合の標準偏差 √(π(1-π)) が √n 分の 1 に縮まる：\n",
    "      σ = √(π(1-π)/n)\n",
    "    試合数が多いほど σ が小さく，観測勝率が真の値に近づく．\n",
    "\n",
    "    【正規近似とその欠陥】\n",
    "    n が大きいとき，二項分布は正規分布に近づく(中心極限定理)．\n",
    "    正規分布は「平均 ± z×σ の範囲に全体の 95% が入る」性質を持つ(z=1.96)．\n",
    "    これを使い σ の計算に真の値 π の代わりに観測値 p を代入すると，\n",
    "    正規近似の信頼区間 p ± z×√(p(1-p)/n) が得られる．\n",
    "    ただし p = 0(全敗)のとき σ = 0 になり区間が [0, 0] になる欠陥がある．\n",
    "    原因は「p を真の値として固定している」こと．\n",
    "\n",
    "    ── Wilson スコア法 ────────────────────────────────────────────────────\n",
    "    【発想の転換】\n",
    "    「観測値 p から出発して幅を広げる」のではなく，\n",
    "    「真の値 π がどこにあれば観測値 p が 95% 区間に収まるか」を逆に問う．\n",
    "    σ の計算に未知の真の値 π を使ったまま不等式を立てる．\n",
    "\n",
    "    【導出】\n",
    "    「p が π の 95% 区間に収まる」条件(σ に π を使う)：\n",
    "      |p - π| / √(π(1-π)/n)  ≤  z\n",
    "    両辺を二乗して整理すると，π の二次不等式になる：\n",
    "      π²(1 + z²/n) - π(2p + z²/n) + p²  ≤  0\n",
    "    解の公式で解くと，信頼区間の中心と幅が得られる：\n",
    "      中心 = (p + z²/(2n)) / (1 + z²/n)\n",
    "      幅   = z × √(p(1-p)/n + z²/(4n²)) / (1 + z²/n)\n",
    "    p = 0 でも z²/(4n²) の項が残るため，幅がゼロにならない．\n",
    "\n",
    "    【グラフ上の意味】\n",
    "    棒の高さ = 観測勝率 p(実験結果)\n",
    "    エラーバー(キャップ付き縦線)の上端・下端 = 信頼区間の上限・下限\n",
    "    エラーバーが 50% ラインをまたいでいる → 統計的に有意な差とは言えない\n",
    "\n",
    "    引数:\n",
    "      k: 成功数(勝利数)\n",
    "      n: 試行数(試合数)\n",
    "      z: 信頼係数(z=1.96 が 95% 信頼区間に対応)\n",
    "    戻り値:\n",
    "      (下限, 上限) のタプル\n",
    "    \"\"\"\n",
    "    if n == 0:\n",
    "        return 0.0, 1.0\n",
    "    p = k / n\n",
    "    # 観測勝率 p を z^2/(2n) で補正した中心と幅を計算(Wilson スコア法の公式)\n",
    "    center = (p + z**2 / (2*n)) / (1 + z**2 / n)\n",
    "    margin = z * np.sqrt(p*(1-p)/n + z**2/(4*n**2)) / (1 + z**2 / n)\n",
    "    return max(0.0, center - margin), min(1.0, center + margin)\n",
    "\n",
    "\n",
    "# depth2 が黒番・白番それぞれの行を取得\n",
    "d2_black = df_raw[df_raw['black_depth'] == 'depth2'].iloc[0]\n",
    "d2_white = df_raw[df_raw['white_depth'] == 'depth2'].iloc[0]\n",
    "\n",
    "n = int(d2_black['games_per_matchup'])\n",
    "\n",
    "# 黒番での depth2 の勝敗(CSV の black_* 列がそのまま depth2 の成績)\n",
    "b_win, b_lose, b_draw = int(d2_black['black_win']), int(d2_black['black_lose']), int(d2_black['black_draw'])\n",
    "\n",
    "# 白番での depth2 の勝敗\n",
    "# CSV は「黒視点」で記録されているため，白(depth2)の勝敗は黒(depth1)の勝敗を反転して読む\n",
    "w_win  = int(d2_white['black_lose'])   # 黒(depth1)の負け = 白(depth2)の勝ち\n",
    "w_lose = int(d2_white['black_win'])    # 黒(depth1)の勝ち = 白(depth2)の負け\n",
    "w_draw = int(d2_white['black_draw'])   # 引分はそのまま\n",
    "\n",
    "# 黒番・白番を合算した総合成績\n",
    "t_win, t_lose, t_draw = b_win + w_win, b_lose + w_lose, b_draw + w_draw\n",
    "t_total = t_win + t_lose + t_draw\n",
    "\n",
    "# 各条件の (ラベル, 勝, 負, 分, 総試合数) をまとめたリスト(以降のグラフ描画で共通して使う)\n",
    "cases = [\n",
    "    (f'黒番\\n({n}試合)',       b_win, b_lose, b_draw, n),\n",
    "    (f'白番\\n({n}試合)',       w_win, w_lose, w_draw, n),\n",
    "    (f'合計\\n({t_total}試合)', t_win, t_lose, t_draw, t_total),\n",
    "]\n",
    "\n",
    "print(f\"\\n黒番: {b_win}勝 {b_lose}敗 {b_draw}分 → 勝率 {b_win/n:.1%}\")\n",
    "print(f\"白番: {w_win}勝 {w_lose}敗 {w_draw}分 → 勝率 {w_win/n:.1%}\")\n",
    "print(f\"合計: {t_win}勝 {t_lose}敗 {t_draw}分 → 勝率 {t_win/t_total:.1%}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7a62d46",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 棒グラフ: depth2 の勝率(黒番・白番・合計)+ 95% 信頼区間\n",
    "fig, ax = plt.subplots(figsize=(8, 5))\n",
    "\n",
    "labels  = [c[0] for c in cases]\n",
    "rates   = [c[1] / c[4] for c in cases]\n",
    "\n",
    "# 各条件の 95% 信頼区間を Wilson スコア法で計算\n",
    "# 信頼区間とは「真の勝率がどの範囲にあるか」の推定幅で，試合数が少ないほど広くなる\n",
    "cis     = [wilson_ci(c[1], c[4]) for c in cases]\n",
    "\n",
    "# エラーバーの長さ = バーの高さ(勝率)から信頼区間の下限・上限までの差分\n",
    "errs_lo = [r - ci[0] for r, ci in zip(rates, cis)]\n",
    "errs_hi = [ci[1] - r for r, ci in zip(rates, cis)]\n",
    "\n",
    "# 50% 超は緑，50% 未満は赤，ちょうど 50% は灰色\n",
    "colors = ['#4CAF50' if r > 0.5 else '#EF5350' if r < 0.5 else '#9E9E9E' for r in rates]\n",
    "\n",
    "# yerr に [下方向の長さのリスト, 上方向の長さのリスト] を渡してエラーバーを描画\n",
    "bars = ax.bar(labels, rates, color=colors, alpha=0.85, width=0.5,\n",
    "              yerr=[errs_lo, errs_hi], capsize=6, error_kw={'linewidth': 1.5})\n",
    "\n",
    "# 50% の基準ラインを引いてどちらが優勢か一目で分かるようにする\n",
    "ax.axhline(0.5, color='gray', linestyle='--', linewidth=1, label='50%')\n",
    "ax.set_ylim(0, 0.9)\n",
    "ax.set_ylabel('depth2 の勝率')\n",
    "ax.set_title('2手先情報あり(depth2) vs なし(depth1)\\n各条件における depth2 の勝率(95%信頼区間付き)')\n",
    "\n",
    "# 各バーの上に勝率と勝敗数を表示(エラーバーの上端より少し上に配置)\n",
    "for i, (bar, (_, wins, losses, draws, total)) in enumerate(zip(bars, cases)):\n",
    "    rate = wins / total\n",
    "    y = bar.get_height() + errs_hi[i] + 0.02\n",
    "    ax.text(bar.get_x() + bar.get_width()/2, y,\n",
    "            f'{rate:.1%}\\n({wins}勝{losses}敗{draws}分)',\n",
    "            ha='center', va='bottom', fontsize=9)\n",
    "\n",
    "ax.legend(handles=[\n",
    "    mpatches.Patch(color='#4CAF50', alpha=0.85, label='勝率 > 50%'),\n",
    "    mpatches.Patch(color='#EF5350', alpha=0.85, label='勝率 < 50%'),\n",
    "    mpatches.Patch(color='gray',    alpha=0.5,  label='50%ライン'),\n",
    "])\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"../img/winning_rate_depth2.png\")\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad541bfd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 積み上げ棒グラフ: depth2 の勝敗内訳(黒番・白番・合計)\n",
    "fig, ax = plt.subplots(figsize=(8, 5))\n",
    "\n",
    "x = np.arange(len(cases))\n",
    "labels  = [c[0] for c in cases]\n",
    "wins_r  = [c[1] / c[4] for c in cases]\n",
    "draws_r = [c[3] / c[4] for c in cases]\n",
    "loses_r = [c[2] / c[4] for c in cases]\n",
    "bottoms_d = wins_r\n",
    "bottoms_l = [w + d for w, d in zip(wins_r, draws_r)]\n",
    "\n",
    "ax.bar(x, wins_r,  label='勝ち', color='#4CAF50', alpha=0.85)\n",
    "ax.bar(x, draws_r, label='引分', color='#9E9E9E', alpha=0.85, bottom=bottoms_d)\n",
    "ax.bar(x, loses_r, label='負け', color='#EF5350', alpha=0.85, bottom=bottoms_l)\n",
    "\n",
    "ax.axhline(0.5, color='black', linestyle='--', linewidth=1, label='50%')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.set_ylim(0, 1)\n",
    "ax.set_ylabel('depth2 の割合')\n",
    "ax.set_title('2手先情報あり(depth2) の勝敗内訳\\n(黒番・白番・合計)')\n",
    "ax.legend(loc='upper right')\n",
    "\n",
    "for i, (_, wins, losses, draws, total) in enumerate(cases):\n",
    "    if wins > 0:\n",
    "        ax.text(i, wins/total/2, f'{wins}勝', ha='center', va='center',\n",
    "                fontsize=9, color='white', fontweight='bold')\n",
    "    if losses > 0:\n",
    "        ax.text(i, 1 - losses/total/2, f'{losses}負', ha='center', va='center',\n",
    "                fontsize=9, color='white', fontweight='bold')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"../img/breakdown_depth2.png\")\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "22c5bbe7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9gAAAS9CAYAAAC8tPEWAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnQd4U9Ubxr+mu6WFlj1FQYaiiIq4QNyKiAxxTwQUVHCigiiKCxGULfOvgqCCihMVERX3RERl792928z/855ywk2apEmb0jR9f8+T3ia59+au3Jz3vN/3nQiHw+EQQgghhBBCCCGEVApT5RYnhBBCCCGEEEIIBTYhhBBCCCGEEBIk6GATQgghhBBCCCFBgAKbEEIIIYQQQggJAhTYhBBCCCGEEEJIEKDAJoQQQgghhBBCggAFNiGEEEIIIYQQEgQosAkhhBBCCCGEkCBAgU0IIYQQQiqN1WoNq6MYbvtDCDk6UGATUo1kZ2dLfn6+z3k+++wzyczMdD5fvXq1tG/fXn7++eeAPgvrueCCC8RsNnudZ+bMmWrdJSUlfq1z69atav5PPvkkoG0hJJRxOBzVvQmEBOU6/vfff+Xll1+Wjz76yOM8EyZMkNNPP73Cn4HfrwMHDqj/8dty4oknymuvvaaeFxUVyfr16wNe5wknnCBPPPGEhAILFiyQM844QwoLC4OyPpyLLl26BGVdhJDQJaq6N4CQcAQNjYKCAtX4yM3NlaysLMnIyJC0tDTZt2+f7Nq1S7Zt2yZ79+6V/v37y/PPP+9xPRs2bJCRI0fKqFGj5I477qjUNqGBgM/T4mHatGkyffp0j/OefPLJZV6bPHmyXHHFFX591nvvvSePPfaY1/cffPBBGTp0qM91XHzxxdK5c2d56aWXpKL89ttv6rOwjq5du1Z4PaR2cc8998jmzZvliy++8DoPvtt16tQ5qttFwpdHH31U3n///Qot+8wzz8jAgQOdnZ5YD67fv/76S/Ly8qRbt25y3HHHyX///Sd9+/b1uA50lBo599xzZf78+er/OXPmyKRJk1zex28WfrvuvPNOadKkiXpfdwSnpKSo6cqVK+WRRx5RnbvHHHOMc1n8Btrtdp/7hN/PPXv2eH0/ISFBUlNTfa4Dy1944YXywAMPqO2sCN99950cf/zx6vN69OghBw8eLHeZDh06yAcffBDQ5+D3Du0CX6xatUpatGgha9eulWuvvVYqw1133SX3339/uW0BfM7TTz/t8RrxtG2EkFIosAkJAu+++65yAiwWi3J/bTabeh0/ynikp6dL69at1Q9Uw4YNVYMHjZNjjz1W2rRp43W9y5YtU9Pzzz8/aOcJIv+rr75SAvfWW291eQ8NqldffVW+//57iYmJcXkvPj7e2YDr1auXy3towOABpkyZ4nz9zTffVI0vI2jw+AMaa/Xr15fKsH37duWuGNfz66+/ysKFC+WXX35Rjc+WLVvKDTfcIDfffLNERESUu84XXnhB/ve//7k0UMoD5x2dBe+8846EUmP+008/9Xn9VRRc/+gY+vLLL1VUBCInahLoENMiwRP4nixatEh13Jx22mnlOlaLFy9WDfXY2NigbN+IESPk888/Vw1ffxraWmjge4vtCQXwfcN3cN26dUE7LjX9GmzcuLG6N7szYMAAJdqeffZZl9chVCHMjOC3Bg7ymWeeKc2bN1e/R3Bh9THB/c8I7tfLly9XkVFGoqJcm4e4j7/99ttqHcZjCcH+1FNPyeOPP646cEGrVq3U9MMPP1TXnVFcA3TUlucIf/zxx+rhjUsvvVSmTp3qcx36N6yiESnoHP/zzz/l3nvvVc/xncdvfHkYr2f83uL7qtm/f78UFxfL9ddf73ztoosuUudIR5ctWbJEHWvcN9B+MF4fRtDmOOmkkyq0b+73Nxwr92sP31F37r77bpdtx2/Ic889V6FtICScocAmxA2EteFHAw2zLVu2qB9IAIGMBipEqXuDED/2CLOLjo5WDROI0cTERDGZTEoonnXWWepH6bbbbgsofBzCHZ+LBgKELdDhePih1q+507RpU5cfZiNwDvDDDIGP7SvPSQDYJ+ybPg4QC2Dnzp1y4403qgaWFs5169Z1NozQKPOnVxtC2H074GDgXKC33hf4DHcRbxQW2G40+NAwgiCBsOzdu7dyYHCc0OCcOHGiOte6p94buCYgrq+77jq/xXV1oDtB+vXrpzoEgpGHCDcXjhRCTg8dOqQa2ji3aBwOGTJEkpKSnPNHRkaqiAe8rsU8Gvs1BXz3tEjwBAQCHCrcC3AdXXnllV7nheOFaztYIhLiCeIakRmVdbGqkm+//Vadf0QDaIESTHBfhcs6bNgwj+uvqdeg7pw1gvs/riH39zzlByP8GB0XuP+PGTNGudjGY5KcnFxGWKFj0f11d7As7rPGz4RIPuecc9Q9FlFLmAfratSokWzcuFF11M6YMUOdK9wf9G8I0pu8iV50fsJRhcBEB7Q76DDAdwm/XeWhBXZF86gRVo9j3qdPH/Xc1z3BGziuxusTxwn3UuNrEM7o6NUgrP7yyy8vVzzj98vfDlL8FkLo43ere/fuHudB57+vThaAdo1xPuN9nxByBApsQtxAw2D06NHKdURPPRoVaHAjBAphcOjlfeONN1wcXoSKBjtcdN68eaoBs2PHjjKOMUDonTfgQmvX+8knn1T7EhcX5/wxR0MBjTA0QBFK6A4aTd7CBdGI0j+w6OHXP7LuP87uIgMhtbt371bP3RtHEPueHA04IOjs8AWceG/h5hCCaFSjoYDGBc4thJGxUQJnCOcOjfDLLrtMzj77bI/rwr6iwdquXbuQyQ88mo4uGmZwonBtoDGIDhB0tMyePVsJPjSI69Wr51wG3w90XOCY4rjpvMxQFoOe6gsYwfUDcE+AuzR48GB5+OGHVSPcW+gt7h0NGjQIynYihBSuOUJVy0uxCEdwj8C9BOk1cKU9iVEjNekaBNg3T+k5+trD/bA8sM/u0UdG0ClkdLEh3CF2kfdsBJ2kCCv3BTrv8L0HL774ovN1o8ONDhD33yR0msINhiOvBRqEM+7XEORIL8J9Gb8ZENNamGNbhw8frrYXv4/loTu1/HGdPYGII2wzBLqv8Ghv4JxhG7AsOot1BzR+/4xiHfcT9zB8OOfGMPPy0sTgfufk5Hj9HUYaAVLOvHVGY3n3awDfr1NPPdXlNdx/jNvJehWEeIYCmxA30PuOxrN76CfCDZHHhcY4fvh0zltVAJcaDRC4g2hwGEEoH8KTIfIRal4e+FGFqDb+sMJxRuPJPQQPjVaEDPoK24QL/+OPP3oNEYeTje02gsYQthdA8LqHvKMxYQShhmikjR8/3qc76E+DHA2OpUuXKtcELlazZs3KzHfVVVepHDQcc28CGx0MEEuYD50MtQlEZBgbyBq4MOhsQCMbzr67q4/vEkIK0fjGNYNIjlAE0Se6IwdRGRAFDz30kM+wYnTK4JpAoxcdcuhc6Nmzp8eOGTSqg4EOiYVYrI0gl9dXbQdP1JRrEOA+jd8XT/enjh07lolG0aH//gKBqjtKjYIJqUg//fRTuZ1s+E4YBRUifnTUD1xq3B8Q0YHON0RJoQNOd+waQYcn7sfXXHONum/gtwmdVcgRR2cuIoQAvleIbsJ9G8tg3dhOfA/8cbBx38Jy7p23EPNw1/FbimsCv4Pu24n6HfjtRKQIzkt5Hb2+GDt2rDoW6EzAtuDzEX0C4Y7fFF3rAb8r33zzTZnlcUzKA8cEv3PoUHfvkEcHqG43IJ/cE+iU+fvvv11eQ6SXO7gGjEK/vHorhNRWKLAJcQMCzJMIww86RDUaQAjhMgpshHL5qs4N0DjwVswMDXM4gRo0BtGAhxCuLCiu5t6rjaqoOgfSE55cFO1io+E0a9Ys5YJAkBsbEWh8YZvXrFnjsix63++77z4VPugtdN2IDhfXed8A6/YnR9oIXAPkmmE74TR6Oq/63CJsDrmI+Gz3xhucFHQQoAHpq1jaDz/8oI4Nrg90UMDtRuPYl2MF4YpGFdwbHBsce7iTOEfujZhx48YpNxQdQAj9xDFBRxD2TTssxgYPGqbGwknu4bpYHvuMhhlCvwE+Fw1bY94krkVvdQDQUITA/ueffzy+f8stt6hGNM6BP+IG24PoDG+hxdhmdODAlUI0CRrQELE4P2hIQnTgNTTacc0iv94YfukJHHcd1aBDarG/5YVfIlwS5w/pH2iIw/FyXwZ5/t5co0Dda1Trx/4gTcMbEAI43ps2bVINelR19tZpBOAG494DoaFDeXGNwymEi6jRhZAwL+4puGYgQOAuYv34jusQbGPRJEyNBZR0cSwN7ps4bjjvSNNAQx/fRXQiuNdgwOfgeANcb/gcfwj0GqxOvIUz47p3f89Teg/SOHRnJxxIzIPfJ9yHkPvrrZo4rhNfhatwnjt16qS2A4IU69bpSjq0G/dr3L/w3cT7yCVGqDPAedVFyeCKoj7H7bffrjro4N7i+w4BiPsmthnXMb7PqBmA7zPmwX0PEQmBdCrgeobgx+Prr79WnTQQuxC6CN/GPQL3D3eBjfu4vh8gYqSytSogetFBgv1ARy7aERDxSLEy4isSzBe4V0K449zjvOF3GPdtdBjiu4QaIOho8gbOq3tROU/OP46VcT50vBBCykKBTUgAoLEM3EUiQve85TJjGYgQuN/exBYa6kYQrozGbmVDS7FNEG7I1cLUCMLD/R2OCxhDzM877zzVwMb2Ydvx44xwODSQjA0EhLd7K2aD/Dod+udpu7XzjXA0NOQgltGAg1hBYxDFfdDQ8pQnpsH+QUBAmBsb9Z6Ao4/PgHvuLsjQYYD98BW1gOOBTgYc65tuukk5mgiJ9yYCIE4QDQDXAo1QLIcCRWhYIozzlVdeUbn97i4Fjg3mR6g2wphx7UF0aXGHhhQcWDQQ8b/OH/TUcYIGFxqeaPyhkweNSTTQ0ShDI9rXsS3vO6HBOUb4NDpnIMzKK1yHbUEnDvYH++G+DTgXaOChwwbvofMD5wXnDccFnwXRhigMNPrRwRJIODXCV9Ew9RUeO3fuXFUfAY11nGcISER+uBchAji+wUgfgcuFc+/rGsQ2QETiOoDLhO8svoNalLoDFw/XAM4J8srxfUZtB4gwiBF0Wpxyyikuy6DzBmIJYddw+NGZhOOAKBSIZIgo3B9w/4IggjjBcw2uSSNXX3212i9c63hgm9CRgGvl9ddf91pvIZAokkCvweoCHW6ehK6+X+D4lgcE44oVK9T/uA9BsGK/ddXtio7KgGsY9yuIfAhF3JON51VjFL+YT7vuENUQ3Jq2bduq60P/9iEaC9cpUjXw/cV1gPugdmMxxf0LxdsCAQIb7i3uq7i/IzQbzjk60BC54ukeh3uHrjNiBNe7LuTmC38KsHkCnRIVCUUHOM8Q0jiOaD/g9w4h+IgwwH0A2+MrdQBi2lPHhXuUHM6Rt/sJIeQIFNiEBIBuuLj/yHsqxqLRQ5egceNPLzhCxiBa0Cj0VMTMnyJnAG4tBBtEJtxId4ENIYyGjD85VGiEGBu0cE3RKEajGg06uGXYbvfiKb5yxuCAuwts/MhDWGn3AO+jUQexgzBbiFUILOSKIVQNohSNCG+uMrYbIhedG+WFFOowXuyHu8CGw4zGiTcnEIIUjgHC79CINAoqHF+jEwjQSEXKAc4LnDWjOIVziLB4VGa95JJLXFx7FDDS0Q0auLlYBs4OGj64xrA8jiGOGxrZ3sD+wC02uje6IBT22R+nyNt3wgga4hClcG1QeM0XOM5oAGNfUFQOQs7IW2+9pebRBb7QcIaIxHbDEXOvsoxHIOD6govv63rBdxqhqxocc28Nanz/jJEYFQXnA9e7+7Wk0REl6HiBy2z8buE74J62AScKbhfmhzA3Cg0cR1xDEEc43kbQsYWK0cbGOoQ4vof4fLwHIYTvEQQU/vd1DeJ6QHiw/nx0hiC6BqHAEJXe9jdQArkGqwOjGNX3DXw3cT0id1wLL4hwdBp5E0u41uA6wx3FbwR+d4xDWiHaAqHA7p26xnsTOq3KG2EA0QroVMX8gwYNUuIQHVr6e4PfFoR643cG14WnDhHcZ7Gf6ATFvQpiDvc9RIPgtwT3+D/++EOJc+wTwv0D6ShD5ywiP9Apg44ciHSE2pcH7qUQ4u7DZuF69qdgmj9RWp7AMYK4d8dbp4sn8D1H5x86zvC9w3WCCKPyomjcQ8SNne/6f71txvYAQ8QJ8QwFNiF+ggYHGjsQl3Blqgo4oZ6G0kEDBmILDRj8uMFJgsj15uSgUYZGDho4aJy4D8+iBbC3MHFv41ajgQchjAYIGv0IV0WoLlwhCDVddR3ghx2uNsSkDjHGaxiSxL1qLRrkcCzRoIJYQ+cAxJUWUhAEcDXQOEaeGbYDodEQ4HC6PYV+6jxyf8bANjYM3UH4NBwXb0IJohrHBILF3a30FNaO4wZRiAY19ksXi9PgGoODjIansZGLRqf7+iGCIUIgHLTL7y9ogLmHRuIzILCNAtIb6GDB9YqOAl8RArpRixxLf8QNRADOKRq0RoGNcw5nFeJPCwZdPMhTzQBv6R7eQAMSghzXa7DA9RRoBXFPaQq4Bn2FN+saBxBl7h1Xnq5BuKH4zuEawHfNCO4pOGf4LrpfU2jAu4s7nC906MDJhsAOBIh5dxcR1yDuS7gGgyWwA70GEXlQ2fBXf8Zqdr/HoxgV7jUQr0g5gYuPVBPduQrRivfLK/Kl30dnkL5HaoGKThJvw7V5KviH7YKwREeqe6QW7mG4l+E+gN8kfH8gtHGNoOMGQ4zhmsB+uf9WoQMFdTawjeiog9jGNYRzjggeXPO4tvBbhmsQvyXoSPNWUBDgPoxOSGwDOjzR8YVr1t+IB9z7cO0hlNs98gX75M96PLniuv2ASCiE6qNjy5NY9ydqqDwQSYP7HgqY4v6DTjJEV3mLGHMHgtpbsT33cdcJIZ6hwCbED37//Xf1ww4HCQ0TY4MVjX78YHoDlT0BGmtwOr0B4QSRisaNewNH92KjoQRRaWwIoWGNUDdv4EfdV+4yBJoxl9oIGgDuvedokOuefTSsdMNerwvun27AIuQUIaZoKOuxMz1VysWxwfsI/YUTBrcB7qp2/wEa8Gjc6WODRgQcKTS2kJuMfD13tIgvrxougNgAngpSQYC4V1P1VKTNn6JzxvlxTfnC3wY+GqRorOJ8+OPQ+DM+qr5uvYFzig4RiAhEFngqZmS8thFK7S7kvAG3BdcSzimiNHQnA6Ib0Ng3OqII20S6A3J74cDgukGuKDp+As3ZR2g0GqHBHDMZ2xtoUTyExuJ600XjcH+Bq+hrmClcUxBz/oaY6muwvKED8b0or9MGxwznCJ146Cwqb8inYF2DgRDoNYhrr7LFmwIdJg+dKhDPcF4h8BHarcU1QtvhFOP+BAGJawKdJOjYcu/wQNg+OvFwn8X5gNiCMEcxM4AOUW+dxJ46GCFacS8yjueMezHEMY4TIiZwbHWus3Y8Iejxe4nlEEGF7ym2H/cOLINioYiAwj0f5xoFPdGJiueIYND1Q3TKCBxodCChQBo6Wd3vOfiuIRcZ+44pIpcCFaxwf5Gz7+k3Fb9LFQkRx7bi+4vjiO82pvjt0h1vuhOwMiHiGvxmIp8dHUnoJMBxRIc2xDZSWQJJj0BUlrHIKPahKs0FQsIJCmxCygHFfxCCiwYEetLd8ywRxuaPC1xe7pKvxhh+NCF2K5I7WJ7IQEGUQH7UkaOrgaBBowNOhdFpRNiYBq+jYYWOAWwLOgbcG/UQyBDXOD66Yio6M3Q4PJwMOBJoqBkdSTRQ0HBEWCHEpXvxJ32u/DluuvPDU947Gqm+RAYanxAV/oYGajEPV8GXaPK3sI7uFPCW7x4IWgz6Sh2AmEf0AxqKcMb8uX7QGNb77Q8IE0bjHdEBcMDQ+IRLhg4b4/iwCDOF040GLVx/fe2hYQ6XBd9df5wbnGMIEFTOraxArAwI58b9BOkBGi00y7sGvVUI9oQ+F3AKfXWOaLHr7zUIx7uyx8+fa7AiBHINGguqVRTcwwIB90cUvUK0D655CCXcN9HZhHsm7mfozMLxxf0KghTfEUyN9x4IUtT7wHFEXQV8N+BiajcdHUiBONgQVoiqwe+f7nSFgEOEA64f9+gV9w5UfBZyvxGRgzQXRERByKPTFLUfjONCI3Qd8+KejXsxthWuMn6nUBANy2OK+4FxaDAA0Yp8a91JWxFwztFh4anAFzomKgLOGx4o7KavP/yeuRc9rWyIOAr/4Tji2KLjG/dJpEZgeeRnI/UGotvf3xUcB2MqQXnD4hFCjkCBTYgPUGwHLiOEG3rcPYWbotHhqyGIH1SEg2E9EA3e8JXzqd2mQHKx/AWNOQhkT+AHFQ2ayqAFNsQLfqwhZBA2aBQUCAtE0SrjcCQ45qgqDHEBJw/uMHI1vTViPbldCDXXY6mWB5wTuEfGsZyNhXJ8FYRDwx3Ojb9upQ7zRph9MBwB3RHhrxiqDHBE0IjDuYTD5m8Ir67a6y8I64dwh0uHBjnOj04LcAffC3w/0bCE+Mf3BU4UIjPg9PkaM14DkQ5xaBQXOKd4Hc42rlN8R9Hox+sAOa7liSiIe3/yNo33E1xPKDqm0cetvGvQPdXAn2sQDmllKyTraxACMVhDklUFgVyDxoJqVYkuRImpDsXGFNc5wsNRpAo5wdgWpMsgRQLXAa5rhNLjOkdnF1xKdMDg+4LwctxzIX61UIIrq8F3yVtKh762jSDtx/1YaNEGdEEwbB8iL/T3DZ3T2A/UzMA9XjvtENZwt3XnL0Q25sV9Ft8xXPu4L2rRjd8G3YEARxXXq3u1bRw/HC/8hlRUXBu/F+4CO9CUAQhqY8ce7l06+g37iHsK5sG+VTZEHNcM7n+6sCXOu/H4oNMQvzWIOEKKFkaJ8AdEcHAILkIqBgU2IV5AOBXcArgHaOB4KwpTnqDSwhk/rBXNr4I4RcPeH7ELkYHcPQhSf/JxsV3e9sGT+40fa4SbGTHmrMKNNgpaNPzRyEJDEccQeW1GIYjwe6BzrTVwKuFGQFRjfQib9NQJgcYkttOTE4ycVX+G5YErD3cFbqcncOx9FcvSOZM4Lv4IToQwAxTxqqzAxvmGoETHgHbw9fH3lbpQEeAgI2wQ24/vh79V7nWeeaARGAgFh8uPxiicOjQa3YueGUEDHu4ZHnBr4ELCdSpPYEMcooGKKuRabOK4okMM0SMINcU+4zrDvHCiIDqQy4oICkRWeBNuuOaNqQ6+QOgsjjG23Zi7i+8xBEZ51yBCgyEC/Olowf7AOcQ1WFmBjVBedIYhPUG74VV1DVaUil6DVQ2EoR52TgNhhmsZxxL3NYQl47zqXGQ8cF3hmkDYOEKtcQ/GNQzxjJBkX8M9ocM3EAcb59bTmMj6fozPgoDE9Ynvgv5s/fuDfdHiGp0c6PTEwx3sI44Hvge4HxuLeBrFLa4tnEvjPqKTAt8z7FtVEGjKgLFIHDrg0RmB339EqqGzAS481of3dCoI8FW41FuHJ35z0dmHGiAIQff0e457Iq6TQEYmYYg4IRWHApsQN9AgxA8fiq6gEid60QPN5QwmEAh4YJxZX8NsaNDwhyCAk+FPPi7WHYgzjjA8nacHQYljBBGkK4ijAYuGuxGEuyKcD+IEosQT7mG82ilEgwsNS0/OMhp1CCFGo6qiQ5oh/BzhmBAlaKx6Ai4fQhSx357OAXLuEO0ABwENV2NHAASMO2hQw8FBxwmOm/sxwefAjXFv6HqKlECjGo1LhJPqz4XbhMYcwjgrkgPsjg7HxHmA+MP59uda1ED4gUBCmLVbhXBR7CNEBq419+sE4aNoyLqHpcLlg7Pjj2OJEFpdOFADpxAhlxD3Og9WC1McV3RiIT0E0R+43hHu6alxj2UR8o37iq9QbAgOOPW4zo25rhq4+Xqsck/gGkTlZBwrY24/rhlcu+6goY/rFSGxiBZwrzGA7YE7igZ7edcgzhH2zxihozu89Lmvbip6DVY1+J7q8dwhHHGNIPwbbq4WkDj3uGcg9Bkgxxj7oSOq4EbjNwoPdAaXB37bPNWs8HR+cS/yp9gcrjtELxjrF3iqa4Hq5p5qjHgSqHj4Ap2aGu1wG4tsVgVw2n0VrkOnMIqxGcH3DB0fOEa6Q1nXKUHBMAyzqO+zelgyf8H3FN9d3P/LK+gY6G8kQ8QJqTgU2IS4gfw1/LAj1Aw/pHCrPAFR5Gnc22CChhR6pVE4rLxiRJpACwMFWuTMGBKrQ1Lxw41K0p5AAw0//hBGaAigajDywLSLC1cejUuEtSG0Dz3xEKtoAELMQfx6CvFGzz3eg6hEsZ1AgThftGiRErLYNgyXhUatJyCCkd+LIk6eRBQ6EHC9wJnAenWoO0InkRvuDhrREGboCMGxwTohcrCfmB+iHI1T94YoRBzWiZBLzItjgOe4PrAuDY4nHCd0skD0IAQTnRVoJMOlDRQcG4hrnDM09lFwyBOIFvDkhkKs6uMYCHDAkE6A8FecI/coBwDRCUGJ6whRG+goQSErXZUYx7c84P7pTg/3UFlP1wTWjwY9vpO4D6ATDpEWCL90F/rYfjS6ca1CIHm6lhHWjn2AsPJUYR/gmkJEjadaAwC5u+hswLlCxxeuJ4heiDf3IfoA9hWdJugkQKQAhBG2Hd8nVIuGKMf9z11gI6QVaSW60wH7BmGP680YdoyRC3Bd4hrFtYmiUXAYsSxerwhwSHUng57C6dSdWBgu0ZsbX9Fr8GiAc4GORBTvwncLETXIoYb4cu/chQOMefDbgE4VXF+47v3tREOHJDqIUDsB51IPSQihBle1T58+6n7hLmJ9FXlEIU1dqdp47eLcoMPIGP2FiB2jMPb2m4PvOqKe/AWfi2seKR34TfNV+PNo8uGHH6rvLcKyse9aYGuRjdfQKY3ILtxfcQ2ggw3nE514On3Kk6jHNYNzpc9XIKkoviLXjFEDqI2i8RR1QAjxDAU2IW7oYX8gXHRumSfgIHgT2Gj8odEMUAgGBDJ8EpZFAwjuGRqkCI92/zHU64MQRSMGDX6IAt0hUJmxd/FDCqGoq4WXN4a0N5C3CtcR4Y9o+MDJQBg2KoYjZA7htRDmEB66EA8amwjthVhBQwsiCSGK2CY0sHFs0FiGCEADE406f3rmEUYNFxTLwUXBc6wbwgqNH1+9/2gEQeDBcfYksNFY0SkFEOJwBSEwsH1wLzyNEY0GK84vhCvCMrEMjjMavBDB7uMWAzS6cX1iOyDy0NkBcQch7u4o47igYQuBhWOLawRiqjLfCbiAvhxJdAC4CxyIPIQmQtz7KujmDbg7OEY4lp7GwUX+KRqfEHo4LhhDHvOhKBPe86cAmy5CZATfO7yG6xXHF6IWDVg0kOHs4lwA7BNEiy4q5A4EOK53zIMOGjT+kQ+J6wluG65FvI71e1sHwPWA6wv76Ok8QrhjeeTeQnDCNYfgRBQA9sWY023sGIIoRycTnDmINnT+4BrEdxPH3B3sC0Q+OqfQmYfvLzoPIPDdwbagcCNEAxw8OLKVSYmAWHcP0zU6nehM0Xm7wbwGqxLcI/Hdxz0N1xcELkSZt5EPcJ9HUTP8xmA5CDOIS1yPvlIhIMzxW4HjgOOIeysiirTAxj0a9wgcQ3w2RmfAA/cmiFV8LsKXdZoC7lW4f0Ls4/6N7cC1gU5XXBf4/cB+ICf4aIHtQAcuOozQ2Yftxr0A90Z833CfxjFGpy8euFfgPoqpe8Exb/iTcmQE3ylEn3mrv4Jjjnlwf0B7A/PhXOD3Hvcf/TuH+yD2yxgW72+nuydwDzIWLPUEOuDcC8lp8HuOc4zfFxxXb53ThNRaHISQoPPaa6852rVrpx4dO3Z03HzzzY6srCy/lh03bpxarm/fvo5PPvnE63wlJSWOO++803HKKac4P6tDhw6Obt26OSZMmFBm/nfffVfNU1xc7HztpptucgwbNqzMvD/88INznRdccIFj69atHrdh3bp1ap4VK1a4vP7hhx86TjvtNMcff/zhmDhxoqOwsND5ntVqVdv37bffOvzlnHPOUft5/vnnOwYPHux49dVXHdu3b3cEQr9+/Rzt27d3nH322Wods2fPduzevdvv5ceMGaOO799//+042uhzt3jxYkdNY8qUKWrbly9f7qhpHDx40PHCCy84LrnkEsfJJ5/sOOmkkxy9e/d2TJs2TX3/AmH16tWO4cOHq2sZ94QTTjhB/Y/v8Pvvv+/X+m677Tb1Pdi/f7/jaDN16lR1Hr/55htHTSOUr8GCggLH2LFjHV9++aXDbDZ7nAfbPnr0aI/vpaenOxYsWOD46quvyryHZa644gr1/4EDB9S1+8wzzzh++uknr9uzd+9edbwGDBjgyMjIcFx33XXqdwjbhusW24Lvw549e9Q10bNnT8fHH3/sXH7ZsmXO3w7ca//888+AjofFYlHL4phUhPz8fMecOXMcN954o/p+derUybk9xgfu5V26dFG/Kddcc43H9WA+7CPA8cVvyD///OPYsWOH18fbb7+tltuyZYtazm63u6x38uTJ6jusWbRokbq3YH89/R7ZbDbHO++84+jevbvz+sUxxWd88MEHPrfF1wPnWYN9xHEykpOT4/OehOuoT58+6tgtWbIkgDNESO0gAn+qW+QTQo4A1xg9wtpZ8Af0yuOr7M9wREaQ86Wrmnpapz9hZDUFhFzDhQkkd9gIwmzhLKOYFJz2o5mXj6Gn4NyhmI0eT7wmAHcOzqkOK6/OWgbhAKI3EBIMV1xXiD5awD1HlAZqMNSksXB5DVYOOL34fUDaiR6mSf8mIKoIvznGtAfMDwcb8yBiKRR+P7Dd+qGLjVa04Giw0W66rl7uDfweh8o2E0LKp2Jxn4SQKgOhW4GIa4Af3kDFNUDjx1v4N9YZCo2jYIFQvIqKa4BQQ4RdI9/0aIubmgga38htRoMWYcIU15UHIc4Yagf55ag2TngNVjW4Z2phh98D428CRKF7TQHMjzBmpG2Eyu8HtgPbhbQppECEklDFdpUnrkEobTMhpHz4jSWEED9BTiIENnIfUUyrMjlw4QwcGQhBVOFGVfVgjLNMSkFO+N9//62GYkLurac8acJrkBBCSPXBEHFCCCGEEEIIISQIMEScEEIIIYQQQggJAhTYhBBCCCGEEEJIEKDAJoQQQgghhBBCggAFNiGEEEIIIYQQEgQosAkhhBBCCCGEkCBAgU0IIYQQQgghhAQBCmxCCCGEEEIIISQIUGATQgghhBBCCCFBgAKbEEIIIYQQQggJAhTYhBBCCCGEEEJIEKDAJoQQQgghhBBCggAFNiGEEEIIIYQQEgQosAkhhBBCCCGEkCBAgU0IIYQQQgghhAQBCmxCCCGEEEIIISQIUGATQgghhBBCCCFBgAKbEEIIIYQQQggJAhTYhBBCCCGEEEJIEKDAJoQQQgghhBBCggAFNiGEEEIIIYQQEgQosAkhhBBCCCGEkCBAgU0IIYQQQgghhAQBCmxCCCGEEEIIISQIUGATQgghhBBCCCFBgAKbEEIIIYQQQggJAhTYhBBCCCGEEEJIEKDAJoQQQgghhBBCggAFNiGEEEIIIYQQEgQosAkhhBBCCCGEkCBAgU0IIYQQQgghhAQBCmxCCCGEEEIIISQIUGATQgghhBBCCCFBgAKbEEIIIYQQQggJAhTYhBBCCCGEEEJIEKDAJoQQQgghhBBCggAFNiGEEEIIIYQQEgQosAkhhBBCCCGEkCBAgU0IIYQQQgghhAQBCmxCCCGEEEIIISQIUGATQgghhBBCCCFBgAKbEEIIIYQQQggJAhTYhBBCCCGEEEJIEKDAJoQQQgghhBBCggAFNiGEEEIIIYQQEgQosAkhhBBCCCGEkCBAgU0IIYQQQgghhAQBCmxCCCG1GpvNJjWZjIwMsdvtQVlXUVFRUNZDCCGE1FYosAkhhIQ0EI8//vijPPbYY3Lw4MEy759zzjny2WefBbTOrKwsycnJUf8/+OCD8txzz6n/d+/erQSrP0yYMEGuv/56OZq0b99efv75Z5fXbrrpJpk3b57z+aBBg+TNN9/0uLzZbJZ///1XvT948GD54YcfnO/9/fffctZZZ8kvv/wi1cUdd9whN99881H/3Pfee08d2wMHDkhNpri4WO3Dhg0b1Hdm+fLl8uqrr4rFYqnuTSOEkFpDVHVvACGEkPDlggsukIKCAklMTHQReWlpadK8efMyovfSSy+VF154QT1funSprFixQgk/0K9fP7XssGHDZN26dc7lMjMzZezYsTJ+/Hjna88//7z06NFDCafHH39cEhISpKSkRK644gq1fszfunVreeihhyQ9PV1OPPFE53LNmjVTy4BNmzbJlVde6XMfIcw8AeE+dOhQn8sWFhZKXl6e1KlTx+UY+cs///wjO3bskMsvv1w937Ztm/z0008ybtw4l/k+/vhjeeWVV1SnQm5urpr/qquucu732rVr5c4775SIiAg1BQ6HQznaL774opo3HPjggw9UxEL//v0rtDyOyeLFi1WHDo41ru0WLVpI37595ZZbbpGYmBi/OmYWLlxY5nxnZ2dLcnKymEwml+vj/PPPl6lTp7psw4UXXqiuZ90BhfOG55gf24P1pKSkSIMGDdT1jGu8adOmFdpnQgghgUGBTQghpEp55JFHXAQNxNwNN9wgX331lct8jz76qMtziIMBAwYoEYhlRo8erV6fNWtWGQcbgvmyyy7z+PmnnXaaEjQvvfSSEhoAIhJOL8T65s2b5a677pJdu3bJ77//Ls8++6xz2Xbt2sl///3nInoARCo+7+mnn5aLLrrI5b38/HwleLwJ5q1bt8r//vc/+eabb+TQoUNq3RBJTZo0kXPPPVc5uB06dBB/wH4de+yxsmXLFvWAkIbgx2fgER8fL2eeeaY6Rqeeeqo0bNhQOnXqJLfddpuccsopah3ohIAgx/G47777nOuGIH/33Xfl4osvlnDhww8/VJ00FRXYWBYCGeceHT5xcXHy22+/yeTJk9V1MmnSJL/Wc/rpp8trr73mfI4OJ5z7N954Qzp27Oh8HR1A+EwjuLYg8L/99lvlViOCQXceoDNk5cqVznnvv/9+OeGEEyiuCSHkKEKBTQghpEqBIJk+fbrzOQQDXES4254cbA2cOy0+jEBcQPwZl4Mo1q/BmUZYrDfeeustefnll5Ww7d69uwqrvffee1UYLUQxxFPv3r2VaAcQnccff7yaB2zcuFG5mFgW4hpCFkJLO/LoCICTaAzbBhDRU6ZMkddff105nhBlEP0Iy4bgR1gvHHuEnUMAjxw5Ui23Z88e5Vhq4JS2atVK5s6dKx999JGcfPLJyu0H33//vRx33HHO5xDUENhwM/GwWq1lOjUQEo4OBmxXz549lfBGeDE6AdCZAfeflBIVFSWffvqpcok1vXr1UtfNnDlz5OGHH1YdJeXxxx9/uFz/ug7AkCFDXFxwXNu4ztzBPOhIGTVqlJx33nnSsmXLMvPgGsC1qtMfCCGEHB0osAkhhISkgw3BifBvhEAjtBn5whCPEDlw9jTIze7Tp4906dLF+dr69euVUwvg7MLJg9iAGL3uuuvUQ4vntm3bKkENYQvBCufcyO23366ED1xrbCM+G6IXDjSEEUQV1gsXeObMmcoFf+edd8qIa4SMYxvgGGM/tNuNcF44zdh+PAYOHKgEdnR0tAwfPlyJOYSCA7j5cD7POOMMGTFihBLM2Idu3bqp9yHa4IC7O7T4fP0A2G4si/PwxBNPKBENtx6fhzxodFCgY+Tss8+WqgLnCJ+BcH+IfwhF5L8nJSW5zIe8e3SI4HgjnB6OPfLHjWHr2G90VHTt2lW5wIhKQEg0OkV0iD+Oi84vN4b145wYw7QXLFigOnFwbrA+RCk0btxYvR8ZGekiro1REmDfvn1+CWxEE3hysNFp4svBhluOa9EIrn106KDDCOHjiH7AdwTXD9DnECIcDj4hhJCqhQKbEEJIlQHhCHGkw7oh7JC3GhsbWyb0GOLpkksucRE+yHP966+/1Hso7pWamlrG0X7ggQfU1Pi6MTwbAhrboEPEIbj279/v/EzMC7EDkQJHGuJEixkA0Qs3FyG4EDFwKiFMZ8+erYQp9gciG4IMYbsQeO755TNmzFCCEsIbYhJA7EKoa/GmgVv+1FNPKeGMjgDss94mgG34888/Ze/evWVC170B59zo6mP79TEGEGYQjzgW6GSAm43Q4qoCnScQvHDi4cJCVGOfdu7c6ewYAThf11xzjeqEuOeee6Ru3bry3XffqWWwrcbwfIhHFHBDBwXOCwp84bxAaCMkG9cJ8vQRqaCvGXduvfVW5eKjIwXXCM4bPgvHwxcojgfcO2e8gWtLd4oYQXSCpxxsDfYDx8nocCNiAh1RyKuHQMe1A9ca4hzuOiGEkKOMgxBCCKlirFarIy8vz9GvXz/H008/7Xx9/fr1jv379/tc9pJLLnH07t1brQOsWLHC0adPH6+Pe++917nsu+++67jpppvU/xMnTnQ88sgj6n9sywUXXOD44osvnPNmZWU5zjnnHMeXX37pdVvsdruabtq0yXHaaac5TjnlFMd///3nsNlsXpfZt2+fo1OnTo7ffvvN5fUtW7Y42rVr5/j33389Hq/TTz/dsXz5cpfXMf9PP/3kKC4uduTk5Dg6duzo6NChg5rigfeNz6dNm+ayPPYN8/z666/q+Q8//OAYP36846KLLnJcffXVjjfeeMN5nKuSW2+9VX1mQUGBy+uDBg1yni8wevRox6WXXuooKipymW/EiBHqXGvOP/98x+233+6y7RaLxXH55Zc7Bg8e7HX9xusEx8X93M+cOVO9np6e7nVfcO579eqlHhXl0KFDXq8Fb5+5bNkyx7nnnuuYNGmSo6SkRF0rZ599tnp/79696ntw8803O/74448KbxchhJDA4TBdhBBCqhQU3kI4L9w55APr3Ga4mHAMV61a5XVZhPQiRBzVvBGCDacVrh0ccDjK7g8U6oLrrcH8nkC1cITpnnTSSc4w3Hr16qnPgCMIZ9kI1oPcbR2eW79+fVX5G+HDyOFGwSuEXMMpX716tcuyn3zyiQrb1WHEGjjycGHhsLsDNxkuuHFYMh3ejXx2uJr4fAD3Hc4tHlgG+ej6OVxfIzosGS4nCqxhPxE6DOfz7rvvVkWydNV2f4Fzj/B548M919sIwrBR6RzuvK/8bhzzL774QoXv68gH/cC5Qxi48XPgVOO4aeD6I59eRyL4g66qrtGh5IgW8Ma0adNUHr4uwleV4NhhiDW41fjeIJwdbjxyslEHANEOAJXDUXkc1zbmQSE0fD9w7AghhFQtDBEnhBBSpUAg6eGeILAhZiGCkUeLvGTkPqMaNgQnCn8Zizwh3BoiB2IJhaFQpRkiEuLKUyVo5GojLF2DcGDk+CJHF+8hLB1hv8jLnj9/vsqZRUg0BCc+FyHHCElHZwDCgiE+IfKxXQhXhnjFcEgI30a4LgqqQQQjtBkVt7FtKE4GIQ5xi4rPCMPWFbuNQDwib1jnyrqDYwYBis6Ft99+Wz7//HP1OoQ1BLG/4eGaNWvWOEPCsV/XXnutyjVGZwUKYuEYYHuN41BD2KIzAfnP3j4POcDuAhTnzVMINEC1dohnnYfuDYQ9Q6xDwOLhCaQF+Bp+Cu8hzBqdMjo0PxB0B4B7JW8Nrh2kPyCMHJXaywPXlq+x01E13xOoA4Bwd3TWoFo5wveR6498eXcwPJ07GJoO1xGu3YoMB0cIIcR/KLAJIYRUOciLhbhGwTPk1EIYoaAWRBicVogtiEa8hkJhELsQBBDHcN8gDpFHDDELcY08ZfdCYgAuHdajgbhCZXKIe+RgQ9xBZML1Q3VmXb0ZBaa0IIcYh0MMhx2iDAXSIIrQIYAq3dgP5AzDTYRjjUrd6ESAU4gK03CrsR8Qpsh1xme4i2hsBzoUsK+eQLEv5PWi8BjmRUcACnahIBkKoLk7reUBgQjXHuIfrrsenxvHB84rogwgwuDEayBK8RyC25eYx3nRYzKXNzY40Ovy1rHg7thDXLoPhabBMfYFzqevSIbyQIeDN9DhgVxtnA9ETvhD586d1fXuji5yhk4aY5Ezd2688UY1xbWMY268fiC+cW5xXRk7KdCJg+sY20kIIaTqocAmhBASdCDo0LCHwNEiFoIKbimeI6wYIdcoRAXHGU4hKmND/EKEQ7jCNcbwVVokwXXFAwLbXwcbrrPR4cTnQEgCFIvC58OB1O4wqlpjbGEdxg4Q8q1ddQyXpYtMoZAUthfLGEFF8WXLljkLXqGQFzoKjCB8F+IZlbM9gW1CNWqEQsO91wITAtsduO1GUFUdD/3emDFj1PogstC5ARGmRfAVV1yhOhTgjkK0IcQY2wThjU4IOPQQuL5AmH0g6POhC815A9uC84UwcEQLVARESqAwmnavIe59ha/7Cwqq4Rij0wUdMP6CY6W/D4E42Pp6w/BuhBBCQhsKbEIIIUEHgvTLL790impU64ZowxBHGKbqySefVOG1WsDCFYYwhnOLcGOEBiOUFXm6CB93x18HG6HgepgmT2Ab0RGgQT41clmNOctwfn3hza1FhwG2HfnnqDwOMQ8xixzalStXyqJFi8o4w+iYgPhesmSJEsXG6uHeMIZjY/0ITTd2PqCDAh0SENBGRxbHG66n7pCAKw6HGxEDOCc4b9juQEPRywOuM/LO8dmIbDDuOxxXnVuOfGpU9IarC/fVfXgsOPyexn/WYF24HhDBoPcbnR64JuCOV3S/cG5QjRxh4YG6wshvRwcOIjHgZiMKAs8R9QBw/eO1Nm3aqOcYng2dRJ46YlBN3RgODkcb3xvjazoKgBBCyNGDApsQQkiVANcQjjKGuEK+M8KutXusgeiGQIQzi3xSOHhwgAHyrT0BRxJCAgWsPAHXVQOH2VvxqR9//FGFnkPoaeCqGgUzirBBcHoC+dgII/fUAQC0qMO4zXDl4YpjCkcbwtXo/KKQG8YFX7x4sXL3kXPsKZe2IqCTA4XRgLt7a3T7kdcLhx7bhv2G2DbmwwcThKhDoOIzkBePcHRENCAc3pivDmf9119/VaHqCI+G64/cdJw3RBIgN9zYWYLhvDDMF0Qprit0EmC8cA3SAtDBA3cenREQtzpc3h/weSiEh5SAY445pkxBOxTKM47H7glEPKATCR1E6GhBhwqGd8P1AvGOjqcVK1aoDgDs+yuvvCLvv/++uo6MIKTcU4g41uUeIk4IIeToQYFNCCEk6ECowjGFADn77LOVG4twZ3cQAgwBDnEEsQAxgeJbOsTZE3D7UEUZYboQ7hDUcOoQytyoUSMVBo0wXIgYCEQIIbh7cAc1yKWGyIJYgjOKHF0UKkPhKKPjDdHjzUXWAtoflxmCFZ0HqOJsHPcagheiD0II4vHqq69W+d7oRDA6u3BrMY/xc/0JEdeiEOHmnsA6kbMLNxTzQXRCqOGYVSVw9SGqce7RsQBRjIJ3cPeNBcVQDRsONgrTIQIAwhkOOES4MYwf4PghVx3zQYQjKgLHAdeEBtcN3HysE9ccitIFIrD1NYScdTy8RS144+uvv1bpCOhMAOhEefzxx1UKARxtnH98D3Au0CGF/HeIa+wr1ms893SwCSEkNKHAJoQQEnQggiCo4VIaBaU3kGOMx/r16505156AEwsBhdBhOK3arYbbh+cQTshVhWCD4ELOKvJwe/XqpUK/IajhDkL8w02HiEFnANYHUGBK/x9sEPqsw581EOcIFUehNLivnoAQxX5AXGH73EPSX3311TJDgBlBQTZvQIAi1xkh5nD6j2aFaYRXu4dYQ+C7g+tH5437ApEBiCrwBY4hXHM8jCCk3lNOP46Lrrzuaz5/wZBhw4YNc0ZpYN/QoaKLxKEjBHndOtIAYfKo7o6IBnQu4Drx5mB7gg42IYQcfSIwGHY1fC4hhBASMBAe/jjGcLAhTuCGuoc54zX89CF8WIOQc4h0dwFMagYQ5giFLk9gE0IIIVUNHWxCCCE1Bn/ENYC4Bp5yiD295s09JoQQQggJhOCWBiWEEEIIIYQQQmopDBEnhBBCCCGEEEKCAB1sQgghhBBCCCEkCFBgE0IIIYQQQgghQYACmxBCCDGQl5enxp12B5XHly5dqobNIoQQQgjxBAU2IYQQYmDWrFny/PPPlzkmP/74oxoGKjo6mscrCGRkZMiZZ54pQ4cOVZ0X1c2jjz6qHtgWjB9dHvfff7+cdNJJaoiwgwcP+pz35ZdfVmNfb926NYhbTAghJBRhkTNCCCFhAwQwXObU1NRy5927d68sW7ZMiSTNhg0b5NZbb5X3339fjaVdWFgo7du3V+8NGTJEvv/+e0lISHBZT5cuXWTu3LlB2weIuwEDBqghyVauXFlmDO8ZM2bIhx9+KGlpadK8eXO54YYb5JZbbpGIiAi/1o99W7BggezYsUPq1q0rl156qRKLxjHACwoK5LnnnpPVq1er5+eff76MHj1aEhMTnfOUlJTIJZdcImPHjpWLLroo4P289957ZdOmTeocJCUlOV/Xx9sTr776qtoWYLfb5bXXXpO3335bnctGjRrJVVddJcOHD3fpBDnhhBPUudR89NFH0q5duzLrhrjGOrt27SrvvPOOuo68MWnSJHnrrbdk0aJFqkMGwhnbUr9+fY/zY7133nmn5OTkyJIlS5zDyBFCCAk/OA42IYSQsALixV0E+wNcxnfffVcee+wxadasmdx1111KtD399NPyyy+/yLfffqv+v/baa9X8EG0XX3yxnHrqqUHbdqvVKiNHjpT9+/dLy5Yty7wPMfvFF18osd+mTRtZu3atTJgwQYldOMHlgf2DUL7mmmvknnvukX379inRCrE9f/5853zTp09X4h7CWx8bjBX+yCOPOOd58803pXHjxhUS14gGwH7MmzfPRVxr+vTpI7169SrzOlxg4zbOnj1bdYh07txZtmzZojo64IzjPIH//vtPpk6d6rIOi8XidbvgXl955ZXy+eefy6FDh9T5N4Jzjo6Hjz/+WB0vdAZMnDhRHnzwQbn66qtl5syZ0rFjxzLrNZlM8sQTT8jll18uy5cvVx0ohBBCwhMKbEIIIWHFOeecU0ZUeRKyJ554ostrl112mRKNsbGxSmDBzX7ppZeUiw1hC7cW7jFEEsQmHMz8/Hy56aabgrbtEMtwsCHc8flG4JJ+8MEH8sILL0jfvn3Va3CfY2JilIsKJ9voQntyUV955RXp37+/jB8/3vk63NxBgwbJzz//LN26dVOvQfxef/316gEOHDggn3zyiVNgY78hbqdMmVKh/YQ4Pf3006V79+4e3z/22GOdTrUn4ARjHcOGDVMdBfpYNGzYUJ588kkZPHiwtGrVSoqKiiQ3N9dl2Xr16sltt92mRL4nEB0AnnnmGZfrCMfg4YcflvT0dHXusY0AbjmOA44tzgHE9o033lgmogAdJjj2iB7A1N+IA0IIITULCmxCCCFhxZo1a5RADRQ4j3BF7777biVa4UxCsD7++OPKqYTYgkuMEGSEN7/44otKqLo7sHv27JELL7xQzjjjDFm4cKHfnw9nEw+EJsNVdufrr79WYeMQ+EYQFo35IZDxud74559/lCuL+d07JCBMv/rqK6fAxnwIP9fA0cdrGohbdFAghzpQcHxwjuCKVxSI4+Li4jL70rt3bxk3bpw6VgibR3QBRLYxRBxuN8K53RkzZoyaDx0Y7q42OjaQl49OGHQsuEdIQCzrnGw41Z9++qlan3snDjosENL+22+/qVB0Qggh4QcFNiGEkLAB4d3GMObygGA1AoEJoY1QZAhMiE6I6gYNGqj3J0+erEQSxBtcUIQyBwOI36eeekq5oK1bt/Y4D0Kg4YLCYTcCJxX7sXnzZp8CG8uDtm3blnkPr2F5DXKzjc4vHGM4vwAO++uvv64eFRXHcH29udfGfHOE+3vKV8a+4Di4h9FD+OK8GfcFOc/GsHCIbuyPsbAalkOnCpx5I1gPridEPKBD4Pfff1c5997AelatWqXEOELG4WSjg0aDa6tJkyYql58CmxBCwhMKbEIIITUe5Asbw54DoWnTpspVhOCCwIWYeuCBB2TdunUq3/bLL790hlijIBcKaiH/GQXAzjrrLOnZs6fL+pCXDAczPj7er8+HYEWYM4pgnXfeeV7nQ2hySkpKmdfhnkL8IvfYF1geeFoHXtu2bZvzOcQf3HRUyAb4HyHdAHnG5557rnJn4fgjnF6HaMPdR76xL5DPjg4MT7nXGnyGDj9v0aKFcqaRE6+PqbdjoffFeCywje5gW+GAQ1Dj2CGkPC4uTrKzs13mQ8cKOlgwP47z2WefraIXygPRD1gnOgncwTXz66+/lrsOQgghNRMKbEIIITUehIQjPBcC9bvvvlMhz+Dvv/9WTiLEsrvz6w6c6fXr1ysHGU4w1ocxsbGO7du3q7BoiDCEfaMyNSpNjxo1SglALDtw4EC1HrizEOCBFDXDZ0FA+gJizdsQYXgdhc7KWx7i15MjjOUhODXoYIDg1+HocLgRAq0rr6NY2htvvKFykXWot65EDmffFyjghk4Nb4wYMUJ9Hlx0dD7gfKIYGgqWzZkzJ+BjgY4B43MUq4OD/MMPP6h0AITWA6zb6HxrsY6w8IrgrRo6OmDQyUAIISQ8ocAmhBASVsBF1aHfKFAGIGhQqAwYHVYIXIg3FPqCYESYMPJjEdr7zTffqHxhuKUo8IVhnCC+EQKMMGRUE7/iiiuU4MSQWRUB4cvIbUboOYbGMm4XHHW8BsGI7cLDOI8RhECX14GA5eHCI8/YXWRjeXQeaBB6jeGsdu3apZ4fc8wx6rjhGEB0owMBgrpfv37OUGcUXnvvvffKFdgQzZ06dfL6PkSvEVQTx3HH0Fj//vuv6tzAvnirBo7XIc41OJ/+ALfa2/jXEOFIC/AXRCR4c7pRmdyfcbYJIYTUTCiwCSGEhBUIL3Z3sFFwDMJPu6EAYg3DVeliXsivhXjWjiWEKApWoUI3ClsBOOEYogkFzjAfqm+XJyh9gZBkDJGFkGtPIF8YIhaFtzDGMgS/OxDiyCkub+xvPUZzVlaWM6dcg9fcl4cI15Wydd7zZ599psLfAdxsYyE0/I/X/KG8MHJ3MBQYBDYiCSCwsS/u4dzGffE0znV5oOr47t27fc7jTyQErilfGAuuEUIICT8osAkhhIQVN998s9PBNoYGQxBDpG3atEkJMLjHELaJiYnqfYSHG4tcQWBiXoQNa8cVucMIi8ZrixYtkv/9739qaK2KgvGQkZPrDgT9xo0blbOtxTBcY4h7hEfDwdVAoMO1Pf74431+li5uBqHsLrDxmnt1cneQn44weFQUB9oN1+C5sXCYN5DzHKjjj1B9oM8VjgVC2iGIjYXOUDEcY3vrfcU44Yg00PneWA+GIIMj7ymkG++7rzPYICJCF4wjhBASfgTWhUwIIYSEOMiRhhDFAwJVg+rNcJwR2oz8aYRAY8xi4zjTRsdWCznk/kI4onAVcnchJCFmUfXbk7iG2MW6IPTKA2IVOcLuDzi0cErxv64qjmJqWLd2kDUYQgrFv4xDZkEoYhuMocgoSgZhjfndq3pD8PoadxrOLXKWjXni2HaIew2KpGnx7QucB4wp7QndWeAOxidHhW44+gDFxtDJ4L4vOOcQ/cZicegoQZg4Qv59ARGOjhQ9H4qb6cJwwQTXBY4BIYSQ8IQONiGEkBoPBCXcZoCK4BhiCuHUEJlGkBeLobeQj/3QQw+5uL5wOxFObgTjLEPsIvcZzjGKmiEnun///mpeT4Ly4MGDKm840HGwywPbimraEPbapcU2Y7isYcOGqQJjxqrqGLLMmAsMoYkCYgh7h8MP9x4FxzCGNoYng2j1Bpz/W2+91RlmDpB/PnfuXOUGowMC+dcojFYeEMkIsYfb7F5pHZ0e77//vhr+DI4yjjscZ4hejG+dnJys5oMDfPvtt6vwfawHY1vDhUehMoTUu3eUuKPz2yHG0WGBzgHsD44vrh8UrUPevvGYBgN8Ljo0gjW8GyGEkNCDApsQQkiNB6LotddeU2MUwwWF6wvBBDcU4xhD2MB9njFjhhpuaciQISpXG2HYCCE+7bTTlMhECDjcWg2EtGbMmDFKYH/99deyePFiJUwxljOGYzpaYxpj2LBp06ap/cVQVBD4cOEhNv0B+4r8Z4hyCFkUA0PovNHJdwfO9YYNG9SxM4L9xjZA5OpjhQiB8kBIPEL3sV73cbuRa43OA4henE/tvCNk3n04tPvuu08J4KVLl6r9gTuPTgD3Imk49zjX2hlH7jauDYSbI5/7p59+Up+BHHTkTyNHHwXNUPTNWPgN4PrwB29jfOPagivuKS2AEEJIeBDh8CdhihBCCKmB6CJnCAmH83vdddcpIQgHF7m2CxYsUIJOFzEDuoo4xLcv4I5D2EGcw+kmgeXJI+TbeNyrAjj8cKMRraBBHjmaPsZK40bgXMPph5v9+OOPu1QR96fIGeZDNICnYdcefvhh+euvv1SxuEALvRFCCKkZUGATQggh5KiCkG/kOKPQnM6rrgow3BnSBzCedXWDEPYrr7xShehD9BNCCAlPQlZgz58/X9asWeMMEfP3B3vKlCmquivys+BSIPdMV5MlhBBCSGiAUG7kgCPc3j0UO9xAeDrC15HHj/B+93HICSGEhA8hF5+EYTcQioWhTwIBw6vgx7pHjx4qFBBhXe+++65LBVlCCCGEhAZPP/20Cs9Hbnu488wzz6h0BVSdp7gmhJDwJuQcbFQN1aAIiL8ONoZdQSVRFJ3RoEjKo48+qgqpBLsSKCGEEEIIIYQQEtIONobowMO9smh5wPXGkCNG4GajUukff/wR5K0khBBCCCGEEEJcCbnk5Hbt2qkpxrosLCz0a5n8/Hw1VEiLFi1cXodrjVzsXbt2Vcm2EkIIIYQQQgghIetgV4SCggI1xZAf7mCcSwjwimCx2SUjz1zp7SOEkGBjt9tVWgymhBBCCCEkNAg5BzuU2JdZIk8v2yIvXXdcdW8KqQSRkSZJTo6X3NwisdkoRsKR2niOUT7DZrNJUZFNIiIipDZQG89zbYPnOPzhOQ5/eI7Dn9p4jpOT49V+1xqBDZcaeAoph7tdmQJnxWa7WK2148IJd3AD4LkMb2rfOTaJzYY6lSFVq7LKqX3nufbBcxz+8ByHPzzH4Q/PcRiHiENAp6amyt69e11eR2h4dna2tGzZssLrLrawEUcICT1ycrJlxYoP1ZQQQgghhIQGNVJg5+TkyIEDB1R4pKZbt26yZs0al/m+++47iY6OltNOO63Cn1VCgU0ICUlKQ8Rrm3tNCCGEEBLKhFyIeG5urppaLBbVeNTPUVVc8/zzz8v7778vq1atclYOHzRokFx//fXyyiuvyGWXXSa7d++WZ599Vr1WmRDxEqtd7HaHmEy1I8eREFIzqFs3RXr37lfdm0EIIYS4gOKbxcXFYjaXHE5jIuGG3R4hxcWRYXmOIyOjxGQyhZfA7tq1q8fnGzdu9LncySefLNOnT5cpU6bIvHnz1PBcV111lYwcObJS22O2OdQjjgKbEEIIIYQQr5SUFEl2dpoqvslRLsKb9HRTmJ7jCElJaSixsfEVX4MDpWiJR3amFckNU9bJG0PbSXJ8yPVFED+JijJJSkqiZGUVsDBSmFIbz3Fa2kFZuvRNGTjwRmnYsLHUBmrjea5t8ByHPzzH4QvE1qFDeyQmJk4ZXYZMThKGREZGhJ177XA4JD8/R8zmYmnUqIWLk52amli7qohXJdrBJoSQUKJOnWTp2fNiNSWEEEKqG5vNquqC1KlTV4lsdoSGf2dZOJ7jOnXqSmYmhh+ziskUU6F1UGCXg9XuEIuVApsQElrEx8fLCSecVN2bQQghhLiA8HBCavP1WyOriB9NrHCww7B3hhBSs0EBma1bN6spIYQQQkgglJSUqDbEhg3/8sAFGTrY5WCzO6TQzCQSQkhokZeXI59//pHKwY6Li6vuzSGEEEJCjokTn5N//lnvHFFo48YN0r59B/W/1WqVqKgomT59jvzxx2/y0UfLJTMzU/r1GyCFhYXy6acfHV7mP2nfvqP6v0eP8+Waa66XG24YIKmp9dWIRxMnTlGfc++9D8jzzz8tTz31nDz77Dh5/vmX1DIPPHCP2GxHzLo9e3ap7alXL9X5GkZFevjh0eXuT3p6mowf/6TLa//++7d06HCCmEyRztd69rxA+vW72ue63nlniXTufIosWbJQnn76BTW0cUX4/fdf5fPPP5XRo123qzZDge2HwC4ooYNNCAkt6tdvKIMGDZOYmNjq3hRCCCEkZDn33B7SuvWx6v85c2ZKnz791fC7+fn58uWXn6vX27XrIKNGjZF77hkqPXteKAcOHJCMjAz13u7du6Rbt7OdAhtAXEOYDxt2h+zevVN27twhb721SOx2m8yaNVXq168v27ZtkeOOayv33fewtGzZSoUeFxUVyUMPjVCiPCEhQa3r33/XS4MGDb1uPxzm558fL5MnT1OOc6NGjWTMmHHO91eu/ExtsxbI6CxYs+Yb9f8rr0yUf//9x+N6u3fvKRkZ6fLgg49WaliqN95YoI7R0KG3ubzeseMJcv/9o2TDhv9UB8SUKbMqNXRyTYICuxzQ4WQ5HCYeE8WIekJIaIAfw7i4ig8hQQghhNQGUNFcj7YBx7phw4bK7TVGf7kLv+TkJOna9Qz1/6effuj8H6+DvLxcmTx5wuHX6iohuWDBbLn44ktlxYpPZOjQuyUxsXSdq1Z9oVzre+99UIYPv0MeeOARWb9+nRLgEOwTJjyjBLcn4LLDFR8/foLUr99APb/44stk1Kj7nPOsXfun+syoqFIH+4QTOsktt9yu/oe4r0o+/PB9iY2Nlffe+8Tl9c8++0QJfdChQ0e57robZerUSbXG5abA9qfIma30EcOjRQgJEXJzc+Tnn7+Xbt3OUT/uhBBCCHElKSlZPv98hXz99VeSl5cnBQX5Mn/+bOewYnCiwRdfrJDFixfKzp3blcPcsuUxsnnzRvUehO306a+o/1u1OkY53VjviBEPyr333ilz5sxQbvemTRtVyPiWLZtk7tyZKqz83nvvl9tvH6Kc8sTERBk48HolPnft2ikvvviKrFu3VoVnN2rkebhNuNOnntpVfa7uIDj11NOlY8cTnfMMGzZIRo0a7RT0cLKPRurYL7/8rMLMX3ppapn3/v77L+nW7Sznc3QKvPXWm7J//z5p2rSZhDuUjH6EiGuBTQghoQIaBmgoYEoIIYSEGp//nSXTV+2rklTLxFiT3HNRM7m0U4rP+e666x758cfvVSg0HFWI4x07tsnatX/Iddfd5Jzvkksul5SUFBkz5hHlMGdlZUlJSbF07tzFOQ+W6dOnn/M5xC7A/M8995TMn79QmjVrLgcO7Fch0Vdffa1z3tNOO0O+++4blRe9YsXHMmTIXer56aefofK9vfHtt1/LTTe5hl7/+ON3smzZO87nBw8ekGeeeVIiI0u3p3HjxsopxvrnzSvtTNBkZmaoUPWUlFSXEPrBg++SQPj44+Xy/vvL5KWXpsiiRf9TIeI4hhDSxcXF8uuvP8vdd490WeaCCy6S77//Vq6++joJdyiw/agijkHHWUmcEBJK1KuXIn37XlPdm0EIIYR4ZMGag7ItraTKjs7/1hwsV2ADuL2zZ89QAvqXX35SbvUjjzwuS5YskmOOaS1nn32u6qyG092kSRPlcCN0+6efflBOs2bfvr1KQILIyEiVdw2N8PLLE9XyCNvGc+RTQ5wjtBvu7vLl78q3366WAQOukXnzXpXk5GTZs2ePvP76fGncuInMmjVNbrttsPTo0bPMtiO0vHXr1mVyp/HQ3HzzNfL885MkKak0fF1z7rnnqYeRmTOnqu1DobYyx/N/c+Wbb1b7PJaDB9+p1mm1Itd8nhrv/KGHHpOsrEz54IP3ZNCgG1X7BJ0LCQmJLsviWEN41wYosMsBxrVdCWw62IQQQgghhPjDoB6NZfqXVedg397dc1i1Bo41KmQjbBsCeO/evbJs2dtyzjk95MUXn1WFzhC6Xfrebrnooktl+/Zt8thjT8iff/4ubdq0lfPPv8i5vlWrVrrkbEMwwg0eN+5Z9RqE8mmndZUzzjhT7rjjZpk69VX1OgqcvfLKTLVuOMhwxRGaDudbxKHmW736S7/GZUbY+pQpk5zPIeSx3ltvvU6555oTTjhRhg93dZDB1q1b5OSTT/H4OQhlx8Mf+vYdIFFRJrEeHsoYjjg6CbCt69b9JQMGHHHvNeh8wKM2QIHtJ0VmhmESQkKH9PRD8t57b0n//tdJgwaNqntzCCGEEBfgLvvjMFcVEJIYkgtDZP311x/K9e3Xr5c899xE+frrVarCN9xcpFuhEBf+nzt3ljP0G2IUVb+NDrYeKksXTXMX9DfffLsS9HC49TJvvvm6emj27NktdeokqeJrRq68sm+ZdTZv3kJ27dqltg8cf3x7Vb0cFBYWyBNPPCb33/+wct9RSMzdsTYCdxoVz7t27SbBZu/ePTJzJiqjJ6rhyfT+G9mxY4fan9oABbYfRIhJCjgWNiEkhEhIqCNnnnmumhJCCCHEFQzDhbGtkfd71VX9Xd6D2/vCC+PlmGOOleuvv1FatXINwz7xxJNUvjXmQ27xe+8tFavVIp06nazGfcYQVEY3FuHmKOoFZxth5XrYLSyvBbEG1ce7dDnNxR33BvKjv/rqC6fABjk52bJ69Sq1b6gWft55F8jFF18uL7/8orz33jLlLkNEx8fHK7H/11+oMv6xbNq0QVUrR9XvYADn/+2333SGfd9wwy2qAJs3Vq9eKU899bzUBiiw/QCRGcUWuyp4Fmk6EqZBCCHVBcbPPPnkU3kCCCGEEA/ArUUY9w033FzGUcW41zNnzlNiuaCgwOU9iFIUKUMotxbBENsQtMjljomJkd69r5I777xdjjuujco9hoP7wAOjlAP+xRefyZ13Dg/KObn00itk8OCbpV+/gar6NsLBkSMOMT9z5lyJjS2tFo687ieffEa57qhSnpZ2UIVpI4QcOedw7xH6Xpnxrt3BuuBII7QeldZ9sWLFx3LsscepcPnaQISjtgTDV4CdaUXSdcwv8soNx0p8dKScfmwdiYsO/MKEOI8yRUhUJMV5dYAckZSURMnKKnDmipDwojaeY7O5RFUqbdKkqcTEBKc3OtSpjee5tsFzHP7wHIcvFotZMjL2S/36TSU+Pi5s79PGEHBgsVjU0FjAbDYr4anDzIPBf//9I5MnvyiTJk0NqWE5jTnYvli3bq1MmjRBpk2brToCatJ1HB0d43w9NTVRIiP904HB68YIYyCLrTZ7hSqJI3f7330FkpZnqZJtI4TUThAi9vHH76kpIYQQQo4O7m64FtcA7nYwxbWugj537ushJa4DzYV//fUlNUJcBwuGiPuB3YFq4g4xBzgWNob42pZWJPuyLJIcx0NNCAkeqakN5JZbhkh8fAIPKyGEEEJIiEDV56dQjjSZAhqqC5H3uzKKZV+2WZLiIiWv2FaZ80QIIWV60FGFlBBCCCGEhA4MEfcDy2Hn2mzxXyQfzLXIjowSSU2MlvgYk8rDrkiIOSGEeCIvL1e+/nqlmhJCCCGEkNCAAtsPrHaHREdGSEGJfwI5u9AqWw4VS1yUSRVFi4mKkBKrQz0IISQYWK1WSUs7pKaEEEIIISQ0YIi4nyHiENhFFrsK/Y7AuF0+ipptPVikquo1TC6tPBcdaRKrzaJcbISLE0JIZUlJSZWBA2/kgSSEEEIICSEosP10sDHMFkLF8YAj7auoWVahVRrXPVLWXVNiYYg4IYQQQgipHSA90lYFzV+MlhQTFTqBuLm5ubJmzddyxRV9qntTQgq73a4ef//9l3TpcprUFiiw/QCiOuqwg10qsD3PtyezRPZnm6VhUoyY3FzuqEiT5Jew0BkhJDikp6fJhx8ukz59rpYGDRrysBJCCAk5cb1+T4EUmIOvsBNjTNKpRWLIiOxff/1JduzYLvPnz5Z16/4q8/7dd4+Q445rKxs2/CcFBfkyb94sGTnyYUlMTJSFC/8nGRkZ8s8/6+TEE09W8z/55Hj58svP5cMPl0v9+g28fm7Dhg3l8cefUp/79derpG7depKVlSn9+w+UY49tI+PHPyHNm7cQm80qkZFRMn36HL/258knR0t29pFhQHfv3qmGCcP6Na1atZQHH3zM53r+/Xe9/Pnn75KZmSmpqfXlmGNaS0XIz8+XESPuUsOVuQ+TFopQYAcQIg5xjUriibFl50H49/4cVAyPUmLcnZjICMkvtpUbYk4IIf6QkJAgnTufpqaEEEJIqAHnGuI6JtKk2tHBAu1xrNcfZ3zFio/lvfeWqrZ3UlKyPPDAKCU4wdVXX6nGZo6KKh3HOi4uTqZOfVVKSopl7NhHlcCsV6+ejB//gsTGxqnXR4wYJlOmzFLzun9Ov34D1ZjP11xzQ5ntMJkilMjdtWuHFBUVSlFRsfofonPQoKGyfftWcTjsMmTIMCW68Tq44YabpVevK8usb9u2rfLLLz/Kddfd5HxtyJDh0qNHT/n8808lPz9Pvdaz54UycuSDal8ef3yU1+OUl5cn9957p9x//yjp3PkUOXTooMyaNd/5/tq1f0ijRo2lWbPmztduv710Pz/99CNZvvxdj+s97rg20qnTSdK379USibCDCrJ06RLZt2+PDBt2h8vrWOesWQskNzdHHnxwhDz44KPSoUNHqW4osP38IuOL6RAIbLvXwmYFJTZp4iE0HOhCZxDosdEU2ISQypGQkCinnXYGDyMhhJCQBuI6NjqYTrNdzH4Eha5f/7e8++47Mm3abImPj5effvpBxo0bLXPnvuGc54UXJivhaGT16lXK/R027F6ZNWuaen7ZZVfIkiWLpG/fAWXE9e7du2TTpo1is9nkvvuGe9wWDKs5ZcpM+fXXn+XAgX0qCg3CFOJ5xYqP1OddcMFFysVes+abMk7z5MkT5MILL1XiF8VNJ058Tu6+e6TLPHPnzpR33lnsdLABXO3Nmzc6HWxvTJs2Wa699ga1fvDkk8/KqFH3Od/fvn2bcq9TU1PVc/w/YcJk9T/2wVMnQLDYtm2L6sBYuvQjSUo6MjzpwYMH5J577lT/w10fN+5ZGTNmlMyb94ZERVWvxKXA9jMHG0RIqYvtDlzpQ7kWVczMmzuNEJa8YosUW+1BvskQQmojFotZ/UAjPDw62nPHHiGEEFJbQd5v167dlLgGZ555tkyf/oocOHBAmjRp4nW5tLQ0p8uNKZ6np6fLb7/9osS6O6+9NleJdLjHW7dulrVr/ywzz6hRo9UUodIvvjhFxo8fKwMHXi/r1q31a18GD75LXnzxWRWKDne6e/ee0qlTaTi5BjnOxx/fXg4c2K+2B479ueeeJ+3atVeu+bfffu1x3fv27ZUtWzbL6NFPOl/D8Rk7drzz+cyZU6VLl1PlrLPOdTrydesmq6LOVcmhQweVaB41aoyLuNbnt1u3M53Pca5OPfU0FVqPDpHqhALbzxBxYIoorRLuTl6xTbIKrJIc7z0nIBKhIXZHaaGz0u85IYRUmOzsLHn//bdVJfGGDV173wkhhJDaTtu2x8uMGVPk2mtvVKHeWVlZytlMTz+kBGREhEnGjHlYbDa7tG59rAwdOlyaNGmqhNratb+rdWzZskkJ1zlzZsgdd9wpc+bMdHZuI5x7/fp1qsBZXl6umh9O7nnnnV9mW3StFLO5WH7//Re1LcjH1px0Umdp3LiJFBYWKAfbHTi048dPkLvvHqIc8zfeeKvMPKef3k3OOuscuf/+u+Wvv46I/CFD7hK73eFVYH/33bfKPTeyf/8+eeGFZ1xysJFP/cknHzlfe/75F6WwsEgeesjVSS8qKlT7Zwwnb9Cggbz00lQJBEQgTJgwXh544BHl+g8Zcquce24P6dOnnxpJBWHpOGdGLrroUnnzzdcpsGuSwIZDXeAhJgXi2mKzS8zhHA5voPCZJ4FOCCGBkpJSX66//jbVQ00IIYQQV+Be9+t3tTzyyP1KWENEI1c3MbGOen/x4mUSHR2tqlxDrD311BiVzwsnGk7x0KG3SZs2xyvhW1xcrPKULRaLjBkzTjnhEKYoQDZ27NNK/AGIX4hTTwI7NjZWBg26U7777hvVSY6CX3gsWDBbXn11unofYeaeinjhcydMeEblM998820qFH306HHSvn0Hl/mwL0CHmI8cOVwt6ys8fM+eXXLGGUecYNC0aTMV0m4MUYeAx7HRREWZJCGhjrz22mKXZX/88Xv58MP35fnnXyrzWT/++J3Mnn1kvZ6AiIZjn5GRJhMmvOwU6hdffJmsWrVSHnzwXmnQoJFytJHzbgTHE+eguqGD7QeWwyHiyCFBMTM40XCk1Xs2hxzMNUtibPkV7aIOFzojhJDKgsYCenAJIYQQ4pmrruqvHgBO8/ffr5FWrY5RzyGugclkkiuuuFKJXP37+sgjjzvX8cAD98hDDz2mxJ1eFtOdO3e4CE4A9xSC1h0UJL3wwkukc+cuMnv2DFUV+4cf1qiwdfDkk89IixYtlYh/7LEHXZZFFW446P37X6NEJmjRopUqZuYusLXrfs89Qw//v9nPS8M1xVUvr4FTv2LFJy6fFxMTI5Mnlx4zI1u3bnZxr40gxFyHmZfHeedd4PIcheYQIYAoA3Q2zJgxr8wyDkdp6m51Q4HtB9rBVkN1mUsLlcXHlF6IOUVWySuySaPk8nMgkYedb7a5CHRCCKkIyMH666/fVSVxFE8hhBBCQpHS+kXBi+D0VA+pPAoLC+XFF59R7i8cYoR5FxUVScuWrdT7K1d+Lqec0qXMct9885W0bdtOCUaEOWMoLrBnz25VIdsdrHfhwndcXoMQPnjwoPp/2rSXVaE0fB5yqFeu/Exatz5OFS2DyLXbbSqP2j3X+JlnXnQZrgvbDZfXE9heo4NdHgiJd3d99fIQq/PmvSotWx4jxcVFqmPhllsGqWMIB9s9B3vv3j2q4vfkyTMk2KBTAh0YCH+fMuVVdT7cwfnR+fPVCQV2AF9kONi5NoyFbZd4KS1UlpZrVon+eJQHhurCsAIlVrskxIT+GG6EkNDFbDbLrl07pWPHk6p7UwghhJAyYFQmjFeNtq8/Vb8DAev1Z9SncePGKPEIQdinT1/p3buveh25zuPHP6ncZjixcEUffXSsy7J4D5XDJ00qzR0+//yL1FBXCAdHTvcdd7i6vADF0NxFbWZmulx++ZXyzTerpVGjRqrwGAR2795XqZBwDCOG8HUMkYWhppDzrVm8eKES1r///pvXfXzhhUnO/+HG5+RkO7cBueFw5BE67q0Q89lnd1fjZV9//ZEhv0pKSlRRtyVLFqrteeihR9Xrixa9pkLnr7yyr5x//vlSt26qc9iwr75aqap9P/zwaGnTpq0ECxw3dHRAvONz0bHgbSxsFDhDiHl1Q4EdQBVxuM5IbTAfFtyFZptk5NukTpx/Yjk6KkLMhSh05pAEFv0lhFQCjJF5/fWlOV+EEEJIqIHIzU4tEv0arzpQIK6x/vLA0E2eaNWqtcyd+7rPZRFC/uqrC5zPMTxXeYW62rXr4JK7rB3sjIwM6d79PDGZzldjUhtzm+G43nPP/er5k0+OV/ndusq5t3GwfW2zu4OOXPHFi99QBdA8ATe8ZcuWKgT+wgsvVsOAoco59mXcuOdcnOJbb71DiVwUO5s/f64qQKb3EXnb+OyEhAQJJujMwOciv9oXMB1+++3nMsOXVQcRjlAIVA9RdqYVSdcxv0ivk1PktnNLq/QeyDFLx2YJ0qxejOzLKpF/9hVKs3qxfq8Ty5/QLEGa1qPCPloghCUlJVGysgqqfDgBUj3wHNcOeJ7DH57j8IfnOLyHj8zI2C/16zeV+Pg4trlqEMhPR/VxuM8dOnT0axlPIeLVRWZmhjzwwL3yyCNjpGPHE4N2HRuHQU1NTZRIf8Im6GAHloOtMVtsqtw9xHJ8dGCh3gjOKAp2nAwhpNaRkZEun366XHr16uuSl0UIIYQQEgjJyckyf/7CGh3V95pbNfPqxD8ZXsvRIeI6D7ugxC65xTbJKbJJkp/h4RqEs2BZQgipDAhVa9euo5oSQgghhJDQgDnYAVYrhMAutNglPc+iSsGjsnggxESVjoWNdWJdhBBSETCOZ7dunvOpCCGEEEJI9UAHO8AQcQhqi9UhaXkWv8a+9iSwMcxXiSU0chYIITUTVDdNSzvocbxNQgghhBBSPVBg+4HFLUQcIeMIE0+IDfzwRZmwvF2KQ6QoACGkZpKdnSlLl76ppoQQQgghJDSgwPYDm9HBNiHE26aEtsnLeHK+wBh0CC2ng00IqQz16qXKwIE3qikhhBBCggsHWgoNfv31Z8nNzZGaBHOwA8zBhkBOSYyWuOiK901gPO38EjrYhJCKg7EuGzYsHT6QEEIIIZ558snHZPDgYWq8Z8099wyVMWPGqbGbNXv27JapUyfJiy++IrNnz5C//vpT4uMT5L///pG+fQeo5bt37yl16tQp91D/8cdv8txzT0lMTIxcf/3NAk+uTp0k2b17lzRr1lwKCgokPj5eLr74Mvntt19k4cLXXJb/+++/5KSTOru81r//1XLeeReE3GkeMKC3y3F0JycnW3r2vFDuuOPOMu99+ulHsn//Po/vaV55ZaLMnfuGDBzYRxo3Lh0f3Mjo0U+qY2oE63z22XEyffocqQ4osAOsIg4qknvtXkk8v8iqesYg2AkhJFAKCvJl/fq/pFOnzqrgGSGEEEJcMZvN8uuvv0hGRoZ6fvLJp8jQocPLHKadO3fIn3/+JpmZmbJ16xY1lnLr1seK3W6X7du3yjHHtFbz/fzzD3LhhZd4PMzLlr0lf/75uzz11PPq+eWXlwpPm80mVqtN3nzzdYmLi5fTTusq33zzlVx99XVSXFwsp59+hjRq1EhatSr9jG+//Vrat28vw4ePdK57zZqv5eyzu7t8Xnp6mgwZcqvcddc9cumlvdRr6AyYOnWyWK1WSUhIlFGjRkvz5i08bu+PP34nCxbMVf83aNBAHnlkrNSrV09KSopl7NhHJTs7Wz0fP/4FiY2NU6+PGDFMpkyZ5TKCSb16KS5CduzYR2XIkGHSqtUxzv3ZvHmj+v/aa/tKw4aNXLYDegjHzTim9eLF76r/169fp7Y/ISFBTCaTV8H81FOPy759e5X5oMG5Q0eK8RzPnfu6en3MmIfl+ecnSZMmTaUqoMAO0MEOBih0Vmx1qGJnsdEU2ISQwMGP8qZN/0nbtu0psAkhhIQkhWbvQ9NGRkRIrCEi1Ne8SMusSPToDz+skauvvlYGDRqqROr3369Rrqmn39S8vDxVOLSoqEgSExMlMjJSHA67MsPgPqttjvRsssGZ/uij5cppjYoqlVc//fS9JCTUkYsuukTatj1eBg26U157bZ5kZWUqR7dFi1ZqfYWFBTJ+/JNy6613SF5ernzwwXsydeqrMnHic3LTTbfJd999Kxs2/Kvccw3ELkQlhLGxMwHidvLk6UrcwkV/4onHPI5vnZ6eLpMnT5TZsxeoMaRXrPhYJk58Vp59dqKsXr1Kjj22jQwbdq/MmjVNPb/ssitkyZJFysn3NDzoL7/8JG+++Yb6f+vWzcq9hygHAwZc45yvbt165brKt912g/P/5cvflSuuuErKw263ybhxz/p00h977EEl5uF2P/DAI/L880+rzoKqgALbFxFlq4gHg5hIk+QXW1ShM+ONhRBC/KV+/QZy882DecAIIYSELF2f+svrez3aJcusW9seef7c31LkZZSdrsfWkdcGtwv4899+e7E89dRz6v/9+/cr4Zmfn6dCsI20b99BiWq83qnTSTJnzkxZt26tM8R5yZJSkXrZZaVOsTsLF/5P7rjjLhUSrunW7WzlkG7atEE+//xTJZ4RGo7PgDuM3OJbbx0kXbueKZMmTZN16/6UCy64WL74YoXMm/eqcr5LHXCrPPbYE871QiRCwF5zzfXKHdb8++96tX/aOT711NMlNzdXOd0NGjR02d5ff/1JunY9Q4lrgFD1KVNeUu5uWlqa0/XGFM8hyBHKPm3abI/7f8YZZ6qHFrJ33XWv0/U3biPE/08//SCLFpWGxGO9EMeNGpWmvN1++xB57bXF6v8DB/bLV1+tlNtuK23rYNtuvPFqdVywP3oUldmz/yePPPK4FBYWOh1rdEDs3btXjjuujXp+7rk9lGOtQfg9HH6kAXTu3EWCDQW2D7S3HGyBjaG+7LrQWXxQV00IIYQQQkitB2HYELzIxR0x4kEl7AYPvlNOOKGTcmXhYI4d+7QzZBmCDaIOodwIC3/iifFKgN5++w1KWH7//bfy77//lDmuOsR51KgxLq/D+UZY8/HHt5dzzukhq1Z9IQ899JjapnfffUflCXfpcrqaNzk5WQk+vHbPPffL+PFPyIgRDyhxjuUhKrUzPn/+bBW9BkfbKF4PHTqkOt+NwOE+dOhgGYGdluY6L9aNfHN0JkBUr11bGrK9Zcsm6dLlNJkzZ4bKk0bHgxbsw4bd7bJOiH6EaW/fvlWeeeYJ5WDfcMMtLvMgf/2UU04Vq9Ui5557nixfvkwKC4vkhhtuLnNcFyyYoyL0sP0tWrRUx3PkyIdUVMJ99z2sOig+++xjNS+OHR5w2C+66FIVDj5jxisqn94bmA/HjwI7RHKwg0WxpWrWSwgJf5Cj9PnnH8ull/Z29kATQgghocSvT7oW6nIPETfy7eiTvM5bkZF7du3aKRMmvKx+LxFOjdolENfqsyMjpXfvq+Shh0aoEGSEbcNlTk6uq/KZkfuLPN2YmFgleu+9905VyRqi0J2cnBxJSkpyCmCAHGg8MjLSVfE0hKAfOnRArrzyYmnT5nglvLVYHjDgWpk1a6raJjjJcK979rxAvvvuG9m+fZtceOHFMm/eLBk//kX55591cvDgAVWgraro0aOncriHDr1NbSsKixlD6PHZ06e/ImvWfCPnnHPkeCB33RiOvnz5MrX/CAs3gmONcHp9LD/88H35+ecf1f+xsbHy4osvKzcex/ucc7o73WvtPKMAHTo14Kh363ZOmUgCCGeAdYwceSTf/sEHH3G6+wAOO855VUAH2wcRhz3sYOdgqwOPSuLFVlxKQV83IST8QQ84fiiM4WiEEEJIKJEQE1kl8/rDzTffrqbIuYULjNBvIxBrr776PyXEkCN9xRV9VBVx7fYiH1k72MgbRv72P//87eXTXDsAIEaxzpKSElUE7Mor+6rXBw26UWbOnKfcbAhlOLwQocgTR2G1L774TG0H3oPYhkt74YWXSsuWx6jXtmzZLNu2bVXiF+zbt0eFssN5xj5iXUYQgq3Dr43AtTeGyaMzoKioUIlhiH+EXGseeOAe5byvWrXSKVAxhUtsFNjIV0fetzEvvXXr48QdFJzDMdH06dOvjIPdpk1bFV0wbdrL6vnevXvUeUTldRSqW7bsbeVkDx58l3MZiHDj0GroTPHlYJfOWzVmJwW2PznYVeBgo9BZfolN7HaHmEwsdEYICQwUXDnnnCMFTwghhBDiuVr2wYP75aGHHi3zHgQbqnprUazp1u0seeGF8cqxLQ3bHqoqWUMMulO3bl3ltkKkahd7797dcuaZZytBrIGQP/bYUsEJRxgh2QBhyhDcRuCgIz9YFxAr3aazVZi2cUgrhL+jCjlcd4j5HTu2K8ccIdVr1/4hSUl1nB0GBw4cUAXKUBkc+4wK4llZWZKSkiIrV34mp57a1emsG8Ps27Ztp8Qtws2xfoDPOP74I/nzAEXRIPQ1nTqdLB06nCCbN28SI3/88asKJcfx8gbCy2MNHiTcaoSqg9tuu0P6979ChYsbq4aj8wP7g/B3f9i5c7s0a+a5wnplocD2gZa9VeFgY6iuIrNdSqwOiY+hwCaEBAZ+mFAwJSkp2SUsjRBCCCHiFKevv75AJk6cUu4hMbqfffterR74rdUOtjeQG9y58ykqrPqss851ClBU4tbiEuJ35sypqnq1fv/EE0vD1fv1u1o9jPTpc2nAYzgjvBoF3Z555kmVs43Og6effsH5PvKiIVIh0OFqjxhxv4waNVIiIkxKZD/66FiX9aFzAZXDJ02aqp6ff/5F8vjjo9TQYBDpQ4eWuscQ1cZQbFfek+zsLBV2DiCAURX90ksvl/vuG66ccFRTLw+EcmPf4NBPmPCM3HLLIFVhHJ0bGBsc7vVrr81XIv/RRx+U7t3LhvK78+WXn6uh0qoCtsr8INhFzrSDnVMEgW2X+BhWEieEBEZWVoYsXfqmDBx4ozRsWDb8ixBCCKnNYOxlCDMIRBTL8gXynV99dboSaxXhllvukKefHqsqgsMFjoyMUutcvPgNue++h9TwWQgHR1VxuOEo3OVeAKwiuOdil4a9L/A4r7tgR5E049Bf7sAdNq4L7vdLL5WKbRAVZRKr1a7CyqdMmel1Pd8eHgcbnRVPP/24cp7RudCpU2d5++03ZeXKFcrBR4cAjltsbIzKnUfHBYAjjfOCiugLFsxWQ67BGb/qqgEybdpkFca/evWXSlT36nWlij5YvHihCkUfNOgmtd3R0UincxzOw26titIhYgHuf1UQ4TB21xAX9mYWS5dHf1ZO9lvD2jtPdLA4kFMiJzZPlCZ1mUNZleAGkJKSKFlZBepGQMKP2niOLRazs5Jn6Q9H+FMbz3Ntg+c4/OE5Du/fpYyM/VK/flOJj48Lm/s03GBv418bWbr0Ldm48T8ZPfpJ5YYbl4EbrMOZMc42RF+wdcXRRgvsQMjPz1eVxN3B8cI43nCicVw8jbVdkfUCrBfnEJ8BEb97904ZPXqUTJz4isdxs43XsbF9lZqKsdH9M0XpYPsBeiCQhh0ZEfwiakVmW3BXSgipFeCm37Rp8+reDEIIISSs8Udcg4EDvYcbG3OFIfJqK3W8iGCIaoS4B3u9wL0YLBzsRYvekaqEsck+iKjiMPHoqAjJLQqP3j1CyNGlsLBAfv/9FzUlhBBCCCGhAQW2nwq7KgqdxUaZpNBsq5J1E0LCm8LCQvnrr9/VlBBCCCGEhAYMEfdjHOyqHKorp9AuJRa7RPsZfkIIIQC514MGDePBIIQQQggJIehg+0mVhIhHmsRqt0txmBSBIIQQQgghhJDaDAW2D4zF/arCwQZYKxxsQggJhKysTDVMF6aEEEJIKGK3O5RJFewH1htKYAipTz75sLo3IyRwcIAqhoj7S1XlSUeZTJJbZJPmKVWyekJImBIVFSUNGzZSU0IIISTUgAjOKLBWSRRoVGSE1E+MEpMpNIa6+vXXn2THju0yf/5sWbfurzLv3333CDnuuLayYcN/UlCQL/PmzZKRIx+WxMREWbjwf2rM5n/+WScnnniymv/JJ8fLl19+Lh9+uFzq12/g9XMbNmwojz/+lPrcr79epcakRsd7//4D5dhj28j48U9I8+YtxGazqjGm3cfC9sV3332rhh274447na99+ulHsn//PpfXwLBhd8jzz09SQ2BNn/6KqpS+c+cO6dLlNOnY8UQ59dTTpU2btlJbYMusGquIg9ioCMkvKR2braaPh0cIOXokJSVLz54X85ATQggJSWAyo/0MDRxMIaxdcay/vFDcFSs+lvfeW6ra2PjdfOCBUUpwgquvvlKSk5MlKqp0CC2MvTx16qtSUlIsY8c+KtnZ2VKvXj0ZP/4FiY2NU6+PGDFMpkyZVWacZnxOv34D5eSTT5FrrrmhzHZg/yFyd+3aIUVFhVJUVKz+T02tL4MGDZXt27eKw2GXIUOGKdGN18ENN9wsvXpdWWZ927ZtlV9++VGuu+4m52tDhgyXHj16yueffyr5+XnqtZ49L5SRIx9U+/L446O8Hqe8vDy599475f77R0nnzqeo13766XtZu/YP+fPP39X41C+/PL3McsXFxfLLLz9JXl6u/Pbbz9K69XFK3IPly5dJq1bHqGO8ZcsmSUysI9nZWTJx4nPqGPoaWqumQ4HtA6PerSoHOybKJEUWu5RYHRIXTYFNCPEPm82mfqTj4xP8HqOTEEIIOdpAXEYFUWBbIbL9aJevX/+3vPvuOzJt2mzlqP700w8ybtxomTv3Dec8L7wwWRo1auyy3OrVq5T7O2zYvTJr1jT1/LLLrpAlSxZJ374Dyojr3bt3yaZNG9Xv8n33Dfe4LXXqJMmUKTPl119/lgMH9kl6eppygyGeV6z4SH3eBRdcpFzsNWu+KeM0T548QS688FIlfq1WqxKpd9890mWeuXNnyjvvLHY62ACu9ubNG50OtjemTZss1157g1Ncm81m2bhxg7zxxttiMpmkd++LZd26tXLo0EGX5SC8c3Ky1TZBpGPM6Tp1ktR76LhISEhwPo+OjpIOHTrKddfdKFOnTpLRo5+UcIU52H5SVTnYMZERYrHapZh52ISQAMjMTJc33pirpoQQQghx5e+//5KuXbspcQ3OPPNs5RwfOHDA56FKS0tzutyY4nl6err89tsvSmi789prc5VIh3t87rk9lKB0f4waNfrwb3emvPjiFDn55M5y6613qHBrfxg8+C5ZunSxzJv3qkyf/rJ0795TOnUqDSfXIBz70kt7Kdca2wPH/txzz1OvnX/+RV7XvW/fXtmyZbNcfnlvF0e+e/fzlLjOz8+XlJQUady4iXzwwXsuy0JAX3llX0lJSVWfkZWVJUuWLFQPhMx/9tmn6n+sT4e6X3zxZbJ16xa/970mQge7mkPEVciI3UGBTQgJCORZ9e7dX00JIYQQ4krbtsfLjBlT5Nprb1Sh3hB/qFuSnn5ImjRpIhERJhkz5mGx2ezSuvWxMnTocGnSpKkS1WvX/q7WgdBmCNc5c2aovOM5c2Yq9xlDZSKce/36darAGUKkARzp8847v8ypwPzAbC6W33//RW0L8rE1J53UWQnYwsIC5WC7k5xcV8aPnyB33z1EOeZvvPFWmXlOP72bnHXWOXL//XfLX3/96Xx9yJC7VFj9t99+7TXXGu65BjniKNiGCDl8LkLWO3c+VVq1aq3C2WfPni7t23eQnj2P7CccbOSSN23aVE4//Qy57bbB8vTTY+Waa66Xdu06yKBBR0LZAT7v+++/lauvvi4sL1sKbD9jxKtKYJd+TIQUm21Vtn5CSPgRExOrfuwIIYQQUha41/36XS2PPHK/EtYQ0bm5OSoXGCxevEyio6NVmPPy5e/KU0+NkVmzFignGkXLhg69Tdq0OV4JX+QaIwTaYrHImDHjVCEvCFO4smPHPi1Dhtyq1gnx68mZhcCOjY2VQYPulO+++0blIh9zTGv1WLBgtrz66nT1PsLMPaV94XMnTHhGOnU6SW6++TYVij569DgldI1gX4AOMR85crha1ld4+J49u+SMM850Pt+8eZNyzFGYbPbsGfL++0tl8uTS/Gts28UXX66c6c8++0QGDrxebVda2iEZNGiIWCxWeeutSSoUfteuncrFhssN0W4E+415whUKbD8d7KrKwQYxURGSW8yhuggh/lNYWChbtmyQtm07qB8vQgghhLhy1VX91QPAaf7++zWq8BaAuAYIg77iiiuVyAUQ44888rhzHQ88cI889NBjsmrVSueymKJKNsS4kTfffF0JWnfwO33hhZdI585dlGhF2PUPP6xRYevgySefkRYtWioR/9hjD7osiyJjcND7979GhVeDFi1aqWJm7gJbu+733DP08P+bA1Y9p5xyqvP/8867QOVwo3ibBsXJUDjt119/VB0Q//vfm3LffXdLx46dVJ52795XuTjYHTqcILfd5lr4DcWdw3k4Lwrsas7BBjGRJik025RLjmEHCCGkPAoL8+Wnn76TZs1aUGATQggJWVTV7yCvryKd0i+++Ixyf+HCIsy7qKhIWrZspd5fufJzOeWULmWW++abr6Rt23bSrFlzadCggXJkwZ49u+W449qUmR/rXbjwHZfXIIQPHiwtDjZt2suqUBo+DznUK1d+pipvo2gZRK7dbpPjj29fJpf8mWdedBmuC9sNl9kT2F6jg10eCImH8+4OOgFQXO3pp5/3uBzC0a1WV4OwadNm8sUXK2TEiLvUsdIO9hlndHOZb8eOHc4893CEAruaq4hrBzuvGJXE7RLFasCEED9o0KCRDB06gseKEEJISILC4TCO1JBaQW5HY73+FCYfN26MEo8Q1X369JXevfuq15HrPH78k8ptRuVr5F4/+uhYl2XxHiqHT5o0VT1HES8MdYVwcOR033FHqUtsBMXQ3EUtipFefvmV8s03q6VRo0aq8BgENpxehIRjGDGEr2OIrAcfHKFyvjWLFy9Uwvr333/zuo8vvDDJ+T/ceFT11tuA3HA48ggd9zYc8Nlnd1fjZV9//ZE8aaxjzBjs6zDlrJdP6fk9/vh28swzE9T/RgfbndWrV8pTT3kW7uEABXYIONjRqCRus6vhuhJjOdwOIYQQQgip2aCQb/3EKDVeddDX7efY2uPGPevxddQwmTv3dZ/LIoT81VcXOJ9jeK6XXioV295AQS8Mx+XuYGdkZByuyn2+GpNaA4cYTu4999yvnj/55HiV340ibL7Gwfa1ze4OOnLFFy9+QznOnoAb3rJlSxUCf+GFF6vQ7Zdfnih33XVPmUrl7qC4GQqvocMCxdD8YcWKj+XYY49zRg+EIxGOcA6ArySZeWbp8OCP6v9B3RvLZSelVNln7c8ukY7NEqR5SmyVfUZtJSrKJCkpiZKVVVAmlIWEB7XxHKNAytdfr5SePS+WevWq7t4UStTG81zb4DkOf3iOwxeLxSwZGfulfv2mEh8fx/t0DQL56ag+/vDDo9VY1f5+l339FtvtduWoG0GO9qRJE9TY5MnJyRLq13F0dIzz9dTURImM9G+EazrYvjB0jFVlFXF1IiJNkl/CBiMhxD/wo4VKqO4/XoQQQgghgQCxO3/+wqAeNJOH9gmKpb3++hIJdyiwQ6CKOIiJjJC8IqsKy/CWI2G22gXxBrHRbFATUtvB2JQXX9yrujeDEEIIIYQYoFILgRxsXeisxOoQs9X752xPK5ZdGSVVuh2EkJoBQq+Ki4ucY14SQgghhJDqhwLbB0YnuapDxGOiTMqhRqEzTxSU2CQtzyrZRdYKDU9ACAkvMjLSZMGCWWpKCCGEEEJCAwpsP6nqEPFIU4TYHA4p8SKwM/Itkl9ilWKLdxFOCKk9JCXVlUsvvVJNCSGEEEJIaMAcbB9EHMUQ8dLPi1AC2h042/uyzZIcFyXFFhuH8yKEqOFC2rQ5nkeCEEII8cE99wxVQ2MlJCQ4X5s8ebr8/fdaWbBgrnreoEEDeeSRsWp865KSYhk79lG1DJ6PH/+CxMbGqddHjBgmU6bMUr/BhHiDAjtEqojrQme5xbYyr2cVWCW/2C6N60ZLodkmRebKOdhYvshik9TE6EqthxBSfRQVFcn27Vvk2GPbSnx8PE8FIYQQ4gUMP9W58ynO5+np6TJ58kSZPXuBpKbWV2MzT5z4rDz77ERZvXqVHHtsGxk27F6ZNWuaen7ZZVfIkiWLpG/fARTXpFwosEPIwUYeNnKtIeajIks/HfnW+3LMqgiaKSJCYqNMkl1glZapFRsvG1XKd2QUS0GxTeoeE6VC0wkhNY/8/Fw1DnbDho0osAkhhIQkpoMH1MOIvW49sR/TWqS4WKI2bSizjPXkUiEcuWWzRBQWuLxna9lKHCmpld6uX3/9Sbp2PUOJa3DxxZfJlCkvqcKhaWlp0rx5C/U6pngOQf7bb7+o8ZsJKQ8K7BAZpgtAROcV26XEapeoyEj1Wk6RTQnqlMTSU4UhuvJLbCpsHII8UNLzrLI/26yS77GeuvG8BAipiTRs2FiGD3+gujeDEEII8Urc6wsk8aUXXF4rHnCN5M2aJ6Z9eyXloh5llkk7lKumSffeJdG//+ryXu6MOVIy8LqAixa//PKLalzmJk2ayh133ClpaYekfv0GznmioqIkPj5BcnKylaheu/Z39fqWLZukS5fTZM6cGWq5OXNmSnp6mjRo0FCGDBnmcaxnQqiuQihEPDoyQixWu8rDTowtFdgHc81q7OvoyNIvMBzszAKLysMOVGBDlO/KKJZoU4QUW+2lLjYFNiGEEEIIqQKKbx0k5st6lXGw1bRZc8n68luvy+ZNe9Wjgx0oyLeOji5Ni/zuu2/l4YdHylVX9fc6f48ePZXDPXTobarWSePGTaS4uFjy8vLEYrHImDHjZPr0V9S6MC8h7lBgl1N0TGOx2Y/OsGAR4qwkjnBxOM7J8aViGyB03O5wSGGJXeoGmHa5L8ssmYVWaVI3RuV1Z+RbpVlKxULNCSHVS05OlqxZ87V0795T6tZN4ekghBASctgbN1EPj8TFOcPBPWFrG5xCnlpcg3PP7SEvvvisNGrUWP7++y/n61arVYqKCqVu3XrKlX7kkced7z3wwD3y0EOPyapVK6VVq2PUa5ju3LkjKNtHwg/GNfjJUdDXCuRZF5SUflh6nkWKrTaJj4n0ME/ZYmi+yCmyyu6sEuVYY/n4GJMqqOapajkhpCYQIZEqlYR1FAghhBBPFBYWyMaNR/K8kUeNyuCnndZVfv31F8nKylKvr1z5mZx6atcyId/ffPOVtG3bTpo1a64qje/du0e9vmfPbmnYsCEPOvEIHWwfwFA+mg42QNh3XrFVhXPvzzFLopu41mHiWYVWVbBMud7lYLM7ZFd6iZitDklNLF1ffLRJcovMkldsk7ho9rMQUtNAL/vll/ep7s0ghBBCQhaEdE+dOkny8/MkLi5ekpKSVKVwONgjRtwvo0aNlIgIk6SkpMijj44tsywqh0+aNFU9P//8i+Txx0fJkCG3KpF+xx1Dq2mvSKhDge0n1sAM4woTGxUhRRaHEtd6aC53IIgLMFyXxS4JHgS4O2l5FjmUZ5YGdWKcr5UK8wjJK7JKwyQO10VITQMdbHa7TUymSL862gghhJDa2Bk9Y0bpWNfuIMUKD1+h5a++usD5HGNfv/RSqdgmxBe0Lsvh8GhZYrEfPQcb7jXCwyG2Ec5ddp7SYmiFfoyHjRDwnenFEhcd6Rz6S5MQY5KMfItyuAkhNYv09EMye/ZUNSWEEEIIIaEBBXY5RB4WpUfLwca41BC8uUU2SfZS4RtuFTRxkR8Ce09micq1rmsolKZBHnaB2RFwPjchpPpJSkqWCy+8TE0JIYQQQkhoQIFdDlEmLbCPXjGwyMOutbvj7O50Zxdafa4HlcL3ZJklNTHaYwgphv7C8GP5xRTYhNQ0kEvWvv0JakoIIYQQQkKDkBTY33zzjfTv319OOukk6d69u7z88suqfL4v7Ha7LFmyRK688ko55ZRT5IILLpDx48dLdnZ2pbZFi1zrUQyjblQ3pty8aORhQxgjnNxbfua+7BJx2B0+i5hh7O3MAt/HlhASehQXF8nmzRvUlBBCCAkV0AYlpDZfvyFX5Gz9+vVy9913y+DBg+XZZ5+VXbt2KaGMSn6jRo3yutyUKVNk0aJFah4I8927d8ukSZPkn3/+kbfeeqvSDrbFdnRvFuUVLUIl8cwCiyp0BjfbnZwim6TlWqReou9TnBBrUvMiV5vVxAmpOeTl5crKlZ/KwIE30sUmhBBS7URGos0ZIfn5ORIVFSE2BkiGNXY7zrEj7MR1fn7O4aFQo8JHYM+fP1/OPfdcue+++9Tzjh07is1mk0cffVSGDx8uderU8bjc22+/LUOHDpVrr71WPT/hhBNUyf2bb75ZduzYIa1bt66cgx1iFxC2C7nayMOu6yFCFFXIscmexLcRiOq8IrPkl3C4LkJqEvXrN5QhQ+49PBY2IYQQUr1gDOmUlIaSnZ0m6ekHVXQpCe/zHZ7nOEJdx+5jotdogf3zzz8rIW2kR48eUlJSIn/88Yf63xNRUVHOweI1CQkJzvdqmoPtb0E0lT9d1/X1nCJrqXudUP5+o0q5QyIkt9AqDepwuC5Cagq48Vfm5k8IIYQEm9jYeGnatJUkJkZLTk5h2Dmc5EgR6Lp1E8LyHEdGRlW6fRVSAjs/P18yMjKkRYsWLq/DtcaA7ggX98Zdd90lzz33nNStW1duueUWSUxMVCHjl19+eZn1+UvE4RxlALdYVxQPFRJiIyWvxK62yxhSnp5vVe51Ypx/zladuEgVJm4yRahHuBEZaXKZkvCjNp7jnJxs+f77b+Wcc3qocT5rA7XxPNc2eI7DH57j2nGOMWa02ewQ21EsEkyOHjzHNUhgFxQUuDjPRiCYIcC9cdNNN8n+/ftl6dKlMnfuXGnbtq0kJSXJzJkzK7w9EaYIiYkuFamoJZaUFFdubvTRJDrOJoUlNolNjJfE2NLtzCuySqG9WFo2rqMEuD/EJdhVxfGo+Dip64frXVNJTma15XCnNp1ju71YHA6bui+lpCRKbaI2nefaCs9x+MNzHP7wHIc/PMeeCRs1NWfOHCWwV65cKQcPHlTuNR4ofuarOJovUIHbJEfCHjKzC9XQVqGUiJ+Ra5F9ByOlweGq41sOFkl6VrE0rRcjuSX+rys7xyx7DkSIPSVWwrGXDTeA3Nwi9qSGKbXxHJtMcXLFFf3U/1lZpZ2T4U5tPM+1DZ7j8IfnOPzhOQ5/auM5Tk6O9zuCLqQENlxqUFhY6NHd9lbgbPv27Woory+++EIV/GnWrJkS1aeeeqqqSI687TPPPDPg7YG0Nh7HErNdTDGh42ADq9WuXOt68ZFSUGKTPZklkhhjCjgfArt5KMcsjcoZHqwmgxsAjhcJX3iOawc8z+EPz3H4w3Mc/vAchz88x54JHTv2cK51amqq7N271+V1hIZjPOuWLVt6XO7ff/9VVewaN27s8jqqkYN169ZVeJt0FfFQLXSGKuHZhaXjWB/KNUuR2eYMFw+EhBiT5BbZpMRCAUpITSAt7aDMmvWymhJCCCGEkNAgpAQ26Natm6xZs8blte+++06io6PltNNOU88zMzPlwIEDzve1sP7xxx/LCG/QvHnzSlcRB1Z76AlsDLOFSuJ5xTbZn22R5LiKBSXExZiUOM8r4aCFhNQE6tRJkh49LlRTQgghhBASGoScwB40aJAS2K+88ops2LBB5VQ/++yzcv311ztDxEeOHCnnnXeecxkIbzwee+wxWbZsmfzzzz/y8ccfy0MPPaTGw7744ouDI7BD0MGOjTIp13lPZrEUKPe6YqcUw3WhgBvCzQkhoU98fIKceOLJakoIIYQQQkKDkMrBBieffLJMnz5dFSebN2+eGp7rqquuUqLaGxCGqByOQmeYwt2Gq92rVy81fFdMTExQQsRDUWBj++CsY5itOrGRlapyDjccQ3wdU98RlsN1ERJOlJQUy759e6VZs+YSGxtX3ZtDCCGEEEJCUWCD888/Xz28sXDhQo8F0u6//371CCZGBzsUc7BBpClC5U83q1fxjgSQEIt87tIw8brxIXlpEEIOk5ubIytWfCADB94oDRtSYBNCCCGEhAJUUYE42CGYgw3q14kWh6PUya8MGILMareonG4KbEJCm9TUBnL77YjQCb+h9QghhBBCaiohl4MdatQUB9vYEVAZYiNNkpZnUWNsE0JCFwxJiPxrTAkhhBBCSGhAgR0GDnYwSYiNlLwimxSaOVwXIaEeIr5q1WdqSgghhBBCQgMK7BpeRTzYoNBZidWuhv0ihIQuNptNcnKy1ZQQQgghhIQGzMGu4VXEqwLkYmfmW6RJ3coVTSOEVB0pKanSv/91PMSEEEIIISEEHewwyMEONgkxJskqtEmxhWHihBBCCCGEEOIvFNjlUNtysEF8jEmKLTaGiRMSwqSnH5K5c6erKSGEEEIICQ0osMuhNjrYGO7LJBGSXWCt7k0hhHghISFRunY9S00JIYQQQkhoQIFdDpG1MAcbxMdGSkaBpdZ0KhBS04CwPuWU0yiwCSGEEEJCCArscoiuZVXEjXnYGKorr5guNiGhiNlcIrt371RTQgghhBASGlBgl0NkpNS6HGwQaYoQh0PUmNiEkNADQ3R99NG7akoIIYQQQkIDCuxyqK0ONoiPNsmhPIvYa1HHAiE1hdTU+nLTTXeoKSGEEEIICQ0osAPIwbbUMqGZEGuSgmKb5JXQxSYk1IiMjJLk5LpqSgghhBBCQgMK7ACqiNc2Bzs60iRWh0PyiymwCQk18vJy5dtvV6kpIYQQQggJDSiwAxgHuyIVtTfuL5R3fkmTzAKL1ERio0ySlmcRBxKyCSEhg8VikQMH9qspIYQQQggJDRhbGIiDHWCIuMVmlxdX7JW8YpscyrXIPRc1k5pGQkykKnSGiuKJsYaKb4SQagW519dccxPPAiGEEEJICEEHOwAHO9AQ8QM5FiWuwe7MmjmUTly0SUqsdsllNXFCCCGEEEII8QkFdhXmYO/LMjv/r8kCFbnYWTU0xJ2QcCU9PU1ee222mhJCCCGEkNCAArsKc7D35xwR2DlFthqbx4xq4lmFNiky26t7Uwghh4mPj5dOnTqrKSGEEEIICQ0osKswB3tfttll2SKLvcaOh11ktklukbW6N4UQcpjExDpy+ulnqikhhBBCCAkNKLCrMAfbGCJek8PEIyIiJCrSJBn5DBMnJFSwWMxy4MA+NSWEEEIIIaEBBXaVOtglYSGwQWKsSTIZJk5IyJCdnSXvvfeWmhJCCCGEkNCAAruKcrARTp1f4hoSnlODQ6wRJl7MMHFCQoaUlFS57rpb1JQQQgghhIQGFNjlYNDXAYWIG/OvjYXOaioMEycktIiKipbU1AZqSgghhBBCQgMKbD+EZfRhlR2Ig73fg8Cu6UXC6vgZJm622mVXRonYAgypJ4T4T35+nvzwwzdqSgghhBBCQgMK7ADysAPJwfbkYNfkHGwQdzhMvLxQ9wM5ZtmZXlyjQ+IJCXXM5hLZsWObmhJCCCGEkNCAAjuAPOzKhojXdIFd6ub7riZeaLbJnkyz5BXbJCOPApuQqgLh4TfccLuaEkIIIYSQ0IACu4oFdoQhhzscHF1UE88qsCkh7YkD2WYpMNukfp1oScuzSHENHfubEEIIIYQQQgKFAtsPnDnYfoaII/cYYdKgRUqMM8S8pjvYOky8yGLzuC9wrfdmm6VefJQS4hDh2YU1v1OBkFAkMzNdFi2ar6aEEEIIISQ0oMAOJAfbTwcbzq3tsHHbtF6MJMdHho3ARph4TKRJ0vNcw8QdDofsyyoRs9UhCbGRpfNFmeRgjkW9RwgJLjExsdKmTTs1JYQQQgghoQEFdgAOtr9Fzoz5183qxUpdLbCLrWEhNuFOZxe6holjCLL9ORaplxDlfC0pLlI52HC2CSHBpU6dJDnrrO5qSgghhBBCQgMK7AAcbH+H6XIV2HCwS0UnXO2Ckpqfk6yqiRvCxO12h+zNKhGH3aHe08DBttjsklXAMHFCgo3VapH09DQ1JYQQQgghoQEFdgBFzmA+Q0yWx74sd4Fd6mCHw1jYxmriOkw8s9AqB3MtUi/xiHutSYyNlIO55oDGECeElE9WVqa8885CNSWEEEIIIaEBBXYAAhv4IxT3uznYOkQc5IZJuHQdFf5tKy1slmmWyMM512Xmi42UvCIWOyMk2NSrlyoDBtygpoQQQgghJDSgwA4gRNzfPGwdIo4cZAhRHSIOcgrDQ2DHRkWoMPE9mSWSnm92yb02YjJFqEe6j7GzCSGBEx0dLY0bN1FTQgghhBASGlBgB1DkzB8HG4W/sg4PTQX3GriEiBfX/BBxY5g48qvhXBtdfnfQyZCRb/U6djYhJHAKCvLll19+UFNCCCGEEBIaUGD7gVE8ljdUl3t4uLvARrXtcAH7VWi2q3GvfZEQEylFGBObxc4ICRrFxUXy33/r1ZQQQgghhIQGvpURCThE3EVgp5QK7LoGARoORc40cK4xzrc/oLo4CqE1qRujQsYJIZWjfv2GcuutQ3kYCSGEEEJCCDrYQXaw3YfoAslxxiri4eNgB4IeEztcirwRQgghhBBCiDsU2EHOwfYksOsaCoCFU4h4ICBfG+Z/JoudERIUMjMz5K233lBTQgghhBASGlBgBzlEXAtsLNI4OcZZcTsmKqJWO9hHxsS2iNlqr+5NIaTGEx0dI82bt1BTQgghhBASGlBgB9HBtjsczhzsRsnRztByVNzWYeLhlIMdKImxJikosUsmi50RUmmSkpKke/cL1JQQQgghhIQGFNhBzMHOzLdKidXhEh6u0YXOkIMMIV4bMUWUOvkHcyxi92M8cUKId6xWq+TkZKkpIYQQQggJDSiwgyiw9+eUzb/W6KG6oK3za3GhLxQ7yyqwsNgZIZUkKytD3nzzf2pKCCGEEEJCAwrsIOZguxY4i3V5zzgWdm3Ow8bQXjiE6XmWcue12R2yK6NEii3M2SbEnbp1U+SqqwaqKSGEEEIICQ0osIOYg70vy7uD7ToWdu0V2KBOXKQcyrVIkdm3cE7Ls8jWQ0Vy0BAZQAgpJSYGRc5aqikhhBBCCAkNKLCDGCLu4mCneA4RBzm1uNAZSIgxSaHZpkLFvYFK47szisVsdajQ+xK62IS4UFhYIH/++auaEkIIIYSQ0IAC2w+iDSHiFj9CxONjTFLXIKhBstHBrsU52Lqqelx0pKq4jjBwT+C97CKbigRAznoGK48T4kJhYaH88ccvakoIIYQQQkIDCuwgOdhwXHVecbO6MUpEenWwC2u3g62LneUU2STbw7GAoN6TZZbkuCgxmSIkPiZS9maV+AzPJ6S20aBBQ7njjrvVlBBCCCGEhAYU2EES2AdyLKLfaeqWfw2MjnZtz8HWxxRH9ZBbsTOHw6HEdJHZpnK1AcYQx/jhvkLKCSGEEEIIIaS6ocAOUhXxfdklXvOvAUPEy5IUH6lc/4KSIx0OWYVWFR6ekhh95CI1RUh0pEn2Zps5fjYh+ruSlSnvvrtETQkhhBBCSGhAgR1gFXFvDrbrEF0eBPZhNxbU9iJnGoR+YwiujPxSZxr52HsyzSoSIC7aVKYKe1aBVQlwQohIVFSUpKbWV1NCCCGEEBIaUGAHGCJuqaDAjo02OUUjQ8SPkBgTKQdyzOq4YliutDyzpBrca+M5wFnAvAgjJ6S2k5SULOeff4maEkIIIYSQ0IACO1AH20fVa03Tup7HpdWFziiwXYud5RXb5FCuWQ3LFRsV6dKhYaReQpSk5VlVcTRCajs2m00KCvLVlBBCCCGEhAYU2AHmYHtysOGoage7QZ0o5VZ7Qhc6Q5Vsb8NT1TaQXx1pMsmhXIsalqtuguvwZkZiokwqBxvzElLbycxMl9dfn6OmhBBCCCEkNKDADkIVcTiwBSV2rxXEjW4tcBxehhzpeDiYaykdlstteDNPUQAHc82qk4KQ2kxycj3p1auvmhJCCCGEkNCAAjsIVcSNId+pid4LDqFQ15FlWKzL6Ew3T4lxDstVXmG0Eotd5WoTUpuJjY2V1q2PU1NCCCGEEBIaUGAHycHWJMV5F9g6BxswD9vtQizHuTaCY7w/2yJF5tKoAUJqI0VFhfL332vVlBBCCCGEhAYU2AEWObOUK7Aj/XKwWair4iTGmqTAbKOLTWo1+fn58v3336gpIYQQQggJDTiAahBCxF0EtsGl9u1gM0S8okREREid2EjZm2WWRskxZcbM9oTZaufwXiSsaNiwkdx118jq3gxCCCGEEGKADnagw3SV52DH+iew6WBXDkQK5JeUDu/lj7heuyNP9mSWVPJTCSGEEEIIIcQ7FNhBz8H2L0ScOdjBcbExPBqKnvkCY5Tvzy6R3ZklzNsmYUN2dpZ8+OEyNSWEEEIIIaEBBXYQxsFmiHj1gM4MHHtfLjbe35VRLKl1oqWgxCYHcuhik/DAZDJJXFy8mhJCCCGEkNCALTN/DpIpQrTGLjcH24eDzRDxKsrF9uJi2+0OJa5LrA5Jjo9S1cf3ZluU0CakppOcXFcuueQKNSWEEEIIIaEBBXaAedieHOx8g8CG4PO+DpPEx5Qe8lzDMqSSudheXOy0PIscyDFL/TqlofkYZ7vYbFPF0Qip6djtdjGbS9SUEEIIIYTUMIE9d+5cn++/9dZbYrPZ5JZbbgnLas06D9uTg63FMsSzMV/bE3UPFzpjFfHgudiJHlxs/A/3OibKpDo2NCmJ0Up057CKO6nhZGSkybx5M9SUEEIIIYTUMIE9efJkKSoqkqFDh8qBAwdc3ps+fbrMnDlT0tPT5ddffw1PgX04Rtxqs3t1sJN9hIe7FzorKLF7LJhGAgfONM5Ber7F+drerBLJLrJJvQTXkegwpBeiEPZmloTldUpqD0lJCBHvraaEEEIIIaQGhohDkMTFxcnVV18t27dvV699/fXXyt2eMWOGNG7cOGxFi9PBtpXN89UCG0KvPIzjZOcWcyzsYGCKiJCEmEg1DBeG5MoutMqeLLMS13jPndTEKDmYa5HMAh5/UnPBvbht23ZqSgghhBBCaqDATkhIkKlTp8oNN9wgY8aMUa+tXbtWHn/8cenUqZMzZDe8c7BdHewCs10cfhQ4cw8RBxyqK3ig4wLF5iCcd2eUiM3mUKLbEwgbB8jFtnkI+SekJlBcXCQbNvyjpoQQQgghpAYXORs+fLgzJ3vEiBHKte7Vq5d6HrYOtg4Rt1esgrgmOY5jYVcFcKrjYzAudokczDWrYbl8kZoYLWl5ZskwhJUTUpPIy8uVr776XE0JIYQQQkgNFdj79u2Tp59+WiIjI5WY7t+/vzz//PPStWtXCWe0g+2eN51nKJYVqIPNQlvBBcOg5RTaVNGz8orN4X0UP0NYuafK8ISEOg0aNJK77rpPTQkhhBBCSA0V2MXFxSosvF+/frJp0yZ56qmnZOLEiWKxHHECwzFM3FhF3OjS55UE6GAzRLxKXezmKbFqzGt/SEmIkswCm6R5GOKLkFAH91mTyRSW91tCCCGEkLAW2Mi5Bl999ZUcd9xxsmzZMundu7d6fe/evdKkSRM5dOiQ3H777Wq+m266SW688Ub1CBeMjqgxDTuvKFCBfUT85RiWJUcfkwnF0UyyK7NEiswcS5jULHJysuXTT5erKSGEEEIIqUECu3Pnzsq1HTt2rDz22GNSWFiohuyCe/LSSy/JG2+8IRkZGdKuXTs1f/v27aVDhw7qEW452O6FzgLNwXYtcsYq1tUNIgpwDvdnl1T3phBCCCGEEEJqg8B+5JFHVBjiZ599JjExMdKjRw/59NNP5a233lJuNsbFzs7OVuIboKo4xDge4ZaD7V7oLOAiZwYHm1XEqx9c1xjOCxXFmRNPahJ169aTXr36qikhhBBCCKmBOdhJSUkqLLx58+ayePFiadOmjaSmpqqK4jk5ORLO+ONg+zUOtmEeCuzQAMN5mW0OVfAM45oTUhNAVJHdbg/bkRsIIYQQQmpFkTOEf3/wwQcq7xoMHTpU1q1bJ5MmTZJwxpiDbawknm8Q2Ml+CGysJzG29LDTMQ0dUhOj5GCORTLyGbZPagbp6Yfk1VdfUVNCCCGEEFKDx8GeMGGCPPfcc+r/Cy64QMaMGSPnnnuueh6uFW29CexAHWxQ93CYOB3s0CEmyqTO8e7MYg7bRWoESUnJcsEFl6opIYQQQgipoQJ7+vTp8t5778lVV12lnl933XVSv359mT9/vtSWEHEM1eUusGOjIpRI8wc9VFeRxS5mY0I3qVYwbFdGgVUOsOAZqQHExcVLhw4nqikhhBBCCKlhAlvn+W3evFnlXJ944onO9+6//35588031VjY4ZoPaCxyZvHgYPtT4EzDsbBDd9iuOrGRsifLLIVmDqFGQpvi4mLZsmWTmhJCCCGEkBomsD/66CM1nTJlipxyyiku751xxhmqwnh0dLSqJI7hu2pDiDg6EyoisHWIOMg1hJiT6gfnsaDEJvuyzNW9KYT4JC8vR7744mM1JYQQQgghoYHfSvj444/3+t6ePXvkp59+Uv/feuutEo5EG6uIHw4RLzTbRUeLV9zBZlGtUAI1BFISo9WwXdmFPDckdKlfv6EMHny3mhJCCCGEkNAgYKv5mWeecbrWYO/evXLLLbc4BXa44snBrkiBszIOdhEd7FAjLtokdodDdmWUiI3DdpEQBZFCMTGxYRkxRAghhBBSU/GrZZaZmamqhmOs608++cQZHr169WoZMGCA9O7dW9LS0uTBBx9UFcVfeeUV+fTTT6WoqCjgDfrmm2+kf//+ctJJJ0n37t3l5ZdfFqvVPyfxyy+/lNtvv12Jf+SIB3PoME8C22WILoMrXR7G4bw4VFdokpoYLYdyLXIw11Ldm0KIR3JzESL+iZoSQgghhJDQ4IiV6oPCwkLlVF966aUqhBaCG6L3iSeekGeffVYuvPBC6dSpk9x8881SUlIiGzdulMWLF8u8efNUxXF/Wb9+vdx9990yePBgtd5du3bJ+PHjVfG0UaNGlTt0GD4L43JjHbGxsX4L84pWETfmT6M4lr8kJxgFNh3sUAQdKgkxJtmZXiz1EiIlIcb/80vI0cBut0txcZGaEkIIIYSQGiSwW7RoITNmzFCCt1evXsqxhuj9+OOPpW7dumoeFDh75JFHnMvs2LFDLr/8ciXOExIS/NoYDPWF8bTvu+8+9bxjx45is9nk0UcfleHDh0udOnU8Lvf111/L0qVL5YMPPpDmzZvL0aoi7upg+3UoS+eNY4h4TQBRCfuzzbI7o0TaNYkP2zHeSc2kXr0U6dPn6ureDEIIIYQQEmiI+AsvvCALFixQxcxiYmJkyZIlEh8fr8Q1hDZEtLv4aN26tQojD8Rd+fnnn5XANtKjRw/liv/xxx8+hTlc76oS195CxHMrnINdfUXODuaYZfqX++TbjQwrLQ9c0/XrRMu+bLMaH5sQQgghhBBCfFGu7QqBfPDgQfnnn39kzpw5YjablXOtx7sePXq0GsILYgSO9VlnnSVDhgyRpk2bKmfZm+vsTn5+vmRkZCi33AiWr1evnnLPPYExYH///XeVd33HHXeo7UR4eNeuXeXhhx+Wxo0bS0WBpI40iURGRkhM9JG+COhrvIbhnDR1EyLVa/5QNzFKEHGOSHOEiPu7XDBY9GOa/LwtT77fkitdWteRegn+O+81lUicROc0sHDahMhIKbTYZU+2WVLrREtMFAtKhf45rh0cOnRQ3nlnsVxzzQ3SqFHF73M1idp4nmsbPMfhD89x+MNzHP7wHPumXHWFCrUoNAbgVKPw2JYtW6SgoEBWrVolDz30kBLU11xzjdx1112q0BjCyMeNGydXXXWV+AvWBzyFkycmJioB7omdO3eqMHKI7IEDB8rIkSNl//79KqQdBdjQGQCBXhEiTBGSlBQvyQlRkpx4pGBbVEyUJCfHS7HtiDBuWj9RveYvcEbT8izKGQ1kucpgttrlr92lx9lmF9mZbZVWTZKktpCYGFux5erEyf6sEil0RErjFP/SHUj1cLS+S6FATExjufTSS6RFi8bqHlmbqE3nubbCcxz+8ByHPzzH4Q/PsWf8si9zc3NVwbK33npLhYhDcH/33Xfy/PPPy+mnny5jx45VDjYENR4//vijyqOGsD3vvPOkKsnLy3OGsTdp0kT9f/LJJ0uXLl3k4osvluXLl8ttt91WoXU77A7JyysSsUaJxXykmnR+gVlyc4skM6/E+VqEzape85cGdaKUwM4usMqhjAI1NFRV89euAim2HHFw/9iaI52bxUlt6GWDuC4oKBEbehYqgMlmk7+3ZUmk1SJJAeTbk6N3jnGTx3ewoue4JnL88SeK2SxiNpd2nIU7tfU81yZ4jsMfnuPwh+c4/KmN5zg5Od7vCDq/lALCxLdv365yneFWa1BUDMN3ITQb4eMahIlPnjxZudj4H6K8PLQDA5fck7vtLdRcrzsrK8spsEGjRo3k+OOPl23btklFQRA8rhmbzaFCujVmi129ZhzDOjHGpF7zlwZJ0SL7SwX5wWyztEitmLsaCH/scI0C+G9fYUDbXHMp/eLjBlDR/Y2PNkluoVW2HSqSjk0TxGS8IEjIgHNstdaOGz1qU+zfv1eaNm2u0mJqE7XpPNdWeI7DH57j8IfnOPzhOfaMXzIcTvS0adPU2NT333+/eg051hDFGE4LhcgWLVrkssw555yjxsVGiLk/QECnpqaq4cCMIDQ8OztbWrZs6XE5nbONUHFPDdC4uOA4tNGG/dDDdOUdFtioMB4bFZjgapQc7fwf4y0fDdbuchXYO9KLXRxt4pvUOlFyIMesIg8IqW5yc7Pl00+XqykhhBBCCAkN/I51feyxx5z/r127Vk488USX19znAd26dZOoKP/DaTH/mjVr5MYbb3S+hlB0DAF22mmnqecYgxuF1rRbDVGObVm2bJlcdtllzuUg1OG6Iyc7GEQZioTrYbryDhc5S4qLDHgIp4ZwsA9z6CgItvQ8i+zJMru8Bnd+y6Ei6dS8duVvVpToSJPERUeqjgkMyxYfw0JLpPpITW0gt946VOLimI9MCCGEEBIq+K0QPvnkE2nQoIF6rFu3zvk/Hihs1qpVK5fXIDifeuqpgDZm0KBBSmC/8sorsmHDBlm5cqVyyK+//npniDgEs3teN1z177//XsaPHy/r169X1ctRcA152BdccIEES1wZHWxUUdcONgR2oBgd7KPhiP5pcK+b1TsSsr/xcJg68X+Itbxim+zKKHZW0iekOoiMjJTExDpqSgghhBBCQgO/7WWEWiPkG+zbt8/5P/j0009dnuvw7Pfeey+gjUFxsunTp8uUKVNUUTWEpqNoWnkuNCqbz5o1S6ZOnSrvvPOOJCUlqUrmDzzwgN8h6uURZci5hYNdYnU4Q8UDGQNb0yjp6IaI/7nrSBGka7o2kFdW7lP/bzxAgR0I6DhKTYyWvRi2KzFaGho6Sgg5muTl5cpvv/0kp59+piQlJfPgE0IIIYTUJIGNQmO33HKL+h/DdOn/AcavfvTRR1XYNgqLIVcbjjaEd6Ccf/756uGNhQsXeny9Z8+e6lFVGEPErTaHcjE1FXGwIc4QVQ4TtKodbGzv+j2FTgf2zLZJUve7SDUG96YDRWK3O1i0KwBio00SbY6Q7elFkhQfeVQqwBPijtVqlczMDDUlhBBCCCE1TGA/88wzHl9HmOwVV1yhqn+np6fLhx9+KBMnTlRVbfv27SuDBw9WOdQ1nShjiDgEdlHlBHZUZMThobqsVS6wNxwodBYz69wyUUwREdK+abz8si1fCs122Z1ZIsc0CP/huoJJSkKUHMg1y66MEjm+cVzAOfiEVPoaTEmVAQOu54EkhBBCCKmJArtfv34BrXjXrl0qnzocxDWIMpiUCA2vrIOtC51BYGNdRWabxMdUTS7l2p1HwsNPOaY0l71DkwQlsHWYOAV2YEBQpyREy96sEklJjHIpWkcIIYQQQgipnfgd24pq3pp///1Xfv75Z5/zY/isjRs3hk0hKGORM+Rg5xVbgyKwNVXpYuv8a3isJ7dIUP/DwdZsYKGzCoHQcOTmo6p4CYc7I0eZ9PQ0mT9/hpoSQgghhJAa5mAjxxoie/jw4TJgwABJS0uTxYsXy7Zt28rMi/zr22+/XVX0DpfQWYR0BzMHGzRKjnEZqqtVfd9h2uisCPR4YnguhICDto3j1PBS4NgGcRITFSFmq0M2HijNzyaBUy+xdGxsHOM2jRgqTo4eCQkJcuqpZ6gpIYQQQggJDQKuzoSxpY1h4EOGDJGioiKXKUT30qVLZeDAgRIuRBsFdhBDxP2tJP7puky5bf5mee/39IA+Y+1uQ3h4q9LwcN1h0LZRqaBHmHpmftVXMg9HkM+OgnV7Mksko4DFpsjRIyEhUbp06aqmhBBCCCEkNKh0+eM+ffqo4bSMU3Do0CHldIcLxmG6gudg+x8i/v7vGVJktqupPYCw+7U7j4x/3aWVa0O8Q9MjztcGDtdVqVBxRBbsTGOoODl6mM1m2bt3t5oSQgghhJAaJLA///xzsVgs8sUXX6jhutauXVvuMv/73/8kJuZICHRNx5CCfTgHOwgC208HO7vQqobUAhh/299xs9ER8Pfh4bmwjccddqw17ZswDztYpNaJksxCq+zMKAmbugMktMnJyZIPPliqpoQQQgghpAYJ7PHjx0t+fr48/fTTaszrd955R2obcCi1ix2sEPHUxCincPflYGMoKF/PvYExrovchucy0q5JvCp8BpiHXTlwbOsfDhX3twOEkMqQklJfbrzxdjUlhBBCCCE1SGCjuFlKSoqaooDZc889V+4yu3fvlnBD52HDwc4/LLAhkONjKhZpbzJhLOzo8gX24SJlgQrsP3cdCQ8/xS08HCTGRkrL1Fj1/470EjVUGKk4sdEm9dieXiwFJTyWpGqJioqSunVT1JQQQgghhIRJDrY3Bg0a5FIQLZwqiSP0OvewwK4TG1mpSum60FlBid2rKHMX1AhD9oe1huG5PAls43BdiGrefLA4oG0nZakbH6k6XzB0l83OUHFSdeTl5cmaNV+pKSGEEEIICQOBjVzT6667TrZu3eoyBVdeeaUsWbJEwlVgawe7ouHhgYyFXSZE3M3R9gSqgmshjtxrPTyXO8Y87I0sdFZp0NnSMClGDmRb1PBdhFQVFguKnO1RU0IIIYQQEhr4HVt48sknq+l9993nLOI0bNgwycoqW2AnOTlZOnbsKHfeeaeMHj1awgWdg11otqtiYyApvnIC21hJHLm7rRu4FiKz2x3Ocaw1EG4lFrsKRy7PvfZUPdxIh8MONti4n+NhB6sjJjEuUranl0iduEip66Vzg5DKkJpaX6677hYeREIIIYSQEMKvln9aWpo89thj6v9LL71UDh48KNnZ2dK+fXv12uTJk6Vnz55y6qmnuiyHIbvsdruYTFUWiV4tOdi6cBhIig2eg33Ig4MNMY2cbyPo39iTVSJtGh0Rx/6Of+3p81MSoySrwCqbDpaGNUcahiQjFQORDQdzzLIjrUROaB7pMo46IYQQQgghJDzxS/lCQC9evNj5fNu2bfLZZ58pJ/uJJ56Q1atXS+PGjcssd88994SNuHYfC1sTTAc7zUP1aWM4uDEc3VehM5yXDYfdaBRga+s2PJd7SLMOEy+22P0uoEbKp0FStKTlmWVPJnPbSfDJyEiT11+fo6aEEEIIIaQGOdhwokeOHCn//POPep6bm6seq1atks2bN8sJJ5zgdLjdeeONNyRc8ORCVtbBblSOg20UvGe1TZIv1meXm4eNUPPswtIc8XaN41W1cl8gTPynrXnOPOxjG3oX5MR/EAlQNyFKdqpQ8SiXaAVCKktcXLx07NhJTQkhhBBCSA0S2GeeeaaadunSRVJTU2XHjh3y119/SUFBgXJLbTab9OjRQ6Kjw1tA6CJnwXSw6yVGKWccY2t7crCNFcO7H598RGD7cJqNxcqMRcy80aFJgvN/ON+XnZQS0D4Q7yTEREqx2S7bDhVJQoxJDY1GSDBITKwjZ5xxNg8mIYQQQkhNE9gIIz7ppJNUznWvXr3kxx9/lHr16ilX+5dffpGFCxfKokWLVFEzVBGvzLBVNU5gV7KKuElVnY6S/TkWVUUcHRbG46eFdGxUhBzfJF6S4yMlt8jmU2BvMgpsQxEzbxzTIFatH4XbNu4/siwJDshxRy49hu5q3yTB43VESKBYLBbJzMxQxc7CvXOTEEIIIaSm4HeC9GWXXSaJiaXVqFNSUuTYY49V/59xxhkybdo0mTNnjnz77bfy8MMPS7jiKQcbVaIriw4dRvG0/JIjBdSQE41wb9AyNVaJ8WPqx6rnOUU2yS60+nSwodN95V8bQ5nbHXa6MwqsciiXw/5UxdBd+7PNsjeLOe4kOGRnZ8q77y5WU0IIIYQQEhr4PX7QwIEDnf936NBBPYy0a9dOZs2aJXl5pbm84YinHOzkuMoPwdTQrdCZdsUxPJeuH97qsLCG0P57T2kBM7jY9RJcP7/QbHPmZ0OMx8f41wFwQrME53rX7S6Ui06MqfR+kSPAtcZwXTsOD91Vvw4dR1I5UlJS5ZprblbRRIQQQgghJDQwBTNc8cEHH5SdO3eq5xMmTFB52uGEp9DeYDjYjZKOiNlDeUfcY2MYeKvUWBeh7a3Q2ZaDxWoYL6BdaX/o3PLIWNlrd+cHsvnETxJiI1VUAfKx0RFCSGWIioqWBg0aqikhhBBCCAkN/LZf3auEx8bGyrhx49T/VqtV7r77bjlw4IA0a9ZM8vPz5a233pIrr7xSwj1EPDkYIeIGB1uHhLsXOGvVoFRY6xBx4CkP21jgrEMAAvu4hnHKOc8rtikn22pzMFe4CkjV+dhpxdK+aQLHHCcVJj8/T/7+e62cdNIpUqdOkl/LmK12dR8rb2QBYLM7JL/YKlGRJlWgL1xraxBCCCGEVIuDjXGvweeff66mX3zxhfO9+++/XzZu3KjCxlFlfNmyZXLcccep4bvC2cFGezMhtvJBAMahulDoTLPbg4PdIiVWInwIbGOBs0AcbDS4T2pRWk28yGyXLYdY7KwqgEjB+Nj7si3MxyaVIjuvUP7buFGycktTO3yB4on5xTZJz7dIZoFVCW1f4H3Mh1oPmfkWyfJjGUIIIYQQEoDAhnB+/vnnVYEzTOvUqeN8r1u3buo1ONclJSWyYMEC5WiHG+4Odp3YSFV4rLI08uBgo0GsQ8DrJURKcnxpsEFstEma1I125mjb7TpLW9T/WmCnJAQ+7vIprQxh4rsKKrVPxDvRkSZVDX57WokSPIQECgTv3sI4aXByXyk2JUlekdXlXuDuRKMgYlaBRSIjIqTEYpeMfKsUlNjKLIP7Dl7H+2aLXd3jkNpQZFgG8xBCCCGEEM9Uyn49ePCgLFmyRG666SYlvAsLC9UQXm3btpULLrhAwr3IWWWH6NLUjY90rls72FmFVhWuDY6p71oJvNXh5xabQw4YQsohuNEQ1u51oCGdnVse6TT5azcFdlWC8bDRX7PlYJESLYT4A8QtUgz+2VcoucV2sTlKoyKyi6xKROOeYASuM8Q47iUoeBgTZVKCGdcenGkso51piO3cIghx6+HoHNQMiFCdiBjPHa/hvYq42dgu923ztY/4TuQUWlSqCiGEEEJIrRHYGRkZMnnyZHnnnXckLi5OioqKpGfPnjJjxgwJR6KqSGCjEavDxPVY2Mbwb1QON+JS6Cyj2GP+tT/jX3sar1nneG87VKwa26TqwPEuLLHL1kPFDL8l5QIBjPvCf/sK1Y07wZEnh/5aLkV5WUoAF5rtkpFnUQX0cA9BqkdmvlUN9wcnGsPxabTQNjrTCAnPLbapKJnYqLI/DXgtPsZU+jkBuNlFh7crPc9S7jIQ4RDwEP/oQPBnGUIIIYSQsBHYyLFeuHChGgcbzjUENoiPD1zc1WYH21jorMQKF8nmWkHcIKjVc4PgNs5nzL9uH0D+tadq4mjOrjs8bBep2nzsg7lmdR69hfgSAsd488EiNUoAxHLdhCiJjIqRuJQWEhUdo1xmREUAiGolUgss6nuM1z1FsxidaQjaEqtdEmMiPRZzNC5Tur7SZXy52doR19uhl8H2eVoGHQOlHQR2Jf6xn2JYBqHtRwO65oQQQgg5KlXE9+7dK506dRKbzaamMTGlQ0uhsNncuXNl8ODBkpmZKZ07d3ZZLpyG6iqTgx1Mge1W6MynwPZSSVw72OgIOLaBa1i5v3RulSgfrs1U//+1K1/OPT65Qush/gFXsX5itOxML1aVmpuluJ7r8oCzV2xxKGeRhCeq6ODBIjmQa5YGdaKV+wxi4+tIcqvTJT7hSGoH3OdIu0OJ1JioCJXvXx5wpmMiIwJKKcEyuM/AAUenIGoKxEebnNXJIaDRUVhksUlcVKQz+gfLFJvtUmIrddV1pwCqlecVl1Y4168ZP0cvg2SKpGT/O6IgyuGKx0Wbyh0VAcIa21FkcUhCTIQkxEaV6VQlhBBCCAmawG7QoIEK/UbxMkyHDh0qzz77rIwZM0batGkjDRs2FLPZXGY4r3DCvYEWjCG6PBY6g8A+XOAMbd4WKUfGyQaNk6MlNipCNWz1UF7IpTx4OB+7baO4Cg+x1aFpvHPd63YXKgHH4XmqFoiixLgo2ZpWrPJkETruL/tzLLIns1iOb5wQ0HLVAUQXBAuvJ/9B7vTmA4UqfLtRUozL99pms4qlMFtsNnSmHTn3EKlRBpHqDxU5J9oBL604bpH46EgV1WNzOCSn0CZ2h0M54sZ1q2ViI8Vis0tOUWn4Ot4vMpfmiHtyz/UyEMC4z8XkmsVutkl0hPfthnuO0PK8EptaLibSJElunQDunVRw281q3ggVnl5otqiOA4hzY3g9IYQQQogv/G6RY9xruNN6mpiYKL///ru89NJL6v2EhAQxmUzSr18/CVfcRWtVOdgHss2yJ9Os/m9WN8bpWGnQQGyRGqtyd1F1HI3Uig7P5Q4crxObJ8gfOwtUoTU45MdU0A0n/gNhkp5XOjwajj+ES3lAQMD5hlO46UChnNg8MajXZDBB+O+G/YVSLz5KXU8ULOWD8Guc1/wSuzSuWxoGbqQoP1vS//5Q8hsPlNSkplJd4P4UddhlNtvsYreXinxf1zDuM5gHwhYJKXCzyxP5+Aw42hDuCCWPjYxQ17v7/dHonqu88ehIFf6OUPO4mNJOAHQi4vMgvvOKkU9uV9ekCktX+4R0ndKOA6M497cjAqIdzrm/Y45jmwtLbBKttrdsJwAhhBBCag4VjiuNjo5W+dfIvV66dKlMmDBBDdG1b9++sHWxqzIH2zgW9l97CsR6OB+3pVt4uHseNubak1kiG/ZXPv/aPQ8brGU18aNG/TpRklNola0Hi8utuKyHcYPIbp4So0QYxBjCiUMN7Av2KT3PKtvSSlQBPea5+uZQrln+3VeoBCgiVjwNBxifWFfqn3C5JCbVk+pGu8zRJlNpkbTo8n9aIFaR2oBHIA56XHSkxMea1LWOYe50tXHjEGMIDYd7rkPkIbQRem6xOiTjcPX00nkt6ruD7YVTbUQtExMpuBUjB9zfPHBc71g/Un0yCqxqO70VacMQahhiDduMEHkIeiznaQg1QgghhNQMKpW4CdcaYeGjRo2SFi1aiMViUQXOVq9eHVa51xr38MWkKgoR32gQy7qqtzvG1xEmHiwHG3RuZRiui+NhHzUgMhomxaiiZ3CmfTWwIVb3Z5ulfp3o0ir0ydEqjBi5uoEOoVSVQFhgX7BPjZNjVCfCjoxi2XyoyO9hm2oTOF57s1ApvPT7jCJ43sRnZFS0xCQ1lKiowMa7r0rgMvsqklYVgj6nyKaqjeP6h0ttMgwx5knQQzgjRx3zQvfCtfa2zVgGwhvLFVtLBT3GE/f0HXMKfCWQkQNvUoIenwMBjUgjo9BW1dUh9ousgn4AuPEQ9JhFLVNgdVaEDwSIdn/FuQ6lx4OdXoQQQshRFtgY43r58uXOaXFxsWp83HXXXTJgwADnfMnJyTJo0CCZP3++hBtV6WDrsEVgbBu5Fzjz9DpCxbellQ7X1bRejCTHVy4Xt2ndaKfghzOOhiE5egIlNTFaDb+2J+tIATsjcNEgUqNNEc7wWAiORskxqhAWcrlDpbGMHHGkGaQkRqt9w/aiUBeiLuC4h1JnQHUDsbMjvVh1sEHU1Uvw/T02FxdK3t51UlxUe8esxzWVFFd6nBCiDmHtHjLuTuTh8PU6cVF+Oe3GfPOYw+JcO+e6k0iPN44HKp8nHhbt/2fvLMDcKtMv/sZl3Ouu0BZ3KLb44q67uLssLLDA8kcXd190YXF3KA4FthRaqLtNO+4T/z/nu7npTSaZSWYyM5mZ8+MZ0uTeXE1u7vnOKxDmTrtZhZtDTGM6rqcQ6XCr/QGJctrxm6pqMoRzzuGaVza274LHiuWK+o0uOMR2PPQ2bhDx2A5sGwYp4KZnyrWDEEII6fcCG870fffdF3mEkAYHHHBAZB6r1arCxI8++mj59ttvpaKiQvoT3elg6y5kLMaWXIkE9vdL6iMh5V0ND9e3RQ8Tx3L/WMN2XT2JdoNtVeHUuFmOBeIUIaj5MUXNIByQy7+m2qOEWm+HmEJMIBxciQyDkIFIQcGutbVeJSY5gKNVsMYg2dINHlVYK5lcep+3RZrXLxCvZ2P0ykD+zkBcxwulTyd6bjmcc71Pd22z5lBDeOsOeTxxjtd11xph6fgeJAqPNzrnelh7VTtCG98h3cGHwFcueNPG3uNGoa0PBmCZWDYEPgYpsBmouwFxjoJvqUaYYB3JDpjpgwEYaIh19gkhhJC+TtJW5+eff97xwqxWFSael5cnu+++u3zyySdy3HHHSX8tcpZOgQ0gjlaFi5sB3GDp/bFjgUud77ZIbTPC+4JpCw/XgcD+5Pda9e/Zqxply1Ebw8ZJ9wOBhRtc9D6220ySF45KwI3x6hqvFLitccUEnLCCsAOONk3DCx29UrUboa0o2IabbmxPvO8SQsYROo6q0/jcJlPYrT+C84xjhYETtGxL1lXNyi2Ssi2PlNx8fjd7Gnx+sy1aBfXGVq0lGnLDO3TOHZaUOjPgO+6ym1RhN48Pfz71+cgORzxBzzahSFu49oKx57k9ZBIvQtTDhdrwHnwfG1V+t/b7Yiw2CMGPP+wTwu7xu5Ll0AbH2osKgFhGu7bG1oAakEWRNuynXkguXsV2bEOrN6D2D+vRBhXN4uwg+iBdYJtZSI4QQkh3kda+Pih4huJn4LLLLpPCwkLpT3RnFfHYSuJgeGHbysGx7nZtc7S7nA4HG0wZ5lZ5gYEg87B7C7TdQrGrxeUtssnQLPX5Q2g4brbR0igRuCEOoO3XhlaxWswyJD+6zVtPFTVDwbZBeYnXjZv7iMgOhGTCYHfaB60yHYgZDKLAzTf2uCZ9A02USo+0RNOFNhzf1oag+p7juwZRq/p8x0RYaeHmpiihDXsbItaKHmcd7BNaqaEaO8SwOyyajZ/PWLGMwT1Mh8sOwa0XloPQhpj1hEW43ppNHwzQBw+qvD71/rxskZwU3HN8h3AckMLV0fcHkSIY/GtWoh7HNP5AACGEENIrAjsYDMrs2bOlvLxctewaP368DBkyJDJ90KBB0p9zsDHanu5WQ7Eh4onyr43Tf1vdHLVNqCidDuAmwlVEsSXk0ULoIceX9CwocrW+zquKlyF0GCGfEKUdgZtXuFWLylsE95w9de6MRc1QsK2jG1fceKMFFULh/1jTJBMGZX4/73QBoYHzg7z52B7XydDcUCMVcz6Txvy9Jc9d2m3bSTIHPdxcF6WqOFoHPc91oe1IsaYpBDNMeYhSOOT4c9vNav34WkMsIywe22R0ztGDXd++Vh9Es0nVi2gO1/JATrpx4FgfPAiFBwJqUKjO7hF/q19QliSRaIaoRv90OOAYDMD3B4MH8dxzf3jexvC8KpfeE4y459gvDAik+h1MJRoBrjn6rAOKekII6d906k727bfflltvvVWqq6tVLnZLS4v4/X7ZYost5LrrrpOJEydKf8ToEHR0U5MOB3tkUfv9p0fETJ9Q5kprDiLCxPVqxrNXNsneUyiwexqcTwhViLDaZrPkOq1JD+wgjQC52gvLW5WQhUPa3ayv96n2YXpRs2TQCrTZVI4pWlPhc5woNaK/gPzThetbVMVpDJh0ZrBOVRHPLlGPZGChi9IeqwxvsSinHKIUoho/M/HCzGO3DwLU4w+Jzx8UexyXPd5AgAWOt8mkrl1IJlch56rA3Mbe5bpYxjZBrDptVvVvOOfYPl00Y1AcQryhJaB6tENE60XxcPeDgQDd3UdevTuJkPjYsHisQ3fC44WdY15UoIeY19u8YV8wKIH1xBZP7Q70HHc69YQQ0jOkHI/40ksvyfXXXy9nnnmm/PDDD/Ljjz/KnDlzVC9s5F4j5/q3336T/ojxhxBuYrqBi5VMgbNEDne68q91Nh++MbeT/bB7D9zgQhzjRjbVtARUosbN1cJ1LVqF4xTBe3Gjm6gasZGG1oAqaoab2Niewh2BGz+49bgPnLeuWYVMp1L4CPMuKW+WpRtaMr4KMm7K569tVhWiOyuugcOVLXmjtxOXOyft20hI3AJvyh2GKNTCvzv67OrF2vC+VNq3QXjiWof1QNSjajsG4PDdQRQPirFhcRjo1iuw6wXoUBhOVWBX1dG1Kuko/AZhHSuczeHty3ZoRd4QEo8ibygWh1D32EKRkUrt4XkwGUIbBeP0yu16cTjMi3B0bDu+69gmve87Bif0InSpFnrTK8Bj2R1d67Qwfq2o3YZ6rUo8QupZVI4QQjLIwV61apXcfvvt8thjj8nWW28dNW3KlCny8MMPy9/+9je55JJL5L333hOHo32B2NcwOnLd4WCnGiI+rAAhuFrFWDBxcHoF9qgShxpIwE3H76ub1Y95R64kfvQfnVGunIBTdxmUcsgdiY9egKgzFGbb1M3fgvJm2WSIO6U2bui3vWB9i5Tm2GRMiTPh+cRN25INWkVwhHx3FoSHo4LxgnXN4vM7VZG2ZIoRQZCvqg9KfUOrNLb4ZUypK2WR31nwvcB+JzP4gUGI+eua1XcK3/euRJwEAwHxexolEMD3fmCE1ZPeJ92pUe0B0WwMOW/x+dVAd8SFjoMmmrGN5nB+enLfDT333OiEY12a0NeccAh8XOv0AQbdEYZgRfg3hDamYf1wxjEv6mDATTe6x3rIvsoJD4eqd+RqxzrhIQmJ1WwWl80kzphc8th58TLOG4rXmVoDapBEr3ifym80lovjg+3ryA3Xoxf044X968nPDiGE9CYp3ZU999xzsu+++7YR10b+8Y9/yD777COvvfZan68gbgoGJG/BHPXjCIY0+mREfb2szB0sJbaAZM9r69Q3Tp6mHl3LF4ulJboAWeuQ4eLPKxBbdaU41q+NmhZwZ0toxGjJsYVk1LpFku+yyKBlGyuKN42bLCGbTZyrlou1sT7y+h6ta+S3QJ5UZRXKJKdHsuctiVpu0OGU5jET1L+z58/ZqMbDNI8eL0GnSxxrV4mtriZqmreoRKYNy5Jffi+XMZWrpfLrGhlXpon4kNUmTeMnq39nLZonJr/WTuqH32ul8Y9a+S13mIwtccn+JS1ir4pu1+bLKxDPkOFibm0R97JFMQfdJI2Tpqp/upcuFLOnNfoYDh0h/tx8sVVViGPDuqhp/uxcaR0+Skw+n2Qtnhd5HQLNle2Q+qHj1E2Xa8VSsTQ3Rr3XUzZEfIXFYq2rEefaVdHnxuWWllF4r8Q95zi+OM7ONSvEWl8XfQyLy8RbUiaWxgZxrVoWNS1ot0vz2EnaMVz4h5gC0Q5zy8ixEnBnqc8KPjNRxzC/UDyDh4m5pVncyxdHb5DZLI0Tp2jHcMkCMXs9khUKKRdj3UKLWLecJO6yQjGtXy+W9dHHMJibJ8FRo0W8XvHPmStV61skyxeU+mBIyvPsMmiXbcRqs4hlySIxNTVFbqSqqr1S7yiW4uGDxFZTJY7yNdHH0J2l9gfWTfaCuW2OYdO4SRKy2cW5eoVkN9SpnsZVC/xiz3NI2aSRYh48SEx1tWJZsTzqfSGHU8qHjFWF4EaUL5Eij0eqGryy2m2V4YVOcWw6ScTtFvPqVWKurore1+ISCQ4ZKtLYKNal0ccwZLFKYFPtGFrmzxOTN7oneWD0GAnl5Epw7Topn79CapoDMihX6x9vKiiQ4MhRIq2tYl04P/Ie3JyvrWyVhlGbSlmuTdwrlqR8jWgZOUYkEJDshb9LsK5aLL98Lqbt9hJHabF4Jm4iYrOJbcUyMTdsvEYAf9lgCZSUirmuVmyrVkTvq9Mp3nFaWo/j99/aXCO84yZIyOkS6+pVYqmtjt6m4hLxDxoipsYGsS9fGr1cq028kzZR/7bP/yNyjYgsd9QYCWXniLV8rVgqo68RgfxC8Q8bLqbWFrEvXhh53WwxiSXHJTJKu6bZFy8QU2v0NcI3fKQE8/LFUrFBrLGf75xc8Y0cLYJq3Av+kFg8k6eIWCxiW7ZEzE3R1wj/4KESKCoWc22N2FavjF6uyy2+seO1Yzj31zbL9Y6fqD6r1lUrxFJXG73c0jIJlA5S5wznLuoY2u3inaBdZ+3zfm9zjfCOHiuhrGyxrlsjlqroa0SgoEj8Q4eJqaVZ7EtirrNms3g20a6z9kXzxeSJ/nz7RoxS1wJLxXqxri+P3tfcPDUd1wjHwnltjyGWazaLbeliMTdH92j3DRkmwcIi9V20rV0dvVx3lvjGjFPXCMvsX8Te2CJBg0NrxnFw2MW2crmYY66z/rJBEigpU69jug6GqEMOh3jHa9dZxx9ztNh24zEcO15CLrdY16wWC65duB7rTnF+sVSVDBJ7a5NYlywRh6oer4lLXCO8kzfVlrtovji92u81Cjb6gkExjRorWfm5YsUx3LA++tzk5Yt/+Eix+T2StWiBGkBQYhvvtZgktPnmKuzctWyxSHOTEusYvEZbtdCIkeIqLhQbrmerVynhj6PsQQ56YZ74R4+VxiavWH+fI1aE6odD7tW5mbiJBCxWkaVLpaW+TnxmFIbTeq9bhg4VKSsTU22NWFZGXyP8dqc0jR6vHHrb3F/VcjGACaENge4fPxG9XMW8aqWEqqrU9mLQEakBvuJSqS8bLPbmRsldu0xsGEBAcn++W8wtPpEJ2jXC8sfvba4RgTFj1TXCvG6tmDasjxL1wYJCCQ4fIdLSItZFC6LfFxJpnjxNRTm44txHBEaMlFB+gZg2bBBL+do214jg6DHqGmGd93vUNHUsNp2qrhGWpYvF1Bh9jQgMGSah4mIx1VSLZVX0NSLkzpLAOO0aYf1tdtvlTpgk4nSKecVydZ2O2qayQerP1FAvlmUx11m7QwKTtGuE5fe5ba4RfnynsrPFvHaNmGOus/guBocNF2luFqvhOquWazJLYKp2P2tZgGtEzDEcOUpCefkJ7yNk3Fh1jbD8OlurlmvcpinT1DXCeB8RWe7Q4RIqKhJTVZVY1kTfi4WysiSA62wwKNa5be/F/Pi9sdvFvHxZm2tEoGywhPD5TnAfEZioXSMsc34TUyhme8dN6Nb7CPP6cvUXtdy8/Lj3EZFtmra5ttzFi8QUc50NDB8hoYJCMVVWiiXmOhvKzpYAPhOBgLpGtFkurmk2m5iXLW1zHxEYNERCpaWRa4QF0UO5LrHUt0jI5pDABO0+wjrn1zb3EcZrhLkm+j4iWFIqwcHafYRl6ZI29xGBTTZN6hphrtgQvdx2rhHQGv6pm2nLXYj7iJbkrhE7bq32IylCKbD33nuHZs6c2eF8999/f+ioo44K9XU8GyrxEYn6+2rL/UObX/5d6OV/f9FmGv5m/FKu/mqnbtVm2h//94CatuDKm9tMq9phNzXt2kd+jLvcbz6bq6ZXTN+7zbRbp58XOv+JuaG5tz/WZlr9pKmRbQrY7G2mz3z1CzVt7SHHtZm2/OTzQze9sjB08AF3t5nWWjo4slz8O3Y63rPjNT+oZcROw7rwPqw7dhq2UV8utj12OvYR0xZdcn2baTg2mIZjFe8YfvvdYjUdxzp2Gs4JpuEcxU7DudS3Kd5yf3jrezWtfP/D20xbdualatrsB19sM615+KjIcj35hW2m/+/pd9W0lcef2Wba6qP+qqb99J+P20zzZWVHlts4ZkLb5d7x79CyVTWhhquva3teDzwktGFDfWjDrD/i7utXP60IrVlXF/LsuHObaXP+/i+1zvnX3tlmWs1WO6hpX8xcEXe53304S01f/6c/t5m25LyrQqvW1IZqn32p7faOnxh667vVoTe/Wx3yZ+e0fe9bn6v9aT75tDbTms48V02rfu+Ttp/DoiLtOGyoD/lHjW67Py+9HlpXXhdacdZlbaY1HHqkel/lD7/E3dfPZ63r0jXiq68XxV3u4p8XhhYsqw417Llvm2nrr75RTVvzwFNtprVsOk1Nw1/A3vYaseyjb9W02qNOaLtNZ1+kpq188e0207yDBkeWi3/HTsd7MA3LaPOdO+oENQ3rjp0WtNtDi1fVqOnY9tjp2EdMwz63OTd77qum4VjFO4aLfluupjfusnubaeU33K6mrb3rkTbTmrfYOrKv8Za7dMbPalrdwUe2mVZ54RVq2qqnX2kzzTNydGS5vsKiNtNXvPahmlZ96tltP6MnnKqmLX9nRptp/uzsyHLxHYqdvvqxF9S0DZdf22Za/X4HqWlLvpsTd18Xzl+npjdtt1ObaetuuUdNw2PsNMyvzs3i+NdZrA/Tsf7YadhOTMN2x07D/un7iv2OnY7jg2k4XrHTcFwxbekrH7aZhvOhLxfnKXY6ziem4fzGTsPnQC13xs9x9/WX+RXqr2nzrdtMw+cP78Xnsc33ZqfdQv+bvyE0d9aylK8Ra6/6Z2jJiupQ5aNPt/18bzJVLffXhZVxrxFrPvsutHptbaju6PjXiPlLq0JLn3+z7edw8JDQ+vV12nV28JC2n+E33lO/N9XntL1GNB9/knpf1Vcz495HzMIxXFChtr3NcXriGfXehhvaXmdb99lPTav4Y2ncY1ixZLWa7tltj7bfjVvuUNtbdf+jbaZ5t9om8psSb7n4vcC0lsOPajOt8bIr1TT87rQ5hqNGR5aL3602n+H3PlHT8HvX5hiefJr2G/jpV22PYXZOZLm+iZPaHsNnX9KOYYL7iOrqxlBo1aq4+7phVYV2DOPcR9Tfdb+ahsfYaZhfbdOqivjHcPY8NR3rj52G7cS0ePcR2L/IMYxzH4Hj0133EZiG8xs7DZ+D9u4j9OXicxU7re7Bx7RjeMsdbY/hbnton+8lq+N/vv9Yqh3DffZrewxvuFk7hk880/bzPXWzyDbhNzoUex34aqZ2DI8/qe0xvOAS7fP9xnttP9+Dh2w8hgmuEerzfcElKV0jsI2RYzh1s+SvEUuWJK0hTfhfMkK8tbVVFTH7+eefVdXw9pg/f74cfvjhal5Xsko/A2lu9sjPr3wRcbCBPzdPWoeOVCOicFjT6WAb3alYEjnYwFM6WHxFJWKtrxXnmpVpdbDrC8rkgkd+leE1qyTbYZar/zxcOcLxHOwNdV6582Ntv5bmDpMmu1se3tMlI4N1ve5gZ2c7ZP3QcRIYoA52ZJ2hkIrAyB1ULJMt9ZJdvSGug12+oVHWfTdLclzWSI4jqu8uHzJRhha7ZGLDGuXqIAQRoeHIRbSPGiG+gqIuO9jWho3HELnfa12FkjVyqExyeiWnfOPnG3mIi+tCysEeXOCQ0lWLpKmhJZI3iVDzuuHjZOTwfBnetEGsMe5rV0aevSNHy9JWu5QvWCGDWqrVMcK2Ip/SXlIogzefKMXWgBp5Rlj48spW5eigf3nTJpul5RqB84HQ+EmD3CqMdaA42Dk5LqkaNUEC/hAd7H7oYFvMISlasVgaYhxsDxxse2oOtnTCwY46hkXFKnLB1NQo9mUxzorBwbYvxDXCG72vI0crN9SyoTyhgw1X0B7rrGBfp2ym5UkvWqiu8ajCrru3vmEjJJhfoM43znvUMczKFt/oseoa4ZjX9jqb6Bqh3PqSQdJaoN1HZK1bpSrIow0bHHJrlltCEydqhegM1whc83Adwn2EOcstllWrxNFQE7W9sdcIrCsIZ9nlkAYUqpu0ibrHci38Q+yhQGR7sN76oaOkxZEtpnVrxVldoX6/cHlH6oCluEiso0eJzdsqpoXzVSg8nHOEsCMsPzhtM8FWmucvkGBLswqTx/vQr940epRYiwrEXFGR0MEOeb0SnDvXUJguXKRv2rQ2DjZ+c3zIzy8eLE25RcrBzipfHa5XEE4vzMruVgdb/e7NnSO2UCC6gn4vOdjmcWNVsdP6736SAB3sfutg5+a6pL6+RfwDxMHO3XFrsSSpa5MW2Bs2bJDdd99dbrzxRsnJyZGysjIZM2aMZGdvLISlg0Vuvvnm8uqrr6r2XX2Vpla/fD57w4DrzRvLHR+slh+XaT8k1x8yQuXxxuO1nyvlvz9G3+QdtEWhnLBD77YQslhMkYsAwvcGOvghRhutohybEmfIxTOCUOY5q5vU9THPHZ1Fgpsp5HMPzbfLqBKnLCpvVUV82ut3nY7txTpznGYZP8itCrchr2/+uhbVPg7rtlrNcc8x9qXJ41cV91HTIB19prE9SytaZXmlRwqzrCq80njtQyg+NmFUkUNyXBbV5xqDAegSkM4qvo1NjbJw4XzZdrMpUlqYKwMBVJjOz8uS2romJbBJ/4PnuHfRRHNIXedsaLEWHmBN5n3J5ljr57i6tlFaW4NKnGI1dpW/blaDkR5VjE3i5onjd0iFy4drAkB444m9nZxyzIP3YF3YTMyrV5o35pQjVB/rRjg8BLt6VVXN14Q78utxzce2Yv34LcLvDI4Z5sVysSgsR1+XVoBPq6OCdXVUVwTLxLqxn1iX1jLP1O682F41uICUuHB+fTLr6ir6YAjOg/H84ze5oCBLamqaxO+PHtQi/YOBeI4LC7O00Ph05mC73W4JBAJy7733Sn19vWrNhQsSRPb06dPliCOOkLFjx6p58frnn38uRUVFnd8LkjFsPzYnIrB/WFKfUGD/sKQh8m98/jBo+dWCOjl2uxIWN8kgVO/pXLsS2QukWSYNdkcKguEmaVlFqyrwE08044ceQnFNjVcVsIG4TqYvd1e3F7nNlY1++X1Ns4wtdaoqwmhdNii3/V7beoGiZZXaPuG9KCTUWXCTBTcafxidN4prgG1BUTnkSy7a0CIum9beqDv6kPtam6Vx9a/imTgG46ppXz4hZOARK5RSeV+qIDcc11CHQdijkJ0Fr1vjt4Az9miHuMN9Bn4jOioYqa3LFFmXVmneHyW2/XDjvXDBg6ptG4SqcbnKrfdqghpiW38NYjt2Xmy7wyDsVYE5UyAigFVRPYMAxm8LflPRgg4F6tR+od+8B+/RxDLeh0csG4MAqFWiz4vXcczwe4MimiLaurQBAe13sKOCdvrgAkS7PhiAZcQT6ThXmA/HA8fALOHjGx4QsPZA3U2sHyRTdI+QnibprwCc6vz8fHnggQdk6tSpUlFRoULBZ86cKZ988ok8/fTTsscee8g111wjgwcPprjuR2w5KjtSRXXmkkb5684YlY2+mK2r9cqKKi38ZVypUzl7EOW1zQHVQ3urUW0jHUhmiOyFphbV4g0ie22NR/Wyju3JbgQ/nhCMqJhbmKW1D+tu8OOJbULLMLS4UqI1J7l14wcf+woXvNUXkLGlLinqRE9w3ACtqGpVYh3iur0q5apvr0VzYlAZvTvIyiuWQdscK7n5/G4RQgaesMfvgtXS+XXFE9u410lUeV4X9kBvkdZRlXqjsFdiG33ZWwMSCuliWxsc0IRqSLnfELeoDq+D3zut0J1PbTfmx2AAfsdj51X7Zd3oLCONCz3jtdfD7ruhUj1+11ABXwl7nza4gOXjPbr7rg8IYBla14yN82ri36zWpwYfwgMCLlThd2lt4RDX356TjmWiTz0GDLD/7bn2+iAA5vWEQ89V5X5EW4T3qzP3JNj+ZES6flz1VAV2yiGJSOnOb6eddlJiGgK7pKRE/e2yyy5y2WWXKaF93333qdzrZ555pk+HhpO2YmGz4Vny8/JG5RwuLG9RrqeRmUsbohzvIQX2iOs9Y34tBXYGojnDmsgGg/PtsqLKq1IiOvrRwPSutOPqLAgPx40AfkCTDV0EmB+Vu3ETBRd8dLFDhhYk1wJM/1FdVe1R7n6ey5pUCzAco2zLwE4vIYSQTMYotlOhM8JKiW3rxtZuWus3tFzTlhfbzi2yLgg5u9Z6DgMCEOoO68Y2cfHANFSIR+s5oAnjkDSFRTp+P7EtSF/Sw9uREmAcMNAHBHRHHO/D+vVQ+OjBBSwzvC4l2rX+8HX1PjGH0C4P27LRSU8k7AFEur6NrnC1eghao7C3mMxKUJvC+1ancuW1QQsMaOiDCO2527oLD7GObdYiBDZWx483L44X9g2lHLRt1AYgsN5UQ/LxGcD4AzLXkml7h23Qw/Ep7vuZwD7ppJPk9NNPV4/FxcVR07bbbjt5/vnn5YYbblC9sF9//fV0byvpRSCaIbD1UPBYgW0MD8e8cAjzXBYVFvW/5Y2q4FQq/ZdJz6AJT01ka21g4Lj2vHBOBbSv6Qz4AcPnEuF9C5EX7QvJqOLk8rIRobGkolX13+3s+tNNS2OtVP4+QxoL/iR57pLe3hxCCCFJEiuAUxoQ0DLDU8IaEY1aGLlygn3BdoW9PiCgO+IwjI391hOuC9toNUm2wypeu0laPfpAguakIzRe3waJI+yBPr3W51euNtLslbuv8uCj59UHSDTButFJx/YbHXhVpA6h5WG3HCH5ulg3myVqIEEXzkB3yzG4AHce22CxaW6+SmsIRz+o1IYOxL1RKGM7sQzVTi4s7nE+dOce8yJyQQ/Fx75hoAFTY8W9NQXnXk/H0CMUOoouwLweX0DNp29jGsrZJIVeJqwvpgCk9NXebLPNZK+99pKLLrpInnrqKbHbo2/EcQAuvvhi2X777aWqqoph4v0IhHjredUzlzTISTuVRkYb19d5VdEnMKbEGck3nT4xT96ZXa3e883Cetl/s8Je3QcSH1yUS3PsahAEhc/6O8jLxo0Nwr0xqICQ8fYKGeLzvXB9q4rkcHchfzvdmMwWsTpzxWzOnG0ihBCS2ShB1kPh+JpIN0fUhhbijZBxTVQmEk7GbUxWZGG6Jmy15yr835CTrgvQSHh9jFh3GLZRF86onqe75cZQfLWNBqdbF87xxD1EKe6f9ekQzBDKqLaP9wfC2xgK+VVuP17DOL7m1ofU4IKWT6/l+euDHVheq9pGPTVAz4FvmzuPdUCsQyjry9Ur6+N9dttGFx7LxiAEBmAwrx61gLOAbUThYOxTljMkDjcK/AXVCEh75ydkGFiInN8EgwKxgxCIdtAGo9qvC5BO8BnQCzd2Ng0gZUvxuuuuk1NOOUW52HfddZcMGTIkavqcOXPEjBGeGPFN+jYoDDVtWJb8srJJqpr8smRDq4wvc8UND9fZfZImsMGM+XUU2BkMLiAozjVQwIV6UDgvu8XbFB4YalvlG0Xc4Hbjop5p3QSc7hzJH7uTuLOYg00IISTzMYrSZOmsexkJ/zc48Kg931HefGe3UYlAiRb3DS0BCYb8ShDqojq2gJ8mcrV/4z3ohNLoCykhq4vqeIMdRnGP92kpAG3ddBUGbxDKetRCKCwkm7xBaTAMCmA79ZB9vXheVOu38DbWtfhF6r3S0OATGNoQ6rEOt0+F1qN4oTawgG3Q90d34bGP+r7oYfi6W6/EtEmU0EbtAnVODfvWkXuvCXVtsADbYRxMMAp1o6jHvBgEQoqEOibqGGj7pjXDTi5fP2WBDeEM9/of//iH7LfffrLnnnuqllw2m03mzZsnb7/9tvz1r39VrbxI/wLiGQIbfL+4ISKwjeHh243ZeN6HFTpUwbPFG1pVATTkr44ucfbClhOSoNBbnl0VTvtjbbM0tjpkRLEzEp6F1xeua1HDtvndVKisKwSDQQn4WiUYxPcw87aPEEIIyQQ2OvCmni3aF/5p1sVad0UXGJ37aDcdFd61MPxYoazl0kcPCmhh8IkL/Rm3UaUBOK3S2mISryco9b5glMMdDA8yxBtYiHLhkQYQdsixeZgndmBB30YcRwwKtHhD0ujZOJighHo4XB5vU8tV+fIb8/sxH4r+GQcTsP/YVgwAQIgr1xoRC2HRDsMdgwn6vpWVhsQUwrI6Pi+duiuDyL711lvl2GOPlbfeeks++ugj1cJrxIgR8vDDD8sOO+zQmcWSDGeb0Tny2JflWpj40no5cccS1ToJAhqMLHKoQllGdp+cF5kOF5sCm2QaKJyGat+oDt4UbuWFH4QF65rVxbm9iuq9SXNDtWyY9bo0FB4pBdmDe3tzCCGEEBKHZMR1uoh107u7RZ8SteF2e0aHW0wS14FP5MLrr7eHObxvOrp7D8e5OSzUsQg9Xz5efr9RqGMQIhRCNXxTJLc+at/0MHp9uyPb2g0OdmxONv7IwAC5q1OGZsmvq5qkosGv8q7nweGLEx6us9O4XHn6mw1qNOmbhXVKlKdS/ZmQngA/AqXhkHHkZeOCipFOhI1nKggRL5iwu7iz2AObEEIIIb1PZ134zhDPvQ8lMaChC/XuTGam0iEpYRTRCA1HwbN403RQFEoPG0eoCiqKJwO+JO/+Wi3Pfrte5UMQ0t3orbz8AVG5PiVxcrIzCavNIc6C4WKzp9pghhBCCCGkf2EyaX3iMwEKbJIS24zOVjkP4Iv5dbKgXHOwhxdqfYXjsdukvMi/Z8yrS2o9v6xokme/3SDv/lojz3+/gWeJ9NjFuSDLqtzsTLlIJ8LnaZGm9QvF49kYRUIIIYQQQnoXCmySEuhlvelQrQc2ely3517rTBnmluJsLRth9qomqW7ydbiez+bVRv79+bw6qQm3IiCEaHham6R++UxpbU4uKoQQQgghhHQ/FNgkZYyVwpMR2HACdw272KgN8Pkf7bvYqN48a8VG0YD8bYSLE0I2kp1XLIO3O1HyCkp4WAghhBBCMgQKbJIy247JiaqfNzTfLsMK2i8VsOfkfFXZD3z8e42q3peIrxfWqUrlRj6eWyP16LlHCCGEEEIIIRkKBTbpVFujyUO0Hthgu7E5HRaDKs6xybajNZe7tjkg3y2uT1jczJinvcWILPWIEvzv/1bDs0VImJamOqma/4k0NWxMpyCEEEIIIX1MYK9fv15mz54tq1atSjgPpp900kld3TaSwewxOV89ohT/9AnJtQnaf1pB5N8f/FYT6XtnBD2zV9d41b8nDXbJ6bsOEr2r1wdzaqTJszHvmxAZ6NUyLfaMrnROCCGEEDLQSLoPts/nk6uuukree++9yGvjxo2Tv//977LDDjtEzVtbWys//fRTereUZBS7TMhVTnaeyyJDElQPjwWCeXSxQ5ZVemRJRassLG+RiYO1gmk6Rvd690l5yvnedWKeKnTW4g3KR3Nq5LCti9O+P4T0NZzuXCkYv6u4s7N7e1MIIYQQQkiqDvazzz4rH3zwgZx++unyyCOPKGEdDAbl1FNPlaeffjrZxZB+AlyzacOzZGSxM6X37DetMPI8NuQb/a6/DYeOO6wm2WGc5owfsmVRJH/7vd9qpJV9sQmRUCgowYBPPRJCCCGEkD4msN9880059thj5ZJLLpFdd91VTjzxRHn33XflzDPPlNtuu01uv/327t1S0i/YaXyOcr3BzKUNUtmwsWUXnsOlBjuOyxWnTft4Dsqzy05hsd3QGpBPf2fOKSFN9dWy/ucXpb62igeDEEIIIaSvCezVq1fLVltt1caRvPDCC5W4hsN93333dcc2kn6EzWKWvTbV8reDIa06uM6M+Ybw8MlaWy+dw7Yqivz77dlV4vUn79q9/nOlXP78Qlla0drFrSckc3C4siV/7C7iykrcIo8QQgghhGSowM7KyhKPxxN32oEHHih33nmnPPbYY/Lcc8+lc/tIP2TvKQWRwmWf/lGrQsPX13nl9zXN6rXB+XaZOGhjlXIwrNAR6b+NKuRGMd4ei9e3yAvfV8jsFY1y5werUxLmhGQyNrtTXMWjxW5PPk2DEEIIIYRkiMAePXq0zJw5M+H0ffbZR26++Wa59dZbowqhERILiqMhBBw0eoLy9aJ6+WJBdHGzeJWRjS72W7Oq2u2lHS/Pu7zOJ+/+Ws0TQvoFPm+rNFcuFa+XkRmEEEIIIX1OYO+7777y/vvvy9q1axPOc9BBB8k111wj77zzTrq2j/RTolt2VcsXYUcaunr6xPhtv0aXOCN9sSsb/fKVQZTHo7rJJ98vie63/cb/qqLyvgnpq3haGqVuyTfS0tTQ25tCCCGEEEJSbdN1/PHHy5FHHilWa/tvQSG0IUOGSHU1nUKSmLGlLhUGvqC8RVZVa32vAQR0YZYt4fsO37pYflnZpP79yk+VsvOEXLFb448TfTy3VgLBja55bbNfPP6QPP/9Brlo76E8PaRPk5VbJIO2OV5y85PrQ08IIYQQQjLIwQZ2u13M5o7fgirjhx56aFe2iwwA9jO42Dq7T9IKoCViwiCXbDlSc7Grmvzy4ZzoVl86yLX+JFxtHPne/zphvOQ6terl3y1ukN/XaCKdkL4K0ihMZkvcdApCCCGEENIHBHYscKnnzp0rs2bNivtHSHtsOzpHirI2RkTkOC2y1ajsDg/acduXii4p3phVJY2tgTbzfL2wXrX0Asj3HlXikuN3LIlMf+rrDRJAGXNC+iitzfVSvfALaW5MruAfIYQQQgjJoBBxI+vXr5crr7xSfvjhh7jTQ6GQclXmzZvX1e0j/RirxaQqir84s0I932VCrnqtI0YUOWTXSXkqb7vJE5Q3Z1XJCTuWRn3+jMXNDtisUD3usUm+fDynVpZUtMqqao98NLdG9p+mTSOkr4HPuYQCwmEiQgghhJA+LrCvu+46+e2331QP7IkTJ4rb7WaYIul0mDj6U7d4A1FVwjviqG2K5dtF9eILhOSDOTWy79QCKc7RcrfnrmlWAhpMKHPJ+HDLL7PJJKdML5OrX1uhnr/8Y6XsNC5X8tyd+hoQ0qu4svKkcOKekpXdcdQHIYQQQgjpGTqlLH766Sc577zz5OSTT07/FpEBhdNmlkv3Tb3gGMT0flML5O3Z1Upkv/xTpZyzx2A17T1DK679N4vO8x5f5pLdwu53szeo3POzdtfeRwghhBBCCCE9noOdnZ0tgwYN6tKKCekqh2xZJFkO7SP85fw6WVnVKutqvTJrhVbArCjbKtuNyWnzvuO2LxGXXXvfjHl1snh9C08G6XM01lXKupnPSl2NlmJBCCGEEEL6qMDeZ5995Kuvvkr/1hCSAtlOixy6pRZWjjzU//xQIR/M2eheI2zcYm6b042WXUduUxx53+NflbPgGelzOFzZkjd6B3G5GSJOCCGEENKnQsRR1MzIYYcdpsLDv/jiC5k8eXLC95WVlXV9CwlpB4joD36rUS274Fxbw4LaYTXJnpMTt/zad0qBzJhXq3pwL6vwyDuzq5UjTkhfwWZ3irt0vNgdWo0BQgghhBDSRwQ2+lrH9lpFBduzzz673fexijjpbuxWsxy9XbE89Hm5eu4Pt97adWKecrgTgWrlyL2+5rUVysV+5adK2XZMjgzJt/OkkT6B3+eRluoV4hs0VoQuNiGEEEJI3xHYN998M6uEk4xl+oQ85UDDjTZWJ+8IFDxDEbT3fq1RhdIenbFOrjtkhKo2Tkim09rcILWLvpTmkaUi+QwTJ4QQQgjpMwIbIeGEZCpms0mO275Ubnt/tXq++YgsGVrgSOq9R29bIj8va5T19T6Zt65FPv29VvXmJiTTycoplLKtjpacPH5eCSGEEEL6dJEz5F1/+eWXCac//vjjsv/++3dluwhJiS1HZsnxO5SoquFn7DoopTZhZ+62cf7nv6+QygYfjz7JeExms5itDjGbO3UZJ4QQQggh3UCn7syQf90eaOG1erXmJhLSE6BGwMFbFKme2uiRnQpThmXJHpPz1L9bfUF5/MvyDj/jhPQ2rc31UrP4a2luqu/tTSGEEEIIIWG6xfr4/PPPpbCwsDsWTUi3cOKOpVLg1jImflnZJF8vpGghmU0oGJSgt1mCwWBvbwohhBBCCEklBxu88cYb6k/nzjvvlCeffDJqnkAgIOvWrZO1a9fKueeem+yiCel1shwWOW3XMvnXB2vU86e/WS+bDc+SvLDoJiTTcGXnS9Em+0h2DgucEUIIIYT0OQfbYrGI3W5Xf8BqtUae639ZWVmy/fbby1133SXnn39+pzYIud0oqjZ16lTZZZdd5O677xa/35/SMq699lqZOHGilJdrrZsISYZtRufIDmNz1L8bPUF54qv1DBUnhBBCCCGEJE3S9txBBx2k/sCJJ54ol112mWy22WaSTubOnauc79NOO01uuukmWblypdx4443i8/nkiiuuSGoZzzzzjLz77rtp3S4ycDh5lzKZs7pJCeyZSxvkywV1stuk/N7eLELa0FRXKeU/vS31uYdJnjv5wn6EEEIIISTDcrCfe+65KHFdV1cnNTU1Xd4YhJzvvPPOctFFF6lK5fvss4/8/e9/l+eff14aGxs7fP/XX38tjz76qHoPIZ0h322VMwxVxZ/6eoOU123sr01IpmB3ZknO8C3E4XT39qYQQgghhJAwnU4w/d///iePPfaY/PTTT9LS0qJey83NVaL4ggsukOLi4pSXOXPmTDnnnHOiXps+fbp4PB6ZNWuW+ncilixZIpdffrnce++9ndgbQjay/dhc2X1Sk8yYX6eqit//6Vq54ZCRYrWYeJhIxmBzuMRWPFFCFqe0eNsWOkP3Lod14xhqvHki85pEHLbOzYvvSKKi+yaT1gqvM/N6fEEJxsxrCYrYPQFp8QbEbm5/XiMuu2Fef1DaqwuXyrxOm0l1MABef1ACaZrXYTOJOTyvLxAUfyA989qtJrGYU5/XHwiJL5D4ANusJrF2Zt5gSHz+UMJzbA6ZItfdePNGLdeycd5AMCTedua1WjC/OeV5g6GQeHzpmRez2cPfT3StaE3TvCl973vpGmE8x8FAeq8RCb/LvEb06DXCeI4D/vReIxJ973mN6NlrROw57iv3Eem4RnSbwEYINkK2R48eLSeffLIMHjxYhXFD5L799tvyxRdfyAsvvCDDhw9PeplwqKuqqmTYsGFRr2dnZ0t+fr4KF09EbW2tnH322XLxxRfLdtttp4R6OjCFf9gsFFZ9Gkv4hkd7TK7i8qm7DpJ565qlvM4ni9a3yuuzquTY7Uu6eUtJT57jvkxdi1+emLFKVq1eK+XeXPGF2l7KdxyXI3ceNyby/MB//aF+mOKxxcgseegv4yLPj7xnntQ2x7+zmjzEJU+dNiHy/IQHF6jvSTxGlzjkP2dPijw//fFFsqzCE3feQXk2eePCTSLPz3t6icxbqw3exos0+eCyTSPPL3thmfyyoinuvPixnXHV1Mjza19eId8tbpBEfP+PjdFZ//fGKpkxry7hvJ9fOUVc4R/zO95bI+//mjiS6/1LN5WCLO08PfDxOnn956qE875+wWQZnK/VO3loxnr5z/cVCed94ayJMqbUqf79728q5Mmv1iec98lTx8smQ7WIhxd/rJIHP12XcN4HTxorW47SCui98UuV3BkuABmPO44ZLTtNyFX//nBujfzf26sSzvt/R4yUPTfR0m6++KNOrnl1RcJ5rzlouBywudaR5IeFDXLZS8sSznvpfkPliG20gf1flzfJuc8uSTjvuX8aLCfsWKr+vWBNi5z65KKE8546vUxOC0c1rdjgkeMfWZBw3uN2KJHz9xqi/r2h1ieH3Tcv4byHbV0kl++v3e/UNAVk/zt/Tzjv/psVyLUHj4jctO51x9yE8+4+OU9uPnJU5PleNyeet39fIyzywWVTIs95jeA1gtcIDV4junCNMHWzwL7//vtVMbPHH39cFT8zAgf6qKOOkltuuUUeeuihpJfZ1KTtlNvdNtwRxdMShYijANqFF16o3O2jjz5a0onJbJKcHJfkspJ0vyAry5H0vLhVvPrQMXLhMwvUiNbrP1fKTpMLZcpwVmzuL+e4r1LV4JMb3lwmTXUVcnTpb/LfDVtJpU8rzmfEarNIfl5W5HnY5IyL1Ro7b+KZMYhhnNdscJJjwbTOzqsPmsQDm2ecF9uf9Ly2xPMC47x2W/s/kXm5WeJ2WJKc1y352Tb1b4dde0xEbo5L8vO0G2Kno/158RuVn6f9bjqdHcyb7Yzsn8upCfhEZGcZ563v8Hunz+t2NbU/r3vjvFnu+OJIx+0yzJsVX3TpYH/0ebOz/EnPm1PX/oAcjmlk3pb2765wrvR5mwLtf87wGdDnDVrii08dfLb0eeEYJTtvR/Tva4SJ14gwvEZo8BqhwWtE568RZhOuOe3Y3Mb3hBBLkCLTpk1TxccOPvjghIXG7rnnHvnll1+SXub69euVSEZ+97bbbhs1bY899lCi/ayzzoor9mfPnq3C1XWxDwf7pJNOUhXJBw3qfPGf5la/fPHbBslxsVVTXwY/wrgBbGrySKC9uMw4vPpTpbz4g+YeleTY5M5jR6uWXqT/nOO+RGWDT65/c6Wsq/WKWYJS4vbLrcdMlpGlrjbzms2mmNCuQLs/NMawqlTm1cK1Qj0yL85zdpZLGptaxG6ILGpvucBlt8SEfadnXmxvdNh3euZF6Fx02Hd65kWYcXT4Z3LzaiGdib9XNqs5JvwzyXlV+Gcw4TnGpyE6/LOd5VrMMSHiiefFfNEh4snNq4V9p2deHNvosO/0zJvK9763rhHGc4zvV3dcT2K/y7xG9Ow1wniO8ZuczmtEou89rxE9e42IPcd95T6iK9eI4YNy1O+ttZ3BPZ1OKcdx48ZF8q7jUVJSEteJbg+41KC5uTmuu41Q8XisWbNGvvvuO9XWS0c/QBDm22yzjRL8nQFLwTUg0M4FhvQFtAsNLgCpnsuDNy+UX1Y0yvx1LVLR4JPHZpTLBeEQQNI/znFfYUO9V254a5X6HILCbLscv9MwKc11ROUjGwkYctcSzdPVeW24cWvHzUrnvEjXgWPsbTV1erlWxHiZ0zMv8kf10WyLbMxH7Oq8oYBIIDyvWUxiT9O8+Jrowj6VeU0dfSbSOG/sOdbPR4fLDaXwGc6EeWXgzBv7/Yw6x6Heu54kmpfXiK5fI6LPsbn7rieGzw+vET37vW9zjvvIfUSX5sXsSYaJd0pgwx1+9tlnVUh2vDAhtNuKdaE7AgK6sLBQCWYjCA1HjnWifG7kXZ9yyilRr82ZM0dVEkdV8ticbkJSAaN35/9piFz232Uq9+2bRfWy5cgs2XlCHg8k6THgWP/zrZVS1eSP5CJeume+bFj2k7SM3F7y3AU8G4QQQgghGUCnBPbPP/+sCpqhX/WQIW3dvE8//VTGjx8v1157beQ1CPF//vOf7S4XBcrQauv444+PvPbNN9+IzWaTrbbaSj2vrq4Wr9cbCf0uKytTf0b0lmEowtaVEHFC9NDw03cdJPd9slY9f+zL9TKq2CnDCvt/vi/pfVZXe+Sfb6+MFBQamm+Xaw8eLhZfg6xpqpaAv/18U0IIIYQQkuECGyHZRUVFsmzZMvUXi8vlktWrV6u/ZApi6MCJPvbYY1X+9r777iurVq2Sm266Sb2mh4ijoNmPP/4oCxYkruRJSLrZeXyuzF7ZKF8tqFd5Gnd+tEZuOWJUVK4HIelmZZUmrutbNHE9otAh1x40XPLcVvH686V4ygGSncvCe4QQQgghfVpgf/755+nfknDxtAceeED1sn7iiSdUey4UUoOoJqS3OW36INU+ZFW1R9bUeOWRGevkwr2GJDV4REiq4HNmFNdoZ3PNgSMkx8kie4QQQgghmUqnqogbCQaDUlFRofKnEcrdn2hq9cvnszfwhraPg0IMubkuqa9v6XIBLOTCXvnqcpWPDf66c6nsP03r00r6xznOlLDwG95aKXVhcT221CnXHDg8qoJ9TXWFzP3+Xdlx94Nl+JCBkQpjsWptNWrrmqKKk5D+A89x/4fnuP/Dc9z/GYjneNTQXFWbKZkq4p2Ob4WLfeihhyrXebfddlOFxQDCunfffXeZMWNGZxdNSMYyON8u5+4xOPL8ue82yPx1bSvfE9JZ1tTEiOuStuIa2OwuyRq0iTicqXVsIIQQQggh3UenBPbbb78t5557rowcOVIuv/zyqL5hqPa9+eabq3kI6Y9sOyZHDtpCc63Rxu3uj9dKbTMLTZGuszZGXCMs/Oo44hrYnW7JHjqVApsQQgghpK8L7Mcff1wOOeQQVYzsyCOPbDN9l112kdmzZ6dj+wjJSI7drkQ2HaI5hzVNfrn347WRvo2EdIa1tVqfa71a+Ohih1x74AjJTpBzHfD7xNuwXvx+rS82IYQQQgjpowJ7+fLlSkQnwul0SmVlZVe2i5CMxmI2yYV7D5GCLK1O4O9rm+XFHyp6e7NIH6W8DuJ6pdSEIyFGQVwflFhcg5amOqn64yNpaqjtwS0lhBBCCCFpF9g5OTlSV1eXcPqiRYukpKSkM4smpM+Q77bKxXsPEb3Wwduzq+WL+Ym/F4TEo7LBJze+vVJFQoCRRR2La+DOzpeSaQdLdm4BDywhhBBCSF8W2NOnT5cXX3xRvF5vm2lr1qyRF154Qc1DSH9n0mC3/GWnssjzR79YJ/PWsugZSQ7k7t/4ziqpaNDE9fBCu+pznUwrLrPFKlZXnlgsneq2SAghhBBCMkVgX3zxxcrBRh72v//9b9UH+JNPPpGbb75ZDjroIHE4HHLOOeekf2sJyUD2nVog+0zJjxQ9u+PDNSrkl5D2aGwNyP+9vUq1fgOD8mzKuc51JSeYPS2NUr/iJ2lpbuSBJoQQQgjpywK7rKxMXn/9ddliiy3kmWeeUVXEIbRfeeUV2XXXXeXll1+W0tLS9G8tIRnKX3cuk82GZ6l/N7QG5Lb3VkuTRytWRUgszd6A3PTuKllZ7VHPi7Ot8o+DRqi0g2RBkTNP3Vrx+zmYQwghhBCSKZhCxh5bnaS6ulqCwaAUFhaK2dzp1toZR1OrXz6fvSGpcE2SuVgsJsnNdUl9fYsEAt1X6bvZE5BrXl8hq2s0wTNtmFuuPGC4WC2mblsn6dlznA48vqDc/N4qmbe2RT3Pc1nkn4eOVD3WU8HrD8ryylbZYkS25KUgzPsyFqtJ8vOypLauSQL+zD7PpHPwHPd/eI77PzzH/Z+BeI5HDc0Vs9kkVr34UjukRQ1DWBcXF/crcU1IqrgdFvnb/sMiAzK/rW6Wp79ZH9UnfqDS6gtKRQPbSfkCQZVCoIvrbIdZhYWnKq4JIYQQQkhmkpTtcdJJJ3Vq4c8++2yn3kdIX6Uszy6X7zdU/vnWKvEHQ/Lx77UyJN8u+29WKAO5kBec/Q31PtlxXI6ctftgcdoG3mBcMBiS+z9dJ7+ualLPXTazXH3gcBlR5OjU8pobqmXDLx9IQ96fJc+9sdAeIYQQQgjpPZK6y7XZbGK32yN/DQ0NMnfu3KjX9L/GxkaZPXu2KnRGyECtLH7W7oMiz5/5doN8t7heBiJw7x+ZsU6Ja/Dd4ga56pXlsjqcezyQjsNT36yXH5Y0qOd2q0mu+vMwGVvq6vQyrTaHuIrHiM3uTOOWEkIIIYSQbnewn3zyyajn119/vWy55ZZy7bXXtpkXrbsOO+wwOf7447u0YYT0ZaZPzJO1tV55/X9VggDx+z9dK9kOi0wLF0IbKHw2r05mrdAcW501tV656tXlysneaXyu9GWQd//R3FopzbXJDuNyxGyKn2//2s9V8vHcWvVvs0nkkn2GqoGYrmB3ZknO8C3E6RpYnylCCCGEkEymU3GaX331laogHg+42Mccc4w8/vjjXd02Qvo0R29bLHtMzotq37Vkg5Z7OxBAq7JnvlkfeX7KLmUyolCLbPH4Q3LvJ2vlqa/LxZ/hRcnaKzKGSuAvzqxQ+3Lt6ytU0bFYPp5bIy//VBl5fs4eg2XLkdldXn8g4BdfU5WqJk4IIYQQQvqwwEbVcISCJ6KgoECFkBMykEF/+NN3HSTbjM6OFPq6+d3VytkeCPnGD362TglpsOcmeapf+E2Hj5TpEze61h/OqZXr3lwhlX2sAFowFJIHPlsni9ZvFNT4999eWa4K26ENF/hhSb08+dXGQYaTdixV0Q3poKWxVirnvieNDZozTgghhBBC+qjAnjp1qvz3v/8Vjyd+HuUnn3yiKosTMtCxmE1y4V5DZPIQV6RH9k3vrJTqpr4lKFPlrV+qZUG55taX5drkLztpRbgcNrOcu8dgOWPXQWJFrHRYmF7+8jL5camWn9wZPvytWk599A954fsNylnubv7zQ0Ukn9phNalCdgAF49//rUYufnGZvPpzpdz3yTqVIgAO2qJQ/rx5+q6Lrux8KZ5ygGTn5KdtmYQQQgghpBcE9t/+9jdZsWKFHHTQQfL000/Ll19+Kd9995289tprcsopp8iHH34oJ598chc3jZD+gd1qlr/tN0xGhqtFVzT45aZ3Vktjq+Zy9jeWVbTKyz9VqH8jJfncPaOrhsPZ/9Om+XLjYSOkJEcrA9Hk0dpXPfFVecoC+edlDfL4l+tlZWWrvP5zlVz5ynJZuqFtqHa6+PT3Wnn7l+rI/l28z1C54+jRcsx2xWIL9zyvafLLyz9WqkryYLdJeXL89iVp3Q6LxSq2rCKxWG1pXS4hhBBCCOk8plAnm/TOnz9fbr31Vpk5c2ZUn99x48bJGWecocR3X6ep1S+fz94Q6WtM+iYWi0lyc11SX98igV7M94XouvYNrV0VmFDmkqsPHCYuu6XTYcrfL25QBbbGl3W+GnU6gTiGwF1do4XBH7JlkRzXjrDEIMOjX5TLTIN7jYEIuP7Dwvna7bGh3qvCsiHQjcAcP3SrIjl8q2KxhkVvOpi9slFufW+1hHWznDq9TPaZUhC1PU99vT6qsNuWI7Pk8v2GqWiGdNLY2CAL5v0m2265pZQVpSfsPNOxWE2Sn5cltXVNEginH5D+Bc9x/4fnuP/Dc9z/GYjneNTQXDGbTWK1mLtPYOvU1dUpN9tiscjgwYP7VWg4BXb/IFMEtl74C8Ww6lo093ryYJdc9efhneoL/cpPleoP/HXnUtl/Wu9/9579dr28+2uN+veoYofcfPioDgUuLkGf/F6r2pn5wucHYdcn71wmu0/OU453PHyBoPzjjZWyJOxWbzMmV6oavLK0ojVKrMNBH1Xc9VZWKypb1fpafJqY//NmBXJSOPQ9dn9+Xt4o78yulkF5djl1lzIVGp9uamsqZe4PH8iOu/1Zhg0eGH2wB+IP+kCD57j/w3Pc/+E57v8MxHM8qicFdn+GArt/kEkCG6DS9A1vrYy4rpsMccmVB6QmsuGGn//CEvEaLmqHblmkwpQTCdLuZt7aZrn+zZUq5xih0rccMUpGhMPik2FllUfu+XhNxP0G24/NUYXi4kWRoAI5iqSBQXk2eeS0TcTT4pHXfqqU1/5XqSq3A1wH4WTDTe+sm42c+atfXSFVTX71fNvR2XLJvkMTtuXqqWgBfJa2GJEtee6kOi72eQbiD/pAg+e4/8Nz3P/hOe7/DMRzPCoFgZ1+W4UQ0i5wU689aIRkObSv3x9rW+T291eLJ+yMJgOca6O4Bm/MqlLh1gE9frmHxd4jMzYW9ILQT0VcA8wPUf6nTTYW7UIhscteWqZCs418t7g+Iq4h5i/bb5hkOS1KQB+xTbFyzvWWYBDaaJOFUPJF61Nvk4bzcvv7ayLielypU87/05BeFdeEEEIIISQzocAmpBcYU+KUaw4cLm679hWcu6ZZbv9gdVIFvtbUeOTzeZq4dNnMqt+2LvU+n1cnd360pkcqaRuBgF1XtzG3/IBOhqsjlPqM3QbJJfsMkezwAERNs1+1N0MBNLQ6Q5uzR2eUR95z8i5lMrokOgQcz285cqRy9fXU51XVHrnmtRWqjRaWkwwI8Hl4xrpI2DmKsl2x/7BuCflOleaGGqn47S1pqNcKrhFCCCGEkN6n9+8SCRmgjC1FkbPh4gqL7Dmrm+VfH3Qsjl+cWREpsoXWT4dvXayKgukRKz8va5Sb3lklTZ6eqVK+eH2LyjcGaL111u6DVAhNV9h+bK7cccxo2Wx4VuS1j+fWyt9eXiZ3frg6kge9y4Rc2XNy/AJfNotZjt2+RLnio0s0NxuHDW20Ln1paRtXPB5v/K9KvlusFWBDCP/f9h8m+RkSjo3q4Y68IWK1ai3CCCGEEEJI70OBTUgvgurfVxuKnP26qknu/DCxyF5Y3iI/LtWEYb7bIgdspjnFO47PlasMedzz1rWoglyVDZ3vt40K34t1yzcAAQAASURBVMgVv/y/y2TBuua48/gDcHjLVf9ncMQ2RUlV/06Gwiyb/P3Pw+S06WVit2qCHS75qmotR3togV3lZ3eUcw43GyHjJ+xQEmmjhVZpcMXv+2St1DZrod+xoC/3Sz9qReTwrvP/NFhGFHW9WFq6cLiyJXfkNuJyZ/f2phBCCCGEkDAU2IT0MhMGuZSQROVs8MvKJrn53VXS7A20CVd+4fsNkedHblMcVRht2vAsue7g4ZLrskRCov/+2nLlMHeG//xQIb+vaZYVVR65/q2V8v5v1VEt+cDr/6tU6wGjix1y0OZFkk4gnveeUiC3HzVa5T7r4Fhdus/QpAvDoUXWQVsUyZ3HjJYpQ92R179ZVC8X/WepfDS3RoKG3HVUDL//07WR50dvVyzbjM6RTCIY8Iu/pU4CgfgDBIQQQgghpOehwCYkA5g02C1///NwlVOtFz678a1V0tC6UWSjtzKcaTA43y57TN5YDMwYdn7joSOlLNemntc2B5Q4nrlkY5/pZEAxsM/+0PK89UJhT3+zQe79ZG0kfxkiFIXVAMLTz95jcFp7ThsZkm+XGw8bKcfvUCLThrlVX+nOOOVom3XtQcPlrN0GRYrMNXuD8uRX6+Xq11fI0g2tUtfsV/nwnnARuZ3G56pc7kyjubFW5WA31mtt0QghhBBCSO9DgU1IhjB5iFv+cfDwSHGvJRWtct0bK1SLKLir//lho3t93HYlypWNB8T3TYePVD22AaqNo/DZm7Oq2jjQ8cC6UFBMn3NSeDkA+chXvbpctdRCaLjeCuvgLYrS0mu6PbC/WM81B41Qbn1XXPE9NsmXe48bI7tN2pi/jX7aV722XP7+2goVQg7Gljjl7N07DkPvDVxZeVK0yT6SldN2oIUQQgghhPQOFNiEZBBwoK8/ZKQUhAtpoSf0dW+slFd/rozkHo8vc8q2Y9rPu811WeWag4bL9Am5USHfj8woV3nT7fHx77WyrEIL+0arq38cNEIu23dopBjbmhqvXP7yskhl7WEFdjl868xzeDsCx+icPQbLDYeMkOGFWqEwjD9UhPPWcQ4u32+o2K2ZeZlEkTN7TplYrVq0AiGEEEJIfyEQDIkvEJRgEuZQOoAJhfUhRbPR41fFglu8QVUXKdUWuJl550jIAAb9oG84dISU5GjCaX29T179WQvFBifsUJqUo4oq2ufuOVi18dKZMb9OVRivb4mft4uCXy/NrIg8P23XMhX2ve2YHLn1iFEyPByWrV/rsBkIDce6+nLkwG1Hjlbh53oePIqhQVwXZmeuePW2NkvjmjniaY1fgI4QQggh/YeeEppGwQlx2ewJqD+PL6hMms5sRyi8LI8/KP5gKGFEJYQsUhEbWv3iDUDYinreGcGrL6vRE1DvxTKwH3hNF+5R++jV1ocWuii0i64x+n0htiWV3c6MfjOEkDa5wjceOkJufGeVcox1thqVrQRhskCIo43X4Dy7PPj5OvEFQvL72mYV5n3ZvsPa9I9+/rsN6gIDED6N3PDY0PPHvyyXrxfWq9fQ7xqV0Ps6GERA+PmO43LlhyX1MnVYVreHvHcVn7dFmsr/EE/rePjxvb05hBBCSL8HwgwiDL4CUtfMXUghg9BE6Zr2TBPNxdWcVawPIg86D1mCeI4/tEhNBn1ZWC/egW3X90NPO4TgxHSfP6TWg2VnO81qG1GbRgnsQEg8gZBYHX6tLg/2I86xCClHWHuPvizMguceiGwJiVm0dWM69hH3YzBtcl02ZXZgGrYbxxyPEMNYJgRv0BdzLLBwk6ht9weNy7KodQewb3hveD+wPhxPTENdHofNorrWGFMws50WlTqJ4E+1j0keawpsQjIUuKcIX77p3VUqZBsXwWO3K+nUstDGqzjHJv/6YLXUtQRUjvE1r69QPat3maDlIf+xtlm+CgtnXGiO377tulC1+7w9B8t2Y3KkrsUft9BaXwZRAwemuRJ6d5GVWyRlWx0tufls00UIIaR3gAsIydFTtUp00YY/SSASU1mWF+Iv1L5g1gVnIBQUq9mshFsgLNC0/ddErrYN7R8Lf1gkQrRZLCbxKH0Koa2/HyJOIvuIXUKqmi44YdzqQlMXinCWY0W3LtyxbGy7L2hclkXtczyxii3XBafTbomIXB1N7IbUyrKzrOJtMUurP6AdCwh3k3YMcWxDcZaFReliGccCjxDuWIO+j/gzHsPo84ptx3s3botPOePa8gBEcp49/rJ0sK2ak66ZLO19diCqEaeJxSQ7oEKBTUiG5wlff/AI+WJ+nYwsdqrw8a60A7v1yFGqz/biDa3qonr/p+tULjWE+5NflUfmxfO8cB54LLhQIWScEEIIIb2PLjTMKbiZiYB46UgsG0WumjUkgtg3TSSKOFJIG9NFrl4fRhepsWJXF6a64wiRiHl0oYnQY13s6q5uIrGruZiaKIUAg8DSHU0sQ3dVAcQnpjusZnE5bGK3hAV2+Jhju5TIDYtd7ItxGfjDJmjOsSbQ0THGaTcrd1UXekaRCIcY25/vsojDZo4rErMc7QhNo0Ns0o4F6spAeEYvq+0yMH+si2sk4ppbzZLntkkwxyZehzksljfmTZvEFFegA6tFE7WdvaPF9tss2rlTOLT2tLpTHnm9HfBdsXfxu9IeFNiEZDguu0X2m1aYlmUVwRU/dIRqS/X5vDr12nu/1sgPSxqkqnFj5ew/bdK/nOn+SEtjrVTO/Uwa8/eWPHfnIhsIIYSkBy2XE+IqLCCUsOrcDTwEWjAchtzeMiBkdCcX68Nzj1ans0ORGYvuZmLWRK6s5pxCSAUjobeIbNNdVTipmN7qDUlDi0/lvZqwHxBZMaHQRsEMQYRlQdxhGXpItC5UEdoLQQZhinsiowCE0NRFKgSeOgYJxC6OlC5y3XBVbRaVYwuxFU8wg6Kwqxpb8FQXmlqJVI1Eohv/6WHPWE6UANSFpkEkYputSYQjxxOa+BwaHWIsB8cr0WegzTI6QVuxapHeoLtaxXYGCmxCBhi4yJ+52yAZW+qUp75ery7Eurg2hQubJZtjQnoPs8UqtqxCsVh5GSeEEB1N2ASVUIS4wE13Z/NkIzma7SxDF50QRRApDguEbkhalEDUwnaT3Q4lOpHTGhYtEGghgzOMZWAJWB+cVfyeZ9k10Yl1Q2tj//2BoLTqTmacZejbgW1WYcYQzGZNMMOpxXYbhSoeVRiz2STOsJOL+WKdSV3sqvDhXIeY/D5pag0YHFXteGAWbIsumHWRq+e8xgpVrCeeyI0n8Fzh+s3GZcDZbfVpy4krchMI5mTc/I6WoQvmRKHK8UVi5+/BsI6uOsSk6/DObACCSnmoqFeaa7wEkIEELsB7bVqg2nChR3Ztc0C9vtem+apVGMl8HK5syRu9g7jczMEmhGQWECZ6uCvkDm72Oyt09RxSJZjbWYYKFQ6H1mY7NJGFbUARJuVihkNlO9oO3Yn2hZ1O6DbjMnRnWOWwYoQa9UmscEStbdxQld+KsF2fYTvgpuJ4GHKG9W1XotOOZYWLMoUFonEZuuOLiLRYoYi91p6bJScs7uItQ3eoTYb8XghmowOoC1XjMtrLaY1sQzh8GGLb67KK22Zusx36dicSzPGEaqpELcNukbxOCOZ05JV3VTCTvgkF9gCkvjWgLjoIw0FuBxm4TBzsVnnZz31XoS7/x+3AUOO+QjAYkICnSYJBDIjwUk4IaYsetosQW90F7GzosnJGVbXgxOHPEG4QcXhEWCrqiOh5obqwswXN4lahwaGkth1z4V4FzmisWMY+qdzZsAOLnFU97zOqinHYGY4V3BvDqE1R2473o00PRCc0sHJSDcuAQ4736+5xbAhuRNxZo0OYjctQLYh82jHAtueFw62NolN3IY3L0AV2MpFm+sBG7DJUnm9QW0574cOxy+gssdvRW/RUITZCeFc2wNB+0EKS57JKfUuAApuom4gL9xrCI9HHaG6okQ2zX5eG4iOlIHtwb28OIaQdtHzQjQWaOqpa2x6RQk/tLEMXpxg5hSMKgao7mM2oaBTO2dWd1I62XQlKM4xAzY3EMvQKwXrrHbi+uMew2zT3Eq6uEoHhvFC9KBbipfDeZm9I/P6gCl025iwbQ7x1NxfOMPbZb3CF9cJWeJ8uhmNzMLE8CEi4mG57fKGrF8eCYMYy3MZtD4PwY30Z+r5ouavJnUM9hDl2GTDAETgdL9w60TK6gnE7CCHdBwX2AAMjt+jzVphtlepGf+RHhRDSt3C6c6Vw4p7iztbarBFCOkavHqzCWJMQl+2hV8ptr7COHhKLn1m4nVhvizcYEXUWkznpglh6TqzuuOoOqO7m6i18jMIaQld3KPFvFaYbFrotvqD6d6s3oLm5MWHLxvXlOHWn1hxZBvYN+4JlYV8gErMcVnHa2u5LROhaRas+nGcXi98rLZ6A2l7l6IaPCY4n2vpAiBqj7FQ4cxxXOJliUB0JXa0fccdurnFfukI6lkEIyVwosAcY+DFEyNbgPLusq/VKkycoOc7eC9chhHQOq80ujvyhYrPRiyB9D1XxFzmnXRS5AIKvI/cP82CAGS5slhMurNY2p9WnictUQqeNwhP+o74MY56x0UF2R4SuJhZznBvdXKO4xKo1NzfamTauD2HEELpYFIxorWq05kxDMINYYW1ED1122LRiUkpcqkGHgCoCpQt/bLhqhWQQ1m2WEQ73TbWIU0TowiUOL8Mo2tvLzW2zjC5+dowONyGEpAsK7AEGfjyLstELzyylOTbVA5kCm5C+h8/TIk3l88VTuqmIO7e3N4f0UeDgaZV9TT22Pl0IogIyBKKq7mvSih5ZUnD1IMYgLvW2QvGEMtaH5WM6hC5EpS7e9FZAWAbmgcgFELgqxzXmmOjrs4SFLhxQfTkeX8CQ36uVNNKFdWytE6Obq4tLPewZg+BGZxpaV1+fXilaR2uto20H3Fy9XVMyLuzGZWj7ClGeawjjxnr1/rs9UcTJKNoJIaSvQ4HdA6yt8aicnnx37x5ufZQfNxigMNsmK6s8kYqOhJC+g7e1SRpW/SKeCaNFhAKbdG7AFQWo4ATqOb3xhGWyoln1/w2HKsdzlNX6AkHVexYDu8irhabFb1CrEpYh8bUGxOYMqPlQbTkeEMsQsgChxMpFDYtfY46x5iQHVdGr7Dihy5q41ARqrMjVhbKeY6zEt2nj+mILUUGg6iJXKwSGfN7khK4uLlHgyuhuq1B2Feodvb544Bw60uXm8s6QEEK6BC+jPQB+X3HzIG7pVXDToIeOgVynRfKyrNLYEpDCbApsQvoSWXnFMmib4yQ3n226+jp6OLEucDpb/AogzBa0lxesh0tjPRhohYD0GISlLrbtSYT8au2FNNGMnrYQ2nju9yKk2Sy2sCON5drCxagwn54zq7uw+F1SzqlJxOkwS2MDcpUDSmLrwh/bguMEAQsxisFiPAI9p9YolOFK57mj15eqyNVzjPXfzvY6b+gitysubKy7TQghpO9Bgd3N4GbHqqpuaiPqvUmzNyCD8+2RkC/cDAzKtcvvDU0p9wYkhJD+SE8XfoSwxe8ECmBBG2s5sGjbY1LiNNltwXZDDOrivNWv5QWj6rNRbEPoQoTCic12WiO/BxCO2Y5wXnBYbDd7E4dMR4l0g2jGco3iVK+cnQPn17C+eKjwbqtZCnLsEvSgAJZZhV5DKGNbEMyO/SnIsqrw63i/WUahnIsOdmkQuTg/aE3F30hCCCHJQIHdzSDMDTcNoZBW9KQrzkRXwfpjw9S1GxWLunnhaDkhfYeWxlqp+uNLaSzYU/Lcxb29OX0eDDLiOqjl82oCN5Vc1rhtjZATbI1fxEsXxJhmFIxwXiFOmzyBpN1krWWRdg2Hq4v1QtgickrlBfsDKsfZHwyqSs952VYliGOXF3Fg44ht47agfy7EbqxIjydOtXxe9EROLUpKD7vWQ68RPo7fsHitmLqbnl4fIYSQvg0FdjeDmwuEwIloPSiRS9Ub6HnW2TEhZxjlL86xyapqDwU2IX0Ik9ksZrtbzCiL3M+AkNLFXE+gWhX5A+KyaQLVHxa4SnCrolHJiTq9oBb+Q1sjBC61KoGK3wGzEp4Qv7prDVGd44oWqFgXxCmm6X1+IXDxFzIUpYKQ1XORsUyEehtdXWs4t1gv5NXiCUqWCsW2JrUv7YlttJXKcdritmOKRdu3rvfudfbi4DQhhBCSChTY3QxuolBcxWLSnARXL/WCUA61HX0l296MF+dYZXWNJxzOzpsYQvpKH+yCcbuIO6t/5WDrDi6ifSB6kcerC9POONI6WAZEbixaMauQ5LmsagBS5erawgJXhTlrIcr6tiQq4KX1BA5oDrEb4tMctT/YFj0829ZBmDPA6w7bRoHrDfcr1sOltQZR0qYydizGQl6dxSi2kZ+MwY9k+w4TQgghAw0K7G4GN1YIo8ONSX2NR3oLFIYZku+Ie1OEG8s8p0UaPYFer3ROCEmOUDAoQb9HgsHuq54I5xNCr6t9ikEydR7gjooppMQnhCocU12YQk26TMmJRIhd9CaGI40wZeTxtqgev/6ISMamYH34dz4KYcUMPuquKYSyHvKN+SM50oawbb3wFgpHImTamsCR1nOTk+3zG29bINCVs+0LiM2qDZr2ZG4w1sVyHYQQQkhiqKa6GTgjupOBf/cG2npDKhQxHnBjBuXb5Y+1zRTYhPQRmhqqZf3/XpeGgiOlIHtw2pevi11cOzy+sKDsRDs/Xeya8J9JlHCOdYD1fGSsw+j+amHOENqaOwxx2tDq14prJejdbBS7OU6rEqcQz9lhkQzBjkdcFuOFaMcDglnfFq3nsbYcbHMA+cUWsxQmyGtOdwskHDuXXdsnQgghhGQeFNjdDorcmFUvSzgwvVGtGzejDuQWttPyA8413B7cxPZWnjghJHmc7hzJH7+ruLNy0nrYQoZq1PlZNnXtwjWkyROURo9fbOGQ7WSuY3p4NMSu3apdX9DGCeJWF+y6AHfbLJLrbit2sR7k+kJ0o4WTO9smrU2t0uIJROVH69sNQQ2xGxsSHSuSsd72BHH7Ihktm7SwbbjbiFDqSKQTQgghZGBAgd2NoPIpUv5wQ4YQSwht3NjheU+Cm84CtzXiCsUDYZSFWRZZX++jwCakD2C1OcRVOFJsdmdS8+s5whaIRJs5YWVrOLO4VuS5Nub14tFt1xzgxlat+Je5g57Nem6zMdcYrqvWnzgozWHBbhZTlNvcHshdRgh2SY5Nmu3mqPxozZG2SK5hu9sVySLpKbxl6+KCCCGEENKvoMDuRiCmtfYqmruBmzrkznU1RDBV0K4Fjk5HlOTaZV2dl8XOCOkD+Lyt0rxhkXjLJom423ex9RxiiGbkD8NFRti3sfAXcntbfAHJUiK1baVp3QGG64vK2BDIWObGQlrmqOJiVr0/ckwos5aTvFGww0BO1UlW4tZmVn+4zkK0Y0DT7bD0aitEQgghhBAK7G5kYzEbzeXBjWttsx9ZdD32ycONNRyrZHpcF2ZZ1Q1xfYtftXwhhGQunpZGqVv2vTSPHSpSkNNhmDbENapNQ8hmhV1khH23+vxKHPsDQTUdRQ/bc5IxDU4xRDEGDLWwb4R5+9Vgoi8YauOAx0MX7F1Fr5JNCCGEEJIJUGB3IwjJRGik7qggdHFDg096EjhVqsBPEgIb2zkk3y5z1zQpN4tOECGZS8CWL2N3+atk5zmVWI7XygrFuALhMG3jIFusi4yw7zy3VXLCAjwZjG2kssIuMpaT7TArB5zXD0IIIYQMRCiwuxG4RghZ1FFFelTn0p4D7tLQAkfS/a2Lsm2S77JKHVzsLLrYhGQaCMGuaECtBLNMHZ6lHpUTrap+b6zSjdoL0MrxwrTjhX13pa/xxl7L2np6upAjIYQQQkimwD4f3QhcYP2GE8DpQbg2Xu8psC6EaiYLbriHFDjE4wupnEZCSOaAomEoRAiXeFi2V77/4l3xtdRLcbZVpXU4w72j0coKehlpH8m0c+qKuG7bI5nimhBCCCEDFzrY3QjcarvBOYZLhLBMhFL2RCsshIfCzUJeZSoUZVslz2WW+tZAp/pi6+1ycGPPm21C0gMGvJBiku+yyMTBbgl4gmJRuceaqEVvZLSzQl402l7hGtOZvtWEEEIIIaTz8O6rm1D9rkXrl6qDHElHuJJ4T+VfZzmQZ5naacY2I6wc4eVwzFKloTWgQszrWwIpv5cQEj8SpbzOq7oBTBri1oqR5eXLfvsdpB6j86LNkue2UVwTQgghhPQCFNg9UEHcePOb47KKN9AzAhsONnKqO+MiF+fY1E18QydEMlr0lOXapdkbUFXMCSGdB9+h9fVeKcuzy6RB7kixMgziBQJ+9UgIIYQQQjIDCuxuvCnWCv9Ei1vkTvqDWu/Y7gQ33fjPWGQtZRc73y5N3kBKN/DYb6RzDi6wK5Fd2di1qumdddEJ6Q/g+7Shwauq+08c5IrKp66s3CCPPnqfeiSEEEIIIZkBBXY3O9ixAhvhm3ilu10njz+kRDJCxDtLSa5dtfdCyHeyNHoCyvkucFtlZLFD5YCjdU9nQOsh9A2vrO/Z1maEZAK+QFCJawx0jS9zqWuHkZycXNlzz33VIyGEEEIIyQwosLtRYEPcxoZno9CZzWJW07sTiNMsu1mtr7OgrRicM4jmZAcE4DiX5thUmyD0wh1eaFcVjTtTkby+xS9luTYlLCC0u0JlvVeaPMwJJ30DFEKsbPDJsEKHjB/kjptP7XS6ZOLETdQjIYQQQgjJDCiwuwm/atHVNjwbjq69BwqdQWAXZFm7XMW7NNcuWXaL6rObjCiwWsySn7Wx8jhafiEPvKrJn3JRJ4SGDy5wyNhSp1o2xHtnQEVzHO2m1qA0U2STDAe1E6oafTIc4rrU1SYKRqe1tUUWLZqvHgkhhBBCSGZAgd1NwPCN5zqhzzSEtzfQfXnYym0OId+7613YkPM5ON8m9a0dC2SIcPTczjHkfUMcIFRcF/3JgrB0OOD5LquU5tpkVLFDapr9nSqahmrmg/PtMrbMqdz0zgp1QrobfEeqm/wyqtgpY0td6nqRiIaGevnkk/fVIyGEEEIIyQwosLsJkwk50PFvjnOd5m51sLFsu80k7i7kXxtB9WK42AjZ7kgcQAybUeXMQGGWTYYV2KW6yZd0wTJUIEd4OgQGXPjhhU71vKLBm1LRM7iBZrPIkEKncgQhXOqaA+p1QjIJfH9qmnxqMGl0ibNdcQ2Kikrk9NPPV4+EEEIIISQzoMDuBuCyWkzRPbCNOO0WVeE7VZCTuaHem1T/a7ct9f7XiYDjjlxq5GInyqWGYMWAQp4rvmuOXNJ8lyWpXGqIa5fdokLcdSA2xpS4JN9tlarG5MPN0Y+7JMem3gfhD4ENRx1iH2HnhGQCiKqobfbJmBKn+kMNg44wm81is2FAi5dxQgghhJBMgXdm3ZR/bUWudQIHCsXDIMBTLfzlC2q5xMhPbg9PmvKvY13soiyrCtOOB8Q3RGyiquXY55HFTvH5Qx26xwjpRqG02Bx2hKuPK3OJ1Wzq0E3XqzADON/6sdBFNtxs5Lnq8xDSm+IaA0EQ1vhsxkaAJKKurlY++ugd9UgIIYQQQjIDCuxua9Gl5R8nEps2q1m8KeQTQ4xDlKOPdkdtr6C/0SorncCNR5g23PlY5xc533gNTnF7oh7T4WRXtRMqrvfRxrzxgIgfU+pULndHOd21zQFVYA3vMaLc8FJXOOTc16m8bkLSAT7H9WFxPbIoeXEd+d55vd3e8o8QQgghhCQPBXY3AFfUZbMkvFl2WE3qL5UQZY8fIdhm1V+62ZdYYGOZWHaWodBYuijKtsqgPJvUxFQEh9B12iyS525/nRDfI4scygmvaojf2xpiA4IYxdISMTjPpsQI8lUTHUOI5kAwqIqbxTsPGPyAGz4o1656DVNkk94Q1w1KXLtSFtcgP79ADjzwcPVICCGEEEIyAwrsbgBirb38ZwjNHKdFPCkUOsO8LptJSnLtYjWjj3YwYUsqZxf7XycCAgAOtM1qimp31egJSmGWJW5bsljQ0xruMdp5oVK4EThxrf6gDMqLL4qNxw9FoIYWOlReejxxjJBbFFcrNORxx4IBi4mDNSebIpv0hnONSuGoCZCquCaEEEIIIZkJBXY3EAiFVL5we0Bg+4MpONi+oGpbleu0KHc3Vpwa54PL3V037NiGofl2qW3xK0GMPwjc4gQh3fGAQz26xCFNHn+UA402X9kOS7uiWAdFoMaWOJUYV5XFDXnp+DeWC+HcUbEoiOzxZS61TxDZLHxGuhsMTkFcjyt1yYgiR6drJVRUrJeHH75bPRJCCCGEkMyAArsbMIlJ7BZzh05uKrfVqDqOsG8IZ7TCSpR/DHGf2054dToYUuBQQr+uJSDN3qBy6xNVD0/E4Dy7Wk5l48Z8bPSoLsu1qWOTDEocD3JJUY5N5VLruajYLgwyFGbbUliOW8sPb2R1cdLNznVr18U1yM7OkenT91SPhBBCCCEkM6DATjNwT2GaIoy6PZxWc7uh3m2XaYq44nCA8f5YkQ33FWIxmVDtroAibSOKnKr6MSp+Izc7WVGsg4GC0cVOKXRbpbpRc7IRNg6xnOq2TChzSY7TrEQ2xHqrLyCDCxwJi8zFA/OOV6LHqUQ2+2ST7sq5Toe4Bi6XWzbddJp6JIQQQgghmQEFdjdUEEeVavSEbg8IUszj8YWSLnCm51XDMYbIjq0mDsGNPO109b9uD1T5Lsmxi5hCSTvF8cTx6FKnGpDYUO9Txc/gjKcKnP0Jg91qeWtrvMrBL85OzVEHOG9jS7VWSdVN/g6rlBMCMKjT0YBMi6GgWTrENfB4WmXZsiXqkRBCCCGEZAYU2N3SoqvjEHHMA6fZm4SDrRc4011i3JyX5NqU+21s0YMCZwVZth4pmAQxCqFQmmNvt+J3R6AQGYo8YVCgLK/9Nl/tgRB1hItDXA/Jd6gBic6AnG0UUBtT4pC6Zp80GYq5ERJPXGNwCH3g19V5VG51bAs6DNSg6B4+V+kS16C+vk4++OAt9UgIIYQQQjKD1G0+0i7+oFZBHAK0I/LdFpWD3BFwx8pyHTHvtYrLblGi2h1uyYUbexRP6ykKsqxqfcnsa3sMLdAEMcR2VyjOtol9qDZw0RUgsuFiYxBkyYZWNWgS20ubEAxuVdT7JN9lUZEYDS0Q2V5ZX+dT0SkY7MH4GdrJdabPdUcUFhbLySefJXZ79LWBEEIIIYT0HlQNaQZiTBe8HZHjsqhCZyrHup0bbxQ4y44RzgiHRu7zuhqvWh9ymG0Wc9LrThddFde6oEU18HRVOU8HOB/Di5xK+C/a0KrageF4p8t9JH0f5Pwj9x/pCRhowgAR+q6jT3x5nU+qm3wSCIaUuMaATbojSywWC/OvCSGEEEIyDIaIpxncUCebA42WVChchkrc7S0PBc4gqGMpyrYp8Q2BrvKv7T2Tfz2QKMuzy6ZDkN9tkvX1Gyuek9TdXgxS1DVr7d36OtgXfHd1ca2DARl8ZqYOc8vmI7Jl06FZ3SKuAULDP/vsQ4aIE0IIIYRkEFRjaQaC156kq4ubcYRZo7pwsgXOjCD3GY51kzeoBHa+29Zh32eSOjhHEEoFbousr/Oqvt8kNVA0DoMUZrOoMGrkKqdbaOt92bub6kafSh+YOMidsD0dBDU+N3C0u6smQiAQkLq6WvVICCGEEEIyAwrsNIKbe9UDO4UCW+jXDJc6EV6/5ojHa4OF9ZTm2FQhLiyju/tfD2QQoj95SJaU5dqlosHLCuMpgM8ndO/YMpdsMSJbJg1yqdchtBtaA2kRxYgsQAV5hGbXNvtVVEd3gGUjTWDiYJcS0L1JQUGhHHbYMeqREEIIIYRkBhTYaS5wZkuiRVescIN4TtQSCgXO2qvSraqGm5ALjf7XPJ3dCUKCJw1xq5BfhDrDhSXtg0r36JU+usShitDhs47c9i1GZqv+5RDXENqNXRTaKDaGHPnJQ9zq+7ehwavCuNMZbYDzjYGsCYOcKj2DEEIIIYSQWKjI0t0D22xSIjtZIIohshOFicOZa69wGVxrvB/51+gHTboXW7hXNoQ2KkSj0BXzsuOD44LjMyTfpirFG0FNgZHFTpWnPL7UpebtbOg4QrbV4MfQbBlW6FDLnDosS1V+r2ryyYZ6b4d9qjsCAwBYxvgyl5TmpqcgX1eprNwgjz/+gHokhBBCCCGZAauIpxG4ZTZragJb9bTOtklVQ9t2XXDLkFMdr8BZVAXuXJu0+rR5SfeDczYk364GRxatb5HyWq8SXemoqN6fgINc6LbKmFJXws8mhPGoEqcqDAYhvLbWq4Q2CgBi4AgF/tpDhZiLyATkQ7utUuPxqO8fzgcc85pmv8qbr2jwq6reOU6rZDnMKVWDx+AXwtzHlzlVTnWm4HZnyTbb7KAeCSGEEEJIZkCBnWYHO9dpSbmVE4QEBAgEulGkocCZw9px6PeQAofKcSU9CxzSKUOzZGlFixKGBeHe5EQLp0bbOORdtzdAZBTacLQhtCvqvbKmFv2kvep44jsVr1AY0iqaPQGZNNglxTltQ7bxHoRyF2ZZZVhrQAl+5GiXh5eL6t8dDUphHUgHGFfqUu54JgFhvfnmW/X2ZhBCCCGEkEwOEf/yyy/lsMMOk6lTp8ouu+wid999t/j97ee6fvHFF3L66afLzjvvLJtttpkccMAB8uyzz0ow2LWw0M4IbLhjqQK3zu0wtwkTR4EzCI+OiqZBJNA97R1wflBNelypU4URI1y5P7Sh6goIpcZneUyJQw1CpIIznKO95chs2QT51BaRDfU+qWqMzqdGbndNk09GFTs6dJUx4IX+6HDStxwVXq7VJJUNcLZ9CcPH0VteW4dTRhQ5Mq4HutfrkVWrVqhHQgghhBCSGWSUgz137lw599xz5bTTTpObbrpJVq5cKTfeeKP4fD654oorEr7vnXfekTFjxsgpp5wieXl5MmvWLLnjjjuktbVVzjjjjB7dB7stdQcT4rgoyyYrqzySqxVYjrhng/NYTCnTwfmDCMt2WmVZRYtySOGowsEdaKB6N/KeRxY5ZVBe58OpMaiEyIySXLsatECEAEQ2NC7EMsK9h+bbZUSRMyXhCwGP5SKEHOHjCEuvavRLdbNPsh1a+DjC0iHmKxt9yrXurj7WXQUtut555zU58sjjpaSkrLc3hxBCCCGEZJrAfvLJJ5ULfdFFF6nnkydPVj1er7zySjnnnHMkOzs77vtuueUWsds33sxvsskmUlFRIS+//HKXBHbqt9ShlCqIG0H+aKiqVWv1FRYMoQ4KnJHMQeXS59iUQFte0aoEIQQ3wpAHEgjDxuACnOV0iFLkUyNsHMuEIF5XowltPB9b6up05Abeh/NVnG1VedxY5vp6n6yv03pc+4JBlWc/tsSZsdEhhYVFcsIJp0pWFnOwCSGEEEIyhYyy2GbOnKkEtpHp06eLx+NRrnQijOJap6ysTNavX9+1DTJphcaSde7gfKVS4MwIhJjTZpGWcLiqXuAMIcik7+C2W2TiYLfKC4YLCoe0u3oyZ2Letd1mVqI0lV7wyYDvAoqWTRnmls1Hope2O25v+FTRw8dHl7hUWPrUYW4V1l6aY1d51+nej3RisVglNzdPPRJCCCGEkMwgY+7MGhsbpaqqSoYNGxb1Olzr/Px8FS6eChDkCBvvCjDgII0sSYhmfyikbviddotYO3FTnm01SyGqiTf6JMdlEk8gKG6nRXJc1k4tj2zEEg7V1h974ks1qtQt+dl2WbqhRSoa/ZLvtijx3V9BHrMnEJJNh2ZJYU73VtoujpOGkY5zjO+Z22mVIYUOwZhIplflb2iol59//lG23npbycnJlYFAT3+XSc/Dc9z/4Tnu//Ac9394jvuIwG5qalKPbre7zTSEQEKAJ8vChQvlgw8+kGuuuaZL22Qxm8XpdkhubsfVg5taA2JzBKW0OLvTrtfooEUaVjaq9fkafFLgtEhZSU6nlkXakmtMcO8BCgpEhpTmyMrKFhU23hIKSXGOPa3CDcW+6psDkp9l7TVBiGiLuhqPTBmVIxOHuHs1X7mnz3Fv4vc3S0VFubhcVikoGFhh4gPpPA9UeI77PzzH/R+e4/4Pz3GGC+x00dDQIBdeeKHsuOOOcvTRR3dpWcFQSBoaW6XeEkwqPNZqNkljfXOnqw0HPX7xtnikstovNU1+yS12Sk2NNvBAujbKhgtAfX2LBAI9W1keFDtFzAUWWVbZKotWt6bVzV5X61XpBYtrm8VpNUueu+Pe0amKZ3wWkaqQlaAeAMLgEVZd6AhKXV2zDMRz3BtYrW456qgT1L8HynViIJ7ngQbPcf+H57j/w3Pc/xmI5zg315V0BF3GCGy9UE9zc3NcdztRgTMjLS0tqqiZzWZT7b3M5q6FEUKmBAMhCRjaA7UXIut0WcPzdi7n1mkxidNqkoaWgHIm8W+/f2B8aHsCXAB663iil/PkQS5ZU+ORVdVeqWvyq5zirri9KM5lt5hUi7AWb1BWVbfKmmqP5Dqtqrd6OkAbKxRua/EEpabRp/KVjUIbA0tmMcmIQocq6NDbn9fePMek5+B57v/wHPd/eI77PzzH/R+e4/hkTCIbBHRhYaGsWbMm6nWEhtfW1srw4cPbfT9EOMQ1RPbTTz+dlCDvCEgfmIFwsjsCBa1cXSy6BLFVlG2VJk9ALCaTOFngrF+B1AEU05o6LEs5vuvrvap3dmed5YZWv4wotKtloRf0ZsOzZUKZS/zBkKyr9ag2b11B+xyKKva1xcgsGVPiFG8gJGtrPWq70Se6pZP9rknXqayskKefflQ9EkIIIYSQzCBjBDbYbrvt5Ouvv4567ZtvvlGO9FZbbaWeV1dXS3l5edQ8dXV1cuqpp6qWXs8++6wS6mnBJEroJlNJHBo8HYIYDiGMd4fV3GXBTjKTgiyrbDrULRMGucQXDKm+2RCrqaC3qhqUv7E+AIrsjSx2yuYjslR/aIjg9Z1Ytj5gBHd6RJFDbS9c6zEQ2iOylGOO70RFg1eGFji61O+adB6XyyVTpmymHgkhhBBCSGaQUbbTKaecIscee6zcc889su+++8qqVavkpptuUq/pjjTyq3/88UdZsGBB5H0nnHCCWCwWufnmm1X/a/zpFBQUdFpwm8SkeuBCbMQpXBwFJDhysLsK8mmz7BYl1jO5RRDpGji3EMGFWTZZWdUq5eH+yyhW1lEONVxjzDOqyBm3LRzE8Pgyp5Tm2mRtjUf1dwYQyrYkc0cg4Mty7UpAxy4bLjx6U9c2+aWoi2HupPNkZWXL1ltvz0NICCGEEJJBZJTAnjZtmjzwwANy7733yhNPPKHacx188MFKVHdUNRwceuihbaadd955cv7553d6m6wWkeQMwJDYrKa0CC+ILORfk/4PcqUnDXZLSY5fliuh7ZW8mDxnI0hXqGn2y+hipxLMiUChPYRt57ksMijfL2uqvVLR6FMRGXgdA0eJqGvWipqNLnEmnA9F2vpz27G+gM/nlaqqSikqKhabjVEEhBBCCCGZQEYJbLD77rurv0Q899xzbV4zutnpBEYiQrWbPO0r7GAwpBzFeG5iZ4AzmcZC0CTDgQNckmtTFcBRBG1NjU8aWr1S4LaqsG8jtc1+yXdZZHhhx63jdKENlzzfZZXqZk1oVzZ6xWo2xxXaKq/aF5BNhmSlrVAa6R5qa2vk9ddfkiOPPF5KSsp4mAkhhBBCMoCME9iZBgR2XXP7hahQVArh4ekS2HAPycAtgoZe2atrPFJe6xVpESWQIYQhfn3+kEwc5GojvJMR8ahaDtFe3WiXtbVeFQaO19E2DKHjoVBIKht9MqzQIWW5tm7bT5IeCgoK5ZhjTpLc3DweUkIIIYSQDIECuwPcdrMS0O2BHG0IoHTkYBOCPPxJg1xK5K5GaHeDV4lvtIIbWuiQkpzOi19L2C0vzLaqUPO1NXC0feGK+SbljiOCgnnVmY/VapPCwuLe3gxCCCGEEGKAArsDbEkUGlMOtiV9DjYhemg38rErG2yystqjPl/oN41pXcUSdrQL3RuFdqMnIKNLXYyg6CM0NjbIb7/NkmnTtpTs7Jze3hxCCCGEEEKB3TFKNIc6FtjIV02H8CEkVgijYjcKmnn9oYTFz7rWe10LHW/xBdO+fNJ9eL0eWb58qUyatCn6D/BQE0IIIYRkAHSwkxDYJrNWvTlR+ySEiDvZUot0IwgRt3fjtxVCm+K6b4Hw8OOOO7m3N4MQQgghhBhgNa0kBDZyqyGiE4EUbfStJoQQQgghhBAycKEqTFZgt1voLMT8a0JIj1JdXSnPP/+keiSEEEIIIZkBBXYyAtsiEmi/FTYFNiGkR7HbHTJ27AT1SAghhBBCMgPmYHcACpeh53BDS3yFHQhqudmoIk4IIT0FKofvsMMuPOCEEEIIIRkEHewkcNosCUPEIbDZoosQ0tP4/T6prKxQj4QQQgghJDOgwE4Cl80sgQRFzlD8DDnaNgsPJSGk56ipqZaXX35OPRJCCCGEkMyAqjDZXtgJIsD9YQebXboIIT1Jfn6hHH74ceqREEIIIYRkBszBTgKb1YRC4Qkd7GynReVqE0JIT2Gz2aSsbBAPOCGEEEJIBkEHOwkQAm42iwTj5GHDwUYIOSGE9CRNTY3y44/fqUdCCCGEEJIZUBl2sRc2XkKVcUII6UlaW1tk3ry56pEQQgghhGQGDBFPuhe2SYWD29scsRB7YBNCepyiohL5y1/O4JEnhBBCCMkgaL2mIrDjONgmvQgaIYQQQgghhJABDQV2EqCAmcNqbiOw0QMb0yiwCSE9TXV1lbz00rPqkRBCCCGEZAYU2EmCQmYIEW/TAzvsbhNCSE9is9ll6NBh6pEQQgghhGQGzMFOEqfdrAqatemBbYaDzXEKQkjPkpOTI7vssgcPOyGEEEJIBkFlmCTxwsARIg73miHihJCexu/3S11djXokhBBCCCGZAQV2kmhh4G1DxJ1s0UUI6QVqaqrkhRf+rR4JIYQQQkhmQIGdJHCpzSaTcq2NIeLIzSaEkJ4mL69ADj74SPVICCGEEEIyA+Zgd6IXtsWshYtDa9PBJoT0BnY7ipwN58EnhBBCCMkgaL8mCQqZoaCZ0cFGyDgriBNCeoPm5ib55Zef1CMhhBBCCMkMKLCTxGrW8rCjemGH4hc/I4SQ7qa5uVlmzfpRPRJCCCGEkMyAIeJJYjKZVDh4rVer2AsnG6HiFNiEkN6guLhETj31XB58QgghhJAMgg52CqCgme5gq1xs1aKLh5AQQgghhBBCCAV2SsDB1iPEIbSRk80cbEJIb1BTUy2vvfaieiSEEEIIIZkB7dcU0MLBNzrYeM4QcUJIb2C1WqWwsEg9EkIIIYSQzIB3ZqkcLAjssIONHGyXzdJNp4UQQtonJydXdt99bx4mQgghhJAMgg52CsCtRmEzuNcIEXfYePgIIb1DIBCQpqZG9UgIIYQQQjIDKsRUe2FbzMq9xh9ysgkhpDeorq6UZ555TD0SQgghhJDMgAoxZQdbK3BmMrEHNiGk98jNzZf99z9EPRJCCCGEkMyAOdipHKxwUTOvP6RysVlBnBDSWzgcDhk1agxPACGEEEJIBkEHuxO9sD3+oMrFZgVxQkhv0dLSLHPmzFaPhBBCCCEkM6DAThGX3SytvpDKxUZONiGE9AaNjY3y7bdfqkdCCCGEEJIZMEQ8RVA5HAXOoK3pYBNCeouSklI566wLeQIIIYQQQjIIWrApYjWbxGrRxDVzsAkhhBBCCCGE6FBgp4jNqglr5GITQkhvUVtbI2+//ap6JIQQQgghmQFVYmd6YZvNKhebEEJ6C7PZLE6nSz0SQgghhJDMgDnYKYLQcIfVJHYrb2oJIb1Hbm6e7L33ATwFhBBCCCEZBFVipwQ2KoibuueMEEJIEgSDQfF6PeqREEIIIYRkBhTYKYL+19lOszgZIk4I6UWqqirkiSceVI+EEEIIISQzYIh4J5gwyJ3+M0EIISmQk4MQ8T+rR0IIIYQQkhlQYBNCSB/E6XTKuHETenszCCGEEEKIAYaIE0JIH6S1tUXmz/9dPRJCCCGEkMyAApsQQvogDQ318vnnH6lHQgghhBCSGTBEnBBC+iDFxaVy1lkXicnEjgaEEEIIIZkCBTYhhPRBIKwprgkhhBBCMguGiBNCSB+krq5W3n//TfVICCGEEEIyAwpsQgghhBBCCCEkDTBEnBBC+iB5efmy//6H9PZmEEIIIYQQA3SwCSGkDxIKhSQYDKpHQgghhBCSGVBgE0JIH6SycoM88sg96pEQQgghhGQGFNiEENIHycnJlT322Ec9EkIIIYSQzIA52IQQ0gdxOl0yadKmvb0ZhBBCCCHEAB1sQgjpg7S2tsrixQvVIyGEEEIIyQwosAkhpA/S0FAnH3/8rnokhBBCCCGZAUPECSGkD1JUVCKnnXauWK223t4UQgghhBAShgKbEEL6IGazWex2R29vBiGEEEIIMcAQcUII6YPU1yNE/D31SAghhBBCMgMKbEII6YMEg0FpbW1Rj4QQQgghJDNgiDghhPRB8vML5KCDjujtzSCEEEIIIQboYBNCCCGEEEIIIWmAApsQQvogFRUb5JFH7lWPhBBCCCEkM6DAJoSQPkh2drbstNOu6pEQQgghhGQGzMEmhJA+iMvllqlTN+/tzSCEEEIIIQboYBNCSB/E4/HI8uVL1SMhhBBCCMkMKLAJIaQPUl9fK++//6Z6JIQQQgghmQFDxAkhpA9SWFgsf/nLGeJ0unp7UwghhBBCSBgKbEII6YNYLBbJymKBM0IIIYSQTIIh4oQQ0gdpaKiXGTM+Vo+EEEIIISQzoMAmhJA+iN/vl+rqKvVICCGEEEIyA4aIE0JIH6SgoFAOP/zY3t4MQgghhBBigA42IYQQQgghhBCSBiiwCSGkD1JZWSFPPvmgeiSEEEIIIZkBBTYhhPRB3G63bLnltuqREEIIIYRkBszBJoSQPojbnSVbbLFNb28GIYQQQggxQAebEEL6IF6vV9asWaUeCSGEEEJIZkCBTQghfZC6uhp5661X1CMhhBBCCMkMGCJOCCF9kIKCIjn++JMlKyuntzeFEEIIIYSEocAmhJA+iNVqlby8gt7eDEIIIYQQkukh4l9++aUcdthhMnXqVNlll13k7rvvFr/f3+H73nzzTdl///1lypQpsueee8q///3vHtleQgjpaRoaGuTrrz9Xj4QQQgghJDPIOIE9d+5cOffcc2X69Ony8ssvyzXXXCOvvfaa3HXXXe2+77PPPlPzHn300fLqq6+qZdx3333ywgsv9Ni2E0JIT+HzocjZavVICCGEEEIyg4wLEX/yySdl5513losuukg9nzx5sgQCAbnyyivlnHPOkezs7Ljve/TRR5W4/stf/qKeT5o0SSorK9Xrxx9/fI/uAyGEdDeFhUVyzDEn8UATQgghhGQQGedgz5w5UwlsI3CzPR6PzJo1K+57mpubZc6cOXHft379elmyZEm3bjMhhBBCCCGEEJJRDnZjY6NUVVXJsGHDol6Ha52fny8rV66M+75Vq1ZJMBhs8z79Od43duzYlLfHbDZJYWFWyu8jmYXJpD3m5bkkFOrtrSHdwUA8x8FgQJqamiQrK0vMZosMBAbieR5o8Bz3f3iO+z88x/2fgXiOzebwTvc1gY2bReB2u9tMw00kBHg89Ndj3wdhbjKZEr6vI/BeiyX5g0kyG7M54wI2SJoZSOfYYjGrgceByEA6zwMVnuP+D89x/4fnuP/Dcxyffn2XEgqF1B8hhBBCCCGEEDKgBDZcaj2nOp67najAmf567Pv054neRwghhBBCCCGE9EuBDSFcWFgoa9asiXodId61tbUyfPjwuO9DrjVCFGLfpz8fMWJEN241IYQQQgghhBCSYQIbbLfddvL1119HvfbNN9+IzWaTrbbaSj2vrq6W8vLyKOd7ypQpbd6H5yUlJTJmzJge2npCCCGEEEIIIQOVjCpyBk455RQ59thj5Z577pF9991XVQi/6aab1Gt6qPeFF14oP/74oyxYsCDyvjPOOEMuvvhi5VZDpM+bN08efPBBueCCC1SxMkIIIYQQQgghpDsxhTKwCtiMGTPk3nvvlcWLF6squQcffLAS1Xa7XU0/8cQT2whs8Nprr8njjz8uq1evltLSUiXKTz/99F7aC0IIIYQQQgghA4mMFNiEEEIIIYQQQkhfI+NysAkhhBBCCCGEkL4IBTYhhBBCCCGEEJIGKLAJIYQQQgghhJA0QIFNCCGEEEIIIYSkAQpsQgghhBBCCCEkDVBgE0IIIYQQQgghaYACmxBCCCGEEEIISQMU2IQQQgghhBBCSBqgwCaEEEIIIYQQQtIABTYhhBBCCCGEEJIGKLAJIYQQQgghhJA0QIFNCCGEEEIIIYSkAQpsQgghhBBCCCEkDVBgE0IIIYQQQgghaYACmxBCCCGEEEIISQMU2IQQQgghhBBCSBqgwCaEEEIIIYQQQtIABTYhhBBCCCGEEJIGKLAJIYQQQgghhJA0QIFNCCFkQBMIBKQvU1VVJcFgMC3LamlpSctyCCGEkIEKBTYhhJCMBuLx+++/l6uuukrWr1/fZvpOO+0kH374YUrLrKmpkbq6OvXvSy+9VG6++Wb171WrVinBmgy33XabHHvssdKTTJw4UWbOnBn12gknnCBPPPFE5Pkpp5wiL7zwQtz3e71e+eOPP9T00047Tb777rvItDlz5sgOO+wgP/74o/QWp556qpx44ok9vt7XX39dHdvy8nLpDfBZPOOMM+S3337r0nJaW1vVPsyfP199Z95880155JFHxOfzpW1bCSGEtI+1g+mEEEJIp9ljjz2kqalJsrKyokReRUWFDB06tI3o3WeffeTWW29Vz1955RX54IMPlPADhx56qHrv2WefHSVEqqur5dprr5Ubb7wx8tott9wi06dPV8LpmmuuEbfbLR6PRw444AC1fMw/atQoueyyy6SyslI23XTTyPuGDBmi3gMWLlwoBx54YLv7CGEWDwh3iKb2aG5uloaGBsnOzo46Rsny+++/y/Lly2W//fZTz5cuXSo//PCDXH/99VHzvfvuu3LPPfcoIVdfX6/mP/jggyP7PXv2bDnzzDPFZDKpRxAKhZSjffvtt6t5+wNvvfWWilg47LDDOvV+HJP//Oc/akAHxxqf7WHDhskhhxwiJ510ktjt9k4t99NPP1UDJxi0SWYb9txzT/V51gegcN7wHJ8nbE9ubq4UFBRIcXGx+jzjMz548OBObRshhJDUoMAmhBDSrfztb3+LEjQQc8cdd5x8/vnnUfNdeeWVUc8hDg4//HAlAvGev//97+r1hx9+uI2DDcG87777xl3/VlttJc8995zccccdSmgAiEg4vRDrixYtkrPOOktWrlwp//vf/+Smm26KvHfChAkyb948MZujA74gUrG+f/7zn/KnP/0palpjY6MSPIkE85IlS+Tf//63fPnll7Jhwwa1bIikQYMGyc4776wc3EmTJkkyYL9Gjx4tixcvVn8Q0hD8WAf+XC6XbL/99uoYbbnlllJSUiJTpkyRv/71r7L55purZWAQAoIcx+Oiiy6KLBuC/LXXXpO99tpL+gtvv/22GqTprMDGeyGCce4x4ON0OuXnn3+Wu+66S31O7rzzzqSWAZFsBE4zBjH0gaBYHA5H5N/4bEHgf/XVV8qtRgSDPniAwZBPPvkkMu/FF18sm2yyCcU1IYT0IBTYhBBCuhUIkgceeCBKYMBFhLsdz8HW2X333dUj3G4jEBcQf8b3QRTrr8GZRlhsIl566SW5++67lbDdZZddVFjt+eefr8JoIYohnv785z8r0Q4gOsePH6/mAQsWLFAuJt4LcQ0hC6GlO/IYCICTaAzbBhDR9957rzzzzDPK8YQog+hHWDYEP8J64dgj7BwC+MILL1TvW716tXIsdeCUjhgxQh5//HF55513ZNq0acrtB99++62MGTMm8hyCGgIbbib+/H5/m0ENhIRjgAHbtdtuuynhjfBiDAJgMAOij2hYrVZ5//33lUuss//++6vPzWOPPSaXX365GijpKAw+Xhg+Xvvvf/8b9z0//fSTcqV14JRjIOWKK66QXXfdVYYPH97mPfgM4LOqpz8QQgjpGSiwCSGEZKSDDcGJ8G+EQCO0GfnCEI8QOQjt1kFu9kEHHSRbbLFF5LW5c+cqpxbA2YWTB7EBMXrMMceoP108jxs3TglqCFsIVjjnRk4++WQ5/fTTlWuNbcS6IXrhQGOgAKIKy4UL/NBDDykX/OWXX24jrhEyjm2AY4z90N1uCCc4zdh+/B155JFKYNtsNjnnnHOUmEMoOICb//TTT8u2224rF1xwgRLM2IfttttOTcegBRzwWIcW69f/ALYb78V5+Mc//qFENNx6rA8CEAMUGBjZcccdpbvAOcI6EO4P8Q+hiPz3nJycqPmQd48BERxvhNPDsUf+uDFsHfuNgYptttlGnn32WRWVgJBoDIroIf44LrqwNYb145zo1NbWylNPPaUGcXBusDxEKZSVlanpFoslSlwboyTA2rVrOxTYAAMa+Ex2BMLGMaCiA7ccn0Uj+OxjQAcDRnDGEf2A7wg+P0A/hxDhcPAJIYR0LxTYhBBCug0IR4gjPawbwg55qwh5jQ09hnjae++9o4QP8lx//fVXNQ1io7CwsI2jfckll6hH4+vG8GwIaGyDHiIOwbVu3brIOjEvRCtEChxpiBNdzACIXri5CMGFiIFTCWH66KOPKmGK/YHIhiBD2C4EXmx++YMPPqgEJYQ3xCSA2IVQ18WbDtzyG264QQlnDARgn/VtAtiGX375RdasWdMmdD0RcM6Nrj62Xz/GAMIM4hHHAoMMcLMRWtxdYPAEghdOPFxYiGrs04oVKyIDIwDn66ijjlKDEOedd57k5eXJN998o96DbTWG50M8ooAbBihwXhB2jfMCob311lurzwny9BGpoH9mYvnLX/6iXHwMpOAzgvOGdeF4tAeK44HYwZl0g/3AcTJGbyBiAgNRyKtHVAM+O3CtMRAEd50QQkjPQoFNCCGk23jvvfciwhoFs+DGIfRbD7+GM1tUVBTX9dMdSriJKAIGxxYiEI52bB62kZEjR7Zb3RsCEmIYy0dRM13ow72Ekw2BYgzJBlOnTlV/EKIQbBDZWAf268UXX1QDCRC7CD+PBUIN80PE6+IaLFu2TIWn6262ERwjLPPrr7+OW2AM2wIhj/BvuN3Iy9WP89VXXx0p0gZHGsIUbin+PvvsM/UaqohDrCEUHK/BHc7Pz1fnB+Ibx7k7QaE5iFEcOz0EHU4s8uCRQqCDgREcB4Q7Iwwf4Bzhs3T//fdHCWy4zRCY+rZjPiwTAyHYVwyU4Phj+Xr6QSwQpsZzj3mRegBnHZ/TeGCgBOcdAzkYMOgJsM433nhDbRtywXGOkV4AcEwwOIJjjO3CeTdGdxBCCOle2KaLEEJIt4LCWxCJEG8QhLq4hosJxxACLxEI6YWgRjVvhGBD4MK1gwMORzn2D4W64HrrxBaT0oGwRtEvCFU4fRBSEJhYBxxBOMtGsByIFT08F2ILoh/hwxDJEDkIuYYgnDFjRptBBoTt6mHEOnDk4cJCmMUCkQgX3NiWTA/vRj47BCLWDyDc4dziD+9BPrr+HMLLCOYFGERAgTXsJ0KHIUzPPfdcVSRLr9qeLBisQPi88S8219sIBjJQ6RzufHv53TjmH3/8sRLKeuSD/odzhzBw43ow8GEcGIDrj3x6PRIhGfSq6jp6KDmiBRIBoY88fL0IX3eCY4fBEbjV+N4gnB1uPHKyMQCBaAeAyuH33Xef+mxjHhRCw/cDx44QQkj3QgebEEJIt6I7jhBvENgQsxDByKNFXjKcYFTDhuBE4S9jqyO4tBA5EEuzZs1SVZohIiGu4lWCRq42HE8dhAMjxxc5upgGtxphv8jLfvLJJ1XOLBxtCE6sF+4fQtIxGICwYIhPiHxsF8KVIV5R5Rnh23BFUVANIhihzai4jW1DcTIIcYhbOMsIw9YrdhuBeETesJ4rGwuOGQQoBhdQ/Oqjjz5Sr0NYQxAnGx6uAzdcDwnHfh199NEqOgCDFXCIcQywvcY+1BC2GEyAw51ofXCJYwUozpueFx4LXGqI53jOvRGEPUOsQ8DiLx5IC2iv/RSmIfQfgzLG6IFk0QcAjK66EXx2EE2BMHJUak8WhOu3V4gvERisQbVyONTI9Ue+fCxoTxcL3Gx8jvDZ7Uw7OEIIIclDgU0IIaTbQV4sxDUKniGnFsIIocoQYXBaIbYgGvEaCoVB7EIQQBzDfYM4RB4xxCzENfKUYwuJAbh0WI4OxBUqk0PcIwcb4g4iE64fqoBDQAK0x9IFOcQ4HGI47BBlCLHFIAAGBFClG/uBnGG4iXCsUakbgwhwClFhGm419gPCFOHWWEesiMZ2YEAB+xoPhCQjrxeFxzAvBgJQsAsFyRASHuu0dgQEIlx7iH+47np/bhwfOK+IMoAIgxOvA1GK5xDc7Yl5nJfY1lKJeoMDfVmJBhZiHXsUmYtthaaTKGxbB+ezvUiGjtBD7+OBAQ/kauN8IHIiFTpb5Oz4449Xj/gs45gbPz8Q3zi3eI9xkAKDOPgcYzsJIYR0PxTYhBBC0g4EHW7sIXB0EQtBBbcUzxFWjJBrFKKC4wynEJWxIX4hwiFc4RqjfZUukuC64g8CO1kHG66z0eHEeiAkAYpFYf1wIHV3GFWt0VtYD2MHCPnWXXXk5+pFppCvi+3Fe4ygovirr74aKXiFvFwMFBhB+C7EMypnxwPbhLx0hELDvdcFJgR2LEYBpldVx58+DTnZWB5EFgY3IMJ0EXzAAQeoAQUUA4NoQ4gxtgnCG4MQcOghcNsDYfapoJ8PvdBcIrAtOF8IA0e0QGdApAQKo+nuNcR9e+HryYKCajjGGHRJRigTQggZOFBgE0IISTsQpJ9++mlEVKNaN0QbWhyhTdV1112nwmt1AQtXGMIYzi3CjREajFBW5OkifDyWZB1shILrbZrigW3EQIAO8qn1Ylp6zjKc3/ZI5NZiwADbjvxzFDmDmIeYRQ7tJ598Is8//3wbZxgDExDfKP4FUWysHp4IYzg2lo/QdOPgAwYoMCABAW10ZHG84XrqAxJwxeFwI2IA5wTnDdudaih6R8B1Rt451o3IBuO+w3HVc8uRT42K3gi9h/sa2x4LDn+8/s86WBY+D4hg0Pcbgx74TMAd7+x+4dygGjnCwnvTFUY1dWM4OBxtfG+Mr+lRAIQQQnoOCmxCCCHdAlxDOMpocYV8Z4Rd6+6xDkQ3BCKcWeSTHn744coBBsi3jgccSQgJFLCKB1xXHTjMiYpPoYI2Qs/1Sue6q2oUzCjCBsEZD+RjI4w83gAA0EUd+jbDlYcrjkc42hCuRucXhdzQF/w///mPcveRcxwvl7YzYJADhdFArHtrdPuR1wuHHtuG/YbYNubDpxOEqEOgYh3Ii0c4OiIaEA5vzFeHs/7TTz+pUHWER8P1R246zhsiCZAbbhwsQTsvtPlC5AI+VxgkQPV5HaQFYIAH7jwGIxCtoIfLJwPWh0J4SAlAtfrYgnYolJdMxW4I39iw+njo0RvxQFpDvBBxtIqLDREnhBDSc1BgE0IISTsQqnBMIUB23HFH5cYi3DkWhABDgEMcQSyg7RCKb+khzvFAjjOqKCNMF8IdghqCBaHMpaWlKgwaYehwwiEQIYQgZuCO6yCXGiILYgnOKHJ0UagMhaOMjjdEciIXWRfQybjMEKwYPEAVZ2PfawheiD4IIYjHI444QuV7YxDB6OzCrcU8xvUmEyKui8J4bdAAlomcXbihmA+iE0INx6w7gasPUY1zj4EFiGIUvIO7bywohmrYcLBRmA4RABDOcMAhwo1h/ADHD7nqmA8iHFEROA74TOjgcwM3H8vEZw5F6VIR2PpnCDnr+EsUtdARGMTAX1egg00IIZmJKdTZyh+EEEJIAiCSUJkaucNGQQn0EPF47aDmzp2rXDujC4gwbbQkgnCBEwsBhdBhCNGxY8dG5oOIhnDCeiHYILh0p3v//fdXod8Q1HiE+EevaLjqGAzA8sDkyZOVyEum0jLcQlR0RshwV0CLJxRKg/saDxR2w3GEsEYxOFQ31wU4XGeIz9gWYEZQkE0X5RD0CAVHVXKIVOS4I9cZIeZwkvtqhWkMDMCpRVRBpoOicRhsSiZ3Gy3GUJEerjTOow4+v8gvT1QkL9bBxncGn21CCCHdDwU2IYSQPgMEYjKOMRxs5PBC6MeGOeM1jC0jfFgHQhw5uXr+L+lb9CWBTQghpH/DEHFCCCF9hmTENYC4BvFyiOO9lsg9JoQQQghJhfSWBiWEEEIIIYQQQgYoDBEnhBBCCCGEEELSAB1sQgghhBBCCCEkDVBgE0IIIYQQQgghaYACmxBCCDHQ0NCg+k7HgsrjaAGG/s2EEEIIIfGgwCaEEEIMPPzww3LLLbe0OSbff/+9agNls9l4vNIA+n9PnTpV9UTPlP7U999/v2oFV1tb2+686NV+3HHHqe0/7LDDpLGxsd35L7vsMtl+++1VX2pCCCH9GxY5I4QQ0m+AAIbLXFhY2OG8a9askVdffVWJJJ358+fLX/7yF3njjTdUL+3m5maZOHGimnb66afLt99+K263O2o5W2yxhTz++OOd3ubVq1fLnnvumXD6O++8IxMmTIg8hwB8+eWX5e2331YitaWlRYnDv/3tbx2uKxgMytNPPy3//e9/1f6XlpbKwQcfLOecc07UwEFVVZXccMMN8sMPP4jT6ZQDDzxQLrrooqh5KisrZe+995bnn39eNtlkk5T2Gcf2mGOOUct75plnIstN5Vign/mDDz6ojkNFRYUMHTpUid6TTjpJTCaTmqe8vFx23XXXqGXMmjVLsrKy2iwbx3DrrbdWkQrLli2Te++9N+G241j/73//k2effVauvPJK1T4OAzOxnw2d1tZWtb8jRoyQ++67L4UjRQghpK/BPtiEEEL6FeiBnUjotMfdd98tr732mlx11VUyZMgQOeuss5QA/ec//yk//vijfPXVV+rfRx99dERo7bXXXrLlllumZbtPOeUU2Xbbbdu8jm3RgeA/88wzZe7cuWo7ICYhNM3m5ALSHnjgAXn00UfVIMJmm20mixcvVoMDENTYNx2I6zlz5qhjAdf1nnvukcGDB8sJJ5wQmQeCEuI1VXENMICBfXj33XfjRgQkcyyuvfZa+fjjj9XAx9ixY2X27Nly2223icfjkTPOOEPNs3btWiXCjUB0Y/54QFxDpGO/sRyHw9FGKF9++eXy+++/q4GB4cOHq+OJ9UFAP/TQQzJs2LA2y8UgxTXXXCPHH3+8GrSAm00IIaR/QoFNCCGkX7HTTjt16BLCBd50002jXtt3333lhRdeUKLqo48+Um72HXfcoUQtxBzcWoi1/fbbT3Jzc+Wll15SocFG0dkVJk2aJLvvvnu789x6661K3MF5TyQSE1FXVydPPvmknH322XLeeeep1/bZZx8pKSlRYdqnnXaaclgxcPDZZ5+p1w499FA13x9//CGffPJJZF+Ro47BiDfffDPl/YSIfeqpp5QrnmgfOjoWcO7feustdTwOOeSQyL7Y7XYl/CGSs7Oz1bmrr6+Pei8GJDAwsnLlyjbLxUAK3g8wqGCMCsBgxKWXXioul0tFAOC4AawHUQE4Xocffrh63H///dssG+74zjvvrM4BBTYhhPRfKLAJIYT0K77++msloFJl8uTJyuE999xzlVD717/+pcQTnEeEiUO0w6lEOPX5558vt99+u9x4442Sk5MTtRw9zBkO7HPPPZe2/YLzivB3OKipims9hxwOLELCjfz5z3+W66+/Xr744gvliMOxxgAEQq518G+IbB3kKkMgjxo1KuXt+Omnn5RAhjjuLNhWhGVjsMMI9u2RRx6RmTNnRs4BHGMdvAfnGYMFsfz1r3+VrbbaSp3b2HxrDLzg/GMeDFDEuu74vCBvH6H7V199tXLmr7jiijbH59hjj1WfL4TnG48vIYSQ/gMFNiGEkH4DQnuTyUU2Ci4j2223nRJg06ZNUwLo888/V6K6uLhYTb/rrruUSIIQhdg66KCD0rr9cFexTfFCvj/99FPl/sIlBXCaEQ6fLHBg4c4jrNkIwumxr4sWLVLP8/LyVA6z0fmF+52fn6/+jfkgUD/44INO7SPy2OH+GnPfUz0W2BfsR2wI9+jRo9V7sI0Q2BhQgDjWwfxwjxESbwSDJBDJOKZGfv75ZyWYcf6Rb4188ylTpiTc5vHjx6s8cYTbw8WG433qqadGpu+4445qPd99950ceeSR7e4/IYSQvgkFNiGEkD4PBB/c5M6A3GKE/EK8IiwY7u0ll1wiv/32m9x8881K2OoFwhCaDfcRDvKMGTNkhx12kN122y1qeWVlZfL++++rUOJUgJCD6wlBCaEIIQ0Rr4tohIZj2chfhpO9fPly5bAj9BhVqvGe9kBRsoKCgrjT8LouOiEAMcDw4osvqjxtONo4BqiWrQ8yIN8Y70FROUQMQKQfccQRKjQ7GQcbx00vRNaZY5FoX7BMDATo+4JQfuRIG9mwYYNy3yHgkWcNcf2Pf/xD5Unj3BuBsMY0pB0AuO7JOO+PPfaYKoIWW2wPx2nzzTdXx4ACmxBC+icU2IQQQvo8CAmHI4qiW998800kPxaFuiD8IJZj3c5Y4Eyj8BbCeuF+YnnoiY1loKo0cmchwhD2jcJeCAeGCERRK7xXF0wIH04lhBsiGU7nmDFjVHVrVMSGoEUIOsLN9TZWEI0QuxDaKMAG8YY8YmwX9hHCGznUiYCgTNRiDK9DbOog5xyhzHoeNAq5wYlFITHkKWPgASH0cGKRpw7Rin3Ace8oPH/dunWyzTbbdOlYJLsvEOLGXG4IXISP4w+DFChUhnBugNdwvo3gs9CZMHiAcPN4YJAEx4AQQkj/hAKbEEJIvwI50nroN4pcAYhCiEZgDDmGY/nEE0+o1k8IAYZ7i7BgVHv+8ssvlaiDSHvvvfdUOyaILRQAQ0g1qngfcMABytWGEOwscFz1qtc6CD2HmEQhtQsuuEC5tcgFhvsJYasDZxUOOgq0QfjD+U0E9g3LiAdeR2i4DgYXsJ9wyTGogEEEuMN33nmnnHzyyWp7UOAMzrkeMo3teP311zsU2Bgk0EPuO3sssC9NTU0J90UfTMF6MECSDBgc0MPkY8F+If0gWZCPrTv+8dYzb968pJdFCCGkb0GBTQghpF+BVkmxDjaKXSHEGO42BDVA0a6jjjoqUmwKIb0QlRCrAPm4CA9GVWk9zBhOOBxPOKqYD+2ksNzu4E9/+pMSlStWrFCiEqHMKA4WL8QdVbeXLl3a7vKKioqktrY27rSampqoXtu6E4ycYh2EgiP3GUXEkJMNtze2EBpamSVDsm3FEh0L7AsGP2JBmD+2LZk+6LEgpxvnPxEQ68gf7wg9nDwRSDUghBDSf0ntF44QQgjJcE488URVGRt/yKXWgSBGGPDChQvVc+QYo20SQpEBwsPRdksH+b6Y1+hqIjcZQg8tqpBj/e9//7vb9kMPV9a3D2IXojKecwunXp8vEQhbR9EvtNgy0tLSovpFjxs3LuF7IVzRJxw9uLEeXSQaxSIGJDBfR8ClTtXxjz0W2BfsB0LFjcBxh4OtDwwg8gBF65CnjjB3VIOPzbPWwXwYwMAx6k4QEaEXjCOEENL/oMAmhBDSr0CoNFxm/KEgl86gQYOU43zxxRer/GlUe0a+rw7EVWyhMAg5hPNCOCI0Gw4mRCUE3A033CC33XZbm/VD4GFZEK3JgHljhSnWgQEAuNN6Pjf6cEP8/ec//4maF/26sQyjc4owbLxmzCnWK1ijf7QRHCeIY+SvJwIVw7FMvYgZXGQMMCA3XQf/HjJkSIf7i/Owfv36Lh0LhKPjOKOYnBHsG7bL2Gca4e0I+8fASHvgnKIoGtqZAUQ+JDNgkCr4XOAYEEII6Z8wRJwQQkifB0JSd6ZRERwtpuD2xoZUo8cxWm8hHxv5w8YQaBTwgqiK7auMcGS4xnBLUdQModPIr8W88QQlxCNaNCXbB/vxxx9XhcvwHhT3Qrg28psR3v7ggw9GwqnhvqKYGiqdwwWFI6sXOYOzfuihh0aWidZU6OltzAWGa4r8aYS8w7VGhXCEfKPiNd6bqAo5xPe9994r5513nhLoOsg/R7g9CpPBkUZ4eLwBh1iw3R9++GGXjgXOGyIUMMihu+84fyhahj7V2Kb2gGiH648/iHKE1yPUH+uFEEcOOpbbXqXzzqAXzcO2E0II6Z9QYBNCCOnzQFQ//fTTssUWW6gwYRQjgwCEy4m+2HAi4T5DpEE0nX766SpXe8GCBapYGSo+owc2hCryrHWMhar01lFffPGFcpGRi7zLLrvIaaedlrAqdjJgHXCmUdUawhkCHsXMIM4hRo1gYAC5zpgXIhriH+IYxb+M4jcRF110kRKfegVt5BX/5S9/URXDE4ECXxC2RgEPUPQN2w1nH64xisslIxzhLj/11FPKeUfueGePBSqZ33///erco8I6BjsQkYBBBCMYbMG5hgOv595joAIDDhhUgOBFVXhUGEel9P32208dTzjmRrA9GOToCshjx2fS6LATQgjpX5hC3RH/RAghhGQAepEzhITD7UT/Zog4VBlHDi+EHpxKY69kvYo4xHd7wB2HSIU4h9NNkgOO+D777CPTp09XReS6E+Rg//Of/4yqTH7SSSepNl6JXG6EnV9zzTUq2kEX6xhkQAX1ZIqcoSAbBDqqn8eCzxVy+1GxnhBCSP+EApsQQgghPQoiAOBAI1QcOdLdBcL6EQ5vbEHWW8C9RrQDwuAxuEAIIaR/krFFzpBTlmrrE/QshTOB3CmE7aHiaaJqoYQQQgjpHdAeDeHWN954Y7e2rULYfCaIa+Re/9///Z/qEU5xTQgh/ZuME9jIvUIblVRbn6C9CnLI8MOFUECEd6GNirGCLCGEEEJ6H4TooyDad999pwbD+zPIxENuOPpzI02BEEJI/ybjQsSNBUR22GEHVbQmGdB2BWFgKDpjzKNCERb8gHdUUZQQQgghhBBCCOlXDjb6kuJvzz33TOl9cL133nnnqNfgZqOQyaxZs9K8lYQQQgghhBBCSIa36ZowYYJ6zM3NVf0pk6GxsVG16IgtlALXGm040CeUEEIIIYQQQggZUA52Z2hqalKP6GEZS1ZWlhLgncEXCEpVg7fL20cIIekGhaGQFtOdBaIIIYQQQkgfd7AzibXVHvm/VxfL7ceM6e1NIV3AYjFLbq5L6utbJBCgGOmPDMRzjPIZ6Cfc0hIQk8kkA4GBeJ4HGjzH/R+e4/4Pz3H/ZyCe49xcl9rvASOw4VKDeCHlcLe7UuCsxRsUv39gfHD6O7gA8Fz2bwbeOTZLIIA6lRlVq7LbGXjneeDBc9z/4Tnu//Ac9394jvtxiDgEdGFhoaxZsybqdYSG19bWyvDhwzu97FbexBFCMpC6ulr54IO31SMhhBBCCMkM+qTARi/J8vJyFR6ps91228nXX38dNd8333wjNptNttpqq06vq9VHl4QQkoloIeIDzb0mhBBCCMlkMi5EvL6+Xj36fD5186g/R1VxnVtuuUXeeOMN+eyzzyKVw0855RQ59thj5Z577pF9991XVq1aJTfddJN6rSsh4l5/UILBkJjNAyPHkRDSN8jLK5A///nQ3t4MQgghJAoU32xtbRWv1xNOYyL9jWDQJK2tln55ji0Wq5jN5v4lsLfZZpu4zxcsWNDu+6ZNmyYPPPCA3HvvvfLEE0+o9lwHH3ywXHjhhV3aHq8/JL5ASBwU2IQQQgghhCTE42mR2toKVXyTXS76N5WV5n56jk1SUFAiDoer80sIoRQticuKihY57r7f5LkzJkqO08Kj1EexWs1SUJAlNTVNLIzUTxmI57iiYr288soLcuSRx0tJSZkMBAbieR5o8Bz3f3iO+y8QWxs2rBa73amMLkMmJ+mHWCymfudeh0IhaWysE6+3VUpLh0U52YWFWQOrinh34g+EVJi4CAU2ISRzyM7Old1220s9EkIIIb1NIOBXdUGys/OUyOZAaP8fLOuP5zg7O0+qq9F+zC9ms71Ty6DA7gCEhyNMnBBCMgmXyyWbbDK1tzeDEEIIiQLh4YQM5M9vn6wi3pP4g7qDTQghmQMKyCxZskg9EkIIIYSQzIACOwmB3exlEgkhJLNoaKiTjz56Rz0SQgghhKSCx+NRg/Tz5//BA5dmGCLeASiO1+Klg00IySyKikrklFPOFrvd0dubQgghhGQk//rXzfL773MjLXsXLJgvEydOUv/2+/1itVrlgQcek1mzfpZ33nlTqqur5dBDD5fm5mZ5//13wu+ZJxMnTlb/nj59dznqqGPluOMOl8LCItVS+F//ulet5/zzL5Fbbvmn3HDDzXLTTdfLLbfcod5zySXnSSCwUUusXr1SbU9+fmHkNbQdvvzyv3e4P5WVFXLjjddFvfbHH3Nk0qRNxGzeWC9qt932kEMPPaLdZb388ouy2Waby4svPif//OetYrPZpDP8738/yUcfvS9//3v0dg1kKLCTcLA94VZdNgtzSgghmQEqWzqdnW8hQQghhAwEdt55uowaNVr9+7HHHpKDDjpMzGaTNDY2yqeffqRenzBhklxxxdVy3nlnyG677Snl5eVSVVWlpq1atVK2227HiMAGENcQ5meffaqsWrVCVqxYLi+99LwEgwF5+OH7pKioSJYuXSxjxoyTiy66XIYPH6Fye1taWuSyyy5Qotztdqtl/fHHXCkuLkm4/XCYb7nlRrnrrvuV41xaWipXX319ZPonn3yotlkXyBgs+PrrL9W/77nnX/LHH7/HXe4uu+wmVVWVcumlV3ap7/Ozzz6ljtEZZ/w16vXJkzeRiy++QubPn6cGIO699+HIQEd/hwK7AwLBUKSSuM3CSuKEkMygvr5OZs78VrbbbifJzc3r7c0hhBBCMhK0DNPbWcKxLikpUW6v0+mMzBMr/HJzc2SbbbZV/37//bcj/8broKGhXu6667bwa3lKSD711KOy1177yAcfvCdnnHGuZGVpy/zss4+Va33++ZfKOeecKpdc8jeZO/c3JcAh2G+77f+U4I4HXHa44jfeeJsUFRWr53vtta9cccVFkXlmz/5FrdNq1XTKJptMkZNOOln9G+K+O3n77TfE4XDI66+/F/X6hx++p4Q+mDRpshxzzPFy3313DhiXmwK7AyCufUHNwSaEkEzqN9rU1KgeCSGEkEzjozk18sBna6XJk/7fqSyHWc770xDZZ0pBu/Pl5OTKRx99IF988bk0NDSo380nn3xUTcPvJ5xo8PHHH8h//vOcrFixTDnMw4ePlEWLFqhpELYPPHCP+veIESOV043lXnDBpXL++WfKY489qNzuhQsXqJDxxYsXyuOPP6TCys8//2I5+eTTlVOelZUlRx55rBKfK1eukNtvv0d++222Cs8uLdUGAGKBO73lltuo9eoDBFtuubVMnrxpZJ6zzz5Frrji7xFBDyfbOHjQXfz440wVZn7HHfe1mTZnzq+y3XY7RJ5jUOCll16QdevWyuDBQ6S/Q4HdAUiZCLKSOCEkw8jPL5BDDjmqtzeDEEIIictTX6+XpRWebjs6//56fYcC+6yzzpPvv/9WhULDUYU4Xr58qcyePUuOOeaEyHx7772fFBQUyNVX/005zDU1NeLxtMpmm20RmQfvOeigQyPPIXYB5r/55hvkySefkyFDhkp5+ToVEn3EEUdH5t1qq23lm2++VHnRH3zwrpx++lnq+dZbb6vyvRPx1VdfyAknRIdef//9N/Lqqy9Hnq9fXy7/93/XicWibU9ZWZlyirH8J57QBhN0qqurVKh6QUFhVAj9aaedJanw7rtvyhtvvCp33HGvPP/8v1WIOI4hhHRra6v89NNMOffcC6Pes8cef5Jvv/1KjjjiGOnvUGAnkYMdCtHBJoQQQgghJFlOmV4mD3zafQ72ybvEd31jgdv76KMPKgH9448/KLf6b3+7Rl588XkZOXKU7LjjzsrNhtM9aNAg5XAjdPuHH75TTrPO2rVrlIAEFotF5V1DI9x997/U+xG2jefIp4Y4R2g33N0333xNvvpqhhx++FHyxBOPSG5urqxevVqeeeZJKSsbJA8/fL/89a+nyfTpu7XZdoSWjxo1qk3uNP50TjzxKLnlljslJ0cLX9fZeedd1Z+Rhx66T20fCrXF8u9/Py5ffjmj3WN52mlnqmX6/cg1f0LsdqdcdtlVUlNTLW+99bqccsrxygDA4ILbnRX1XhxrCO+BAAV2UphYSZwQklFUVm6Q119/SQ477BgpLi7t7c0hhBBCooC73JHD3J3AsUaFbIRtQwCvWbNGXn31v7LTTtPl9ttvUoXOELqtTVslf/rTPrJs2VK56qp/yC+//E/Gjh0nu+/+p8jyPvvsk6icbQhGuMHXX3+Teg1CeauttpFtt91eTj31RLnvvkfU6yhwds89D6llw0GGK47QdDjfIiE134wZnybcD6xDB2Hr9957Z+Q5hDyW+5e/HKPcc51NNtlUzjkn2kEGS5YslmnTNo+7HoSy4y8ZDjnkcLFazeL3a4MncMQxSIBt/e23X+Xwwze69zoYfMDfQIACOxlMIs1s1UUIySDc7mzZfvud1SMhhBBCooGQREsutMj69ddZyvU99ND95eab/yVffPGZqvANNxd52SjEhX8//vjDkdBviFFU/TY62HqrLL1oWqygP/HEk5Wgh8Otv+eFF55RfzqrV6+S7OwcVXzNyIEHHtJmmUOHDpOVK1eq7QPjx09U1ctBc3OT/OMfV8nFF1+u3HcUEot1rI3AnUbF82222S7tH5U1a1bLQw+hMnqWak+m77+R5cuXq/0ZCFBgJ4EJDrYPo18hNdpFCCG9Ddp7TJu2ZW9vBiGEEJKRoA0Xelsj7/fggw+Lmga399Zbb5SRI0fLscceLyNGRIdhb7rpVJVvjfmQW/z666+I3++TKVOmqb7PaEFldGMRbo6iXnC2EVaut93C+3VBrIPq41tssVWUO54I5Ed//vnHEYEN6upqZcaMz9S+oVr4rrvuIXvttZ/cffft8vrrryp3GSLa5XIpsf/rr6gy/q4sXDhfVStH1e90AOf/v/99IRL2fdxxJ6kCbImYMeMTueGGW2QgQIGdJL6AiDcQEicFNiEkA/B6PaqQyqBBg8VuT8+PJSGEENJfgFuLMO7jjjuxjaOKvtcPPfSEEstNTU1R0yBKUaQMody6CIbYhqBFLrfdbpc///lgOfPMk2XMmLEq9xgO7iWXXKEc8I8//lDOPPOctOzDPvscIKeddqIceuiRqvo2wsGRIw4x/9BDj4vDoVULR173ddf9n3LdUaW8omK9CtNGCDlyzuHeI/S9K/2uY8Gy4EgjtB6V1tvjgw/eldGjx6hw+YGAKTRQguE7wYqKFtnm6h/l3uPGiNUssuWobMl1cUyir4EckYKCLKmpaYrkipD+xUA8x/jxfOWVF+TII4+PG6rWHxmI53mgwXPc/+E57r/4fF6pqlonRUWDxeVy9tvrtDEEHPh8PtUaC3i9XiU89TDzdDBv3u9y1123y5133qd6bmcKxhzs9vjtt9ly5523yf33P6oGAvrS59hms0deLyzMEosluQEKqsUkwBgE2mCzFzYhJFMoLCyWk046XVwud29vCiGEEDJgiHXDdXEN4G6nG1RBf/zxjTncfTEX/plnXpSBRPriBPp5qy5kYnv9NPsJIZnzA48iKfEKiRBCCCGEkN6BAjsJdOfa209DXQghfY+Ghnr54otP1CMhhBBCCMkMKLCTwB8IidVskmZvoPvPCCGEJIHf75eKig3qkRBCCCGEZAbMwU4CXzAkNotJmjx0sAkhmUFBQaEqcEYIIYQQQjIHCuwkHWwIbISK+8L/JoQQQgghhCQG6ZWBbvCnUMzZjhY/GUJ9fb18/fUXcsABB/X2pmQUwWBQ/c2Z86vq/T1QoMBONkTcYpIWX1BdKGwJigpVNfoky2ERpy1zvvCEkP5JZWWFvP32q3LQQUdIcXFJb28OIYQQEgXumeeubpImb/oVdpbdLFOGZWWMyP7ppx9k+fJlqkf1b7/92mb6uedeIGPGjJP58+dJU1OjPPHEw3LhhZdLVlaWPPfcv6Wqqkp+//032XTTaWr+6667UT799CN5++032+0xXVJSItdcc4Na7xdffCZ5eflSU1Mthx12pIwePVZuvPEfqld1IOAXi8UqDzzwWFL7c911f5fa2tqonuJoEYbl64wYMVwuvfSqdpfzxx9z5Zdf/ifV1dVSWFik+pJ3hsbGRrnggrNUNfW+UNyVAjvJKuIQ2HhM1KoLF5FlFa0yrNAhg/LSX6KfEEKMuN1u2WyzrdQjIYQQkmnAuYa4tlvMaY3+xL04lpuMM/7BB+/K66+/IiaTSXJycuWSS65QghMcccSBqi+z1aq12XI6nXLffY+Ix9Mq1157pRKY+fn5cuONt4rD4VSvX3DB2XLvvQ+reWPXc+ihR6qWVEcddVyb7TCbTUrkrly5XFpamqWlpVX9G6LzlFPOkGXLlkgoFJTTTz9biW68Do477kTZf/8D2yxv6dIl8uOP38sxx5wQee3008+R6dN3k48+el8aGxvUa7vttqdceOGlal+uueaKhMepoaFBzj//TLn44itks802lw0b1svDDz8ZmT579iwpLS2TIUOGRl47+WRtP99//x15883X4i53zJixMmXKVDnkkCOS7iEdj1deeVHWrl0tZ599atTrWObDDz8l9fV1cumlF8ill14pkyZNlt6GAjtJB9tsMkkwGEpYSby22S81zX4pydnYC48QQroLtztLttpqWx5gQgghGQ3EtSOt0Z1BSabu8Ny5c+S1116W++9/VFwul/zww3dy/fV/l8cffzYyz6233qWEo5EZMz5T7u/ZZ58vDz98v3q+774HyIsvPi+HHHJ4G3G9atVKWbhwgQQCAbnoonPibgvaat5770Py008zpbx8rYpCgzCFeP7gg3fU+vbY40/Kxf766y/bOM133XWb7LnnPkr8orjpv/51s5x77oVR8zz++EPy8sv/iTjYAK72okULIg52Iu6//y45+ujj1PLBddfdJFdccVFk+rJlS5V7XVhYqJ7j37fddpf6N/Yh3iBAuli6dLEawHjllXckJycn8vr69eVy3nlnqn/DXb/++pvk6quvkCeeeFas1t6VuBTYSWB0reP1wg6FQrKh3iet3hArjRNCegSfz6t+oBEebrMxaoYQQggxgrzfbbbZTolrsP32O8oDD9wj5eXl8v/snQWcG3X6xt+4rLvUvYVCcTm0cLhL8cPhsMNdDikc7q7HUeyP3AGH93AtUCilhbqvu8Rl/5/nnUx2kk12k9Vs9v32s43MZGYyk0zm+T2vlJaWxt1ZdXV1YZcbt3hcX19PP/30A4v1aJ5//mkW6XCPV69eSYsW/dJlniuvvJZvESp9110P0ty5N9CcOcfT4sWLEjpoZ555Dt11120cig53erfd9qSZM5VwchXkOE+ZMo2qq6t4e+DY77rrHjR16jR2zb/88vOYy66srKBVq1bStdfeGH4O++eGG+aGHz/22EO09dbb0M477xp25HNyssk/wC2Ma2trWDRfeeV1EeJaPb477rhT+DGO1TbbbMuh9RgQGUpEYCcAQsOBQa8jV4w8ElQXb3L4KdOq5/sQ3AhFEQRBGCiam5voP//5P64kXlQUOfouCIIgCCOdyZOn0KOPPkjHHnsih3o3NTWxs1lfX8sCUqfT03XXXUGBQJDGj59AZ599HpWWlrFQW7RoIS9j1aoVLFyfeupROuOMv9JTTz0WHtxGOPeSJYu5wFlbWyvPDyd3jz1md9kWtVaK1+umhQt/4G1BPrbKFlvMopKSUnI6HexgRwOHdu7cO+n8889ix/yFF17tMs922+1IO++8C11yyfn066+dIv+ss87hKNx4Avvrr79k91xLVVUl3XHHrRE52Minfu+9/4afu/32u8jpdNHll0c66S6Xk9+fNpy8sLCQ7rnnIUoGRCDceedcuvTSq9j1P+usU2jXXXenQw89gjupICwdx0zLn/+8H7300r9EYA8nB9tk0JMjRkxKo8NHnkCQcmxGdrgxv9koAlsQhIEjL6+Ajj/+VB6hFgRBEAQhErjXRxxxNF111SUsrCGikaubkZHJ019++Q0ymUxc5Rpi7eabr+N8XjjRcIrPPvtUmjRpCgtft9vNeco+n4+uu+4mdsIhTFGA7IYbbmHxByB+IU5jCWyLxUKnn/5X+vrrL3iQHAW/8Pfcc0/SE088wtMRZh6riBfWe+edt3I+81/+ciqHol977U00bdr0iPnwXoAaYn7RRefxa7sLD9+0aQPtsEOnEwzKyso5pF0bog4Bj32jYjTqyW7PpOeffznitd999w29885/6Pbb7+myru+++5qefLJzubGAiIZj39BQR3feeX9YqO+zz/70ySfz6bLL/kaFhcXsaCPnXQv2J47BUCMOdoI52GoOicePcvMdHBqhTqtp9ZHNZODpTg8qjUNgD+yBEwRhZIOLBYzgCoIgCIIQm8MOO5L/AJzmb775isaOHcePIa6BXq+ngw46hEWu+vt61VXXh5dx6aUX0OWXX8PiTn0tbtevXxchOAHcUwjaaFCQdO+996VZs7amJ598lKtif/vtVxy2Dm688VYaPXoMi/hrrrks4rWowg0H/cgjj2GRCUaPHsvFzKIFtuq6X3DB2aH7KxP8aEQag+rrVeDUf/DBexHrM5vNdN99yj7Tsnr1ygj3WgtCzNUw857YY4+9Ih6j0BwiBBBlgMGGRx99pstrOjqU1N2hRmRgEgJbadXVQd5AB1lDArvF5ac2V4AKs0yEp/xBFF7A6FHql5AXBGH4ghysX39dyJXEUTxFEARBEFI3ErT/cnXjdfTpDqfTSXfddSu7v3CIEebtcrlozJixPH3+/I9oq6227vK6L774lCZPnsqCEWHOaMUFNm3ayBWyo8Fy5817LeI5COGamhq+//DD93OhNKwPOdTz539I48dP5KJlELnBYIDzqKNzjW+99a6Idl3Ybri8scD2ah3snkBIfLTrq74eYvWZZ56gMWPGkdvt4oGFk08+nfchHOzoHOyKik1c8fu++x6l/gaDEhjAQPj7gw8+wccjGhwfNX9+KBGBnUQOtlGv4w8SKomrva4b2v3h/GzQEacQmiAIQn/i9Xppw4b1NGPGFrJjBUEQhJQDXZnQrxottRKp+p0MWG4iXZ9uuuk6Fo8QhIceejgdfPDh/DxynefOvZHdZjixcEWvvvqGiNdiGiqH33uvkjs8e/afudUVwsGR033GGZEuL0AxtGhR29hYTwcccAh98cVnVFxczIXHILAPPvgwDglHGzGEr6NFFlpNIedb5eWX57GwXrjwp7jv8Y477g3fhxvf0tIc3gbkhsORR+h4vPpQf/rTbtwv+/jjO1t+eTweLur2yivzeHsuv/xqfv7FF5/n0PlDDjmcZs+eTTk5+eG2YZ9+Op+rfV9xxbU0adJk6i+w3zDQAfGO9WJgIV4vbBQ4Q4j5UCMCO4mRMjjYgQ7FwQYoeFbX5qMsa+dB1pGOPL6BragnCIKAHpnHH6/kfAmCIAhCqmE26mnm6IyE+lUnC8Q1lt8TaN0Ui7Fjx9PTT/+r29cihPyJJ54LP0Z7rp4KdU2dOj0id1l1sBsaGmi33fYgvX4296TW5jbDcb3ggkv48Y03zuX8brXKebw+2N1tc7SDjlzxl19+gQugxQJu+JgxYzgEfu+99+E2YKhyjvdy003/iHCKTznlDBa5KHb27LNPcwEy9T0ibxvrttvt1J9gMAPrRX51d8B0+OmnBV3alw0Fuo5UCFRPUdbXuWj7636gg2bl0Sm7KFV6q1u8NKPcTuW5Zqpq9tLSCgeV5pjDo0L1bT4qzjbSjPKMId56QQUhLHl5GdTU5BjwdgLC0CDHeGQgxzn9kWOc/sgxTu/2kQ0NVVRQUEY2m1WuuYYRyE9H9XG4z9Onz0joNbFCxIeKxsYGuvTSv9FVV11HM2Zs3m+fY20b1Pz8DDIkEjYhDnbyuR6Q0b5QobPqVi9ZjPqIkAsUOpNWXYIgDDQNDfX0/vtv0YEHHh6RlyUIgiAIgpAM2dnZ9Oyz84Z1VN/zUdXMh5LEZPgIRy1ypuZaO70BavMEqIV7X0fmAJiMunCrLkEQhIECoWpTp87gW0EQBEEQBCE1kBzsJAW26lA3tvu4+Fl0/oe06hIEYTBAH88dd4ydTyUIgiAIgiAMDeJgJ1FFXBXQvlDv6wxL1wp2XGk83KpLEARhYEB107q6mpj9NgVBEARBEIShQQR2AmjDvVFJHI8dngBlxhDYyMeWVl2CIAw0zc2N9PrrL/GtIAiCIAiCkBqIwE4yRBwC2+UNkF6nI32o93U00qpLEISBJjc3n+bMOZFvBUEQBEHoX6TRUmrw448LqLW1hYYTkoOdZIg4hHW2zUh2syH+Tg0VQhMEQRgo0OuyqEhpHygIgiAIQmxuvPEaOvPMc7nfs8oFF5xN1113E/duVtm0aSM99NC9dNddD9CTTz5Kv/76C9lsdvrjj6V0+OFH8et3221PyszM7HFX//zzT/SPf9xMZrOZjj/+L4SGQ5mZWbRx4wYqLx9FDoeDbDYb7bPP/vTTTz/QvHnPR7z+t99+pS22mBXx3JFHHk177LFXyh3mo446OGI/RtPS0kx77rk3nXHGX7tMe//9/1JVVWXMaSoPPHA3Pf30CzRnzqFUUqL0B9dy7bU38j7VgmXedttN9MgjT9FQIAI7SQcbQGB3h7TqEgRhoHE42mnJkl9p5sxZXPBMEARBEIRIvF4v/fjjD9TQ0MCPt9xyKzr77PO67Kb169fRL7/8RI2NjbR69SrupTx+/AQKBoO0du1qGjduPM+3YMG3tPfe+8bczW+88Sr98stCuvnm2/nxAQcowjMQCJDfH6CXXvoXWa022nbb7emLLz6lo48+jtxuN2233Q5UXFxMY8cq6/jyy89p2rRpdN55F4WX/dVXn9Of/rQb34dwXLx4EeXk5IanY7AA24jtfemlF+izz/4HD56XrV2Olu+++5qee+5pvl9YWEhXXXUD5ebmksfjphtuuJqam5v58dy5d5DFYuXnL7zwXHrwwccjOpjk5uZFCNkbbriazjrrXBo7dlz4/axcuZzvH3vs4VRUVNwlUgD7TdvT+uWX3+T7S5YsplGjRpPdbie9Xh9XMN988/VUWVnB5oMK9gUGUrTH+Omn/8XPX3fdFXT77fdSaWkZDQQisBMg2ZZb2lZdZmPsMHJBEIS+gB/lFSv+oMmTp4nAFgRBEFKS7iI6DTodWUz6hOZFBKlVM2+ifPvtV3T00cfS6aefzSL1m2++Ytc01m9qW1sbFw51uVyUkZFBBoOBOjqCXF8J7jNvsyF2BCuc6f/+9y12Wo1GRV59//03ZLdn0p//vC9NnjyFTj/9r/T8889QU1MjO7qjR4/l5TmdDpo790Y65ZQzqK2tld5++9/00ENP0N13/4NOOulU+vrrL2nZst/ZPVfB+9lvvwO7bMfDD99PLpeTnnjiOXbP41FfX0/33Xc3Pfnkc9xD+oMP3qW7776Nbrvtbvrss09owoRJdO65f6PHH3+YH++//0H0yisvspMfqz3oDz98z8IerF69kt17iHJw1FHHhOfDoEBPrvKpp54Qvv/WW2/SQQcdRj0RDAbopptu69ZJv+aay1jMw+2+9NKr6Pbbb+HBgoFABHZ36LqGiCeCtOoSBGGgKSgopL/85UzZ0YIgCELKsv3Nv8adtvvUbHr8lMmdj//xG7l8sbvwbD8hk54/c2rS6/+//3uZbr75H3y/qqqKXdX29jYOwdYybdp0FtV4fubMLeippx5jl1gNcX7llXl8f//9u4paMG/eP+mMM86JELU77vgndkhXrFhGH330PotnhIZjHXCHkVt8yimn0/bb70T33vswLV78C+211z708ccf0DPPPMHOt+KA++maa/7e43ttampiZ/zVV//TrbgGP/74PW2//Q4srgFC1R988B52d+vq6tg1BrjFYwhyhLI//PCTMZe3ww478Z8qZM85529h1x8Otsp99z1C33//Lb34ohISj+VCHBcXKylvp512Fj3//Mt8v7q6ij79dD6deqpyrYNtO/HEo3m/FBYWhbuoPPnkP+mqq64np9MZdqzhtldUVNDEiZP48a677s6OtQrC7+32DE4DmDVra+pvRGB3g66XDnZkq674udqCIAiCIAiCIPQ/EJsQmgipvvDCy1jYnXnmX2mzzWayKwsH84YbbgmHLEOwQdQhlBth4X//+1wWoKeddgILy2+++ZJ+/31pl/WoIc5XXnldxPNwvhHWPGXKNNpll93pk08+pssvv4a36c03X+M84a233o7nzc7OZsGH5y644BKaO/fvdOGFl7I4x+shKlVnHMt94YXn6LXXXmFH+OSTT6OtttqGfv99CWVlZfH7qq6uJIPByPnfu+yihJZrqaur5YF6FSwb+eYYTICoXrRICdletWoFbb31tvTUU49ynjQGHurr61jgnnvu+RHLhGuNMO21a1fTrbf+nR3sE044OWIe5K9jW/1+H+266x701ltvkNPpohNO+EuXbXzuuac4Qq+2toZGjx7D7/uiiy7nqISLL76CByg+/PBdnhf7Dn9w2P/85/04HPzRRx/gfPp4YD6IfxHYKZKD3RPSqksQhIEGOUofffQu7bffweERaEEQBEFIJX68MbJQV3SIuJYvr92i2xDxZNmwYT3deef9/HuJHF3ULoG45nUbDHTwwYfR5ZdfyCHICNuGy5ydncOh18j9RZ6u2Wxh0fu3v/2VK1lDFEbT0tLCwlYVwMDv9/NfQ0M9F09DCHptbTUdcsg+NGnSFBbe4Nlnn6SjjjqWHn/8Id4mOMlwr/fccy/6+usvaO3aNbT33vvQM888TnPn3sW50ldccW0413jJkt/ouusup3nzXudQczjBcHMRxl1RsYm3G04yBGqi7L77nuxwn332qbytKCymDaFHvvcjjzxAX331Be2yS+f+QO76s88qTj+AeMb71+aKA+xrhNOr+/Kdd/5DCxZ8x/ctFgvdddf9PFiA/a0ODsC9Vp1nFKDDoAYc9R133KVLJAGEM8AyLrqoM9/+ssuuCueFA+wXHPOBQBzsbkC7rd4IbPW1njhhLiOVJoefGtp9NLbAQmajdIgThL6AEXD8UPQUBiYIgiAIQ0V3XXf6Mm8i/OUvp/Etcm7hAiP0WwvE2hNP/JOFGHKkDzroUK4iDncWIB9ZdbCRN4z87aVLf4uztsgBAIhRLNPj8XARsEMOOZyfP/30E+mxx55hN7umppodXohQ5ImjsNrHH3/I24FpENtwaffeez8aM2YcPweBrS3khfdUUlLGgwBw4nU6fThHGk40BhTgKEcLbMyrDZPHYABytyGGIf4h0lUuvfQCdt4/+WR+WKDiFi6xVmAjXx3V07V56ePHT6RoUHAO+0Tl0EOP6OJgT5o0maMLkFMOMFiA44jK6yhU98Yb/8dO9plnnhN+DUS4trUa3nt3DrYyb/IaLxFEYA9ADjbvWGnVFcbrD1JFk4c2NnrJ4w9Sts1AxdkiCgShL6Dgyi67dBY8EQRBEAQhdrXsmpoquvzyq7tMg2BDVW9VFKvsuOPOdMcdc9mxVcK2z+ZK1hCD0eTk5LDbCpGqutgVFRtpp53+RKtWrQzPByE/YYIiOOEIIyQbIEwZglsLHHTkB6sFxJRt+hNtvvlMDkdH2DZYs2YVO8JwYyGMN2xYx89NnDiZ87yx/osuuoznra6uZvGNyuB4z6ggjrztvLw8mj//Q9pmm+3Dzro2zH7y5KksbiHu161by8/DlZ8ypTN/HqAoGkLMVWbO3JKmT9+MVq5cQVp+/vlHDiXH/ooHwsstls7HcKvV93zqqWfQkUcexOHi2sEGDH7g/SD8PRHWr19L5eVKrnl/IwK7G9SxqN4IbGnVpYwMNTr8tL7eTQ0OP+XajITBopoWHxVlmTiUXhCE3oEfJhRMycrKjghLEwRBEASBwuL0X/96ju6++8Eed4nW/Tz88KP5D7+1qoMdD1zPzpq1FYdV77zzrmEBikrcqriEk/3YYw9x9Wp1OsQyOOKIo/lPy6GH7hd3nQiDvvfeO1nwI6T6lltuD7vWuH/ffXfxwADE8qWXXhnOMUdeNEQqcqkRSn7hhZfQlVdexK43RPbVV98QsR4sA5XD7733IX48e/af6frrr6SzzjqFRfrZZyvuMUS1NhQ7kn9Tc3MTh50DCGBURd9vvwPo4ovPYycc1dR7AqHcKFYHt//OO2+lk08+nSuMY3ADvcHhXj///LMs8q+++jLabbeuofzR/O9/H3GrtIFArsoSINkiZ2Ckt+pCePzGRg9tavTwiac020x6vY4Meh01Of3U7glSllUKwAlCb2lqaqDXX3+J5sw5kYqKlOqbgiAIgiAooPcyhBkEIopldQfynZ944hEWa73h5JPPoFtuuYErgkPYosAYlvnyyy/QxRdfzr2hEQ6OquJww1G4K7oAWKKgEnc8pk6dHleYRz+Ptl/a1l/RwB1Guy8ViPh77lHENjAa9eT3Bzms/MEHH4u7nC9DfbAxWHHLLdez84zBhZkzZ9H//d9LNH/+B+zgI5oA+81iMXPuvGrEwZHGcWltbaXnnnuSW5TBGT/ssKPo4Yfv4zB+9P2GqD7wwEM4+uDll+dxKPrpp5/E220yIXK2I5SHPZ6jABCxgD7hA4GuQztcI0RQ0eimra9eQHod0avnTk9q7/gCQWpxBmjb8ZmUGUdI1rX5yGLUUbYtvcY5Gh0+Wl3rpmann/IzTF36FlY2e2hqiY3GFXbtozcQ4ASQl5dBTU0OPhEI6cdIPMY+nzdcyVP54Uh/RuJxHmnIMU5/5Bin9+9SQ0MVFRSUkc1mTZvzNCp4x+t/reX111+l5cv/oGuvvZHdcO1r4Aar4czosw3RN9wjOVWBnQzt7e1cSTwa7C+v18tONPZLrF7bvVkuwHJxDLEOiPiNG9fTtddeSXff/UDMvtnaz7H2+io/H73RE6shlV7KboBAhHgw2MEObH+16kLhtHX1birKNKaNwA4EOzjXel29h0PBS3PMMas+ZpgNVNvqpfI8C4fSC4KQPDjpl5WNkl0nCIIgCANIIuIazJkTP9xYmysMkTdSyYwjgiGqEe7e38sF0cVg4WC/+OJrNJBIKedu0Eq/ZPOwe2rV1ezyU4vLT63u9Bjdc/uCtKLGRSur3WQx6qkwyxS3pQIc/VZ3gN+/IAi9A+04Fi78gW8FQRAEQRCE1EAEdnfo+paH3V2rLoSHe30d5PQGetUGLNXaby3d5OB86/xMY9yQeBXkYUN8Yx8IgtA7nE4n/frrQr4VBEEQBEEQUoP0iE0e4D7YoDciOF6rLocnQA1tfsq1G9nhRusqY4LhJ6kEwuarWry0ps5NiISPFxIeC4hw7ANHfoAyLMPvvQvCUIPc69NPP3eoN0MQBEEQBEHQIA72QFYSN+jI4Ylseg5Q/MvlC3A/aH8gyOHVww0MOEBYL69yksmg57ZbiYprYDcbeB+0OCVMXBAEQRAEQRCE9EAEdjdo9WKvemFrWnVpC4HVtHjJZjJwnjYWO9wEttcfpJW1Llpb76Ycu6nX7bawD6pbvLxPBEFIjqamRm7ThVtBEARBSNVoR5gy/f2H5aYSaCH13nvvDPVmpAQd0qBKQsQTxd9LB9vpCbLINoeC8VtdKO4V4PZVwGjQc0/o4QIGA1ZWu6i61UuFmSYyG3s/RgNhjpZe2Cd5GV2zFXDyRDG0bKshqQrugjASMBqNVFRUzLeCIAiCkGrgOq7B4R+QWkNGg44KMowpc33444/f07p1a+nZZ5+kxYt/7TL9/PMvpIkTJ9OyZX+Qw9FOzzzzOF100RWUkZFB8+b9k3s2L126mDbffEue/8Yb59L//vcRvfPOW1RQUBh3vUVFRXT99Tfzej///BPuSY2B9yOPnEMTJkyiuXP/TqNGjaZAwM89puP1yI7F119/yW3Hzjjjr+Hn3n//v1RVVRnxHDj33DPo9tvv5RZYjzzyAFdKX79+HW299bY0Y8bmtM0229GkSZNppCBXZgNURTxeq676Nh+71jgxALNBR20uP4/2pHo/POSOo1J4Q5uPirPM4ffQW/B6DHI1tPu6CGwI+fX1bqpr89O0UhsVZXe2NxAEgSgrK5v23HMf2RWCIAhCSoLrXYhraOD+FMKqK47l92TzfPDBu/Tvf7/O19j43bz00itZcIKjjz6EsrOzyWhUrjHRe/mhh54gj8dNN9xwNTU3N1Nubi7NnXsHWSxWfv7CC8+lBx98vEufZqzniCPm0JZbbkXHHHNCl+3A+4fI3bBhHblcTnK53Hw/P7+ATj/9bFq7djV1dATprLPOZdGN58EJJ/yFDjzwkC7LW7NmNf3ww3d03HEnhZ8766zzaPfd96SPPnqf2tvb+Lk999ybLrroMn4v119/Zdz91NbWRn/721/pkkuupFmztuLnvv/+G1q06Gf65ZeF3J/6/vsf6fI6t9tNP/zwPbW1tdJPPy2g8eMnsrgHb731Bo0dO4738apVKygjI5Oam5vo7rv/wfuwu9Zawx0R2N2g62sV8ahWXRCNqJytDak2G3Xk8XfwPBZT6gpstNRaUe2iNleASrLN/XaiRIEz7JMx+RaymPQ80IDRzrW1Lmp2BTivG2HkhVnGlB+AEITBJBAI8I+0zWZPuEenIAiCIAw2uGaE6dRfoHpPMIHr8iVLfqM333yNHn74SXZUv//+W7rppmvp6adfCM9zxx33UXFxScTrPvvsE3Z/zz33b/T44w/z4/33P4heeeVFOvzwo7qI640bN9CKFcv5d/nii8+LuS2ZmVn04IOP0Y8/LqDq6kqqr69jNxji+YMP/svr22uvP7OL/dVXX3Rxmu+7707ae+/9WPz6/X4Wqeeff1HEPE8//Ri99trLYQcbwNVeuXJ52MGOx8MP30fHHntCWFx7vV5avnwZvfDC/5Fer6eDD96HFi9eRLW1NRGvg/BuaWnmbYJIR8/pzMwsnoaBC7vdHn5sMhlp+vQZdNxxJ9JDD91L1157I6UrkoOdIL0Nb9G26kI7K4c3QHZz525HiDVymt3+1A0Tx3b/XuGkdneAirNN/ToKmWHRszPe5PTzflhb56YlGx3k8nVQWY6Z8jOMLLgRKi4IQieNjfX0wgtP860gCIIgCJH89tuvtP32O7K4Bjvt9Cd2jqurq7vdVXV1dWGXG7d4XF9fTz/99AML7Wief/5pFulwj3fddXcWlNF/V155bei3u5HuuutB2nLLWXTKKWdwuHUinHnmOfT66y/TM888QY88cj/tttueNHOmEk6ugnDs/fY7kF1rbA8c+1133YOfmz37z3GXXVlZQatWraQDDjg4wpHfbbc9WFy3t7dTXl4elZSU0ttv/zvitRDQhxxyOOXl5fM6mpqa6JVX5vEfQuY//PB9vo/lqaHu++yzP61evSrh9z4cEQe7G7QysjcOtrZVF8JZkLdsNeojnFj0hEaRL7c3SDnK9z/lnOvl1U522Iuzzf2+fOwLDDLApUbLL4TQ59mNZDMbwg5/IOinulYf5djk4yoIKsizOvjgI/lWEARBEIRIJk+eQo8++iAde+yJHOoN8Ye6JfX1tVRaWko6nZ6uu+4KCgSCNH78BDr77POotLSMRfWiRQt5GQhthnB96qlHOe/4qaceY/cZrTIRzr1kyWIucIYQaQBHeo89Znc5FJgfeL1uWrjwB94W5GOrbLHFLBawTqeDHexosrNzaO7cO+n8889ix/yFF17tMs922+1IO++8C11yyfn066+/hJ8/66xzWId8+eXncXOt4Z6rIEccBdsQIYf1ImR91qxtaOzY8RzO/uSTj9C0adNpzz073yccbOSSl5WV0Xbb7UCnnnom3XLLDXTMMcfT1KnT6fTTO0PZAdb3zTdf0tFHH5eWH1tRLN2hEcK9ycHWtuqCA9vi8FOO3RhTZKZiJXE41iuqnOTyBgdEXKsgZL6m1Utmg55KY4SfZ1oMVNvqo9H5FrKaJOhCEIDZbOEfO0EQBEEQugL3+ogjjqarrrqEhTVEdGtrC+cCg5dffoNMJhOHOb/11pt0883X0eOPP8dONIqWnX32qTRp0hQWvsg1Rgi0z+ej6667iQt5QZjClb3hhlvorLNO4WVC/MZyZiGwLRYLnX76X+nrr7/gXORx48bz33PPPUlPPPEIT0eYeay0L6z3zjtvpZkzt6C//OVUDkW/9tqbWOhqwXsBaoj5RRedx6/tLjx806YNtMMOO4Ufr1y5gh1zFCZ78slH6T//eZ3uu0/Jv8a27bPPAexMf/jhezRnzvG8XXV1tXT66WeRz+enV1+9l0PhN2xYzy42XG6Idi1435gnXRGBnWiRs1462GqrrtoWL4v0WFW3Uegs1UKguaBZtZNa3UEqGeACY9gn5TmWuKHnCCOHw93Y7qPyPEuv1tHuHpgqloIwVDidTlq1ahlNnjydf7wEQRAEQYjksMOO5D8Ap/mbb77iwlsA4hogDPqggw5hkQsgxq+66vrwMi699AK6/PJr6JNP5odfi1tUyYYY1/LSS/9iQRsNfqf33ntfmjVraxatCLv+9tuvOGwd3HjjrTR69BgW8ddcc1nEa1FkDA76kUcew+HVYPTosVzMLFpgq677BRecHbq/MsGPROc1+FZbbRO+v8cee3EON4q3qaA4GQqn/fjjdzwA8c9/vkQXX3w+zZgxk/O0Dz74sAgHe/r0zejUUyMLv6HmUjq38xKBnSC9FtihVl2NTj9lWo1xBSYELULFETI+1MBNR7XwJqeScz0YxcW6y+vG+q0mA1U1e6kkx5zUPkJe96YmDzX5PFRg7qDy3IFz4gVhMHE62+n777+m8vLRIrAFQRCElIWrfvfz8nozKH3XXbey+wsXFmHeLpeLxowZy9Pnz/+Ittpq6y6v++KLT2ny5KlUXj6KCgsL2ZEFmzZtpIkTJ3WZH8udN++1iOcghGtqlOJgDz98PxdKw/qQQz1//odceRtFyyByg8EATZkyrUsu+a233hXRrgvbDZc5FtherYPdEwiJh/MeDQYBUFztlltuj/k6hKP7o2pIlZWV08cff0AXXngO7yvVwd5hhx0j5lu3bl04zz0dEYE9gFXEta26/G4dFefEdoKRZ9zmDrKwRVXtoQSCFNXC0YqLq4WnSOVuhJGjnReKoaH/diKgx/b6eg8PFOTlWqmiycc9E1GtXBCGO4WFxXT22RcO9WYIgiAIQkzgh6AlK7fU6ucoQiw3Eb/lppuuY/EIUX3ooYfTwQcfzs8j13nu3BvZbUbla+ReX331DRGvxTRUDr/33of4MYp4odUVwsGR033GGYpLrAXF0KJFLYqRHnDAIfTFF59RcXExFx6DwIbTi5BwtBFD+DpaZF122YWc863y8svzWFgvXPhT3Pd4xx33hu/DjUdVb3UbkBsORx6h4/EMsz/9aTful3388Z150ljGddfhvZ7LznrPKMd3ypSpdOutd/J9rYMdzWefzaebb44t3NMBEdgJ0tscbHyYkQ4BER1PrMLl9vmHXmBjEGFljYvzofuzFVd/nUix+xBq35PARtX2jY0e2tTk5cclOSbKzTbT8mY31bf7aFQvw8wFQRAEQRCExMB1JIyNXl5Cd7/sBHtr33TTbTGfRw2Tp5/+V7evRQj5E088F36M9lz33KOI7XigoBfacUU72A0NDaGq3LO5J7UKHGI4uRdccAk/vvHGuZzfjSJs3fXB7m6box105Iq//PIL7DjHAm74mDFjOAR+77334dDt+++/m84554IulcqjQXEzFF7DgAWKoSXCBx+8SxMmTAxHD6Qjuo50DoDvI41tXpp+2Xd8//TdSmj/LfJ6HcoCcdhdqHV1i4dmlNl7nWPcV/AxWF3rprX1birOMrOgTTUwAOH0BGircZkRvcS176G+3U/r6t3U7PSHq5EbDDrKzrbRhuo20lMHbTU2M2YuvDB8MRr1lJeXQU1Nji7hSukKCqR8/vl82nPPfSg3t3fnpuHGSDzOIw05xumPHOP0xefzUkNDFRUUlJHNZpXz9DAC+emoPn7FFddyr+pEv8vd/RYHg0F21LUgR/vee+/k3uTZ2dmU6p9jk6kztTQ/P4MMhsT0gzjY3aHru4MNEhlhg7uNauNDRXWLjzY0eCg/w5SS4hqggniTw8fh69ECm3OtGz20vsHDOdqlOV3D27NtBqps9LAIl1xsYbiDHy1UQo3+8RIEQRAEQUgGiN1nn53XrztNH+P6BMXS/vWvVyjdEYE9wFXEEwWOapvbzy7sYBQVi+51vabOTTazPuXbYKFQHPqJl+eZwy50a2j769p8PEAQ7z3oQ8XSKpo8VJRl4tB8QRiuoDflPvscONSbIQiCIAiCIGhIbTWVQgy8wNaRy9fR62JqvQX5yqtrXOwAZ9tSf7wFLbvQn7vR4efQ+8pmL/22yUmN7X7OG+9pgCDHZqBWZ4BbfgnCcAahV263K9zzUhAEQRAEQRh6RGB3g9ZJ7kuIeCJYjHoWuS7f4F0sQ6Ai57rBkXhl7qEGLjT2VVWLl5bXuGhZpYMLXSTavgvh+hjMgIuNtmiCMFxpaKij5557nG8FQRAEQRCE1CD1LcsUYaCdZYhDCD44ymSjQaGy2cNCE+I6lSqG9wSc9po2L4fwY9uTLViG1ze0e9n1LsoeHgMLghBNVlYO7bffIXwrCIIgCIIgpAYisFMkB1tZn45c3sFxsJscflpb56FMi3HYVdRGEbbiLBMPSvSmTzdeb9DrOby8INM4rAYXBEHbLmTSpCmyQwRBEAShGy644GxujWW328PP3XffI/Tbb4voueee5seFhYV01VU3cH9rj8dNN9xwNb8Gj+fOvYMsFis/f+GF59KDDz7Ov8GCEA8R2N2h0V2DkRttMuo4v3iggYhfVevivoSZMdpdDQdMCZbJj0eu3UgNDh81OodPeLwgaHG5XLR27SqaMGEy2WyDFPYiCIIgCMMQtJ+aNWur8OP6+nq677676cknn6P8/ALuzXz33bfRbbfdTZ999glNmDCJzj33b/T44w/z4/33P4heeeVFOvzwo0RcCz0yvKzLoXSwByFflyuJewIDmhuMKuUbGz3cJzo/c+SOr8DFxvGtavLyPhGE4UZ7eyv3wcatIAiCIAiJ8+OP39P22+/A4hrss8/+tHDhj1w4tK6ujkaNGs3P4xaPIch/+ukHFtqC0BMjV2GlYIi4hR3sILl9QcqwDIyzjOrblU1Kv+vehFenE3Cx69t91ITBhgxxsYXhRVFRCZ133qVDvRmCIAiCEBd9TTX/aQnm5FJw3Hgit5uMK5Z1eY1/S8VpNqxaSTqnI2JaYMxY6sjLT7po8f3338V9mUtLy+iMM/5KdXW1VFBQGJ7HaDSSzWanlpZmFtWLFi3k51etWkFbb70tPfXUo/y6p556jOrr66iwsIjOOuvcmL2eBUEEdnfoBtfBRl9mbyBIHv/ACGyEuW9o8PCJJtX7XQ8GnHveQVTV7KU8u3HQ+48LgiAIgiCkM9Z/PUcZ99wR8Zz7qGOo7fFnSF9ZQXl/3r3La+pqlcisrL+dQ6aFP0ZMa330KfLMOS6pbUC+tcmkGClff/0lXXHFRXTYYUfGnX/33fdkh/vss0/lWiclJaXkdrupra2NfD4fXXfdTfTIIw/wsjCvIEQjArsbtHJrMHKwFYGnI7dvYNZV1exhx7Y02zwgyx+O5GYYqa7VR825AcrLkK+DMHxoaWmir776nHbbbU/Kyckb6s0RBEEQhC64TzmdvPsf2MXB5tvyUdT0vy/j7rW2h5+I6WAniyquwa677k533XUbFReX0G+//Rp+3u/3k8vlpJycXHalr7rq+vC0Sy+9gC6//Br65JP5NHbsOH4Ot+vXr5MjLsREFEW3aPpgD4LABiho7fT0f6EzFE/b2OilbKtUzY52sZGCjZZluXaDuNjCMEJHBgMiXSTyQhAEQUhNgiWl/BcTqzUcDh6LwOS+d8pwOh20ceNGmjZtOj9GHjUqg2+77fZcQbypqYny8vJo/vwPaZtttu8S8v3FF5/S5MlTqbx8FFcaX7duLT+/adNGmjhxUp+3T0hPRGB3gzZieLAENgRfq8vfr8sMBhEa7ubc7tIcca/728VG73IUjkOI/7hCadsgDA4YZT/ggENldwuCIAhCHBDS/dBD91J7extZrTbKysriSuFwsC+88BK68sqLSKfTs8i++uoburwWlcPvvfchfjx79p/p+uuvpLPOOoVF+hlnnC37XYiJCOwEGYwcbGA2KiHiXn+w3/pTIyy8usVH+RIC3a8uNqqPN3A/cTf3FbdbDFSQaRq2rc+E4QU+f8FggPR6ibwQBEEQhHiD0Y8+qvS6jgYpVvjrLrT8iSeeCz9G7+t77lHEtiB0h1S6SiBke7BysIHZoGdxDbe5P4C7ur5BcVf7S7CntYvtDCS8X1fXuum3jQ7uK16Waya3N0AVTR5p+yUMCvX1tfTkkw/xrSAIgiAIgpAaiOJKoF/yYIaIY31YlaefCp3BlW12+FlACj272CgE111fbEyra/PR4k0OWlvvpmybkV1rtDzLyzBRVUviIj3esiubvXKohB7Jysqmvffen28FQRAEQRCE1EBUV087SK8jL3WQb5BCxFWcXoi0vvVmbnH5aVOjl/s9j/Se14mAQYjaVh+VxcnFRmQB2pwh39qg13E+u3a/ovUZ8uc3NXoox2YgvRr+kAAOT4A2NHq4ZZhBpyObSS9VzYVuQS7ZtGmbyV4SBEEQBEFIIVLSwf7iiy/oyCOPpC222IJ22203uv/++7l8fncEg0F65ZVX6JBDDqGtttqK9tprL5o7dy41NzcPKwcbIJy71d23SuJwQ+GEegMdnBssJOZiB+O42M1OPy2tdHZxraPJzzBRbZuXGtoTK1SH1IONDW5atMFBFY0e7scd7FD6lQ/mZ04YfrjdLlq5chnfCoIgCEKq0F0koCCMhM9vyjnYS5YsofPPP5/OPPNMuu2222jDhg0slFHJ78orr4z7ugcffJBefPFFngfCHCX57733Xlq6dCm9+uqrfXKwwWCKHYtRz44m1qkK/GSBQK9t8bF7LSROXsjFLs8L8L5DBfbqFi+tqfeQzx/kHuLdOdM4Xsij39joZkccgyXxvryNDj8LaRShy7IaqSzXEhbpCBWvbfVSeZ7ynCBE09bWSvPnv09z5pzIbrYgCIIgDCUGA645ddTe3kJGo44C/d91VkghgkEc4/QaTOno6ODPr9IKtfcaKuXU17PPPku77rorXXzxxfx4xowZFAgE6Oqrr6bzzjuPMjMzY77u//7v/+jss8+mY489lh9vttlmXHL/L3/5C61bt47Gjx/fN4E9iCHiFpOOWpxKobNM7nObPDUtPt5mhC0LybvYlU0eHuhY1+Dm+xkWI+VlJ9biDMK8ptVLdXEEMo7rxgYPF0RDxfJo0Q6RnmHRc3G6HLuRMiQCQYhBQUERnXXW30K9sAVBEARhaEEP6by8ImpurqP6+hqOLhXS+3in5zHW8ec4uif6sBbYCxYsYCGtZffddyePx0M///wz34+F0WjkZvFa7HZ7eFpvUR3kwaoiDkwGPfkCfq5O3ZuWT+3uAAs85AELyQOBDBfb4Q1yaHhhpimpCuwQy3azgXOq8zNN4UEOjIrVt/lpXb2Lml0BdqrjDYBkWQ3snCOfe2qpLeHWYcLIASf+vpz8BUEQBKG/sVhsVFY2ljIyTNTS4kw7h1NQMBh0lJNjT8tjbDAY+3x9lVICu729nRoaGmj06NERz8O1RkN3hIvH45xzzqF//OMflJOTQyeffDJlZGRwyPgBBxzQZXmJoovKwcaHabDAurzBDjL2orVWvcND/iBRpi2lDu+QYTDoNbc9j7TZDQZyB4Kcvz4q39KrAnF5mUYuWFbb5qOJxTZ2rdfXw7X2EjZjdL6lB9Gso6JsM9W0+akkN0iFWX0reDeyjvHIoKWlmb755kvaZZfduc/nSGAkHueRhhzj9EeO8cg4xugZ7fV2UCCQjg6nIMe4e1JKgTkcjgjnWQsEMwR4PE466SSqqqqi119/nZ5++mmaPHkyZWVl0WOPPdbr7dHpdWQxKS4wwq2zsqyD5iR6yUAdRhPl5WUk7V63BTw0ujiTMnrhfqczGRmJ5zNnZ/c9p9VgMVOLL0itAT1Xc29yE40uyUwqbL+j1UuNHqJx5TbpYz5Ix224EAy6qaMjwOelZM8Tw52RdJxHKnKM0x85xumPHOP0R47xMBDYfeGpp55igT1//nyqqalh9xp/KH7WXXG07ugIdpBO43g2NrviFq3qb7zuAFW5vDQqS8ch44myptZFdQ1uKs8zU6u0Uw6PskFcOxyeQR9JbWjxhj83KKDmdXnIm0TRZ1Owg9ZVuchCARpXaB3ITR32xxgn+dZW14gZLdfrrXTQQUfw/aYmZXAy3RmJx3mkIcc4/ZFjnP7IMU5/RuIxzs62JRxBl1ICGy41cDqdMd3teAXO1q5dy628Pv74Yy74U15ezqJ6m2224YrkyNveaaedkt6eDk2RM+D1BUk/SJ3NEBne7AxQuytAWQnqKuRsb2rwUIZZn3b5EH1D+eLjBDDY+yU/1HYLgyRKHYjk14/jubbOTdlWA+dmC/HBMfYjP0JIa+Q4pz9yjNMfOcbpjxzj9EeOcWxSKpENAjo/P58qKioinkdoOPpZjxkzJubrfv/9d65iV1JSEvE8qpGDxYsX93qbDBqBPdiFzpD37fYmLhbq2rzk8Aa4ArWQGuDzk0wEQixQ6A6DO+iXjbZhggDq6mro8cfv51tBEARBEAQhNUg5JbbjjjvSV199FfHc119/TSaTibbddlt+3NjYSNXV1eHpqrD+7rvvughvMGrUqF5vjzYkfDB7YQNoe6c3sSaCHl+QC2hlWgxScToNyc80clVxFE0TBJCZmUW777433wqCIAiCIAipQcoJ7NNPP50F9gMPPEDLli3jnOrbbruNjj/++HCI+EUXXUR77LFH+DUQ3vi75ppr6I033qClS5fSu+++S5dffjn3w95nn336ycEe3NBTiPtWV2ICu77dR+0ehJNLCHE6AhccBffW1bs5FUAQbDY7bb75lnwrCIIgCIIgpAYplYMNttxyS3rkkUe4ONkzzzzD7bkOO+wwFtXxQGVvVA5HoTPcwt2Gq33ggQdy+y6z2dw/DvYg6xr0XoZoRmh6d8XVvH6418i9Fvc6nUFf86oWL21s9NCUksGraC+kJh6PmyorK6i8fBRZLFIATxAEQRAEIRVIOYENZs+ezX/xmDdvXswCaZdccgn/9SdaB9s/yA422jk1Of3cQ9lkiO9MN7T72ekuyen9QIKQ+kBQF2SYeDAFIeOFmdIbeyTT2tpCH3zwNs2ZcyIVFYnAFgRBEARBSAVSLkQ81YjMwR7cdRsNOgoEuy901tHRQbWtPrIY9aQXRzPtsZj0POizvs7NkQvCyCU/v5BOO+0cvhUEQRAEQRBSAxHYKZyDDbD27gqdtXuC1Oz0c6VpYWSAftqNTj9tavQM9aYIQwhaEiL/GreCIAiCIAhCaiACO6kc7I4hWX9LN4XOmhw+8gWDnK8tjAwQqZBrN9KmJi8PrggjN0T8k08+5FtBEARBEAQhNRBVlqJ9sLUhwY5QobNoED5e1+ojm0kcrJGG3Wzg47++3jPo7eOE1CAQCFBLSzPfCoIgCIIgCKmBCOwUd7CRW+3xd3Chs2ja3AFqdQe497Uw8ijINFFdm5eqmiVUfCSSl5dPRx55HN8KgiAIgiAIqYEI7KSqiA++wEahM1Qvd8XIw25s9xE0P+YRRuZnM8tqpPWNXmp1Sai4IAiCIAiCIAw1IrCTqiI+NKG4OtKRK6qSOELGa9t8ZDfLIRzJoLidxxeUUPERSH19LT399CN8KwiCIAiCIKQGos5SPAcbmE1dC521uPzkkPBwgYj7Yde0+qi6RULFRxJ2ewZtv/3OfCsIgiAIgiCkBiKwe8A4xDnYah52dKGzxnY/V5PWawYAhJH7GYWTva7By3n5wsgAwnqrrbYVgS0IgiAIgpBCiMDuAW33q6FysLnQma8zDxsFz+rbfJQhva+FEFlWA3l9QVpX5+bq4vEIBjtEhKcJXq+HNm5cz7eCIAiCIAhCaiACuweMQ1zkLFzoLNhZSbzF6SeXLyj510KXquJKqLg35p5BFMSyKict2eSghnaf7L1hDlp0/fe/b/KtIAiCIAiCkBoYh3oDhlWI+BD2G9bpOgud1bX5WPjjOUHoEipe76Fsm5FdbdW1RkG8dfVuancHuK7Amjo3ZVgMZDXJGNtwJT+/gE466QzKyJAcbEEQBEEQhFRBrq6TcbCHKAcbmI06anYG2IVscvpZSAlCNBDVHk2oOAZllte4aGmFgwJBotIcMxVmmajZ6af19W4W38LwxGAwUnZ2Dt8KgiAIgiAIqYEI7CQc7KHKwVbzsJ3eAOdeI1RcnEehp1DxtfVuWryxnSoaPZSfYaJcu5GjHlAcD5XHNzV5eD5heNLW1kpffvkJ3wqCIAiCIAipgQjsYeJgq4XO6tt9Iq6FhELFV9e6yBdQXGuztlofR0ToyWYyhMPG44Fpa+tcXfqwC0OPz+ej6uoqvhUEQRAEQRBSA4ktHCYOtlrorM0dpBybhIcLPYeKZ1j07FbHI8dupJoWL62tc9OMcnvEZx3h5SiWhnxutP6CwJ5WZo/oCy8MfQ72McecJIdBEARBEAQhhRAHexhUEVeBWPIHg13cSEGI93lJLJzcSxVNna2eIKh/r3DSskoX4eNfmmOiymZfxDyCIAiCIAiCIHRFlFoyVcSHuCAUilMVZZqHdBuE9Pt8o+L4+gYPpx9sakTetoMr1ePzhmkmg56ybUp1cmnvlTrU19fR888/ybeCIAiCIAhCaiACexg52AjP1Qp+QegP0K4LY0crq120rMrNn7OSHHPEZw3zdHQQrantPh/b6w9SVbM33LNdGDhsNhvNnDmLbwVBEARBEITUQAT2MOmDLQgDSUGmkUV2UZYp3D871jwtLqXoGXK0o2l0+GhphZN+2+TgAmvyfRlYMjIyabvtduJbQRAEQRAEITUQgZ2Egz2URc4EYaDztdHGq7sICbT4Qtg48rE3NXbmY6O6/aoaFy3e6GQBDpFe2eylDQ1u6oDtLQwIPp+Xqqsr+VYQBEEQBEFIDURgD6McbEEYarT52MjZRq724k0O7rmdadGzuEYRPvTdXtcgfbYHkubmJvr3v1/lW0EQBEEQBCE1kDZdwygHezgDJ3PBmja+v9Ok7KHeHKEPIB8bedjI2UauNb4j6LWtrVpuNaFvu55W1br5PtxxoX/Jy8un4447mbKzc2TXCoIgCIIgpAjiYPeAQbOHxMHuPR/81kT3fVTJf7+sb+/DkoRUAPnY+D7k2IyUn2mK2RIMfbb9/iCtrum+MJrQO4xGE+XnF/KtIAiCIAiCkBqIwO4B5J2qLrbkYPeO6hYvvfx9Zyuh71YrTrYwvL8XCAO3mLo/hRRkmajJ6efCaBIB0r+0t7fRt99+wbeCIAiCIAhCaiACOwFMoTxsEQjJE+zooMc/qyKvvzO8/teNDil+NUKAs12UZeaiZxsbpehZf+L1emjdujV8KwiCIAiCIKQGIrCTKHQmDnbyfLykmf6odEU81+Tw06YmqXw8kr4/yMFGYbSaVt9Qb07agPDwE044jW8FQRAEQRCE1EAEdhICW3Kwk6OmxUsvfVcbfrzDhM5+vb9ucCS5NGE4YzMbyGJUip41O/1DvTmCIAiCIAiCMCCIwE4ANQdbQsSTCw1/4rNq8oRCw/fdPJeO27EoIkxcGFlw0bNAB62scZHTGxjUCvbp2I+7sbGeXnzxWb4VBEEQBEEQUgMR2MnkYEsf7ISZv7SZllY6+X5RlpFO3LmIRuWZqSBDadf0e6WTvH6pLD3SKMw0UovTT6tr3N0e/2Cwg+pafdTu7psQb3X5+bO2rDr9iqyZzRaaNGkq3wqCIAiCIAipgQjsBJAq4slR2+qlF7/tDA0/Z3YZhwij8vSssRnhfPbo3Gwh/cFnoDjbTNWtXs7JhpCOxuEJ0LIqJ/26qZ2WVzl75XZ7fEGuXI5IiZoWH21q9NDaOjcF0miQLDMzi3beeTe+FQRBEARBEFIDEdjJ5GCnmQM2EHREhYb/ebNc2mK0IqrBlmM670uY+MjEoNdRYaaJq4pvauqsgA3xW9nk4fz8qhYfFWQoLb5W9eB2a4FgR+7/4o3ttLrOzXnfJTmInDDR+gYPra93xxT1wxG/30f19XV8KwiCIAiCIKQGIrCTCBHHdXm6XJwPFJ8va6ElFUpoeEGmkU76U2feNdhydAbplN0pAnsEYzbqKctqpDV1Hg4F51DuCif9Xuniz0dpjpnngdtd0+qlVTU9h3g3O3wcDr60wkEeP1FJtpkyLAaehn7deRmoZO6mjY2etMjJbmpqpNdem8e3giAIgiAIQmqgJMQKCRU5U/OwzZrHQicI5X35+7rw47/uWUp2syJwVDKtBppcbKWVNYrQaWz3UX6mSXbjCATiF/3RUfQM41Yef5CKskzhiBHV7cZzFc1eFtwTi6ykj/r+wd2GE97kdVNji5c/TyZD17FDq0lPQauRnW1MHp1vpeFMbm4+HXXUCXwrCIIgCIIgpAbiYCeA9oJfemHH598LG6jFpeTL7jAxk7Ya29mWS4s2THzxJqkmPpKBqwxxjSgRuNba75oKxHJ+hok2NESGlMOFrm/30ZJNDlpR7WaXGuHgscS1it1ioAyzgcPOq5r7pxc7Qttd3sEv2GcymaikpJRvBUEQBEEQhNRABHYCaC/6JQ87NtUtXnr/1ya+D7H0l52L4+7PWRqBvaibftiVzV5aUS2F0EaCyEZkQ3fAfc5ESHmtmz9rELSIgvhto4Pa3EEqyTHx9ETAuiDG4ZwjPL23QOA3Ony0tMJJize1U5NjcPt7Oxzt9MMP3/KtIAiCIAiCkBpIiHgSOdhAHOzYzPu2NtzG7KBZ+ewkxmNysY1sZj2LpN82OTmvPTrsF9Wjb3lnI+/vS/Ytp50nZyf2iRbSOqQcA1xwn40GojZ3gJ1tiG+EkidDts3Ignh5tYt0erQPS84FRvswuOnVzV7qCFVHR+XzaWU23qbBwO120R9/LKFJk6ZQRkbsaBFBEARBEARhcBEHuxc52EIkv21y0I9rFRct126gI7bJ7zEiYItRdr4PkbS23h0x3e0L0iOfVIUHM/73e7PscoHJsRu5CFowSFSWY2Zx3RfnHC708ioXO9HJtP9atNHBrb8g1FGIDXniyCdfVumihvbul4WCbqiW3tdomIKCIjrllLP5VhAEQRAEQUgNRGAngISId59/+vzXnT2vT9ipmHte94TaDxugLVO0G16jCd1FCC6EeG9BmPlr39X0qp+ykHrk2o0hod33YoMoiAahC5Hd7PR3+zlHzvaiDe20qtZNZoOOynItHGquUphl4gG4ZVUuzg2PBp+/1TVKb+4llU5aWeuSiBhBEARBEIQ0QwR2AoiDHZ9Pfm/mauBgUrGVdp+WWCi3Ng/7V02hs1/Wt9P8pZGONYIGflrbRr0BbZuuf3MdPf1pBT3zeU2vliGkN4Wq+1zljCmyEUqOQR60EfOHnHO1/Vc0BZkmTnmAyK5r84WrnG9scPNA0toGN1nRfizLxA74impnwj2+o2lsbKBXX32BbwVBEARBEITUQAR2kjnYUuQsMg/1/36oDz8+dZdi0ifoKiKstizHFHaY4e5heU98Vh2eZ/b0nPD9BWuSF9j1bT66/6MKCoT0yzcrW3kdghBLZLu9QRa8COEG+EyuCjnOaCeHeXITcM7hiquh5+tZWLdzrjcozTZzJXNUOi/OMnMhP8yHtIhkMZnMNGrUaL4VBEEQBEEQUgMR2Akgbbpi88ZP9eHQ7V2nZNO0MiWvOlHUMHEIYDiEz3xZTU0hB3GrsRn019mllJ+h1OFbvNGZVIg3XMF7P6oItw0DCN/9emVrUtsojBwgoB3uIBfYQ1QGO871bsqyGqgoO3YLsXiohc4gnj1+4qJ/yNfWinMsryTbTDWtXnbPk01hyMrKot1224tvBUEQBEEQhNRABHayDrYUOWMqmjz00RKlLZfZqKMTdkq+0JK2H/bL39XRt6sUlzrDoqdzZpeyG45+2up+/3l9Yj2z4R4+82UNra51hwuvqXy+rCXp7RRGBhC/RdkmbvsFwQv6UkgNRdRG5Vn4Nl5kB6qfQ2Qj2mJZpZMcnsRFtt/vp5aWJr7Vfvbhhje1+3rliguCIAiCIAh9QwR2kjnY0qZL4bUf6sOh14dtXcDuX7LMHJVBhtAnsKLZG37+rN3hXCvL23Fipzv3Q4Jh4h8taQ4LaYj/Gw4dS1NKFXd9TZ2bNjREVi0XBK3IhttcFsNxHijQog7rbHYGuGaAGqLeE01NDfTSS//kW7XCOfLFIdbbPcr9ZAS7IAiCIAiC0HdEYCeAVBGPBMWZvl+tiN0cm4EO2ar7tlzxgDM4PSR8Vf40OYv+NKWzUNr0MjuH6KoF0CAiugMC5V/fdBYzO3d2GY0vstJ+swrCz30mLrbQA4MhrLXA4S7ONlG7SxHZEMc9kZOTR4cdNodsGTnU5PBx5XL0lsf3KtNq4HZmKNrW5vKzsx0PDBqiNkFP3y1BEARBEAShZ0RgJ4AI7Ej+vbCB1Mt1iOu+9CLWhonn2Y105u6lXUJot5+ghIl7/B1ccCoecO7u0xQ1O3SrfNolJNZnb54XjkT4akWrFKsTUjZE3ePrYJFdp2lVFwuXX0dNHfnU4CRyeIJkMeq5gBq+MwCPkd6COgRwxVHdPFpY43l8b9AHvNHhl1Z2giAIgiAIfUQEdgJIDnYnlU0e+maVUigMzvK+M/P69AFEWy/kXFuMOjp/7zJ23qLRhonHqybuCwTp3g8rqDVU1AxtwLR54Qj3VfO5Mc/P69v7tN2CMFAiG+kWMJyRB47e29Go1c1/WlVPi375kZxOB7cNU4W1FlQrR6/uVneA3Wz08/ZrhDXEN9I0sqwIh1dakvXkeOP1CD2XHG9BEARBEISuKCWahW6RHOwo97qjf9xrtW/w4ydP5qrfEMGx2GJ0BtnMeg5/XbiunS/woys6v/J9Ha2uU3KrS7JNdNE+5ZzbqmWvzXLDhdSQo72DRrgLQiqBwmgQwRDZ/kCQRudb2HGubvHSpkYvObwB0vld1Fa5hHzTJyNgvNvzl91sIIc3SP6gIrIxIIXvrtXUOaAFxxvfLQhxFBXE91Er2jENohrh5N5AkKehbZndrB+UkHpst8cTIKPL18WNFwRBEARBSBVEYCeAONgKuLj/KtTmKtOip/1m5vbLh1C50I8v1CGmtx2XyS22nN4gLalw0FZjFTcaLNrQTu/+2hQWE5ftPyqmE45wdLT9QigsHGwICQgEQUhFIHD1ugCtqHHx4FKzy8+OM9xmFGHzBYqpbbvjKDu387vQXY53hllPbl9H2LGO912z6Qzcfg+pFjno+00UIawhxPF6iHQ43l6/vosY14KBAbc3wANevRHjeD3yw+GaIz7FrzeSz+0nu0lHZqMEYQmCIAiCkFrI1UkCiIPd1b0+eFY+2cxdRexAsdOk2GHiLU4/PfpJVfjxSTsX0fhCa8xlQADsPk1x+mCAfblcWnYJqQ0GinJsRlrX4CFfgKg0x8ypGb1xjPEaRIL0JErxPcm0GFhUN7b7wjnaWCWEtfp6hJ9jYAxiXBHawbg53uhvj3nUMPVEwPK0OeJ4FdJJMizG0LZ1nzOO17c4ffweordtMIDjLwiCIAjCyEMEdgJIkTOimhZvWJDiInf/LfqWe50syKlGnjb4cW07h4gGOzrosU+r2NUDW4/NoAO27H679pzeGUqLMPHuck0FIRXAQBb6aSPaQttP29XeTPVL36f2NiV6oz+BGEdeN74e0cI6lhj3+BXBC+GrFcbaHG9VjCOCpDvBq7QbU6qit2peD+cc28VOuEXZFoh2iGhVtIf7gIdej57miHppaFdalvX0fcd5pS+tGPF6RBtA1Nfh/Wu2TRAEQRCEkYHExyaykzT5viPVlfjPzw3s+oIDt8znasWDCQo1ISwc7jUuupdVuWhdvZt+2eAItws7b6+yHp298lwzTSu10fJqF21q8tLqWjdNLrEN0rsQhP5DrzeQ0ZZLBr1xQL93PYHvHHK8IWwb2n08CIAcbgyIaXO8VTEOAdoQ6KAcu4FfByB80SXA6QmQyxdkYY91G03xv8+YjvWggBvcfbVOA8Q+7G6z5vUQ9Go4O8R6dA0HiGC3GoYeVJ3y2IXjYgFRjnUgjB73cRpC5BMGGBCWjxB6bF888Fq8DulIEvYuCIIgCMMbEdiJ7CRtoZ8R6EbAifki5F7jIvHAHlzigWLHiYrABv9eWE+/V7rC01CBHPmiiTB7eg4LbLUntghsYThisWdR7sQ/kS2j5xzswQAOtToAGa+mAotxjePtswbJbDSwsHaHhDGEc6LCFufmDLMi2l2+ABl0Sti61ukHEK0GfQe1e+Cw+8KCF8IWwtrpCZIvGCSTHvMRtbj8LPizrYa4gwwYFPD64VhjUEApHGc26CPyzCGYIbAR4p7pR3/yzlx1uN3egPr6IO87hN0jBQDLiC7SGA1ej9UMds92QRAEQRC6RwR2kkXO+hI+OFx56+eGcG9piGs4O0PBNuMz+YIagxyLNznDzx88Ky+i6FlP7Dw5i/75dQ1fQH+zspVO2aVYXCNh2BEMBingdVIwaEuZU3m0MxwPS0jwwn3WU5BQSU15rne55YlE1ETkljt8ZPXqWejj3GY2YFrnPsR5BqK3wRGkbKsxQvByNXO/Ispxy267EcLeGCfvXTlnqW52lk0JvYfbrQ5IYADAZtIpTrvTR26fgYV2tLiHqOeicb4gDyqYjUoo/2C53uqgALbfatKJuBcEQRCEGEgOdj+FiP9R6aT/LGzgHMN0AnmUn/7RzPfhDB20Zf6QbQvCSbcYbY94bkKhhY7X9LtONKd1x1DRNORn/rC2vc/V1V/7oY42NXr6tBwUbHvjp3quki4IPeFsa6TaX96gtpbGYbmzVPcZTjK+270R170B5zE4zR6f4hhnxhCoatg7thGCF+HlyA2HKMY5saENhdMQBq+Ekvc0sIDlYD0Q83DuEUoPkcrvXfN6bAf2CdbV4EAOulIUDn8o6IbXIqIIaTL4JXJ4OvPLu2tdBlGOebCMZOtOKE69klePdfP7b1f2SSLF47BdIzW1ShAEQRiZpIbtMcwdbLgJd7y/iR0FhBaeumsJpQvvLW4Mu9cobBar/dVgAmGs5l0jxxP9rnGRnCwIE/9yudJy7NPfm2nXKdm9FtfX/3s9X/B+9kcLPXjixF65SbhYventDVTV7OUQ1fuOm0hlueZebZMwMrDasylv6l5kz+zdZzcVGKrwZgjaRNx2nFsg/HGOd7fD7e5QRLAl+UruqpsNwdrda1VHHqIUvyf4XYEmRgi6Qa+PcPphukPkwpG3mSJdbwhbROm4fYpzjtcjdB5uPM7jPZ2n1LxyDELiFtuAfYbX41cQ24WwfrR/Q2V37f5UnXYMFOD10P7YNgwoDNZAiiAIgiAMFeJg90MONkbzcbEBNvbRxUwlcFEJ0agOMiAUe6jZaWIWlWSbWISevWcpledZerWcGeV2Ks0x8f0lFU6qaEr+uCFa4fb3NrG4Bg0Of1i0JwNaF90SEtcAAxr/90Nd0ssRRhZGk5mseaPJZOrdd0BIDEWUGtj51lYz7y2JvhaCFW62Wskdoj6WQIVQxvYhXF2pvO6ntpDbjN8mCFz8hmHb8Xq1qrrqjmuBKA9XYQ+1R4PQV536cCX30CAActYR+o554ZBDiOO2PuS0YxrWgE1GJADmi+eic6E7n1qB3svbMZhdHjAggG0biWlggiAIQv8iDnY/hIhrw8JVsZUOID8ZF2NglynZXBhoqMFF3X3HT+ABjb5sDy4Q9908j174tpYff7SkmU7fLfHIA1xI3v3BprAoVnn7lwaaPSMnYZemJSSuK6KW8+2qNjpsazdNKIrd01sQfB4XOaqXk6dkcyJ7Z594YWCILpw2GEDMWrqppB49CKC43oHwoKi24Jo6H4Qy3GzVHcd5FAOWqtvMVdBDwj1WXnn0b2OWwcivRWsyg0HHot0Y5bSr2wNHHWHu2C4ld1zH61ND2HGr1+tJZw5Sc5uP0I2tO7ddzQnH+8ayko0eUl16N6rPB4IUCHSQ0YBtUwYtuotyUF16vEdx5QVBEAQt4mD3g4OtFdjI0UsHcPHw0ZLO/rr7zcylVAFhm/0h9tETGxdlAFXS4ZgkAvpvP/pJFbcKU1uETSlRhHBNq4++W61UOu8JODW3vLOR24WBwkwjHTyrM8f9lQXiYgvx8bod1LrhJ3I7+1ZDQEgfIAiR642/7px2nEPhjuPnDC433ObmkNtsj8oLTwSEpUMwKzntSs/zaNGJbcHzajs1uO11bX6+RW/0YFDJj8+wKstCETUIfkxHP3HVWdY63bWtiive5PSHXfme8r1VMY88etWlh/Dnbecq70pUkerKa11+dd1toXWrOenR88UD29ZdrnwiufBYl7peJX1AHHdBEIRUY+gtyTTIwW7TuNaoipsOrKhGn2klbHpysZUmFadfr2g4I8i9/vSPFr5Q+XJ5C+07s+cw+Je/rwuLaOSBX33QaK44fMvbG/m5txY20C6Ts7oNBcWgzNx3NoZTCgoyjXTjYWMpP9NI369u5RDLRRsctLTCQZuPyui39yykDxk5hVS2w0mUk5cabbqE4YUieHU8YAiN1lcXFssLjVd2ixpejsFqOMYoOGeI4dJjeyC0IUpb3XDXfWQ3K23P1IFuDH6rLr3iyge4ujsqtWtFPpbhDYScaj9eH+SWbibu1R55GQShjT81tx3bh98KCGMIfqxbzUfHOnBNoJ3PhjZxmn2pOPSd64aAx3xWY2Kt2FSHXw1fx1vH+8Zxw6AwD0qEBiSif3PU941BAWwz9jt+s6S1myAIwsAiDnZ/hIh7OkW1WthluIOQaZVEROdwRfvePl7S3KMb8PGSJnrnF6VqM65lLt53FA8+bF5uD7vYGxo99PP6+JXAEeUw950NtL5BEdf5GYq4Lskx84XdMTsURYh5cSgEQRgoIHiHIsQZIjGRnueqK4/Z2txBdtkhKhHCjZDwzp7jSkV4xLdD8KrOMvLJ1Xx0DIQqFd2VfHRtdFo0akV3/CRgeWo+uSpoESGAfWeJmg/rUiu2I2y+PmrdqLHB7jnnx3et/q7mwYertrf72FGHw4914T2q71/p5d7By8egLJanutxYhzYPH+tXtkUtnNf1ty6gWTe2fTAdcnXd2HZlQECceUEQhi/iYCfpYPcUIq4+ju5fOpzAj/l3q5ViXaj8+qfJ6ZvfObHIysJ4ZY2bhTHCvlEALRY/r2unZ7+qCT8+Y7cS2na84h7iIu+IbQrorg8q+DFatm0zLqOLU4ALiNvf2xiODsizK+K6NKezYvjuU7PpnV8aOHQc2/XTunbafkL6HgOhd7gcLdTwxxfkyNuLcuyFshuFtAaC15zAFQtEKPqaq8LToNPFdKqTyYG39OBFqPOZO9Q8cx8LfXbJ2enW9Fg36KjDqMwHEYxrBTjaEOseX4BcXsWhx08HBh8gpuPl/+tDlenhZqPtXKPPT3q9IlZjrVudz+1T1otccwxMwGGHqMU09RoHq+Re66H5YjnuqsMOUY9bqzn2fN2FvLtCxfEQmYDlwZ7Ay7Ec1XGPtTy8R6wTpgf2U7z5BEEQhgIR2MnmYPcQIs6P3QEqzFIqVA9H0LZKbc2Fgl29aTs1nNhvZh6trKni+8g7jyWw0eP6gfmV7FKAQ7fK7+LsbzM+k8bkm2ljo5dW1Ljoj0oXbTbKHvHZuffDChbNau72jYeN6dKOCxcJ6O19d0isv/J9HW07LlMuHoQIuJqzyUo6XFELgtBVGA/yQLcadk89rFedTyu0O534rsXpekIV2hCt0MexQu6180Fo8wBEW2dhOkzjdWuiAlRB3uD18XUABgIwD64PMBigDdfHS+CUYzqHwMeITlAFudvfQd4WLzvsXl8gvG61bgC2B/vF5fOFl4dp2B41ShDTsTz1igz1VNTIglj1A/D7q4brqwMXgxW5oQ4E4F908T9BENITEdgJAMGD8yF+R3oKEefHwzgPGz9s85cq4eH4Cdh389QpbjZQ7Dw5i6uJowL8gjVt3JM6L6Pzq+H0BOjuDyvCRdB2mpRFJ+zcGcatgouEw7cpoIf/p4j1//zcEBbYuDB47NMq+nWjEjqOC6jrDxkTt83YduMzw846nOwvV7RyUTZBiOiDPXl3smdIDrYgDEe0Qlt93NflJVKbTq9ZLy5pbD0I8o4OJSIAIfAQh8idxzS1L7q63YorrcyHFm5wvjHIES3IDQY9FVjMSuV3fdfLUKxDHTBQl4fK9PgdxV+0II9erx2Oe2iQgwU9erkHOsKF6CB0tfNFmwhYnj+o9J73+oJ8DRhrvnjgOhHv0wdn3q+IenXd3a0XYNCAXwtB3qEMHAyWyYFtVLcd+zfdzRVBGEhEYCe6o0IhZz0VORvuAnvhunbu5wy2HpdBxdmR7mo6ghC5vWbk0ls/N/CFwCe/N9PR2ysht/gxf+h/leF2XOMKLHTeXmVxQ/b+NDmb/u+Heq4wCzG9ps5NEwot9K+va+nrlUrYPX64rjpwNI0rjN+CCxcNJ+5UTDe9vYEfv/ZDHe0yJYu3VRBAR0eQgn4v3wqCMHwZqqJjiRam04bAdyfItSH1CPtGdXeIZYhGrSA3miAwDeTmnPT4udba5UGkmnSx3d/o9SJfvt2DfuuKMcJpAqGidCqYrzU0nxqODiAwka+uimI96dglV+ezmbuGrWtFcbSYRwQkfrexz9TWblgvrhPV9eJnHa+HmFeK8CmvV3rOK+HyNgxWxHC/VUGM94PXYEAjUZdcK6i1241/PAjTzXrV9+IPLQPHFoX+kuk+IAjpTMJX608//XS301999VUKBAJ08sknp2VxCjUPO1YOdnRrruEssLWtufbfIn2Lm0Wzz+a5HOIG5v/eHI5UeOPH+nDBskyLnq44YFTEj3Q0+BFC+LgKRDuc7A9+U/YrfqMu2bc8bp63FrjfW41VKoijgM18TeE5QXC0NlLNwleptblBdoYgCIMjyBMMb4b7mWU1KoXZrEYWktqidMkCkZqIaORQdqzLoLjEuM8F7aKEHxexC7WWg6BW27ahBg0cerXlHLY7Yr72yEJ2zaHCdvhDuzkIZLW6PYesmzqL6eG9q+vFfnH7O5eHW4dXGSzFdmPfqe321DSCulYfF6BDNB2uO9X1Yrsh2hGir50Polt7Pc5940NF8FAnAPOpbfLUCvfYbrzv8HrbfWwYoFUe1qu+Z7VNHabDZAq3+3Mo82nXq4px5PSrxfvU+RJpWwfR39v2dtr3jHXiD9uRSFs9Trno5XoFIWEH+7777qOTTjqJLrroIrrllluotLQ0PO2RRx6h1157jWbPnk0//vgjfyjTrQ2EeoKM5WC3ponArmzy0G+bnHy/JNtEW44ZOe2hirJMnOeMgmIIEf9pXRuP4L7xU0NExfBEHH2Ecr/xUz01OwP0/eo2/lP5656ltF0SBcuO37GI23WBNxc20J4zcrh6rCBY7VmUyyHiUgBPEITUZKjyjRNdL67tjFwFXs0l1/U4n1pAD7PC4VZbtsWLbIu3ffgtD+fNx9neznB5Xdj97qAAp/BhGrZLO+gf7ZJDKCvV5pUidgF1fRxRQGTWxx70UNeLdwg3v90TDFXxV1x95O5HO9vqfPjDYIHJpvSmb0d/+lBbPnWQxuvr4PlgXmHAAaHwuI/pqquOW4hwvB+sBuIfAxbqfD258sjVx7FS3rPiyiMcAevlQZCQO491Y3naSASE92OAQWlvp8yH9cYrpKfud8zf3XwDAd4v3h+OheT3D9MQcXyArFYrHX300TRv3jyaMGECff755+xuv/jii1RSUpKW7jUwxnGw8aFG6FA6COzI1ly5Sf1YpEuxMwhs8OZPDTxCq3LiTkUJDzhghPrgWfn04nd1Ec+fsFMRzZ6RXE77hCIrV3H/dlUbf65QnfzEnYuTWoaQnhhNFrIVjCeTOX6qgSAIgtAziZpC/V1AL9G8ecX9xl/i80FsQmC6UF1epwwScJX3JK/tlN7wigbobj+p8+G6GKIWgxAQ2LqgMi06tYAHKwIdnEqA7YOI7QgJRtVhVgcRsDyE/uvcAb7GgtjmiIjQdTlew4I6HObeOYiAvHfte1bFMK6p2igQCuPXdRHjWDdehvlaOwLhAoRqe0G1kj0GL/BaVR9geRjU0Ip3LaqQxx/a7ynh9YmJcnXbkc7I1f+xXlVgh2orWEzKgEWssH7UFsB2awsbDkZYfyC0Tmw7dofyWUlvjZGUwLbb7fTQQw/RY489Rtdddx29/PLLtGjRIrr++utp5syZPE+6OdfRDnZ0kTOnB6Ew3YeMDwcwSvj58ha+jw/97OnpX9wsmi3G2Kksx0RVLb5wj2qwy5RsOkQT9p1oyDlCwx0eJeTr4Fl5dNjWyS1DK8x/XNvOJ6b3fm2iP2+Wyz2zhZGNz+smZ90q8pZMJ7JLoTNBEAQhlgvdPyR6fc/CzajjMPeAx0ABf0f8wQoj/jrbrmEN0a48MFLkfGrhO6BWk1fFOJbZ3baGByFCJpnPD6e8I6YYB2bNYIAq8jEPDySgaF94vXgt8XyIINDpFPEOUW4yothfR1QkAd5vZ/cAVZRrHXCtI68V8uprObIi5FzjeVxzqg69KraV96iIcV6vpmyLUlEff4YIsa0dBMBrvQEcFwpFEHQvjrWv9WPgQzMIoNQWwLKUdopo7YdlqVEJ2gEE7iaAdAMi3jfa+WKhDiDgtrv5UrrI2XnnnUennHIK37/wwgvpjTfeoAMPPJA++OCDtHWwwznYUQI7lls9HB3sr1e0cl4K2HVKNrfFGGnghInWW//6pjb8HIqanbNnadJfVBRCQZ9suNgofHbSn4p6/WVHWPpBs/I5nxsnLCzzsv1H9WpZQvrgcbVTy5pvyTVxFFGeCGxBEARheJJoeHPnfHrFMUa4ew+CuqfrPkQk9IR2MICr2QeVbYm1Xu18vpAoR1g/bz8740rhOlXIq+JdK8ohen0BJS1VqZ6v1PBRhXysfaUIUFVoKmKb9QhSGUKOPMSxMfR+1fmQuw9j0Mh1CxAqr6w37OYjJQBh/X4lYhfiGO8xw2akTL9SEBBCWBXE2kgAXei16iCAur84hN/fQQ6vj0U9b5eewq9V0wnU9+lyKFEOShSBMhigRhFoBx/wWshQbRRBrJB9NUoCr+X5Q+I9kc9gomnQSQvsyspKeuaZZ+jKK6/klRx55JG0fv16OuSQQyidUUd1fGkqsD9fprjXaqj0SAX5068uqOMvvlrUrLehYLtOzeG//uCIbfLpsz+a+USNVmK/VzgjemwLI4+M7AIq3eEkys6VHGxBEARhZJFowb3+BmJVb0hQvIfEdjLiHTqj3a20h4sWpomAeVWxncx8EMoQ2+yMx3HzgZIb30HugI/I5KWWVvSzVww6fYwBhPg1DZSBEjUqwefHoAVxgUJDjEEP1c1HIUKuf6BTBDZUGT4K6gAC7qt1CCiUAoCBA0QR+NF6L9ApsFnRdSh1lnjwIpT+obr0ami76sbn4DUJdl9IWmC73W4OCz/iiCPogQceoJtvvpnq6urok08+Cc8z1Lb8QFcR145exBbYSpur4UJtq5dW1Lj4/ph8M00sHrk5nSi2cfn+o+nrlS3sGqdKmzI44sfvVERPfFbNj//1TQ3dfvT4QS2kIaQWOAfpdL2vyisIgiAIQuqgivKhaKKs5tAnYjjiD5ED7DzjNpERh36KXrCEQvvh6sdLB1AHLNSQc7j5AXcgFEHQNZUgws0PufTYJKxDWVeoZR8UOf/X8/YmZM2dcMIJfPvpp5/SxIkTOST84IMP5ucrKiq4onhtbS2ddtppPB+qjZ944on8l44jZcgNUIktsIdXX1oU0FLZZXI2jXRmjc2g8/cup/Hd9KkeCvaclsM9tcHaek9E1IEw8nA7Wqlx+afkaJfPgSAIgiAIgwuL7SEwevShavQ9GQxqazy020NNALvaOi8qR1tx81E8z8Bt6jA9HGrO7f6U1ybjZyQksGfNmsXq/oYbbqBrrrmGnE4nuVwu0uv1dM8999ALL7xADQ0NNHXqVJ5/2rRpNH36dP5LF7RV9rSVxGO51UpbgeEjsr9Z2RpR0EtITeBWn7JLSfjxKwvquCelIAiCIAiCIAh9RwkX7yrEkyEhgX3VVVfxCj788EMym820++670/vvv0+vvvoqu9nV1dXU3NzM4hugqjjEOP7SBe0IjTYPW+tWa6seDpc87E2NnnDF7CklVqlOneIg73rHiUrOLfKx31qo9OkWRh7WjGzKn7YXZWT2T56/IAiCIAiC0HeSqt6UlZXFYeGjRo3iFl2TJk2i/Px87oPd0pLeYYoRDrZGYGtbcpXnmoddq66vte61hIcPC07auSg84PPur02cQy+MPBBV1NERTNvODYIgCIIgCMORpMsjI/z77bff5rxrcPbZZ9PixYvp3nvvpXRG2/NNG/7dqgkR1wrs1mEgsHFhroaHIwJiZxHYwwL0wD5ollLpXW3bJYw8HK0NVP3Di9TaXD/UmyIIgiAIgiCE6FX/oTvvvJP+8Y9/8P299tqLrrvuOtp11135cbpWtNWGiKOReSynumyYOdira91U0+rj+5uX2ykvYwjKFgq94ohtCyjHplRt/H51Gy3Z5JA9OcKw2DIpZ+KfyGaXNl2CIAiCIAjDVmA/8sgj9O9//5sOO+wwfnzcccdRQUEBPfvsszRyQsSDXXKtzUYdFWgEqtJ/LbX5ZpUUNxuuoNLh8TsWhR8/82VNROqCkP6YzFayF00msyW1qt0LgiAIgiCMZBIW2Gqe38qVKznnevPNNw9Pu+SSS+ill14in8+XtvmAkQKbugjsLKuBskKO4nBwsIPBjnB7LjR2VwtnCcOHPWfkcGE6UNnspXcWScGzkYTf5yFXwzryed1DvSmCIAiCIAhCsgL7v//9L98++OCDtNVWW0VM22GHHbjCuMlk4kriaN81EnKwMZgQIbCtnQK7zZPaAvuPKic1OZT88a3GZlKmZtuF4QH6AJ61R2m4L9+bPzV0W/Cs0eGj+z6qoMc+reJWcsLwxu1so+ZVX5LT0dnHXhAEQRAEQRhaElbCU6ZMiTtt06ZN9P333/P9U045hdI/B1tx6V2+IKnR4l0EdoqHiH+zsvOiXHpfD1/GF1rpgC3ywu3j/vl1bcz5mp1+uuXtjZyv/fmyFnr5eymMNtzJyM6nkm2Po+zcgqHeFEEQBEEQBCFE0lbzrbfeGnatQUVFBZ188slhgZ2umGKEiGvDwLsI7BQOEUeu7verlfxri1FH243PHOpNEvrAMTsUhgvULVzXTj+ujXQ0W1hcb+AwcpUPf2uiPyqdst+HMTqdnvRGM98KgiAIgiAIqUFCV2aNjY1cNRy9rt97771wePRnn31GRx11FB188MFUV1dHl112GVcUf+CBB+j9998nl8uV9AZ98cUXdOSRR9IWW2xBu+22G91///3k93e2wuqO//3vf3Taaaex+EeOeH+2DtM62L5gsEshM4RYZ1gMpBsGAnvxRge1e5T3sO34TLKa5AJ9uBc8O2WX4vDjf35VEw4Bb3X5ae47G2lTkzc8oKLy+GdV5OkmVBzfcfRJ/9/vzZyzL6QWbmcrNXGIeGexQkEQBEEQBGFoSUhZOZ1Odqr322+/sOCG6P373/9Ot912G1166aX0ySefUHFxMVksFlq+fDnddNNNdOKJJya1MUuWLKHzzz+fdt99d3rttdfo+uuvpzfffJPuu+++hFqHqe3CHnvsMXr11Ve5hdjAFDlTxEa7Js8622ogg15Hdos+5QU2RJPKrlOyh3RbhP5h50lZtOVoO9+vb/fTmz/Vc4TFrf/dSBsaPfw8qtzffewEmlpi48fVLT76vx/q4oprhJs/NL+Snvq8ml79QXotpxo4RkGfmzpCA36CIAiCIAjC0JNQ4+PRo0fTo48+Shs2bKADDzyQHWtUDH/33XcpJyeH50GBs6uuuir8mnXr1tEBBxzA4txuVy78ewKtviCQL774Yn48Y8YMCgQCdPXVV9N5551HmZmxQ5k///xzev311+ntt9+mUaNG0UAQS2BHO9gAYeIOTzBlBTYcSzWEOMOip1ljM4Z6k4R+AP3nT9+9lC5/dS3XCHj310b6eb2DNobEdZ7dSH8/bCyV5pjp3L1K6crX1nHO9nu/NtFOk7JpaqkiukGwo4Oe+aKGnWuVt39uoK3GZtBm5Yl9l4WBx5aRQwUz9qWMLEnxEARBEARBGFYO9h133EHPPfccFzMzm830yiuvkM1mY3ENoQ0RjQt8LePHj1ccliTclQULFrDA1gI32+Px0M8//9ytMD/zzDMHTFx3ycEOhctqc7DhYAM1D9vpRQG0+GG1K6pd9MI3tVTdEr/q80CwcH07efzKdqE1lwk9uoS0oDzXTIdvk8/3UXxPFdc5NgPdeNgYKss18+NReRbO2wb4JDz+aRV5/cr3FKHgT3xWHSGu1fke/l8lObqpjo/v+6e/N9NL39V2O58gCIIgCIIgjFgHGwK5pqaGli5dSk899RR5vV52rtV+19deey238ILAhmO9884701lnnUVlZWXsLMdznaNpb2+nhoYGdsu14PW5ubnsnsfC7XbTwoULOe/6jDPO4O1EmPr2229PV1xxBZWUlFBvgaSG/jQYdGQ2dgpRGNh4rt3bOXiQbTfyc9m2zl2KKuM59q67GPsO7ZIaHX6qaPbQ9YeOpcFiwZrOAli7TcvhbU53DKFBBOU2vcNpj9y+kL5a0Uo1rT5+nG0z0M1HjqMx+ZaI+Q7bpoAWrG6jVbVuqmj20hs/NdAJOxfRY59V0ZfLlRQClB342z7l9L+lzbS0wkkN7X565ssaumS/8i4DanC9n/uiloungbX1+FyP4bSJwWAkHWMVZ3MDVf3wH5qSO4fys0tpJDASj/NIQ45x+iPHOP2RY5z+jMhjrOtHgY2e1ig0BuBUo/DYqlWryOFwcN715ZdfzoL6mGOOoXPOOYcLjSGMHDnYhx12WMIbguWBWOHkGRkZLMBjsX79eg4jh8ieM2cOXXTRRVRVVcUh7SjAhsEACPTeoNPrKCvLxuI5O7OzYJvRZKTsbBtpTbqywgx+Lj9bcQlB0KDMF01Tu4/FNW9/vSfmPAMBQtt/3ajs5yybgXaeUTBoAigVyMiIFJnpyhWHjqfrXl1FWTYj3XbsJJpYEjus+6rDJ9B5zy7jUPF3fmmg9Y1e+mWdMgCD8+V1R0yg3abn0Q7T8umvT//BERvfrGylXWbk0T5bFER8ru7+7zr6dKkirtVCeu8ubqG/7F5Gg8lIOcaMPp+Kp+5MxSUFlJszslI9sjIH55wpDB1yjNMfOcbpjxzj9GckHWM9d23p6L8c7NbWVnrmmWe4cBhCxCG4v/76a7r99ttpu+22oxtuuIEdLQhq/H333XecRw1hu8cee9BA0tbWFg5jLy1VXJwtt9yStt56a9pnn33orbfeolNPPbVXy+4IdlBbm4vIbySf19e5ToeXWltd1NCqhOACfcDHz1k1EddV9U7Ki3G9v7q6U6xDaNc1OsiiccgHCriQzlD18C1HZ5Cj3U0jAYyuQXg5HB4KqI3L05gJeUb655lTCSaz2ajjz2UsYGofvX0hvfJ9HSGbQRXXqJh/+QGjaFa5VflME9HZe5bSfR9W8PSHP9hI43ONVJJj5pz+ez+s4PZgQB2vwfLmfVVF4/ONNGvswOcIj7RjDDx+PZnzJ5PHq6fmFmXgLN3BccaPeVu7a8Qc55GGHOP0R45x+iPHOP0Zicc4y5ZF+qgIzj4JbISJr127lnOd4VaroKgY2nchNBvh4yoIE0flb7jYuA9R3hNwqVWXPJa7HS/UXF12U1NTWGADVDSfMmUKrVmzhnoLxijwmQkEOsLCASBfFc9pi5zZTXp+LtNiiOg/jOeiqdH0Iwa1zV4qj6XE+5mfNf2RtxqTEXPb0hPli48TwEh5z2pbuZ7e7yGz8un7Va0c0q3WGrjigFG01djMiNfuNDGL9piWTV8sb+XUhwc/rqSrDhxNd3+wif6ocoVfi/DxjQ1eemVBHX9/Hvi4ku6aM57yM00D+n5H4jH2uj3kaNhI7pIJlGkZKQ625jiHakkI6YYc4/RHjnH6I8c4/RmBx7gj8TDxhGxTONEPP/ww96a+5JJL+DnkWEMUo00XCpG9+OKLEa/ZZZdduC82QswTAQI6Pz+f24FpQWh4c3MzjRkzJubr1JxthIpHg+JoViv8t/7tg61WEVcrhWOa2ktaLXKmnR5NbZuv28cDxaJQeDiQ6uGCWh3//L3L+HOLqvIQzRDXsThttxIqyVaE8vJqF1340uqwuLaZ9HTtwaNpu/FZdNg2+bR1qDo9BqEemF/ZbcE/oQ99sFd8Ss526YMtCIIgCIKQKiTkYINrrrkmfH/RokW0+eabRzwXPQ/YcccdyWhMeBU8/1dffRXRPxuh6GgBtu2224Z7cKPQmupWQ5RjW9544w3af//9w6+DUIfrjpzsfq8iHiWwIU7Uok+ZmhjxuAI7VIAq3uOBoMnhp3Uhl3JikZVyYxRfE0YmYwus9PjJkwh1Cy2hgaJY2M0G+tufy+nv/1nPIeDtoXQDfP6vO3gMTSxWBrMQPnPBn8vpytfWcmG0ZVUudrRP2rl40N7TSMCelU/FWx9NWTlK5XhBEARBEARh6Ek48fe9996jwsJC/lu8eHH4Pv5Q2Gzs2LERz0Fw3nzzzUltzOmnn84C+4EHHqBly5bR/Pnz2SE//vjjwyHiEMzRed1w1b/55huaO3cuLVmyhKuXo+Aa8rD32msv6m8H2xfsKrBVsq3GHgV23RA42Is2dBaJQz9jQdCCKvndiWsV9Ms+ajulxRcoyDDSLUeMDYtrFXwnLtl3FBdLA+/80kg/hXK8B5N19W5uG7a2Lv3qDSA6yGC2k17fef4RBEEQBEEQhpaEbUyEWiPkG1RWVobvg/fffz/isRqe/e9//zupjUFxskceeYQefPBBLqqG0HQUTevJhUZl88cff5weeugheu211ygrK4srmV966aUJh6gnEkqrdbBR3AnVl6MFdmYvQsTrBsHB/mVDZ3i4CGyhLxy5bQF5/EF2p0/YqYiKskxxxThc6399U8uPH/2kiu6cY6FiTaX9geSLZS301BfV/D394Lcm+vuhY3mb0gWPs42a1/xIroKdKceeN9SbIwiCIAiCICQjsFFo7OSTT+b7aNOl3gfoX3311Vdz2DYKiyFXG442hHeyzJ49m//iMW/evJjP77nnnvw3UGhDxHHBrhXPWlGNvsPdCWz0C66PFtgD7GAj//W3TYrARp7tlJL0ERnC4IPWbomGex+4ZR79UeWkH9a0k8OjVBy/5YhxCbnlvSUY7KAXv6ujd39tDD/n9XfQ7e9tpLlHjKPRUT3BhyvBYID8rmYKBJWWf4IgCIIgCMIwEti33nprzOc7OjrooIMO4urf9fX19M4779Ddd99NFouFDj/8cDrzzDM5h3q4E1HkDO27NOI5wsHWVBFH3+Bomp3+sPM9WCHiK2tcLG7U9lwjqfe1MLQgVeS82WW0oWEdVbf4uFr5k59X09/+XBauWxALhHQvrXTSHtNyIr5fPeHwBLid2CJNxAbC2Bscfv4O3PbfjTT3yHFUGMd1H07YMnOpcPMDKTNr4NugCYIgCIIgCP0ssI844ghKhg0bNnA+dTqI61gh4vEENuazmfXk8gapNYbAjhUOjkrLbl8wXIm8v9GKja3HSf61MLjYLQa6fP/RdN2b68jj76CvV7ZyzvbBs2IX5/pyeQs9/lkVt8j7ZGkz3XrUOMrQDFzFY2ODm65/bR1VhtrgIf/7tF1LaLep2XTz2xtpTZ2bhfY/3t3ILro28qS3fPZHM73xUz2NK7ByNfZEtlMQBEEQBEFIXxJWdKjmrfL777/TggULup0f7bOWL1/ODnfaC2xNWDg/Dl24x3Kw44WDR4eN9ye/RBQ4E7dLGHzGFlhYgKq8+G1tOG1BBeeKd35poEc+UcQ1qGj20n0fVYQr93dXxO9v/1weFtf4Dl5/yBjad2Ye2cwGuuag0VSaowz2bWry0h3vbeI6Cr0Fr33s0yp6/LNqqmvz00/r2unWdzbG/M5Hp4jgfaP4Wl9xtDZQ9U+vUmtzfZ+XJQiCIAiCIAyywEaONTjvvPOoqqoq3ALrkEMO6fJ3/vnn088//8wVvbsLAx1OmNRyyDFysLOiXCv1cbsnwPmg8Vpyjck3D3irLoSkr61T2nNNKLRIey5hyNhpUjYXSAP4WjzwcSXVtnrDwhPF0JA7HZ2W8dsmJz3zZXXcwbr5S5votnc2cng4GJNvoduPHkebj+qM1sixG7mVWE5oMGxFjYvu/7hn4R6LiiYPXfvmevp8WUvE86vr3HTrf+OL7Bann4X93Hc20pWvraOPljRRXzBZbJRZPpMsVnufliMIgiAIgiD0H0nHJENYa8PAzzrrLHK5XBG3a9asoddff53mzJlD6YJRs6e6y8Hmx6GLeOgBhzcYN99681H2Ac/D1oaHzxL3Whhijtm+kLYOtYnDd+ieDytYGD80v5LeX9wpOI/bsZBuPGxMuLjgp3+00H8XdRYtU0X5vG9r6ekvaliwg+0nZNKtR46NWam8JMdM1x0yhmyhVIyf1zvoyc+reDmJgvD2a95YTxsblUErixEF34rCwh1h6HP/u6GLyF680UFXvLY24vv47Jc19NbPDdRbzBa7CGxBEARBEIQUo89Jv4ceeii309LegtraWjrqqKMoXdA62D2FiGsLnUVXEteGiG9Wbh/wSuLa/teqsBGEoUKv19GF+5RTWShce129hy54cTV9u0rpkQ3T+pzZpXTktoU0rcxO5+7VGVb+0nd1tGC1Mp/XH6T7P6qMEN1zdiqmKw8azSHh8RhfaKUrDhwVdse/WN5Kz39d02Mqiy8QpGe+qOaBANRLUCNQbj96PB26dQHdeNjYsMhGxMjcdxSRjXPFy9/VcnG1ZqdyLtDWWnj5+zr+600qTcDvJU9rNfl9ShSAIAiCIAiCMEwE9kcffUQ+n48+/vhjbte1aNGiHl/zz3/+k8zmwel3OxgYknCwI1p1uSJb6Kih4HDRJhZZuzzfnyA8/deNimNmN+vTqgewMHxBIbArDhgdFppqhXuzUcfP7zUjNzzvrlOy2fUGkKAPf1JJP69vp5vf3kAL1ihiG1koZ+1ZSmfvPZr0CaSkzByVQRfugyrmyuMPf2vuVuQ2tPvoxv9soI+XNoef231aNt121Phwyy/cRojseg/d8s4GuvGt9fTWL4287WDWmAx66MSJ3D9cBS72P7+GC5+cyHY5Wqnxj4/J0R4Zqi4IgiAIgiCkuMCeO3cutbe30y233MI9r1977TUaaSCXXHW9kIPd3o3A1lYnbgvlhaqCt75dEdLF2SYqyDSxYzdQDvaqWndne64x0p5LSB0gSC/QFD3LtOjp74eOpW3Hdy3Cd9R2BVwJXO1njTzmlTVKkTCI9KsPHE37b5GXdD442oepvP1LI/1nYddw7d8rnHT16+v4uwQQsg6H/fy9yrpU/cd7uunwsZRrN4TdeXU7MUCHUPJrDh7NdRAO36aATt+tJPxaiPwnPqvmnvWJYs/MpaJZh1NmdnLvXRAEQRAEQRhigY0K4nl5eXw7duxY+sc//tHjazZu3EjphlpJHGGfrW7FmYZAhjusJVsrsF2dArvR4Q9XRy7KMnE/6oJMpVOaWuxp4KqHS3i4kFrsMDGLrjpwNB00K4/d4HgRFhjcgqidXhY5PT/DSLccMZa2Hte7yvh7TM+hM3bvFLmv/lBP7/+qhJzDzX5/cSO70C2h7zC+s7cdNY4d9njFG0flWeimw8ZSnr2zA2JJtonmHjGOQ8m1DjsGBc7bq9NJR9E0FH5DOHoi6A1GMlqzyWBIuNuiIAiCIAiCMMAM2JXZ6aefTk899RRNmDCB0gW4V26fEiLucQfD7nX0xXaEg61xurUuNRxs9aIdbX7aPUFyegNk7yZ/NFkWre8sqCQCW0hF4FjHcq1j1UC4fP9RdMN/NlBVs5fGF1rYuc7PVL5HvWW/mXncckutXv78N7WcJ76yxkVfrWgNz7flaDtdtO+oLtEqsSiHyD58LL2yoI4H0OZsXxj3e73n9ByymnT04PxKHnxD2Psd7wX4vXaXS44BgCXr6qh23W80PmdHMhu7uth6PYqwdQ7+uaIKLkbMqyOymHo3L3LS40W349Ro7eW8OC7Rhr4hSGT2BMjlDZBZ3/28WmyaQVCPP0jBYP/Mi2Onnv9RFyDQT/NaTLrwYAwGXPyB/pkXaRgY2E12XgwqI3IrHiZjZ4RXUvMGO8jn74h7jPUdus6B7RjzRizX0DkvIkEQ7RIPo6Gzrkoy8yKNw+Prn3kxmzn0/cT32d1P8yb1vR+ic4T2GAcD/XuOiPtdlnPEoJ4jtMc44O/fc0S8772cIwb3HBF9jIfLdUR/nCMGXGDjIB533HG0evXqiFuAdl2vvPIKXXvttZQuaEPE1dBrrZiO5WC3xxHYENYA1Y5/r3SFe2GPLegfgY2WQGgbBMYVWCg/o29CRBCGmmybke4+ZjxX6p5cbIvoTd8X4Cy7fEF68yclRPy5r2oiph++dT4dt2MRC+9EKcs106X7jUo4XB0/CKiojgt9tCW76e0NdO1BY7i9WDQYtHvq82pasaGa9s2vor/NW0FN/q4RKjtPyqK7j+0c4DzkwaVxf3QxAPfISZPCj+c8+gc1a6JvtCCS4JnTpoQfn/TUcqpuiZ3igoGQF8+eFn585j9Xcuh8LNCn/I3zZ4Qfn//ialpWpZwbo0EY/rsXbx5+fNn/RVZojxa2/7tii/Dj699cT9+FiuXF4utrtwzfR0u16HZsWuZfPpNsZuVzcfcHFfTBb/Fbr/33os0oL0M5ng//r4r+000F+dfPm86fIYBj/cqC+L3OXzhrariexwvf1NI/v66NO+/Tp06mGaHimq//WE+PfVodd17UCtgmFB3y9i8NdP/HlXHnveuY8fSnyUoax8dLm+gf726KOy+iTtQ6C18ub6G//2dD3HmvPXg0HbhlPt//YU0bt7eLxyX7ltNR2yn1GlB75MKX1sSd97y9SumEnYr5/opqF531/Kq48562azGdsXsp38dn9+SnV8Sd9/gdC+n8vcv5fk2Lj+Y8tizuvEdsU0CX7a+cI1AA8ZAHf4877wFb5HEHBIDv8D73LIk7Lwbtbj1yXPhxd/Om9TnCZqB3L5FzBJBzhIKcIxTkHNH3c0S/Cuwtt1QuOi6++OJwMaBzzz2Xmpq6XlBkZ2fTjBkz6K9//Wt6CezQBT1GT9RKwrEcLa3obtUIbG0hM1Vgq7fq9LEFnYXP+oJa3AyIey2kC3Bxppf1f99nFFLDd/q9XzvPZ2jBdf7eZSyAB5qtxmbSDYeMoTve38SDd6hEfsN/1nPvbrQXU/ltk4Me+aSKmhxIUcmg/6vdfsC3TRAEQRAEQUgcXUcC/WHq6urI7XbTmDHKCGpNTQ01NzfTtGnKqON9991He+65J22zzTYRr3vkkUfovPPOI70mlG844XD76dNFtWERfdHLazg8VQv67qLycXTV4XNfWM33d5iQSZeHpj/2aVXYDcGIP1oGfbGshR79tIqfO3XX4vBofV9BOyH07AXICd1M03N7pGEw6Cg720atrS4KdBOWJIzsY4xTIdy/D39rovJcM7tLY0JVwgeLTY0ebunVwAJacWqvPXgMjcoz0yvf19O7oRxxtTDcgVvk0bE7FrG7PyJCxI1EOdkZ1NLqkBDxdA0R1xxjCRFP0xBxzTGWEPH0TCPRHmMJEU/PNJLoYzxcriP6EiI+flQ2RzMata2l+uJgQ0Cjx/VVV13Fj9esWUM//PADTZ06lW688Ub65Zdf6Nhjj+3yugsuuIDSCVOMENFYDnZWIjnYqoMdysWOnt5X/qhyhl04ac8lCD2DCxtU9j5y2wJutZdIy6/+BpXI5x45jm57dyNVNHk5dPTGtzZQUaaJNjR2hk1uMdpOJ29rpg2/fkBe5yFky+ks1tYf+UPJzBtdTb2/5tX++KoYjDqyWwzkNRsooBFmlmSWaxyYec0DNC8uxkyGoZ0X0VuJpmQkNS8uVEIh9j0d41jzxgMX/bYBmBfnhIGYVzdA8w7k974v54h4xzjWvN2R1PdezhGDeo6IOMb6jn49R/THvHKO6Pv3vrtjnMrXEf0xbyIkJLAPPfRQuuiii2jp0qX8uLW1lf8++eQTWrlyJW222WZ0zTXXxHztCy+8QOlCrBNCLIGNiycIW48/sl+2GiKeYdHzh1IrtLXT+wpyuRvaFQdsSkn/5aoKwkgAbbSGksIspeo42pGtqHHxKLAqrnEBgR7aB87KI6fDQfXFk8ls7p+0EkEQBEEQBKHvJHQludNOO/Ht1ltvTfn5+bRu3Tr69ddfyeFwcChCIBCg3XffnUym9C6khWqF0cSrKoznPe3+sMBGpVKEjkeLarQaQqQBQoH6y8FG0RYVca8FYfiBOg43HDqG7v+4gn4OdQMYnWemC/cp59QSYLbaKWv0VmS1SQs+QRAEQRCEYSWwEZK0xRZbcM71gQceSN999x2HjMPVRqj4vHnz6MUXX+SiZqgiHq9H7HBHzRvTEquKuCqw69vRfivAgxAQ12psv7awGWL5CzNNVNPq6zcHe7lGYEf3DhYEYXiAcKXL9x9N//u9mQfo9tk8NyK0OOD3kbe9nvx+5IlLL2xBEARBEIRUIOGrsv33358yMhSnJC8vL9zfeocdduC/FStW0P33308LFy6ke+65h9KRWKHW2pZcsZxtONMI8YzVA1sFghsC2+kNksMToIxQ+Hh/ONgIERcEYfiec/bfomuPa+BytFDD0vfJUTaHCrLley4IgiAIgjCsBPacOXPC96dPn85/WlDw7PHHH6e2tvj9RdNRYMdzsKNbdcXqgR0huCuU+5ivLwIb1fXW1iv9r8fkm/ss1gVBSE1smblUuMUhlJkdW4ALgiAIgiAIg0+/lUzz+Xx02WWX0fr16/nxnXfeyXna6R4i3pODDdrdgYjw7+Lszr62sXph94XVta5wKLrkXwtC+mIwGMlkz+NbQRAEQRAEITVI+Mosukq4xWKhm266ie/7/X46//zzqbq6msrLy6m9vZ1effVVOuSQQyjdi5x1l4OtdbBru3GwIwR2HwudafOvp5WO3N7XgpDueNwOat3wK7mLtqEce+5Qb44gCIIgCIKQjIP94Ycf8u1HH33Etx9//HF42iWXXELLly/nsHFUGX/jjTdo4sSJ3L4rnUPE8SjTkpiD3V0OtvZxXR8dbG3+9bRSycsUhHQl4POQu3E9+bzeod4UQRAEQRAEIVmBDeF8++23c4Ez3GZmZoan7bjjjvwcnGuPx0PPPfccO9rpRnSIOPpZowp4LLJsncEBaNWlhn5DeEc3SS/uJwc72NERdrCxntKc9G6bJggjGXtWPhVvdQRl5eQP9aYIgiAIgiAI/ZGDXVNTQ6+88gqddNJJLLydTie38Jo8eTLttddelG5EO9jxemDzNI2z3eT0U6PD30VMq+RmGMPivS8OdmWTlxyeYNi9Ttd2aYIgCIIgCIIgCKlIn6rjNDQ00H333UcGg4G23357crlctOeee7KjnY5E52BnWePvvixbp8BeV+emDrUHdlR4ONDrdFSUZaSqFh872Oib3RtxHBEeLv2vBSGtcbY1Uu2vH1NbzoGUYy8e6s0RBEEQBEEQ+upgI8d63rx59PDDD7NzDYENbLb0zP2NDhHPtMbffVp3e3Wd0jYrnoOtLXSGNlvtIRe6bwXO0vMYCIKgYDCayZo3moymyK4EgiAIgiAIwjBwsCsqKmjmzJkUCAT41mxWLupQ2Ozpp5+mM888kxobG2nWrFkRr0unVl3RDna2Js+6O4Gthm3Hc7A7W3c5w2Hi3YWf9ySwDXqiiUXWpF8vCMLwwWLLpOyx25HN3lkPQxAEQRAEQRgmAruwsJAeffRRLl6G27PPPptuu+02uu6662jSpElUVFREXq+3SzuvdM7BjldBHFiMOhbkvkAoNjxBBxvUtnlpYnFyArnV5afKZqWaMMS12dhvLc4FQUhBAgE/+ZzNFAjgXCG9sAVBEARBEFKBhK/K0Pca7rR6m5GRQQsXLqR77rmHp9vtdtLr9XTEEUdQupJMkTPkUKNHdlOouFm8HtixnG214ngyrKzpDEOX8HBBSH9c7c1U/9s71F4yh/KzyoZ6cwRBEARBEIS+5GCbTCbOv0bu9euvv0533nknt+iqrKxMWxc7OgdbW8gsFtkxBHg8ga11trU9s3uTfz1V8q8FIe2xZeRQwWYHUEZW7lBviiAIgiAIghCiT3HEcK0RFn7llVfS6NGjyefzcYGzzz77LK1yr+NWEe8mRBzAwdaSYzOQJaoHtkpxHx3s5dVK/jaYVmpP+vWCIAwvDEYTmbOKyGiUfveCIAiCIAjDTmCjx/Vbb70VvnW73RwGfc4559BRRx0Vni87O5tOP/10evbZZ2mkO9jRIeRaER0NxLcq4JN1sP2BDloVChHHOvIyJB9TENIdr9tJbRWLye1yDPWmCIIgCIIgCMkKbDjTDz30UPgWQhocdNBB4XmMRiOHiR977LH0zTffUF1dHaV3H+zkBHa88HCAwQo1TLwu1As7UdbVu8PF1KaWSHsuQRgJ+LwuctYsJ6+nMz1EEARBEARBGFoStjo//fTTnhdmNHKYeE5ODs2ePZvmz59PJ5xwAo3EImexpserIK4tdFbR7CWPv4NaXQHKsSd2eFZo+1+XicAWhJFARnYBlWwzh7JzpU2XIAiCIAhCqtCvscQoeIbiZ+Dyyy+n/Px8GqltumI62N2EiPP0qEJniQrsZVqBLQXOBEEQBEEQBEEQhpfADgaDtGjRIqquruaWXVOmTKHy8vLw9NLSUkrnHGybWd9FcPfsYJu7nT+60NnkBMK9EUquVhC3mvQ0Nt/S42sEQRj+ONuaqO63T6g9d1/KsRcP9eYIgiAIgiAIvRXY77zzDt1xxx3U2NjIudgul4v8fj9tvfXWdOONN9K0adPScudqc7BjteDqTwe7NsFCZw3t/nCv7SklVtJHFWITBCGNq4hnFvGtIAiCIAiCMEzbdL366qt000030V//+lf6/vvv6YcffqDffvuNe2Ej9xo514sXL6Z0ROtYR7fgSqzIWffjGb3pha3tfy3h4YIwcrDYMilnwo5ks2cN9aYIgiAIgiAIvRHYGzdupLvuuoueeuopOuWUUyg3Nzc8bebMmfT444/Tn//8Z7r00ku5mng6h4gn62CjdZbJ0P3u7k0vbG3/66mSfy0II4ZgIEB+TzsFAoGh3hRBEARBEAShNyHi8+bNo/3335+22267uPP8/e9/p/3224/efPPNYV9BXBcMUM7y38huVoRxWZuPxra20obsMso3+inzj65OffuMLfnWtm4VjWptpy3qN/Dj8R0WMrYUkD8nj0yN9WSpqYx4XcCeSR1jJ5BNH6TJtaso322kzD+awtMdk2dQh8lE1o3ryNje2rmNiyqpyJNN9fZ82szmocw/1kQsN2ixknPiVL6fuew3JG1HTHdOmEJBq40slRvJ1NK5PuAtKCJvcRkZHO1k2xC53A6jiRxTZvD9jJV/kM4fOSDgGjuRAhmZZK6tInNDZLs2X04eecrHkN7tIvvalVE7XUft07fgu/Y1K0jvUfp7q7hHjSV/di6ZGurIUlsVMc2fmU3uMeNJ5/NRxqo/ws8jbN6WaaHWUZN5TMm2fg0ZnO0Rr/WUlJMvv5CMLU1krdwYMS1gs5NrPF5LMY859i/2s7ViPRlbWyL3YWEJeYtKyNDeRraNayOmBc1mck6aruzDFb+TLuCP3IfjJlHAnsGfFXxmIvZhbj55ykaT3uUk+7pVkRuk11P7tJnKPly9nPTeyMEu9+hx5M/KIXN9LZnrqiP3YVYOT9f5vJSxalmX98rL1WMfriaDM7L/sqd0FPnyCsjU1ECW6orIfWjP4PdDwSBlLl/SZbmOydOpw2Qm66b1ZGyL2odFpeQtLObnMT1yH1rIOUlJSbEuXUyBNhcFg52fcef4yRS02clStYlMzY2R+zC/kI873gfej5YOg5EcUzcL7cNlpPd6I6a7xkygQGYWmetqyFxfE7kPs3PIPWocf3bxGe7uHGFwdQ6QAXf5mG7PEa5xE4kCAcpcsZSCLY1k+OVT0u24D1mKC8kzbTMik4lM69eSvq01cptKyihQVEz6lmYybYzchx1WK3knK/vQsnRxl3OEd/JU6rDayLhpIxmi9mGgsIj8peWka28j87qu5wjvdGUfmpf93uUc4R0/kToys8hYXUmG+shzRCA3n/yjx5DO7SLzqs59qDfoyJBlIxqvnNPMq5aTzh15jvCNGUfBnFwy1NWSsSbyHBHMyibfuAlEPh9Zlv9O0XhmzCQyGMi0djXpHZHnCH/ZKAoUFJK+uYlMmzZELtdmJ9+kKco+XPJrl+V6p0yjDouVjBvXk6GlOXK5xSUUKC7lY4ZjF7EPzWbyTlXOs+Y/lnY5R3gnTKKOjEwyVlWQoSHyHBHIKyD/qNGkcznJvDrqPKvXk2cz5TxrXrmMdFED4r6x4ymYnUOGuhoy1kSeI/A8ppPXS5YVf3Tdh1iuXk+mNatIH3WO8JWPpmB+AekbG8hUuSlyufYM8k2czOcIw6JfyNzuomCo/SQvF/vBbCbThnWkjzrP+ktKKVBUws9jesQ+tFjIO0U5z1p+/42XH7EPJ02hDpudjBWbyNDUELkPCwr5uOsc7WRe2/Uc4Z2xubIPV/xBuqhzBD5n+LwZaqvJWBt5jgjk5JJ/zDjSedxkXrm86z6cOYtvTatX8jk+Yrmjx1IwN4+PN457xD7MyCTfhEl8jrD80fU8myrnCP4eZ9rI7PaRa0r/niMYnY48myvnWTlHDM05IjhxAp8jzL/9GvE97q9zBH+Xo5BzxOCeI8Lf43YXBUyWYXMd0ZdzhK5oRyJrgrWuOpJg33337ViwYEGP8z388MMdxxxzTMdwx1Nbj49IxN8ns/bvmPi3rzpefPrTLtPw99kv1fzXvMW2Xab9fusjPG351f/oMq1h5z152uzL/hdzuV9/soSn1+2+b5dpN+x4XseWl3/TseSup7pMa52+RXibAiZzl+kL3vicp1UefkKXaetO+xtP++XpN7tMcxeXhZeL+9HT8RpMwzKip2FdmIZ1R0/DNqrLxbZHT8d7xLSVl97UZRr2DaZhX8Xah998u4qnY19HT8MxwTQco+hpOJbqNsVa7vdvf8fTqg88qsu0tX+9jKctevSVLtOcY8aHl+vJze8yfeHz7/K0DSf+tcu0TcecytN+fPnjLtN8GZnh5bZPnNpl+uL7/8XTVl9wbZdpNX8+mKd9++HPMd/r5wvW8/SmbXfuMm3ZDffyNNxGT8P8mIbXx1ou1ofpWH/0NGwnpmG7o6fh/WHal4trOvyZWV2mY/9gOvZX9DTsV0zDfo6ehuOh7kMcp+jpOJ6YhuMbPQ2fA0zD52IgzhFffrUy5nJX/bSiY/naxo62vffvelyvm8vTKh55rss01+Zb8jT8BcxdzxFrP/qGpzUfc1LXbTr3Yp624ZV3ukzzlpaFl4v7Xfb/K+/wNCyjy3fumJN4GtYdPS1oNnes2tjE07Ht0dPxHjEN7zl6GvYNpmFfxdqHKxev4+ntu83uelxvvounVd73RJdpzq23C7/XWMtd89lPPK3lsDldptVfdCVP2/j8610/h+MmhJfryy/oMn39mx/ytMYzzu36nTvpDJ627r+fdZnmz8wML9c9ZVqX6Zueeomn1V5xQ5dprQccytNWf/tbzPe6YlkVT3fsuEuXaVW3P8DTcBs9DfPzsVkV+zyL9WE61h89DduJadju6Gl4f+p7xfuOno79g2nYX9HTsF8xDfs5ehqOh7pcHKfo6TiemIbjGz0NnwNMw+ci1ntVl4vPVfQ0fP4wDZ/H6Gn43GIaPsfD4RzhKy0fkHMEtlFdrpwjhuYcgXN04x9rBuQcgdfLOWJknCO8A3Qd0etzxOrVHT5/ICENqcN/iQhxt9vNRcx++uknrhreHcuWLaOjjjqK57XZhm9fZqfTQz+9/nnYwVbdKWf5WDJ6PQm7U8GODtLrdAm5U4//bxPVf/szP3fh3uU0Kt8c18FGnvY9H1ZQtb2QJs4cR1f9KYOsFVHOijjY7GBnZlqoZtRkCoiDnZYOtsGgo+KNK8kxghxsXyBIlc1eml5q55oQqeJODbSDnZVlo4bxUyng7xB3Kg0dbIO+gwrWr6I2cbDT2sHOyrRRmzjYae1g59pM5PzhJ3Gw0zTKJfw9HkEOdvnsHUlntZCxh5RfXkWiAru2tpZmz55Nc+fOpaysLCopKaGJEydSZmZml3mxyK222oreeOMNbt81XHG4/fTpotouxcoGkncXNdIL39by/XNnl9LsGZ157tF8v7qV7vtIuQifs30h/wldgfjKzrZRa6uLAlGhSkJ6MBKPcbujnVasWEY7zJpJxfnZNBIwGHWUm5NBzS0OFthC+iHHOP2RY5z+yDFOf0biMR4/KptNu0QEdsI52Ha7nYvpPPjgg9Ta2sqtuXQ6HYvs3XffnY4++miaNGkSz4vnP/30UyooKOjbOxmBjC3ojO3f0Nh9obgNDZ3Tpf+1IIwsfG4ntW/6lTzTJqLs4lBvjiAIgiAIgpCMwIZTjarhjzzyCG2xxRZUV1fHoeALFiyg+fPn0/PPP0977bUXXX/99VRWVibiuj8EtkZAx0I7fVxhgkn3giCkBRk5hVS6/fGUnds1ikgQBEEQBEEYBm26dtllFxbToKioiHbbbTe6/PLL6aOPPmKB3dzczLnXK1dG5XIICZNrN1K2zZCQwF4fmm4x6iJafAmCIAiCIAiCIAgpLrBPPvlkevXVV6m+PrJQAthxxx3pxRdfpH333Zeuuuqq/tzGEYca7t3iClCLM7JghYrbFwz3yh6db+EiaoIgjBxc7c1Uv/QDam+LbK8nCIIgCIIgDBOBPWvWLNpnn33o4osvJm9UNTw19/qSSy6hP/74gxoaIvtJCv2bh72p0UNqSYFxmvkFQRgZ6PQGMlpRcGPwijAKgiAIgiAI/SiwwY033hh2sysrI9vIgN9++430ej2ZzUp7KaFvAlsNA49m/TAtcBbQtFAaTFzewJCtWxAGAqs9i3IFXx/+AABXXklEQVQn7UL2DClwJgiCIAhC6hIIdpDHH+S/RK/H/YEObkmaYMMrni/Za/1Elz1gRc5UIJyfe+45+vvf/04HHHAA7b333tySy2QysXP9zjvv0KmnnsqtvITeoRXM8fKwIyqIDxMHGyK3ts1HJdlmspqSHtvpNfgyt7X7yOn0UWFG6ueq48uOaBBB6I5gMEgBn5uCQVtvTuWCIAiCIAxzFFHJrcsTThcN4jozFHk8UAQ7Olgg+4MdfB/bZtQr61NFtlGvJ5NBR+h6hW3BvGi1iltgCM3v9Qf5Fq838vy68HvHvP4AUYDXwS2uKeDrID0p8+JPu1+wXnU9QVK2C6sz6HQR26JFfR+KFk9sn/Xqqgwi+4477qDjjz+e3n77bS5yhhZeY8eOpccff5x23nnn3ixWCDEm38KHD8dxYzyB3Tj8BHarK0DFWSZqdwcGVWA3Ofw0eZSd1ji9/CU1Gwdv3clS3+bjbSzJMYdPIIIQC2dbI9X+/G9qy59DeZllspMEQRAEoQenMh0MDEVUdrq1uF4MQjB2dIpQVcxqhaiP51FEpWrcYl4Iy2hxzkJUI3Y7QmLUFF62LqbQxzoCIbEL0Wo368li0vNr8FqAefDn8cHRhrONpXfw+8B82RYDX6vjPjaL5/cHye3vIG8A5gK2ScdbgNeg2LPVbOD50acarrc3tGzUrMJbwJW/KqgxX4ZFT2aTnrcR79HtDZIX2+SHyaUsHftK3b8s1DGIkaCE6JPtgZxs/An9Cz6IpTkmqmrxsZAOBjv4A6P9EKsOdq7dQNm21Hev8CXCBxRV0puc7kFzadvcAbKZ9TS51E6tbS6qbfFRUVZqCuxWl5/3UUGWkRodfirKSn23XRjaEPG8qbMlRFwQBEEQYhAtEnHZCc3EYs/YVVR2hiXjNUEWcCzIQiI01nUrRBiLSnZEO51QvCYRgRztynbrBodcV8xrMugpy2oIrwvLwnY4vUEWmG5flJDWK2IXwhWvwS6BoePyBsMiFPNgXfjDOvBe0NkI64IAxrU8lguxawgSWX0Bfq3XG9pXGrFrCglxrX5RMRt1ZDYSZVgMEe6wMjDQdRAE2wJjLpMHCigUNt7V0VYxGQxkNxtYP6kDC/5AkEwh0R59LGFTYlvUfYj35/V3kMVkCA9WqE54olECqa/MRihjCiwssHGgq1t9VJ7bmdPe7AywcBxO+deohl6SY6LyPDO/H5cvyB/+gQRfrDa3n2aOzqAsm5HKci1U1eThL3N3J76hACcopzdAM8ozyGbS068bHRxSbxvgfSQMX4wmC1nzxpDJPDzOAYIgCELqgmsjdgeDirgyG/TdXiupwhKvUwRf9yJRXQcEDzRKLNc01jrwGsymuJk9X7uxoPIrAjnsiNoURxSvhqh0akSlKeSSYj0dGkc0x2zi7fOwiOxgIYrpLOhCrif+8Jaxjkwr9pc+7IS6/YGw44tlhgVyB65BFZELF1VxcCNDprEOVYRr16G6rhC8qhuswscsJFoVhzjIglidN5YQZdFq6RSheI/8/jWOs3af47pdFaE8mBCaxwYRHhLuyUZfGnsYjNCCbTEZFAGdCBD35tB+Ier5NTyoEBLzfUUEdooyrsBKP6xp5/sbGtwRAjsy/9pKqQ7nTuiIBS6+nPl2A9W0+gZcYMMFLsw0UWlo3+VnGCk/w8ROcX5m6rjDOFk1Onw0odBKZTkmPoGMzjPT2no3n+SkBZsQC5/HRY6aleQpmUFkl5oXgiAIqQp+51mcJSg+EOWH+Qfy9z8ibBjizqAPO5y4boOoVEWiKra1jrAqerOsevIGiMW539vBgs4aiqPFOiD01NBkVUBiORC4qmupFdux1hEMEjn9iksa7SZHhz9jHeaQQMZ8XdxKiEqrMj9cShg+eP8QyGZjpyOsgihIVVSqji/Wh/kUdzfSqVVdWewPDoGG4xsIhgWy6oqqAlnZR8pfpzhX5lfXod6P5QbHQnnfioubjAjFticqQo1GPeXmmMnS4Sd/KEda6EQE9jApdLbTpM5p6xvcwyr/Gv28IXRzbMoXtzDLRFXNvoTCxCGGMy2GhE8qKjip4USLSACc7AFOCGW5Zlqyydkl7H6owD6oCxV+G1doDe8P5OE3OXzU7PTzoIAgRONxO6h13QJyTx5DlCcCWxAEIZVgh9ffQb6QAwkB6fYFNIWdul6DsBjlfFQlnFl1WOOFM6tiFOsAmCOWqFQJi9HQOrANENVWU6Sw1IpEiD4llzXA102YL9dqZBGrrkcrEuEOQ1QigtDpCXJBITUPVxXquAbjHFxNiDLEthqarK5DfS/YVohh1U3GOrSo78MSx92NBtvcGaas53V3d02odTbh+HI4dTfrUFxZReDiGKmh4LHWEbktnSHT6n5IZdIhn32gEIE9HHphRxU6G04FzpQckyC7yOqJJcdm5BFBnCC7Gy1DMTTMg6IJeRnJfVThCEOkFkS9roCFvp5a3QHOB+8vMBCAE3ROksuEy47R30nF1ogTKX4kILgxGJDqhdmEoSEzp5DKdvwL5eRlyiEQBGFYA4HmDeWxGroRlFrUEFpcWsQTlNHrgKhTc2oTQc3dTdR51oZNY3Pw250VcjmxfWp4MoQli2d2binSRbYoghfeAESlw6PkuarboYYbq8JdXQeehwB1eRUBymLbqLir6japLrq6Dgi7eCG9WpHYGQoee19rRSKEbodORxlZZjIHfVxcKnodnKsbCkWGYFXdYVXAx1qHzayLcJPxXpX19i40WbvtyehEbGMyV2SqOB+IkGkhdRGBnaKUZJs4BwSjhtG9sFXBjRMCQolTmZZQODbCs1VwQs3PNFJVkzeuwMYPYavbT6XZZqpp9VJHhyHhkTKIXSx3NKqxR70GJ+HyPAv9UelkR70/Rt/ww6f++CUjhjGAACYV22LuBxQ5K8szU0Wjh8PrBUEQBCGdYJfUr+S24vcZYbpqvit+nbmSsEZsqK4wnFU8D0cUy4AI5VDXUBGjWK4wUHNbEfocz0lWBRxyeDEPZKnbF99J1rq3akgzri8UNzVSKCphu/pwBWXVRIjlIgNVsKpuLxxhvHcucBUS7tp1sMNqVUKf4ThjX2L/asOTuxPV8VDXk3CerBHbYSCfy9Bj+LBWbCdCf+bJCsJAIQI7RcEJBwJxda2balt9LOBwMsGJv6LJy/OU55hT2tnEaCxO7OU5ti4nczjJlU2ecLuAaByeIGWYFZGMgm49ud0q2D/4oZ1Rbo87P8LVMa3dE+QKjH0B26/mT+O9ojBdaU7Pgx6Yt93jp6klNt4X8X6kkCrQ7PDzoMFwqBYvDB4uRws1LPuSHHmzKcdeKLteENIcrZBTBam5B+cWYlLtIauIJH1iTnKwo8ciV+F1hEJao1sDdfe7iSKeDgwyI3w45KbCVMC1Txa2mQsuhYpL+QK83WrLHLyPApuSX4trIGwrxCdCmZG7qophtApSc3IhLlHZGPsLzrFH4ySrecDYFq0rnG0z8a263zEornWSuX2QRrgjV9ZiVPJ/uzsmnW4vtqszVDsRAYr58X67c+yxLNXtDVeq7oPDKwhC8iR9xV5TU0NVVVVUUFBAY8aMiTnPokWL6L777qMXXnihF5skqIwNCWycfDc1emhyiY2qmr18ogfIL0713GuETMcqKIbRXVTIxmgsRjljudcQnwgNL842sWufiMBGyHVBlomKs+OLXPxIoWjcihpXnwV2Y7ufw9ARjo4LgkZHgAV+d9uKH/z6dh8f31F53R9DLGdcARx3F9nNqVf9XBg6cHGlN5glB0oQ0hwIJDiSSLeC0ISQw8A0fmvwZ9DDmex0VlVBiN8k6Gl0psCt0wsh6g8XgdIObqtCHGKTqwKblOrGELcQ2tGiEb9j2CbV5cVvk9IaKLbw1w4OGCBes3R8bQC5H+2MQlBaQw6lGjoMMQzxGkvAKvm3Sigz5lXDqm1GiOrOvN/w8lkQdzrJEM1wzGGZ59kjc4sVOkOfVWcYYdjYV1rh3pu6Lsm+RsKNBSHNBLbP56NrrrmG3nvvvfBzkydPpmuvvZZ23nnniHmbm5vpxx9/7N8tHYFAWKkgTBwCW5uPrZ2eavAItS9AE4szYoYVYeQWIdB4X9ECG441CpupIhlF0TY2evjHu7vRd4Rb4UccwrWnUCZeZpO3RzHcHU6PEuI9vsjKot1iIhqVZ6JVtW7+IY43ulzf5mNRPr7QmtCPa0mOmRra/UoxtATccWFkYLVnU96UPcieKTnYgtBXIMwgtuBM9uRAakUviiX35CJrnWE17DkR1OrLAMLSbkHqGMSysi44lGrYsFokCqJZFeK5oTBldX1wP1XnVg3BxrLg2uKnVQ1TVp1kVdyq9VDU8Gc1FFrr8uI3F/OqYc/q/HjeH6CIwYEMq5GKc8zUnED1YbUacqK/09gWtXBVT8dE6yQjDxiz9+Q8YyBDrUINxBUWBKFPAhtu9AcffEBnnXUWbbvttrRhwwZ69dVX6YwzzqArr7ySTj311EQXJfSh0NlwKXCGH2S4w4WZ8T9icKfxvtSei+pFSLsnQNNKbXzxALKtBsrNMFKbK0D5mfEvTJqcfu6zrc33jgd+rEuzTbSu3t0rgY1tRn755GJbRJXv8lwLC2G497GKqGHwACPpE4ttSeUbjS208DLx+r667kJ60NERpGAA1filPYYg9O47pIhkX8iFRcFJhCTHcoXjiV5OS/IGYrrCQA1fVp1h3CI9yBSaP1rQqduk5tlmmPUc7RVrXtW5hduM1zi9AW5nZIsS4l2LVoXcaW+AX4ffTFUkxxK3YTc7NH+mJfY2KeIWAwGh6tCcL9zBgl27TWjvM9DVh5Ndfm+cZEEQhD4L7LfeeouOP/54uvTSS8PPnXTSSfTQQw/RnXfeSbW1tSy0hQES2CFhHdEDW9PKK5VQRfL0Ulu3I/XIKc6w6vliRs0vVgWkNsQbP3wodrakzRG3tRfcZPx4j87rWtgsHnCDEXKv5rcnA1zooiwzjYo6BhDNY/KttLTCwS68NiwNo/sOj5+ml9mTrmCOyuvjCsy0vNrNFzsSKi44Whup5qd/U2vuHMrNKJMdIgwKXFW5hxY1WnDOhh5NtAqzWr8jGRJp+RixfDW8OaAUpcQgKX4/8J6Q/4s8XtQBYZc35NQqjnWn6LVbDOHn8RsSdoV1ivBWq0kDK4tOxRlW83+1rjDmB1ohjtoc6jb1hNZZTQTMbzUpIdiJ7Du9Jqc3kRaX2pBt5ADL75UgCCONhK/yN23aROedd17EczgpX3TRRTRx4kQOH7darXThhRcOxHaOSCA6c+0GanYGWFjjh1CtKI4fxqLs1OyPjAsTiMvCrO7DmXERUZxlojV1Hsq2KRc9jpB7HS14McKOZTri5Gw3u/w0qcialLuLebEPK5u8ZE0i9BqDAGaTniYUxQ5FR854bauZi5+pAwVq3jWKtpX1Mswb1c/RXqw6wUJqQnpjsWVS7qTdyJYhPbCFwRHWCP/Vqf18/ciJjV80C+c89MLlQpZ6pPAoQjKe2FJDqIN+IpM1SA53kIwISe5GYEK8QZQCFsI9FOXSuskQozl2E4tfrWDUa1xhuLYYvHX5lCrMLMRDlaG1YhJRUNr5sW+wj2K5z2r+b/T8AM9hfjVEezAYaKdXxLUgCCORhAV2RkYGeTyR7aJUDjnkEDKbzXTZZZdRXl5e3OJnQvJwFWmnk0UdKlQj/BiMyTf32CNyqGhz+2likTUc4t0duXYT6XWecJsNiN5Yeca4qImXs93qUl4HAZosKHaGKu0IfcOFTU8gPBCVT6eX2+JW9cYF15gCMzU5Oqu/oxhavt3I1cZ7e+GE5SJvG++3xelPuue2kF6YzFayFU4gs9k61JsijBBhjbxWiEmIMq4C7UEV5gCLVFVIaYW1UvXYwOIU8ytFtpRiVer82jBthE3nZ5moKMdMAbebuyd4/F2FOReyCuVLI6wbrYewfAhhzK8UqdJ3EeJ4DxCxqpvcU74tXF7MlxnqzdxTpWe4vHiNkqPcfVuj6PlBKncFEQRBEBIn4Sv0CRMm0IIFC+jwww+POX2//fZjAQ4n+8ADD0xiE4SewsQXb3Ly/W9WtkY8n4rgQgwXNqjknQgoeALBjJBy5I9tXm6Pe5GBwmSopq7tNY1wNbwObbl60xMRIhlu8IYGd0ICG6HhZbnmHh1kVCLFfCjOlmU1ctsP5F33tW8jLlYhsn+vdJDN31m8Rhh5+LxuctavIW/pVCK7FDpLJdQCWNE9beOhikxDgm2OAM6DEGmJzg+RiapWic7Pbi9aEoWENVxdbQiyyWYkqykYIZyhV1V3ONOC6Z0iFucqmzlyfghWVKGG8wx3GOdHi9nAt7kZJi4eps4Plxetl9TcZLUThSpi8ZoMv3b5AZ4fAwRw0NX3kEgBs1iFsFJlfkEQBCH1SfjqfP/996f333+fKisr485z6KGH0vXXX0///e9/+2v7RjxjCzrdqa9XtITvj9M8n0oghLkg08iFyRIBF1gIE292+rniKUR0PHBBlZdhYjdfW9gM4ePdteVKxMVG5VS1Kng84KaoArenAie4aEI4OC4A0XJsfKGFi7r1ByXZJnbrG9pR4Cq5XEUhffC42qll9dfkcrQN9aYIIfB9RB4uxCNEE1xZnFfU/r2xgIhF9A40H7cj8gRY3HYXRYMoISwykfkhMLF8tQ2To4f5MQ3LxHtAf+LCTBOfd2Pl90I0I8wa53wUvoLTjNxhFLdEBFO0kNXOD+cZ51EIa5z3cW6NPq+q82M6zv9YHOZHNBMGR6Md4ljzYxBX+x4GuriWIAiCICR8xX/iiSfSnDlzyGjs/iUohFZeXk6NjY2yd/sBrVONEPFULnCGC7NgMMgh3slcxHCv7Awjjcq3duvIYpklOSbOZcYFK9aHi83R+bYe23J1Bxz00hylojhCB2OhhrBvVm5PuOo45hubb6Z2b7BX4evxgGs1vsBKbS5/aIAhNXPxhYElI7uASrc/kbJzs2VXpwAQpD5/kHviImoFocUI/UUxK4hufG+1YclKz2AlXBr9gBG67AudZ1D8CilAWgdYDXOGCEWRRLixXME6lCOsurhq6pBafEsb2g3U5aNQGQSnKmpxTsX8AOIY8ydaNEutHp0oyc7P1axtEOWJFTNLdn5BEARB6E+SstSQZ50Ie+yxR2+3R4hidJ45HHanJRVDxLkCuM3I4dHJALcbrnB37rUKhDhajHCFV0+AirPM7E70FYRz17T6+GI4OscbwC0uyTYn3Yd6TIE16Qq3iYAL4AmFNlpS4ehVFXRh+IPPlE6v5MOOFLgidZIVprnIVpIVppOZH8LX5QsoYc4hoazWWYCLnZeBXNsOdp3Rzgl5xnCTtUJZDSO3hHowY36kzUAMIxxaDXOGS4wewuqAIl6H+e3+TiGP5aqOuSqstWKW2yiZFSdbrWIN8BJse4a15/zkoSLZbUrF9yAIgiCkP32KWYVLjZBxr9cbc/o222zTl8ULoYuh8hwzVTR7Iytqp1gvZFz4Ihd6fKE96aqhuBiFwE10f8BtXl7t4rDuMQWWfqm2iovQUblmWlnr4otS7YWZWjV8fFHPoeGDeZFXmGWkMfkWWlvv5jZmg1V1VkgN3M5WalzxLTnzd6McewGlOwhvDqCAlQ9CMkAmDDB0891Sha/6nYV47HZ+TTEvuLtWc6cbHAvVIYbwjRbKWrBOFLMyG008P4RwLOEbPT9Ersus5/kxqIhzfrz51WJccLIxv1mnzh97H8GZZmFuUYQ5yExhYS0IgiAIaS+wa2pq6Oqrr6bvv/8+5nTVsfvjjz/6un0Cu6CWCIGdiu41nBBcYA5GuDJcogyLl3O3kWfXX3Bf7BYvC2q1Qjgu0uE8oad3Mi3ABgN8x/BZQG44wuYTyUOHMGl0+DmHMdEQTW1ROSF14Pz7jgC0YFoDN1Z1ZvHdL8w2k9vppnaXn8Oro9tEcR50KNQZ5wdUmIaIZPfYoOQJR8/v9nUQ/kH4om4CcpBxTkNBsGiRivnRXgkFFrsTvtFo2zklMhim18yP1fckfDFdbS+lPu5pflWYJzK/IAiCIAgDKLBvvPFGWrx4MffAnjZtGtntdvlxHkAgor5f3ZbS+de4gMV2JtKaq68gpBxF3uDg9udFIbZ9VJ6Z3XGIaSy7MRQaXpabevsc4MIe1cmXVDhZaMdrHaYKZfRUR5G02jblffXkyKMdGCITzKHiRT0B0dHg8PP+k7D1gcWWkUP50/amjMz0rSCOnGMMcqlC1m5VKkdjIA+f9DZPgHxoExVym5X2TUGymZAH3ZlDzNWofXpucYfQaDwP8azOj2gY5E2rn1mITqs5SG2uAIdq43mIc3V+hIPnZqLqdfKOb7KRJsnOL2HUgiAIgjAMBfaPP/5IF1xwAZ122mn9v0VCF8ZFOdap5mBzuxid0kZrMJ3bgQCis7LZyxfiEJ9Go47GFVqSDnsfTBCeir7jf1Q6WAjEctMQzgqXG5XN0Ytbp3NxT3WI7XgX5Bg0wbGdVGyjTU2eHgU8nEYId1TtbXL4uVJwKjjfqFCPbRuo6AoIQOyneAXyogmGWjIN5AAEjncy6QyYH7MnKs56Mz9IdJvU8GuIYFTfh8DWrgvLQb0HCGWIYDjOmK5WpY52iVU3GJ/HdjcGjYLk7lBaVuXZTbx87fyqGwy3G4IcNR/cPj+L7FybkY91b9JFBEEQBEFIf3p1hZeZmUmlpaX9vzVCTKId61QT2BCjCN3sz3DtoQIX7MhrRjgpQsOx73O6EZWpQmm2icbkW5UK61FFoBDSCjGNgnCTiqws7CYVW7lNTkO7P+byOFfU46eJxVaaUGSlycU2fi5eKzNeR6uPW61NL7PzoBAKw6FS8lCCvuUARaFqW7393tYMwrq2zcs9ehNZPsR4TYuXBy8wf3ftm3qivaWeqha8QC1NdV1qIcD5hfOaSEEwHFd1fuQh9wTylPEafEfw/hOZX/uX6PwI1y4ItW+KJ+QhmPMzjaG0EURZGHn+eK4vPgdo1wQRjvMVt5eyxp8fIhqDSpgPr+H2UjajiGtBEARBEPpXYO+333705Zdf9ualQi8oyjaF8+RwHYgw5lQBYs4fDHLhsXTJ4UN+MlxhXNz3Z3utgYRbdxVauKK6KipV6tv9lG3V0+SSzjZoECFwpvF50vYVBxBNjQ4fO90YbAA4vnDJW1z+mCIJ68y06mlqmZ1DcyHKR+VbWHRDVA42EJoQsBaTjlurzSi3s5CqbVVavPUHGGzAIALSFTYLLb+6xRtX1EKU1rV5OUpis1F2FniYv7eDEBZbJuVM2JlsdiVEnFs2hfKGIQYzzHrOuY8ngrEf4M7iMwCXGNuDedVWTfHmBxC1cH7xVrEfYg0sqC2kQB7mz0RKB8UV8pi/XTM/voOJtN/DeQefZwjnRCMmkA4C4Zzo/Jgv0VxrQRAEQRBGNsZEi5ppOfLIIzk8/PPPP6cZM2bEfV1JSUnft1Dg3MKdJmXRF8tbabvxmV2K+gx5ay6rcnGbLuAiekqJ0lu7L/21hyYf20q/berMx0Z4NMLbp5R27d+NnGrMv6zKye8TzjbEMFxwOPfjOJS8swASxDZCm9c3uKkoyxwOm4e4Rg7stJC4BpgGtxwDMAi5H8wq5xyq3urjQQUIfjUCASJ4eZWTHWQUhOtLiC9y0+H64nOC/YL3BtG2qsZNNa1eHujQijE41ghNRjs67Ffsb+yrNbUuLmCoVqFOBpPZSvbiKWS22FikY+ADIhC5xNj/XMDKpOdBEbja2ira6vz4TMCR5c+5GQIyyJ8dCGN8HtR9xLnH/qj5Q22oOK/ZG4goOKbmTsNVztS0lULuclsoRNuv6+wLjW2BwM6Mml8QBEEQBCEtBTb6Wke7k3Aszj333G5fJ1XE+49zZ5fRgVvmhx3FVAEXylNLFcGQTkDwDEcgJtV8bJiEEEUQlvHeT3mumSs0r6t3s+CGuMZzcKCjBSi75EVWLvKkiuZmF/JSdTSttFPIqkBgIrTcHyAWnajSnkx/4d4AkQYBjVZ2U0sVV1kF4nB6uZ1FMMK6izI7BwkSBec9hNVj38AV1+awQyBPL7OxaNzY6OH9AdGNfHT4tVh3GfZBaL9CwGJQAq9DqzUMXiTzufP7PORqXE/thRPJbLLzIJe2xZzq7MLRboXA9wS4QBg+E5glen6A7TUaTDwYgLxj7J9AAD2YlQre0bnQHKKdoSOHR6cUHAsoDjSOc6zcaSwP67WaFCGPbcJ0FCGDa91TKy1BEARBEIRUJ6GruX/84x9y0TPE4AIXoieVgCsGkZBIdWlhcPOx291WqmjysNiGsI0HxAwcVYjsjU0e7keO0PF4obAQ05juDSjOtN0Cl9jGYioWcFCnlFopEAxyuHhxN0XVYjnRyQhyOKZwrhHaP63UFtMRxnOYBqMV2x/tNHe7PUEllx2h8FNK7DHfsxr9gO/F2jo3i+tsu4Eml9h4XdFAqKOIHvYjC/8WLxcLTMTtdzlaqXnlF+QbW0T55Tlxi6bhGOQbdNSqVwbEcAwh/tUK29FgOoS+4mYrPeARPh5vP2Fb4WpjOoQ8xix6CqeGkDcZTOTwoAAdhV13QRAEQRCEESGwERIuCNG0uwJUmmfuEnospEY+NkQR8sl7gkUz52fruMp4T9WtMX1KsY1gy8LtjiUco0Ut3GS46hDZRQmIbIQwQ8xCYEOU9yS0fYEOqmr2cK44cse7ew8s+ktsvJ8qGj0hR1Xfs3hvU8Qv3rvWGY8Gy8WgBZaJ94Cw8O7mx75AyDrmX13rpuoYIebRILfabcimbfb+C00dl9fj9kPIQzTbzB3saPckZlX3G9uAWRMR/NivBQaEfCdWXRzbkGOXwTlBEARBENKLXiXzIu/6iy++iDv96aefpgMPPLAv2yWkOAjFDVJHQgJOGHwgjDgkO8E8Y3Z2y7rmaccDgnHWmIxu3fHo+Xn5VkV0dldtG+Iaed2j8ywc6o2Q7+jK6NHit67VS6PzrbyORNpfsdNcbGMx3uz0cY50T5XCMZgwoywy7Lw7sG9mjs5IeH7kzG8+ys75700OX5ficyrIq8e0ycV22m5yIWVYEwsrh+jFvknGKcbgSzK585hXQrwFQRAEQRjJ9Epg99SKBi28Nm3a1NttEoYBECTZVsOwaGElDAzJFi2DgFRyjuOLbNW5RgVyhFVPK7NxyHe86tyYH+IX8282OiOpKs8QmijyNrXERi5fkIVrLKcYOdcQvXDhB7J3tTbEHK3OlJD3zlZeXLytxUvY68j/LrB46LNPP6DW1pYB3SZBEARBEAQhcQbkavHTTz+l/Pz8gVi0kEL51whrTbfiZsLAggEZFPtCDi6EdCxxDecaxdHw2eLCYaV2doNRKE0rsuEss9PN4jd+3nh3cHX0AivNKLNxIbJ6jfDHIBIqcE8sUsT+YH3WMXCB9nAzRyutvPC+0QoLgww5dgNtPtpOpTlm3k6Ho52CwaHtNS4IgiAIgiB0krD9+J///If/VO6991569tlnI+YJBAJUVVVFlZWVdP755ye6aGGYgZY6aMeDqsKC0CuRXWbn9mAQ1Egz4DBvONe55i5iFmIcAhrPID+5OMvMQrvBobQTQ9G1vraug4CHQF9Z46SaVh871cjrhrsNAT8UYc/Imd5sVAZXGK9pUQYSJhZaw8XJcnPz6PDDjxn07RIEQRAEQRD6QWAbDAYymzvzLY1GY8RjoNfraaeddqJdd91VcrDTGOR/IjcWPWsFobfiESL7j0onh0FDYI/K6yquVZSWVihMplT/1pGOxhdYubJ+f1WfRlXwzcozaGWNi6ttw9VONMd8oOD3XWLjlmjZNkOfencLgiAIgiAIKSSwDz30UP4Df/nLX+jyyy+nWbNm9fsGoXjagw8+SCtXrqTc3FyuYP63v/2NBX2i3HDDDfTaa6/xspAPLvQfCEtFKG8ilaAFIRGRvbzayfn8ENfdhXmr+cm60P1Yvbr7CgqSoW842pBlJVicbDBCxmO1BKuvr6V///tVOvLI46iwsHhItk0QBEEQBEGIpFcVqubNmxfxuKWlhfMA8/LyqC8sWbKEQ8vPPPNMuu2222jDhg00d+5c8vl8dOWVVya0jH/961/07rvv9mk7hPg4PEGuNJ1nl+JmQt+BcNwiVJwskRxnzIcCXwM5uIMQbMswyH6w2zNpp5125VtBEARBEAQhNei1Slq4cCE99dRT9OOPP5LL5eLnsrOzab/99qMLL7yQCgsLk14mcroRXn7xxReH24Ehr/vqq6+m8847jzIzu7+Q/Oqrr+jJJ5+ka6+9lq6//vpevjOhOxyeAI0tsITzQAWhryTbR10iJxTsdjttueU28gEUBEEQBEEY7gIbDjEc5QkTJtBpp51GZWVl7DKvXr2a3nnnHfr888/ppZdeojFjxiS13AULFrCQ1rL77v/f3n3ASVldjR8/U3d2Z2crC2rQqNgFLKhoFGxJJCSCoqhEIwYDUbCRGMVETfQNWMiL2CWIIooFxViiKajIK8GAikbIX7ErEinL9jo75f85F2Yz2ys7z/PM7/v5jJd5pvjsXmaYM/ecc0dKfX29rF271vy5Lfr//tWvfmXSy7FraJ2sLhwW0twMSLlwuF42b/5Gdtttd/H7M1J9OgAAAOhugH333XebZmbz5883zc+SaYB8zjnnyC233CL33Xdfp5+zqqpKtm/fLgMHDmxyXFettRZb08XbUlZWJpdeeqlMnz5dhg8fbgL13qBJqNqc2MNWVEZFXUTyQz4pCPls1WzJs7PDdGKE86TjHJeUVMif//ysnHfeT6R//wGSDtJxntMNc+x8zLHzMcfOxxzvggBbt+LSQLp5cK10/2ttgjZ37twuPWd1dXVj2mNzwWDQBOCtiUQicuWVV5rV7XPPPVd6k8vtklAoU3KoNzbKG1xy4J4h6VcYEDvKyclM9SlgF0unOc7J+bb5UlHfH1t7L3aydJrndMUcOx9z7HzMsfMxx70YYO+3336NddetKSoqajVQ3hXuv/9+02H8uuuu6/XnjsfiUllZKxKhoVdtOCrRhpi4I2EpLY2K3b5l0zeAiopaiUZjqT4d7ALpO8ceqaiok3SRvvOcPphj52OOnY85dr50nOOcnMxOZ9B1K3K88MILZdGiRWbFuLWGQ9oN/JhjjunSc+oqjKqpqWl1dbutBmebNm2SVatWyZAhQ5psJaVOOeUUOfroo01n8e7QZ9G/M9HojudLZ2XVERmQ45MMj0siEXu+kPQNwK7njs5JpzmurKyQd95ZLcOGDZdQKEfSSTrNc7pijp2POXY+5tj5mONeDLDffvtt01RMt9PaY489Wtz+yiuvyP7772/2o07QQPzmm29u8zk1gNb0cg2Yk2lquNZYt9UwTVMkJ02a1OTYunXrTCdx7UrevKYbXReLxSUWj0tRjp9fH2ARWh6zbdtWMwIAAMDGAbauGBcWFsrnn39uLs1lZmbK119/bS5d2VpHG5TpVlvnn39+47GVK1eKz+eTYcOGmeslJSUSDodlt912M9cHDBhgLslKS0vNqF3OE/dD91XVR81WSrmZ6VXnCVhZfn6BjB//3/dKAAAA2DTAfu2113r/TETMSvSECRNMg7RRo0bJxo0bZebMmeZYIkVcG5qtWbNGNmzYsEvOAS3VhmOyd78M8Xvp3AsAAAAAbelxxBSLxWTLli1mH+yeGjp0qNxzzz1mH+2zzz5bbrrpJhkzZozZ3xqpEY3FzX5l+UEfUwBYSHHxNnnoofvNCAAAAGvodntsXcXW/bA//vhjiUajsnjxYjnyyCPNqrM2Qbvxxhvl5JNP7vLz6mPae9yjjz7aqVRzVrh7R3V9VEIZbgkFSA8HrER3ajjssGF9tmMDAAAAdtEK9gsvvCDTpk2Tb3/722Z1OdG1W2kzssMPP9zcB84IsItCfvF6Oq6hB9B3srKCMmzYMWYEAACAjQPs+fPnyxlnnGFqpcePH9/i9hEjRsh7773XG+eHFIpE4+JxuyQvyD7ggNU0NITlm282mREAAAA2DrC/+OILE0S3JRAISHFxcU/OCxbpHp4d8JAeDlhQWVmp/OlPT5kRAAAANg6wQ6GQlJeXt3m71mUXFRX15LxgAbUNUekf8plVbADWkp9fKBMmXGRGAAAA2DjAHjlypDzxxBNmP+rmNm3aZBqe6X1gXw3RmHhdpIcDVuX1es1e2DoCAADAxgH29OnTzQq21mE//PDD4nK5ZNmyZTJr1iyzrVZGRoZMnTq1988Wfaa6PiY5mR4JZdA9HLCiqqpK+cc/XjcjAAAAbBxgDxgwQJ599lk54ogj5JFHHjFdxDXQfvrpp+XEE0+UJUuWSP/+/Xv/bNG36eE5fnGTHg5YkmYQffXVl61mEgEAACA1XPHkPba6qaSkRGKxmBQUFIjb3a2Y3ZKq6yLy2ntb067JVzgSk4raqBzx7aDkZNo//dTrdUt+flBKS6slEoml+nSwCzDH6YF5dj7m2PmYY+djjp0vHee4oCAoHk/n4txeiZ40sIazuoeb9PA0+2IBAAAAAHqiUwH2hRde2K0nX7RoUbceh9Sqb4jLvkU+U1sPwJq2by+Wl19+TkaPPkMKC/ul+nQAAADQ2Rpsn88nfr+/8VJZWSnr169vcixxqaqqkvfee880OoP91DfExO91Sa4DUsMBJwsEAnLAAQebEQAAANbQqShqwYIFTa7/7ne/kyOPPFJuuOGGFvfVhjvjxo2T888/v/fOEn2muj5qgutghnNq6QEnCgazZfjw41N9GgAAAEjSrSjq//7v/0wH8dboKvZ5550n8+fP785TI8XqIjEpyiE9HLC6hoYG2bZtixkBAABg4wBbu4ZrKnhb8vPzTQo57KWuISYBn1tyM2luBlhdWVmJPP30YjMCAADAxgH2kCFD5KmnnpL6+vpWb1+2bBmdxW2aHp6X6ZUsP+nhgNXl5RXI+PHnmxEAAADW0K1OVtdee63pLD5mzBiZMGGC7LPPPqYR2jfffCMvvfSSrFq1Sn7961/3/tlilwpHY1KY7aV7OGAD+p5bVDQg1acBAACAngbYgwcPlscff1xuvfVWue222yQejzfett9++8ntt99ugm/YRzgSE5/bLSG6hwO2UF1dJevX/0sGDz7MNDwDAABA6nV7L6aDDjpIFi5cKOXl5fLll1+Kx+OR3XffndRwm6oJxyQUcEuQ9HDAFurq6uSjjz6Q/fY7kAAbAADAInq82XFubq4MHTq0d84GKVMbjsrA/Exxu13MAmADhYX95Cc/+VmqTwMAAABJ6GYFiUTj4nG7JDerx9+3AAAAAEDaIsCG1ISjkpXhluwMtucC7KKkZLs88cQjZgQAAIA1EGDD1F8XBn3i9ZAeDtiF3++Xvfb6thkBAABgDeQEp7mYdoCPxyUvyF8FwE6ys0Ny/PEnpfo0AAAAkIQV7DRXG45JVoZHcgKkhwN2EolEpLS0xIwAAACwBgLsNFddH5X8oFf8Xv4qAHZSWqo12AvNCAAAAGsgqkpj8XhcorG45NM9HLCdvLx8OfPMc80IAAAAa6DwNo3VR+IS8HkklEl6OGA3Pp9fdt/9W6k+DQAAACRhBTvN08NzMz2S5SfABuympqZa3nlnjRkBAABgDQTYaaw+EpPCbJIYADuqqamRf/3rHTMCAADAGoiu0lQ4EhO/xy2hTP4KAHbUr1+RTJp0aapPAwAAAElYwU5TNeGYhAJuCfr5KwAAAAAAvYHoKk3VhqNSmO0Tt9uV6lMB0A26B/bTTy82IwAAAKyBADsNRaJx8bhdksv2XIBteb1eKSrqb0YAAABYA5/M0lBNOCpZGW7JzqB7OGBXoVCOnHTS91J9GgAAAEjCCnYaqg3HpDDoE6+H9HDArqLRqFRVVZoRAAAA1kCAnWbi8bjE4iK5dA8HbK2kpFgWLZpvRgAAAFgDAXaaqY/EJeBzSzDA1AN2lpubJz/60TgzAgAAwBqowU7D+uvsgEcyfQTYgJ35/Rmy1157p/o0AAAAkIQoK83UN2j9tVdcLuqvATurqamR999fa0YAAABYAwF2GonF4mbf61CAxAXA7mpqquSf/1xpRgAAAFgDkVYaqQnHTGp4MIPvVQC769evv0yZckWqTwMAAABJiLTSSG1DTPKyPOL3Mu0AAAAA0NuItNJIJKoBti/VpwGgF5SVlcpzzy0xIwAAAKyBADtNhCMx8XncpoM4APtzu90SDGabEQAAANZADXaaqA3HJCvDLUE/H8YBJ8jJyZXvfW90qk8DAAAASYi20qj+Wrfn0i7iAOwvFotJXV2tGQEAAGANBNhpIB6P638llEnCAuAU27dvk4ceut+MAAAAsAYC7DRQ1xCTDJ9HsjOovwacIhTKldNOO92MAAAAsAaWNNOk/jon0yuZ1F8DjhEIBGTQoP1TfRoAAABIwgp2GqiPxKQwm+9SACepra2V//f/1pkRAAAA1kCA7XDRWFw8bhfbcwEOU1VVIa+/vsyMAAAAsAaWNdMgPVxTw4PUXwOOUlQ0QKZO/UWqTwMAAABJWMF2uJpwVPKyvOLzsD0XAAAAAOxKBNhpkCKuATYAZykvL5U///lPZgQAAIA1EGA7WDgSE7/XzfZcgCO5xOPRrffITgEAALAKljYdrCYck6DfLVlszwU4Tm5unvzgB2NSfRoAAABIwgq2g9U1xKQg2ytuNytcgNPE43GJRiNmBAAAgDUQYDuU+dAdF8nOIEkBcKLi4q0yb95dZgQAAIA1EGA7VDgSF7/XJVkZTDHgRKFQjpx66igzAgAAwBpY3nRwerjuf53pI8AGnCgQyJQDDzwk1acBAACAJERfTq6/DlJ/DThVXV2tfPzxh2YEAACANRBgO5S2PcoO6BY+AJyosrJCli172YwAAACwBlLEHbr/tc/jkmAGATbgVIWFRTJ58uU798IGAACAFRBgO1BtmPprwOncbre5AAAAwDr4dObQ+uv8LOqvAScrLy+Tv/3tRTMCAADAGgiwHSgWj0uI+mvA8Xvdh8PhHXveAwAAwBJIEXdg/bXf66b+GnC4vLx8Of30s1J9GgAAAEjCCrYT97/2uSTLz9QCAAAAQF8iCnNggJ2X5RO325XqUwGwC23btkXuv/8OMwIAAMAaCLAdJhqLS04m2/YATpedHZKRI081IwAAAKyBGmwHaYjq/tduyWL/a8DxMjOz5NBDh6b6NAAAAJCEFWyH7X8d8FN/DaSD+vo6+fzzT80IAAAAayDATnG9tHb97s3ny8/yiYf6a8DxKirK5S9/ed6MAAAAsAZSxFOotDoiGgsPyPX3yvNRfw2kj4KCfvLTn14ifn9Gqk8FAAAAOxFgp0g8HheXKy5xEYnF4+J29azrdyQaF6/WX7M9F5AWPB6PqcMGAACAdZAiniIN0fiOhmR+j6md7qnahpgEzP7XdBAH0oGmhr/66l9JEQcAALAQAuyUBtguyQ54pKY3AuxwVPKyvOL1sP81kA6i0aiUl5eZEQAAANZAingKA2xN5+6X7ZMt5eEeP180HpfcTKYTSBf5+QUybtx5qT4NAAAAJGEFO0W0e3h2hkdCAY9keN1S3xDrWf21yyVZGUwnAAAAAKQKEVmK6IqzBsTBnZeepInr9lwBv1uC1F8DaaO4eKvMn3+PGQEAAGANBNgp4oq7xO91i8vlksJsn9Q1RHvU4Cw300P9NZBGsrKCcvTRx5kRAAAA1kDRbgpoSrfHLZLh3dGQLCfTKx63y+xjrWOXny+mATZTCaQTDawPP3xYqk8DAAAAVl7BXrFihYwbN06GDBkiI0aMkDvuuEMikUi7j3n99ddl8uTJcsIJJ8hhhx0mP/zhD2XRokUSi/W8O/eu0BCNic/rNrXXSjuJZ/rd3dquKxbbsYd2JunhQFoJh+tl48YvzQgAAABrsFSAvX79epk2bZqMHDlSlixZItdff70sXbpU5syZ0+7jXnzxRdl3331l9uzZ8sQTT8iECRPMYx588EHpS7pVlq5Od6aDuN+rKeI7Vqt1u66CoE9qwl1PE6+LxEygrh3JAaQP3aLrxReXmhEAAADWYKm84gULFphV6KuuuspcP/jgg80erzNmzJCpU6dKdnZ2q4+75ZZbxO/3N14/5JBDZNu2bSZInzJlSp+df3FVg2T5Paamuj3hSFzysjym/jpBr3+1XSQejzc53pH6hrgEA27J8BFgA+mkoKBQLrjgYgkGqcEGAACwCktFZatXrzYBdjJdza6vr5e1a9e2+bjk4DphwIABsmXLlh6dj4a5Whfd2VRtXUnW7bc6oqvcwYym321omnjA55b6SOf+fwn1kZjkZ3q69BgA9ufxeCUnJ9eMAAAAsAbLfDKrqqqS7du3y8CBA5sc11XrvLw8+eqrr7r0fBqQa9p4T+hCsoa7Ho+rU9tu6SpyfTQubrc+tu3H6PMFAx7x7qzBVjlet+QFPVJeGzW3dfoc3SI5QV+T50Lz37e7yQjnScc5rqyskLffXiNHHXWMhEI5kg7ScZ7TDXPsfMyx8zHHzscc2yTArq6uNmNWVlaL2zQFUgPwzvroo4/kL3/5i6nh7gmvxy2BrAzJycno8L7V9VHxZMTMSrY/Q5uWtR4kx+JxyY66pX+/bMlvlko+KOqRdRsrJScn0Knz09XygrhH9ugfkhBdxDuUk5PZqd8r7Cud5jgSqZFt2zZLZqZX8vPTK008neY5XTHHzsccOx9z7HzMscUD7N5SWVkpV155pXznO9+Rc889t0fPpcFwZWWdVHg6TvuuqI2YLba0o3dxdb3kZrX+q61viEk4HJXa6lopbQg3/f/VR6S+NizbS2Om8VlHKmsjZqW8vqZOInVd394rnb5l0zeAiopaiUat2VkePZOOc+z1Zsk551xg/lxauuMLSqdLx3lON8yx8zHHzsccO186zrH+vJ3NoLNMgJ1o1FNTU9Pq6nZbDc6S1dbWmqZmPp/PbO/l1lztntZgR2MS7URn8HBDXHIyd3Tz3ljdINkZra9g14VjpvBdb400q9cOeF2i2eFVtRGzN3ZHqutjMiDHJ/FYXCKdrBVPZzqXzX/ncBbmOD0wz87HHDsfc+x8zLHzMcets0whmwbQBQUFsmnTpibHNTW8rKxM9txzz3Yfr0G4BtcaZC9cuLBTAXln6AqxdvbuiAa4mT63aVbWXmO0cDRmOo3randzekw7kNd0cj/sSCwmuTQ4A9JScfE2WbhwnhkBAABgDZYJsNXw4cPljTfeaHJs5cqVZkV62LBh5npJSYls3ry5yX3Ky8vl4osvNlt6LVq0yATqvUH7lHndrk6tDusqtzY5y/S7TaDc1n7YDZG4ZGe0/WvPyfKKS+ImPb09Wuut6eht1XoDcLbMzEwZPPgwMwIAAMAaLJMiriZNmiQTJkyQuXPnyqhRo2Tjxo0yc+ZMcyyxIq311WvWrJENGzY0Pu6CCy4Qj8cjs2bNMvtf6yUhPz+/2wG3S1zi9bhESwt8HcWxLr2Py6xi79huKyZeT8sHadgcaCcoDmXodl0ek0qe1UaaudLn123BNCUdQPoJBrPlqKOOTfVpAAAAwKoB9tChQ+Wee+6RO++8Ux588EGzPdfYsWNNUN1R13B15plntrjtsssuk8svv7zb56S17GY1umnD75b0Ll6X+L1uU39dVhORYLMA2aSa63Ze3rYbkukqeF6WR7ZWRtoNsOsadC9tt7k/gPTT0BCW7duLpbCwn/h8/lSfDgAAAKwWYKuTTz7ZXNry6KOPtjiWvJrdmzRFXFeJO6qJNuna7h0r2Eo7iG+tbGhxP001162/9Dnb0y/kk/+UhXc+r6vNFeyB+R1F/QCcqqysVJ599kkZP/58KSoakOrTAQAAgNVqsK1I073bqqduEji7XeaiskyNdbxFczStv/abVe72t9TKD/okJ9MjlXXRdu/X3go3AGfLzy+Q88670IwAAACwBgLsDmiNc0dNznasTLsaV7C1DtvvcUs40vRxYW2EtjONvD36PLvn+qU63HqAHdb6brfLdCMHkJ68Xp8UFPQzIwAAAKyBALsDPhMMdxBgR+OmVjs5wA74XCaNO1lDNC7BQOey8gtDPtMhvKa+ZZBdH4lLwK8dxJk+IF1VVVXKqlUrzAgAAABrIELrgM+kfbs6XMHWzt+6Z7b5pbpdkpvlk7qGpgF2JBqTYCeDYl2dHhDytZomXt8Qk5xA63tpA0gP4XC9fPHFZ2YEAACANRBgd0A7g2vc3N6+1LqCravWybIDHmmeWa4BeEcNzpIV5fhEY2hNCU/WEItJbqbl+tMB6EOaHv7jH//UjAAAALAGAuwOaNq31jtH26nD1tg70GxlWmu3NThOPE5Hve73dX7VOTfTI4XZPqmo/e8qtnYW1/25NX0cAAAAAGAdBNidCLA1Fbu9TuJ6S6KDeHKAravVms6dqL/Weu6urGDrivduuX6JxGImsFZa162dzam/BtJbSUmxPPbYAjMCAADAGgiwO2C23/JonXV799LguWmArZ3Cdbuuup0P1DRvXXT272yE1ll5Qa+pt67YWYtd1xA3wbsG2QDSl9+fIYMGHWBGAAAAWANRWke/IPeOuum2VrB1Zdnt+u8WXcnys7xm7+vGDuJ+j3m+rjBbduVlSE04avbV1hXsvCzSw4F0l50dkuOOG2FGAAAAWAMBdidovXNbe2GbPbDdrQfY2gk80RtNA2xtfNYdBdle81w14R2r4cEMAmwg3UUiDVJcvM2MAAAAsAYC7E7QDuFtNTnTlW3vzkZozWmKuKaO7+gCHpeMbqZ1my27cnxSVh0x/x+9DiC9lZaWyJIlj5oRAAAA1kCA3QkaQLfFrGB7Wl/B1jrpDJ9r537YXduiq7l+IZ/4dz4fDc4A5OUVyFln/diMAAAAsAYC7E4wwXO87QA74HWbjt/Nafdx3a+6si5qmpv5mzVC6wqzZVfQa0Z9XgDpzefzyYABu5kRAAAA1kCA3ckA2+0WiSUKqpuliLfX0Vs7gGt6uaaK92QFWwP4vYsC8q18OgYDEKmurpI1a1aZEQAAANZAgN3DvbC1NDvgd7fbIE1rrzUIby/VvDNCAY/kZHp79BwAnKGurlY++GC9GQEAAGANRGudDLC1uZimg/vbuL0tume1rlxn0/kbQC8qLCySiROn8DsFAACwEFawOxtge3akg7e0o8lZW3T1OifgNoE2AAAAAMC5iPo6Wf8c8LXcC1trq92u1juIJ/t2v4AUZtOICEDvKSnZLk8+uciMAAAAsAYC7C7thS0tAuy2tuhKpnXT3d0DGwBa4/P55VvfGmhGAAAAWAM12J2kAXK0WYq4poxrbbbPQ/AMoG+FQiEZMeIUfu0AAAAWQmTYSWaVutlCdWTnCnYPdt8CgG6JRCJSXl5qRgAAAFgDoWEn6T7W2tCseYCt229pjTYA9KXS0u2yePHDZgQAAIA1EGB3YQVbG5rFkhqdaYq41mYDQF/Lzc2XsWPHmxEAAADWQA12d/bCdu9YsdZYm+ZlAFLB79cmZ3vyywcAALAQll87SYNrrbduuhd2vMMO4gCwK9TUVMu7775lRgAAAFgDAXZXVrA1wG62FzYBNoBUqKmpkbVr15gRAAAA1kCKeCdpIzNtaFbWEGncA1trsjXoBoC+1q9fkVx88TR+8QAAABbCCnYXBLzuxhRxswe2R/fAJsAGAAAAABBgd0nA7zaNzRIr2FqX7fPwHQWAvldaWiJLlz5hRgAAAFgD0WEX7Fit3rmCrQG26Sy+q6YGANrm9XqloKDQjAAAALAGPpl1McBOJIRrinh2wGNqswGgr4VCOXLyyd/nFw8AAGAhrL92NcB2uUx6uK5gZ/r49QFIjWg0KtXVVWYEAACANRAhdoFJCd+5F7bWYmtXcQBIhZKSYnnkkT+aEQAAANZAhNgF2tBMG5vt2At7Rw02AKRCTk6ejB59hhkBAABgDdRgdzFFXC/hSNz0OmOLLgCpkpGRIXvvvS8TAAAAYCGsYHeRpoWHo3Fxmy26WMEGkBq1tTWybt17ZgQAAIA1EGB3I8Cua4g11mMDQCpUVVXJP/6xwowAAACwBlLEuxFga5MzrcXWmmwASIWiov5yySVX8ssHAACwECLELtK0cK/nv/XYAAAAAAAQYHeDz+syq9cZbNEFIIXKykrlhReeMSMAAACsgRXsLtLgWi+ZBNgAUsjtdksgkGlGAAAAWAM12F2kddd+r9vUYgNAquTk5Mr3v/9DJgAAAMBCiBK7SOuuM3zUXwNIrVgsJuFwvRkBAABgDQTYXaRbcwUzPNRgA0ip7du3yYMP3mtGAAAAWAMp4t1wwACte6SDOIDUCYU0RfxHZgQAAIA1EGB3A8E1gFQLBAKy334HpPo0AAAAkIQUcQCwobq6Wvnww3+bEQAAANZAgA0ANlRZWSGvvfY3MwIAAMAaSBEHABvq16+/XHLJVeJy0Q8CAADAKgiwAcCGNLAmuAYAALAWUsQBwIbKy8vk5ZefMyMAAACsgQAbAAAAAIBeQIo4ANhQbm6ejB59RqpPAwAAAElYwQYAG4rH4xKLxcwIAAAAayDABgAbKi7eKg88MNeMAAAAsAYCbACwoVAoR0455TQzAgAAwBqowQYAGwoEMuWggw5N9WkAAAAgCSvYAGBDdXV18sknH5kRAAAA1kCADQA2VFlZLn//+5/NCAAAAGsgRRwAbKiwsEh+9rNp4vX6Un0qAAAA2IkAGwBsyO12i9+fkerTAAAAQBJSxAHAhioqNEX8JTMCAADAGgiwAcCGYrGY1NXVmhEAAADWQIo4ANhQXl6+jBlzdqpPAwAAAElYwQYAAAAAoBcQYAOADW3btlUeeOBOMwIAAMAaCLABwIays7Pl+ONPNCMAAACsgRpsALChzMwsGTLk8FSfBgAAAJKwgg0ANlRfXy9ffPGZGQEAAGANBNgAYEMVFWXy8svPmREAAADWQIo4ANhQQUE/mThxigQCmak+FQAAAOxEgA0ANuTxeCQYpMEZAACAlZAiDgA2VFlZIcuX/92MAAAAsAYCbACwoUgkIiUl280IAAAAayBFHABsKD+/QM46a0KqTwMAAABJWMEGAAAAAKAXEGADgA0VF2+TBQvuNSMAAACsgQAbAGwoKytLjjzyGDMCAADAGqjBBgAbysoKyhFHHJ3q0wAAAEASVrABwIbC4bBs2rTRjAAAALAGAmwAsKHy8lJ5/vmnzQgAAABrIEUcAGwoP79Qzj//pxIMhlJ9KgAAANiJABsAbMjr9Upubn6qTwMAAABWTxFfsWKFjBs3ToYMGSIjRoyQO+64QyKRSIePe+6552T06NEyePBgOfXUU+Xhhx/uk/MFgL5WWVkpb7zxmhkBAABgDZYLsNevXy/Tpk2TkSNHypIlS+T666+XpUuXypw5c9p93Kuvvmrue+6558ozzzxjnuOuu+6SxYsX99m5A0BfaWjQJmdfmxEAAADWYLkU8QULFsgJJ5wgV111lbl+8MEHSzQalRkzZsjUqVMlOzu71cfNmzfPBNcTJ0401w866CApLi42x88///w+/RkAYFcrKCiU8867kF80AACAhVhuBXv16tUmwE6mq9n19fWydu3aVh9TU1Mj69ata/VxW7ZskU8//XSXnjMAAAAAAJZawa6qqpLt27fLwIEDmxzXVeu8vDz56quvWn3cxo0bJRaLtXhc4ro+btCgQV0+H7fbJQUFwS4/Dtbicu0Yc3MzJR5P9dlgV0jHOY7FolJdXS3BYFDcbo+kg3Sc53TDHDsfc+x8zLHzpeMcu907f2i7Bdj6YVFlZWW1uE0/RGoA3prE8eaP08Dc5XK1+biO6GM9ns7/MmFtbrflEjbQy9Jpjj0et/niMR2l0zynK+bY+Zhj52OOnY85bp2jP6XE43FzAQAAAAAgrQJsXaVO1FS3trrdVoOzxPHmj0tcb+txAAAAAAA4MsDWQLigoEA2bdrU5LimeJeVlcmee+7Z6uO01lpTFJo/LnF9r7322oVnDQAAAACAxQJsNXz4cHnjjTeaHFu5cqX4fD4ZNmyYuV5SUiKbN29usvI9ePDgFo/T60VFRbLvvvv20dkDAAAAANKVpZqcqUmTJsmECRNk7ty5MmrUKNMhfObMmeZYItX7yiuvlDVr1siGDRsaHzdlyhSZPn26Wa3WIP2DDz6Qe++9V6644grTrAwAAAAAgF3JFbdgF7Dly5fLnXfeKZ988onpkjt27FgTVPv9fnP7T37ykxYBtlq6dKnMnz9fvv76a+nfv78JyidPnpyinwIAAAAAkE4sGWADAAAAAGA3lqvBBgAAAADAjgiwAQAAAADoBQTYAAAAAAD0AgJsAAAAAAB6AQE2AAAAAAC9gAAbAAAAAIBeQIANR1i7dq1cccUVcuKJJ8rQoUPltNNOk7vvvlvq6+sb71NVVSU33nijHHvssXLYYYfJj3/8Y1m3bl1Kzxs988ADD8iBBx4ob7/9duMx5tkZ3nrrLbnkkkvM6/XQQw+VX/7yl423Mcf29/LLL8tZZ50lRxxxhIwYMUKuueYa+eabbxpv37Ztm0yfPl2OOuooc5/JkyfLl19+mdJzRscWLFggF110Uau3dfZ1+9xzz8no0aNl8ODBcuqpp8rDDz/Mr94Gc9zQ0GA+d51xxhkybNgwGT58uPz0pz+V999/v8V9V6xYIePGjZMhQ4aY1/8dd9whkUikj34C9OR1nKy4uFhOOumkVu+7Is3nmAAbjrBs2TLJycmR//mf/5ElS5aYD+aPP/64zJo1q/E+M2bMMIHY7NmzZfHixbLPPvvIpEmTZMuWLSk9d3R/zv/4xz+2OM48299jjz1mAqpDDjnE/KP89NNPy/jx4xtvZ47tTd+jf/WrX8kPfvADM9e///3v5dNPPzUf0mpqaiQWi8nPf/5z2bx5s9x3330mwPJ4PObDem1tbapPH62oq6uT1atXtxsMd+Z1++qrr8r1118v5557rjzzzDMybdo0ueuuu8z9Ye051temfnGm79WPPPKIee3m5+fLxIkT5auvvmq83/r16828jhw50rwX6HwvXbpU5syZ04c/Dbr7Ok4Ih8NmHsvLy1vctp45FokDDlBfX9/i2FNPPRUfPHhwvKGhIf7JJ5/EDzjggPi6desab4/FYvHRo0fH58yZ08dni5764IMP4sccc0z8pZdeMvP61ltvmePMszPmdsiQIfH333+/1duZY/sbN25c/IYbbmhy7Ouvvzav5ZUrV8ZXrFgRP+SQQ+Jbt25tvL22tta85vV9Hdajc5e4TJw4sduv2/Hjx8dvvvnmJo+dN29efMSIEbv4J0BP5zgajZrPW8kikUj8xBNPjN9zzz2Nx6666qr4z3/+8yb303/L9X2/srKSibDwHCe7+uqr49OmTYtfc801Le57FXMcZwUbjuD3+1scGzBggPmGrbS01Hwjp9+kaspZgsvlkhNOOEHefPPNPj5b9MT27dtl6tSp8pvf/MaUAyRjnu1PVz7Gjh1r0spawxzbn8/nM+/LybKysszo9XrNHGvpR1FRUePtgUBAjj76aN6vLerFF180F03p7u7rVrMXNGVcjyXTlU5d5dYsB1h3jt1ut3n9JtPME30dJ2cp6N+F1uZYS/q03A/WneMEzR78+OOP5fbbbzev4+ZWM8ekiMO59I06NzdXCgsLTXrSt771rRb3GThwIHV9NpJISfrRj34kY8aMaXE782x/b7zxhgmmLr/8cvMh7Pjjj5dLL7208cM1c2x/P/vZz+SVV16RmTNnSklJiTn26KOPyuGHH26CaJ1jfW9ujvdr6zrggAPMRUu1WtOZ1+3GjRtNeUDzuU9cT04zhvXmuDWVlZXyySefyL777ttYh69fkjef4+zsbMnLy2OObTDH+t69aNEiUwKQ+GI0GXO8Q9OvmgCH0AY5WoOtdVz6raq+4Ft7I9A39erq6pScI7ruhhtuMF+YaPOj1jDP9qbzp69d/XJMGyBpIKYB2EMPPSRnn322/OlPf2KOHeC73/2ueS3PmzfP1NkedNBBpvZv4cKFje/Xu+22W4vH8X5tX515b9b7qOb30/voKlnidtiHvsZ17k4//XRzPTHXrf1dCAaDzLHFffjhhyZ7UBvM7rHHHq3ehznegQAbjlzl1ABMvyHV1c72xOPxPjsv9Myzzz4rH3zwgTz55JOtpiS1h3m2h8QH6Ouuu850j0447rjjTFCmDbHawhzbxwsvvCB/+9vfzEXTgrXR0YMPPig333yz3HbbbW0+jjl2ns7Mqd6Hubcf7SKtX47qa1q/GIf9aXme/vusOzugfQTYcJRoNCpXX321STXTD22ZmZmN34DrB7nm9Jh+awrr27Rpk6n5SQ68Ei688EKTfqh1Q8yz/XsplJWVNTmuKeO67cvnn38u+++/P3NsYxUVFfLb3/5W7r//fjOvetFdH3SLxTPPPFO+853vtLlSzfu1fXXm32C9T+JY8/sk3w7r0yykq666ygRkidVrlZjr1v4u6GueObb+57Bf//rX5pKgZR1Kd/3QnXv0y3CV7nNMgA3H0P31dOsX3R5A6/m0yVnCnnvuafbWbO3NYq+99urjM0V3aMqw7m+ebOvWrXLxxRebN3XdV3XVqlXMs41pEyT9ANbafsfaAEeDMV7L9vbZZ5+ZD179+/dvcvzggw+WgoICs2euzrE2yWmO92v76szrVrPOtERAj+kXacn3UfxbbQ/vvPOOTJkyxXzxfdlllzW5TYMrfZ0n5jQ5e0m/WNW/J7AubYDW3Ny5c01dvW6Tq6U9zPEOdBGHY9LCr7jiClMforXXzf8hPvbYY03XWg2+EzTlbOXKlTJ8+PAUnDG6SlPMEg04Epe999678YOZ7qnKPNtboquw1lonvhVPfPh69913TQMs5tjeEl98/vOf/2xyXPe81np7zUTR9+QNGzaYevzkL1jWrFnD+7VNdeZ1q1+uaZdxbXSYTK9rJ+pEoyxYl3aE194ZunLdVq8Une/mc6x/D3R3Ac1UgnU1/wyWaIim2aLJzdGGM8esYMMZNLjWD2R/+MMfTApK8nYeoVBIBg0aJKeccopce+21pn5EV8q0lle/RdWVUTgD82x/2jfhnHPOkV/+8pdy0UUXmdVO7VaqX7DocW2Ow2vZvnbffXezC8Ds2bPNF6P6pYkG13fddZe5TedYP6TpCuaVV15pPqRr6YA2S9Kxtd0DYI3Uf9XQ0GBKtRLXEx+4O/verCufOuf6Jbl+SNe+G/fee6/5N76rvTfQt3OsX4Lq/E2cOFFOOumkFtuq6ZxqED1p0iSZMGGCWfkcNWqUKenTHQX0WLqkD9t1jjtrEnMsLt0QfJfMEtCH9B/u5ilHCVrXd+utt5pVMB2XLVsmtbW1pl5kxowZZmsY2NPXX39t6q4XL17cWJvNPNvfe++9Z74s0z1xNahKfDDX1ELFHNubBtb6mtXGhfrhWudVMxc0oE40Q9J9c7X0Q1e2NJvhyCOPNN1rWcW0Jt23vDX6xXdCZ1+3S5culfnz55v3dy0l0MBr8uTJu/xnQM/mWF/P+uVJW1599dXG7bmWL18ud955p9nCS7fnGjt2rHn9J/pwwLqv4+b0NaxfkuouEMmWp/kcE2ADAAAAANALqMEGAAAAAKAXEGADAAAAANALCLABAAAAAOgFBNgAAAAAAPQCAmwAAAAAAHoBATYAAAAAAL2AABsAAAAAgF5AgA0AAHa5aDQqH374oYTDYX7bAADHIsAGACBNPPvss3LKKaeYPxcXF7d73yeeeEIGDx4shx12mKxevbrd+zY0NMjcuXMlEomY+x511FHmeGlpqcyaNcv8ecOGDTJ27FgpKSnptZ8HAACrIcAGAMDmLrroIjnwwAMbL4899lib943FYvLFF1/I97//fdm+fXur91m+fLnMnDlTbrnlFrn66qtl6tSp8q9//avN5/T5fPLqq6/Km2++2eT4X//6V9m6dav58zvvvCMDBgyQ3Xbbrds/JwAAVudN9QkAAIDu27x5s1xwwQXmkhAIBNq8fzwel7333ltOP/10+eijj+S4445rcvtzzz0nN954o7nofRIr1BMnTpSbb75ZxowZ0+rzaiBeVFQk5eXljccKCgpk0qRJjUH78ccfz1QDABzNFdd/aQEAgC1t3LhR3nrrrSbHsrKy5LPPPpM777yz3cfm5eU1pn/X19fL7bffLs8//7zMnj1bTj755Cb3XbZsmVxzzTUmzVuD6ezs7MbbLrnkEvn000/NnysqKqSsrEz23HNPcblc5tj06dPNYzVQd7vd4vF4TDq51+uVRYsWyZFHHtlrvw8AAFKJABsAAJtbv359k9rmQw45RPr169fifho8a9D92muvNTn+3nvvyW9+8xuz4qw10xoct+bjjz+Wa6+91tRWX3fddfK9732vMYhWS5cuNY+vrq6Wo48+Wn73u9/JoEGD5KGHHpLbbrtNXn/9ddl9993NfU866SS56aab5MQTT+zF3wQAAKlFijgAADanAfO///3vxutTpkwxddHJHbv1ut/vN928E6qqqkxgrfXRl156qQmGv/vd77b7/3ryySdl1apVJtCeN2+eua6p5hpAh0Ihk0b+29/+1tRtX3755TJjxgxZuHChWVV/9913TYCt56D131qTDQCAkxBgAwBgc1dccUWLYxrcrlmzxqRra+CrK8rnnHOOSc1O0DRvTQW/9dZbJTMzs7Hbd0eOOOIImTBhgrz//vuyadMm+f3vf28C6hEjRph09YyMDFPb/eKLL5ogfvz48SYtfO3atTJ69Gj5/PPPTS34Pvvs08u/CQAAUosUcQAAbE5roP/xj380Xp8zZ45J39Zg+tBDD5VnnnlGhgwZYlLBtVlZex3Be0IDbv1/XHjhhS1uW7dunVkl19X2xYsXy0svvWTOCwAAJ2EFGwAAm3vggQc6dT+ty66rqzM10sFgsMltur1XZx1zzDHy6KOPtjj+9NNPS21tbauP0T21NU385ZdfNivbo0aN6vT/DwAAuyDABgAgTege1FqHrZ3HDzrooBa3z58/X0aOHNnuc/zhD39osgJeWVlp0sx1f20N3DUd/aijjjK3abCtqeGXXXaZqQvXrcS0U7l2Gr/vvvt2wU8IAEBquVP8/wcAAD2k6d9aF62BrXYQ15Xk1ui2WPvvv3+Thmg9pQH122+/Lb/4xS/k8MMPN3/WizZC09vuvfdeE1yrcePGmeBa09c12AcAwGkIsAEAcABdfdbAtrWV6WTHHnusrFixwvx57ty5jX/uCe1W/uCDD8oPf/jDJlt2aRO1448/vvHYkiVLTHMzrRf/z3/+0+P/LwAAVkOADQCAQ2kHb7V69WpZsGCBCaZPP/1002hsy5YtZv/s3qDp4dop/OGHHzZp4IsWLZLZs2fL//7v/4rbveOjxt///ne5++67zZZduuKuK97J24gBAOAE1GADAOAAzz//vNmWa9u2beb6mWeeKV988YVZ0f7www9N6vhee+1ltsbS7bS087jervtZJ0yePLnTTc6SBQIBmTZtmpx22mmm3nrWrFnSv3//xnN5/PHHzT7Z2t1ctwvbb7/9zJZh+hhNIde6cAAAnIAAGwAAB/D5fGb/6YsuukiGDh1qgl2tgXa5XC3ue9NNN8nFF18se++9twwaNKhLTc7uuususx1XMg2o33zzTSktLZXzzjvPXF555RVZuXKlvPPOO7J8+XJ57LHHzMq1ys/PNyvZup3Xu+++K8OHD++13wMAAKnEPtgAANicBrYaTGsTs1TQlfM99thDBg4c2OI27VheVFRkVrmb0y3DWjsOAIBdEWADAAAAANALaHIGAAAAAEAvIMAGAAAAAKAXEGADAAAAANALCLABAAAAAOgFBNgAAAAAAPQCAmwAAAAAAHoBATYAAAAAAL2AABsAAAAAgF5AgA0AAAAAQC8gwAYAAAAAQHru/wOFgWKrqO875QAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1000x1200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 折れ線グラフ: 累積勝率の推移 + 信頼区間帯 (横軸 = 試合数)\n",
    "# ログファイルの最後の行 = ゲームの最終着手\n",
    "# 「自石X, 相石Y」と手番の情報が含まれるので，そこから勝敗を確定判定できる\n",
    "\n",
    "EXTRAPOLATE_TO = 150  # 外挿先の試合数 (実データを超えた先の信頼区間を計算する上限)\n",
    "\n",
    "def get_game_num(filepath):\n",
    "    \"\"\"ファイル名から試合番号を取得する．例: eval_depth2_vs_depth1_5_*.jsonl -> 5\"\"\"\n",
    "    m = re.search(r'_(\\d+)_\\d{8}_\\d{6}\\.jsonl$', os.path.basename(filepath))\n",
    "    return int(m.group(1)) if m else 0\n",
    "\n",
    "\n",
    "def parse_last_line(filepath, depth2_is_black):\n",
    "    \"\"\"\n",
    "    ログファイルの最後の行を読み，depth2 視点での勝敗を返す．\n",
    "\n",
    "    ログは 1 ゲーム = 1 ファイルで，黒・白両方の全着手が時系列で記録されている．\n",
    "    最後の行 = ゲームの最終着手のリクエスト/レスポンス．\n",
    "    content に含まれる「自石X, 相石Y」と手番から勝敗を確定判定する．\n",
    "    \"\"\"\n",
    "    with open(filepath, 'r', encoding='utf-8') as f:\n",
    "        lines = [l for l in f if l.strip()]  # 空行を除いた行のリスト\n",
    "    if not lines:\n",
    "        return None\n",
    "\n",
    "    last = json.loads(lines[-1])\n",
    "    content       = last['request']['messages'][0]['content']\n",
    "    # レスポンスから LLM が選んだ手の座標を取得 (例: \"a7\")\n",
    "    response_move = last['response']['message']['content'].strip()\n",
    "\n",
    "    # 最後に打ったのが黒か白かを判定\n",
    "    is_black_turn = '黒の手番' in content\n",
    "\n",
    "    # 選んだ手に対応するシミュレーション結果行から「自石X, 相石Y」を抽出\n",
    "    # 例: \"- a7: 自石35, 相石29, 相手の次の手...\"\n",
    "    m = re.search(rf'- {re.escape(response_move)}: 自石(\\d+), 相石(\\d+)', content)\n",
    "    if not m:\n",
    "        return None\n",
    "    my_stones, opp_stones = int(m.group(1)), int(m.group(2))\n",
    "\n",
    "    # 最後に打った側の勝敗を判定 (自石 > 相石 なら勝ち)\n",
    "    if   my_stones > opp_stones: last_player_result = 'W'\n",
    "    elif my_stones < opp_stones: last_player_result = 'L'\n",
    "    else:                        last_player_result = 'D'\n",
    "\n",
    "    # depth2 視点に変換\n",
    "    # 最後に打ったプレイヤーが depth2 かどうかで結果の反転を判断する\n",
    "    depth2_was_last = (depth2_is_black == is_black_turn)\n",
    "    if depth2_was_last:\n",
    "        return last_player_result\n",
    "    else:\n",
    "        return 'L' if last_player_result == 'W' else ('W' if last_player_result == 'L' else 'D')\n",
    "\n",
    "\n",
    "# ログファイルを試合番号順に取得 (depth2 が黒番・白番それぞれ)\n",
    "d2_black_files = sorted(glob.glob(\"../log/eval_depth2_vs_depth1_*.jsonl\"), key=get_game_num)\n",
    "d2_white_files = sorted(glob.glob(\"../log/eval_depth1_vs_depth2_*.jsonl\"), key=get_game_num)\n",
    "\n",
    "d2_black_results = [parse_last_line(f, depth2_is_black=True)  for f in d2_black_files]\n",
    "d2_white_results = [parse_last_line(f, depth2_is_black=False) for f in d2_white_files]\n",
    "\n",
    "\n",
    "def actual_ci_series(results):\n",
    "    \"\"\"実データ部分 (1~n 試合) の累積勝率と Wilson 信頼区間を返す．\"\"\"\n",
    "    wins     = np.array([1 if r == 'W' else 0 for r in results if r is not None])\n",
    "    cum_wins = np.cumsum(wins)\n",
    "    ns       = np.arange(1, len(wins) + 1)\n",
    "    rates    = cum_wins / ns\n",
    "    los = np.array([wilson_ci(k, n)[0] for k, n in zip(cum_wins, ns)])\n",
    "    his = np.array([wilson_ci(k, n)[1] for k, n in zip(cum_wins, ns)])\n",
    "    return ns, rates, los, his\n",
    "\n",
    "\n",
    "def extrapolated_ci_series(results, extrapolate_to):\n",
    "    \"\"\"\n",
    "    外挿部分 (実データ終了〜extrapolate_to 試合) の信頼区間を返す．\n",
    "\n",
    "    「現在の観測勝率が今後も続くと仮定したら，試合数が増えるほど\n",
    "    信頼区間がどう狭まるか」を示す．実データの根拠はないため仮定の外挿．\n",
    "    \"\"\"\n",
    "    wins     = np.array([1 if r == 'W' else 0 for r in results if r is not None])\n",
    "    cum_wins = np.cumsum(wins)\n",
    "    final_n  = len(wins)\n",
    "    final_p  = cum_wins[-1] / final_n  # 最終観測勝率を固定仮定値として使用\n",
    "\n",
    "    ext_ns  = np.arange(final_n, extrapolate_to + 1)\n",
    "    # n 試合時点で勝利数が final_p * n であるとして信頼区間を計算\n",
    "    ext_los = np.array([wilson_ci(round(final_p * n), n)[0] for n in ext_ns])\n",
    "    ext_his = np.array([wilson_ci(round(final_p * n), n)[1] for n in ext_ns])\n",
    "    return ext_ns, np.full(len(ext_ns), final_p), ext_los, ext_his\n",
    "\n",
    "\n",
    "fig, axes = plt.subplots(2, 1, figsize=(10, 12), sharex=True)\n",
    "\n",
    "for ax, results, title in [\n",
    "    (axes[0], d2_black_results, 'depth2 黒番'),\n",
    "    (axes[1], d2_white_results, 'depth2 白番'),\n",
    "]:\n",
    "    ns, rates, los, his                = actual_ci_series(results)\n",
    "    ext_ns, ext_rate, ext_los, ext_his = extrapolated_ci_series(results, EXTRAPOLATE_TO)\n",
    "\n",
    "    # 実データ部分: 実線 + 塗りつぶし帯\n",
    "    ax.plot(ns, rates, linewidth=2, color='#1565C0', label='累積勝率 (実データ)')\n",
    "    ax.fill_between(ns, los, his, alpha=0.2, color='#1565C0', label='95%信頼区間 (実データ)')\n",
    "\n",
    "    # 外挿部分: 点線 + 薄い帯 (仮定)\n",
    "    ax.plot(ext_ns, ext_rate, linewidth=1.5, color='#1565C0', linestyle='--',\n",
    "            label=f'外挿 (勝率{rates[-1]:.1%}固定仮定)')\n",
    "    ax.fill_between(ext_ns, ext_los, ext_his, alpha=0.08, color='#1565C0',\n",
    "                    label='95%信頼区間 (外挿)')\n",
    "\n",
    "    # 実データと外挿の境界線\n",
    "    ax.axvline(ns[-1], color='gray', linestyle=':', linewidth=1)\n",
    "    ax.axhline(0.5, color='red', linestyle='--', linewidth=1, label='50%')\n",
    "\n",
    "    ax.set_ylabel('depth2 の累積勝率')\n",
    "    ax.set_title(f'累積勝率の推移 - {title}\\n最終: {rates[-1]:.1%} ({ns[-1]}試合)')\n",
    "    ax.set_ylim(0, 1)\n",
    "    ax.set_xlim(1, EXTRAPOLATE_TO)\n",
    "    ax.legend(fontsize=8)\n",
    "\n",
    "# 横軸ラベルは一番下のパネルのみに表示\n",
    "axes[-1].set_xlabel('試合数')\n",
    "\n",
    "plt.suptitle('2手先情報あり(depth2) vs なし(depth1) — 累積勝率と信頼区間', y=1.01)\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"../img/cumulative_winrate_depth2.png\", bbox_inches='tight')\n",
    "plt.show()\n",
    "plt.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5be0a46a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "analysis",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.14.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}

次回は

前述のとおり，「LLMは与えられた手からランダムに選んでいるだけなのか？」について検証していきたいと思います．
そのうえで，LLMを使用することによるメリットがあるのか，それとも根本的なところから見直すべきなのかについて検討していきます．

余談

前回作成したオセロAIとの対戦を友人にやってもらいました．
その結果がこちら．

  a b c d e f g h
1 W W W W W W W W
2 B B B W W B W W
3 B W W B W W B W
4 B W W W B W B W
5 B W B W W B B W
6 B W W W W W W W
7 B W B B B W W W
8 W W W W W W W W
白の手番
置ける位置:

白 はパスします

=== 終局 ===
黒(HUMAN): 19 石
白(LLM): 45 石
→ 白の勝ち！

ボロ負けやんけ