今回の目標
前回の記事で，「LLMは与えられた手からランダムに選んでいるだけで，一手先二手先の情報は参考にしていないのでは？」という疑いが出てきました．
今回の記事ではこの疑念について検証して，LLMを使う方針にそもそも無理があったのか，あるいは方法を変えることで何とかなるのかについて検討していきます．
ここから本題
LLM VS ランダム VS トップ
LLMには，そのターンで取れる有効手一覧を渡していますが，全ての有効手を渡しているわけではありません．
以下のようにフィルタリングして削っています．
- X位置とC位置は渡さない(それ以外に有効手がない場合は渡しています)
- ターンごとにスコアを算出し，そのスコアの上位半分のみを渡す
スコアの算出方法についておさらいすると以下のような感じです．
- 序盤(~19手目): 相手の取れる手数の-1倍(相手の取れる手数が少ないほど高スコア)
- 中盤(20~49手目): 安定石の増加数がそのままスコアになる(安定石がたくさん増えるほど高スコア)
- 終盤(50~60手目): 自分の石の数がそのままスコアになる(単純に自分の石の数が増えるほど高スコア)
LLMはこの中から，いま最も有効と思われる手を一つだけ選んで返しています．
しかしこの「一つだけ選ぶ」というのが，ただ当てずっぽうで選んでいるだけなのか，ちゃんと根拠あって選んでいるのかはわかりません．
という事でこの憲章では，上記アルゴリズムで合法手を絞り込んだうえで，
- その中からLLMが選ぶ
- その中からランダムで選ぶ
- その中からスコアトップのものを使う
を対戦させて，どれが強いかを確かめます．
もし大して勝率が変わらなかった場合は，残念ながらLLMによる選択は大して意味がなくて，絞り込みが強かっただけということになってしまいますね．
実際に対戦させてみました．その結果がこちら．
[llm_simV2_m3 vs random_m3] 完了 黒 22勝72敗6分600 (16%) | 経過 13m05s 残り約 65m25s
[llm_simV2_m3 vs top_m3] 完了 黒 15勝84敗1分600 (33%) | 経過 25m06s 残り約 50m12s
[random_m3 vs llm_simV2_m3] 完了 黒 70勝30敗0分600 (50%) | 経過 37m36s 残り約 37m36s
[random_m3 vs top_m3] 完了 黒 23勝73敗4分600 (66%) | 経過 38m00s 残り約 19m00s
[top_m3 vs llm_simV2_m3] 完了 黒 80勝17敗3分600 (83%) | 経過 50m03s 残り約 10m00s
[top_m3 vs random_m3] 完了 黒 59勝38敗3分600 (100%) | 経過 50m46s 残り約 0m00s
LLM弱すぎるだろ．
かなり圧倒的な差がついていそうですね．
ちゃんとグラフ化してみましょう．
まず，合法手からの選択方法についてざっと勝率を描画したのがこちら．
LLMが最弱ですね．
いつも通りヒートマップも作ってみましょう．
今回の場合はあまり必要ないようにも思いますが．
まあ，はい．
上のグラフから受ける印象そのままって感じのグラフですね．
それぞれの選択方法について，対戦相手ごとに信頼区間も出してグラフ化してみましょう．
試合数が多いので信頼区間も結構小さいですね．
疑う余地なく「LLMは弱い」が可視化されてしまいました．
しかし，ランダムに選択するよりも弱いのは驚きですね．
勝率が変わらないどころか弱くなっているというのは，完全に余計なことをしてしまっている状態．
さらに，実行結果の標準出力を見れば分かりますが，LLMを使用しない同士の対戦は100試合あっても1分足らずで終わっているんですよね．
LLMを使用すると，ランダムに選ぶよりも弱くなるだけでなく，対戦時間も非常に膨大なものになってしまう．
いいところが一つもないじゃないですか．
グラフを見てみよう
ここで少し疑問がわきました．
実は，LLMに渡している有効手は「スコアが高い順」になっています．
LLMはこの中で末尾にあるもの，つまりスコアが低いものを優先して選んでいる可能性があるのでは？
という事でそれを実際に可視化して確かめてみました．
実行ログが残っているからこそできることですね．
ログには「LLMに渡した合法手一覧」と「その中からLLMが実際に何を選んだか」が記録されています．
それを使ってグラフにしてもらいました．
必ず末尾を選んでいるというわけではないですが，高確率で後ろの方の手を選んでいるようです．
対策として考えられるのは，「合法手の渡し方をスコア昇順にする」ということですが，それで末尾から選んでも別にLLMが強いってことにはならない…．
合法手をランダムに渡して試してみてもいいですが，正直今までの実験結果からあまり期待は持てないだろうなと思ってしまいます．
今までの実験全部を揺らがすような事実が発覚してしまいました．
正直，今後の方針が全く想像つきません．
フルバージョン
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,
}
/** 探索深さ．[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 プレイヤーが使用するモデル名を返す．
* @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; }
/**
* 候補手の選別戦略（デフォルト: 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);
}
/**
* ビットボードを 2D ASCII グリッド形式 + 手番 + 置ける位置のテキストに変換する(人間対戦用)．
* @param board ビットボード
* @param turn 手番(false=黒, true=白)
* @return 盤面テキスト
*/
public String boardToText(long[] board, boolean turn) {
StringBuilder sb = new StringBuilder();
// 2D ASCII グリッドで盤面を描画
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");
}
// 手番と置ける位置を付加
sb.append(this.turnAndValidMoves(board, turn));
return sb.toString();
}
/**
* 手番と置ける位置のリストをテキストで返す(LLM 入力用)．
* @param board ビットボード
* @param turn 手番(false=黒, true=白)
* @return 手番と置ける位置のテキスト
*/
public String turnAndValidMoves(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();
}
// ── 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.turnAndValidMoves(board, turn) + "\n\n"
+ this.buildSimResults(board, turn, moveCandidates);
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);
}
/**
* topHalfMoves で絞った候補手の先頭(スコア最高安全手)を選んで着手する．
* llm() と同一のフィルタ・フェーズ判定を用いつつ，候補からの選択を「先頭固定」に置き換えた版．
* LLM 判断・ランダム選択・トップ選択の 3 プレイヤー比較実験用メソッド．
* フェーズ判定ロジックは llm() と同一のため，変更時は両方を更新すること．
* @param board 今の盤面
* @param turn 手番(false=黒, true=白)
*/
public void topFromTopHalf(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[]> candidates = this.topHalfMoves(board, turn, scoreFunc);
// 候補が空の場合は全合法手からのランダムにフォールバック（通常は発生しない）
if (candidates.isEmpty()) {
this.random(board, turn);
return;
}
// 絞り込んだ候補の先頭(スコア最高安全手)で着手
int[] rc = candidates.get(0);
this.place(rc[0], rc[1], board, turn);
}
/**
* topHalfMoves で絞った候補手の中からランダムに 1 手選んで着手する．
* llm() と同一のフィルタ・フェーズ判定を用いつつ，候補からの選択のみをランダムに置き換えた版．
* LLM 判断とランダム選択の勝率比較実験用メソッド．
* フェーズ判定ロジックは llm() と同一のため，変更時は両方を更新すること．
* @param board 今の盤面
* @param turn 手番(false=黒, true=白)
*/
public void randomFromTopHalf(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[]> candidates = this.topHalfMoves(board, turn, scoreFunc);
// 候補が空の場合は全合法手からのランダムにフォールバック（通常は発生しない）
if (candidates.isEmpty()) {
this.random(board, turn);
return;
}
// 絞り込んだ候補からランダムに 1 手選んで着手
int idx = OseroBase.rand.nextInt(candidates.size());
int[] rc = candidates.get(idx);
this.place(rc[0], rc[1], 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) {
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);
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();
}
// ── シミュレーション補助 ────────────────────────────────────
/**
* シミュレーション結果を格納するデータクラス．
*/
protected static class SimulateResult {
/** 着手側の石数 */
int myStones;
/** 相手の石数 */
int opponentStones;
/** 着手後に相手が置ける位置一覧 */
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 before = countStableStones(board, turn);
long[] boardCopy = {board[0], board[1]};
place(row, col, boardCopy, turn);
SimulateResult res = new SimulateResult();
res.myStones = countStones(boardCopy, turn);
res.opponentStones = countStones(boardCopy, !turn);
res.stableGained = countStableStones(boardCopy, turn) - before;
// 着手後に相手が置ける位置
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;
}
// ── 探索フレームワーク ────────────────────────────────────
/** 盤面評価用インターフェース */
@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;
/**
* M3_strategic フィルタで絞った候補手の中から，
* LLM が選ぶ場合・ランダムに選ぶ場合・トップを選ぶ場合の 3 プレイヤーを総当たりで対戦させ，
* 勝率を比較する実験クラス．
* フィルタの寄与と LLM 判断の寄与を分離することを目的とする．
*
* 使い方:
* javac *.java
* java Evaluator
*/
public class Evaluator extends Osero {
private static final int GAMES_PER_MATCHUP = 100;
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;
};
/** プレイヤー設定(識別名・LLM 使用有無・着手関数)を保持する設定クラス． */
private static class PlayerConfig {
final String name;
final boolean isLlm;
final BiConsumer<long[], Boolean> player;
/**
* @param name 設定識別子(CSV・ログ出力に使用)
* @param isLlm true のとき LLM API を使用する
* @param player 着手関数
*/
PlayerConfig(String name, boolean isLlm, BiConsumer<long[], Boolean> player) {
this.name = name; this.isLlm = isLlm; this.player = player;
}
}
/**
* 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));
}
/**
* 評価のエントリーポイント．
* LLM 選択 (llm_simV2_m3) とランダム選択 (random_m3) を黒白入替で対戦させ，
* 結果を CSV に保存する．候補手フィルタは M3_strategic 固定，
* LLM 側は V2_noFlip + depth1 + 盤面表現 OMIT．
* @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_llm_vs_random_vs_top_" + startTs + ".csv";
// プレイヤー設定: LLM 選択・ランダム選択・トップ選択 の 3 種類
PlayerConfig[] playerConfigs = {
new PlayerConfig("llm_simV2_m3", true, (board, turn) -> {
ev.setMoveFilter(MOVE_FILTER);
ev.llm(board, turn);
}),
new PlayerConfig("random_m3", false, (board, turn) -> {
ev.setMoveFilter(MOVE_FILTER);
ev.randomFromTopHalf(board, turn);
}),
new PlayerConfig("top_m3", false, (board, turn) -> {
ev.setMoveFilter(MOVE_FILTER);
ev.topFromTopHalf(board, turn);
})
};
// 自分同士を除いた総当たり: n × (n-1) × GAMES_PER_MATCHUP ゲーム
int n = playerConfigs.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_player,white_player,model,date,games_per_matchup,black_win,black_lose,black_draw");
// 外ループ = 黒設定，内ループ = 白設定（自分同士はスキップ）
for (PlayerConfig blackCfg : playerConfigs) {
for (PlayerConfig whiteCfg : playerConfigs) {
if (blackCfg == whiteCfg) continue;
int blackWin = 0, blackLose = 0, blackDraw = 0;
// LLM が黒・白いずれかに含まれる場合のみログを開く
boolean needLog = blackCfg.isLlm || whiteCfg.isLlm;
for (int i = 0; i < GAMES_PER_MATCHUP; i++) {
String ts = LocalDateTime.now()
.format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
if (needLog) {
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(blackCfg.player, whiteCfg.player);
if (r == 1) blackWin++;
else if (r == -1) blackLose++;
else blackDraw++;
}
ev.resetLogWriter();
} else {
int r = ev.runGame(blackCfg.player, whiteCfg.player);
if (r == 1) blackWin++;
else if (r == -1) blackLose++;
else blackDraw++;
}
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": "code",
"execution_count": 3,
"id": "f44a5d10",
"metadata": {},
"outputs": [],
"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)"
]
},
{
"cell_type": "markdown",
"id": "13abf2f6",
"metadata": {},
"source": [
"# 合法手からLLMがランダムに選択する方法が有効かどうかを確かめる"
]
},
{
"cell_type": "markdown",
"id": "9d452dd9",
"metadata": {},
"source": [
"全ての合法手からスコアが高い上位半分に絞り込んだうえで，その中から実際に打つ手を以下のように選択したうえで対戦してもらう\n",
"- LLMに選んでもらう\n",
"- ランダムに選ぶ\n",
"- スコアがトップのものを選ぶ\n",
"\n",
"スコアは以下のように計算する．\n",
"- 序盤(~19手目): 相手の取れる手数が少ないほど高スコア\n",
"- 中盤(20~49手目): 安定石の増加数が多いほど高スコア\n",
"- 終盤(50~60手目): 自分の石の数が増えるほど高スコア\n",
"\n",
"なお，X位置とC位置は渡さない(それ以外に合法手がない場合は除く)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"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_player</th>\n",
" <th>white_player</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>llm_simV2_m3</td>\n",
" <td>random_m3</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-17</td>\n",
" <td>100</td>\n",
" <td>22</td>\n",
" <td>72</td>\n",
" <td>6</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>llm_simV2_m3</td>\n",
" <td>top_m3</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-17</td>\n",
" <td>100</td>\n",
" <td>15</td>\n",
" <td>84</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>random_m3</td>\n",
" <td>llm_simV2_m3</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-17</td>\n",
" <td>100</td>\n",
" <td>70</td>\n",
" <td>30</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>random_m3</td>\n",
" <td>top_m3</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-17</td>\n",
" <td>100</td>\n",
" <td>23</td>\n",
" <td>73</td>\n",
" <td>4</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>top_m3</td>\n",
" <td>llm_simV2_m3</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-17</td>\n",
" <td>100</td>\n",
" <td>80</td>\n",
" <td>17</td>\n",
" <td>3</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>top_m3</td>\n",
" <td>random_m3</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-17</td>\n",
" <td>100</td>\n",
" <td>59</td>\n",
" <td>38</td>\n",
" <td>3</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" black_player white_player model date \\\n",
"0 llm_simV2_m3 random_m3 gemma4-osero-e2b 2026-05-17 \n",
"1 llm_simV2_m3 top_m3 gemma4-osero-e2b 2026-05-17 \n",
"2 random_m3 llm_simV2_m3 gemma4-osero-e2b 2026-05-17 \n",
"3 random_m3 top_m3 gemma4-osero-e2b 2026-05-17 \n",
"4 top_m3 llm_simV2_m3 gemma4-osero-e2b 2026-05-17 \n",
"5 top_m3 random_m3 gemma4-osero-e2b 2026-05-17 \n",
"\n",
" games_per_matchup black_win black_lose black_draw \n",
"0 100 22 72 6 \n",
"1 100 15 84 1 \n",
"2 100 70 30 0 \n",
"3 100 23 73 4 \n",
"4 100 80 17 3 \n",
"5 100 59 38 3 "
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"df = pd.read_csv(\"../csv/compare_llm_vs_random_vs_top_20260517_104741.csv\")\n",
"df"
]
},
{
"cell_type": "code",
"execution_count": 5,
"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>player</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>top_m3</td>\n",
" <td>296</td>\n",
" <td>93</td>\n",
" <td>11</td>\n",
" <td>400</td>\n",
" <td>0.7400</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>random_m3</td>\n",
" <td>203</td>\n",
" <td>184</td>\n",
" <td>13</td>\n",
" <td>400</td>\n",
" <td>0.5075</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>llm_simV2_m3</td>\n",
" <td>84</td>\n",
" <td>306</td>\n",
" <td>10</td>\n",
" <td>400</td>\n",
" <td>0.2100</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" player wins losses draws total win_rate\n",
"0 top_m3 296 93 11 400 0.7400\n",
"1 random_m3 203 184 13 400 0.5075\n",
"2 llm_simV2_m3 84 306 10 400 0.2100"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 各設定の総合勝率を集計（黒として + 白として）\n",
"players = df['black_player'].unique()\n",
"records = []\n",
"for player in players:\n",
" b = df[df['black_player'] == player] # この設定が黒の試合\n",
" w = df[df['white_player'] == player] # この設定が白の試合\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({'player': player, '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['player'], 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.85)\n",
"ax.set_ylabel('勝率')\n",
"ax.set_title('合法手からの選択方法ごとの勝率(黒白合算，400試合)')\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": 8,
"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_player', columns='white_player', values='black_win_rate')\n",
"\n",
"# 行・列を設定名の定義順に並べる\n",
"order = ['llm_simV2_m3', 'random_m3', 'top_m3']\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": "code",
"execution_count": 12,
"id": "521a4330",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 1000x600 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# wilson法を使用して，信頼区間も一緒に表示する\n",
"# プレイヤーごとに対戦相手 2 種類の勝率と 95% 信頼区間を計算（黒白合算，各 n=200）\n",
"players = ['llm_simV2_m3', 'random_m3', 'top_m3']\n",
"records = []\n",
"for focal in players:\n",
" for opp in players:\n",
" if focal == opp:\n",
" continue\n",
" # focal が黒, opp が白 の対戦\n",
" b = df[(df['black_player'] == focal) & (df['white_player'] == opp)].iloc[0]\n",
" # focal が白, opp が黒 の対戦\n",
" w = df[(df['black_player'] == opp) & (df['white_player'] == focal)].iloc[0]\n",
" wins = int(b['black_win']) + int(w['black_lose'])\n",
" losses = int(b['black_lose']) + int(w['black_win'])\n",
" draws = int(b['black_draw']) + int(w['black_draw'])\n",
" # 引分は分母から除外して二項分布として扱う\n",
" n_eff = wins + losses\n",
" p_hat = wins / n_eff if n_eff > 0 else 0\n",
" ci_lo, ci_hi = wilson_ci(wins, n_eff)\n",
" records.append({\n",
" 'focal': focal, 'opp': opp,\n",
" 'wins': wins, 'losses': losses, 'draws': draws,\n",
" 'n_eff': n_eff, 'p_hat': p_hat,\n",
" 'ci_lo': ci_lo, 'ci_hi': ci_hi,\n",
" })\n",
"\n",
"pair_summary = pd.DataFrame(records)\n",
"\n",
"# グループ化棒グラフ: 3 プレイヤー × 対戦相手 2 種 = 6 本\n",
"fig, ax = plt.subplots(figsize=(10, 6))\n",
"x = np.arange(len(players))\n",
"width = 0.35\n",
"\n",
"# 対戦相手ごとに色を変える\n",
"color_map = {'llm_simV2_m3': '#1976D2', 'random_m3': '#FFA726', 'top_m3': '#43A047'}\n",
"\n",
"# 各プレイヤー位置に対戦相手 2 種の棒を並べる\n",
"for j in range(2):\n",
" means, errs_lo, errs_hi, bar_colors, opp_labels = [], [], [], [], []\n",
" for focal in players:\n",
" opps = [p for p in players if p != focal]\n",
" opp = opps[j]\n",
" row = pair_summary[(pair_summary['focal'] == focal) & (pair_summary['opp'] == opp)].iloc[0]\n",
" means.append(row['p_hat'])\n",
" errs_lo.append(row['p_hat'] - row['ci_lo'])\n",
" errs_hi.append(row['ci_hi'] - row['p_hat'])\n",
" bar_colors.append(color_map[opp])\n",
" opp_labels.append(opp)\n",
" offset = (j - 0.5) * width\n",
" bars = ax.bar(x + offset, means, width,\n",
" yerr=[errs_lo, errs_hi], capsize=5,\n",
" color=bar_colors, alpha=0.85,\n",
" edgecolor='black', linewidth=0.5)\n",
" # 値ラベル（勝率と対戦相手名）\n",
" for bar, m, eh, opp in zip(bars, means, errs_hi, opp_labels):\n",
" ax.text(bar.get_x() + bar.get_width() / 2,\n",
" bar.get_height() + eh + 0.015,\n",
" f'{m:.1%}\\nvs {opp}',\n",
" ha='center', va='bottom', fontsize=8)\n",
"\n",
"# 50% ラインで優劣を一目で判定\n",
"ax.axhline(0.5, color='gray', linestyle='--', linewidth=1)\n",
"ax.set_xticks(x)\n",
"ax.set_xticklabels(players)\n",
"ax.set_ylim(0, 1.1)\n",
"ax.set_ylabel('勝率（引分は分母から除外）')\n",
"ax.set_title('対戦相手ごとの勝率と 95% 信頼区間（黒白合算，各 n=200）')\n",
"\n",
"# 凡例（色 = 対戦相手）\n",
"legend_patches = [mpatches.Patch(color=color_map[p], alpha=0.85, label=f'vs {p}')\n",
" for p in players]\n",
"ax.legend(handles=legend_patches, loc='upper right')\n",
"\n",
"plt.tight_layout()\n",
"plt.savefig(\"../img/winning_rate_pair_ci.png\")\n",
"plt.show()\n",
"plt.close()"
]
},
{
"cell_type": "markdown",
"id": "74f0321a",
"metadata": {},
"source": [
"# LLMが有効手のうちどれを選択しているかをグラフ化する"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "5be0a46a",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"総選択数: 11057\n",
"リスト長 n の出現分布:\n",
"n\n",
"1 2197\n",
"2 3428\n",
"3 2823\n",
"4 1748\n",
"5 648\n",
"6 173\n",
"7 35\n",
"8 5\n",
"Name: count, dtype: int64\n"
]
}
],
"source": [
"# LLM の選択順位を集計：各リクエストから候補リストと選んだ手を抽出\n",
"# 目的：LLM への入力「## 全合法手のシミュレーション結果」のリスト中で\n",
"# LLM がリストの何番目（0=先頭=スコア最高）を選んだかを，\n",
"# 局面ごとに記録する．Random 選択であれば順位は一様分布になるはずで，\n",
"# LLM の選択が偏っていれば順位ヒストグラムが一様から逸脱するはず．\n",
"\n",
"# 対象 jsonl 集合：LLM が黒または白で出場した 4 種類のマッチアップ\n",
"# ../log/eval_<黒>_vs_<白>_<試合番号>_<タイムスタンプ>.jsonl\n",
"# 1 ファイル = 1 ゲーム，1 行 = 1 リクエスト/レスポンスペア（= LLM の 1 手番）\n",
"log_files = (\n",
" glob.glob(\"../log/eval_llm_simV2_m3_vs_random_m3_*.jsonl\") + # LLM 黒 × Random 白\n",
" glob.glob(\"../log/eval_llm_simV2_m3_vs_top_m3_*.jsonl\") + # LLM 黒 × Top 白\n",
" glob.glob(\"../log/eval_random_m3_vs_llm_simV2_m3_*.jsonl\") + # Random 黒 × LLM 白\n",
" glob.glob(\"../log/eval_top_m3_vs_llm_simV2_m3_*.jsonl\") # Top 黒 × LLM 白\n",
")\n",
"\n",
"# 結果蓄積用リスト．要素は (リスト長 n, 選択順位 rank) のタプル\n",
"# 例: (5, 2) = 候補 5 個のうち 3 番目（0-indexed で 2）を選んだ\n",
"selections = []\n",
"\n",
"for filepath in log_files:\n",
" # 1 行 = 1 リクエスト．ゲーム途中の全 LLM 手番が時系列で並ぶ\n",
" with open(filepath, 'r', encoding='utf-8') as f:\n",
" for line in f:\n",
" line = line.strip()\n",
" if not line:\n",
" continue\n",
" # JSON パース．構造: {\"request\": {...}, \"response\": {...}}\n",
" obj = json.loads(line)\n",
"\n",
" # ── 入力（候補リスト）の抽出 ───────────────────────\n",
" # request.messages[0].content に LLM 入力テキストが入っている\n",
" content = obj['request']['messages'][0]['content']\n",
"\n",
" # 「## 全合法手のシミュレーション結果」以降を切り出す\n",
" # （その前には「黒の手番」「置ける位置: ...」が入っている）\n",
" sim_start = content.find('## 全合法手のシミュレーション結果')\n",
" if sim_start < 0:\n",
" continue # 見出しがなければスキップ（フォーマット異常）\n",
" sim_block = content[sim_start:]\n",
"\n",
" # 候補リストの各行は「- <座標>: 自石X, 相石Y, ...」形式\n",
" # 正規表現で座標部分（a1〜h8）だけを順序を保ったまま抽出\n",
" candidates = []\n",
" for ln in sim_block.split('\\n'):\n",
" m = re.match(r'-\\s+([a-h][1-8]):', ln)\n",
" if m:\n",
" candidates.append(m.group(1))\n",
" if not candidates:\n",
" continue # 候補ゼロ件はスキップ（パス局面など）\n",
" n = len(candidates) # LLM に渡された候補数\n",
"\n",
" # ── 出力（LLM が選んだ手）の抽出 ───────────────────\n",
" # response.message.content に LLM の応答テキストが入っている\n",
" resp_content = obj['response']['message']['content']\n",
"\n",
" # 思考用 <think>...</think> ブロックがある場合は除外して\n",
" # 「実際の回答部分」だけを対象にする\n",
" think_end = resp_content.find('</think>')\n",
" move_area = resp_content[think_end + 8:] if think_end >= 0 else resp_content\n",
"\n",
" # 回答テキスト中の座標パターン a1〜h8 を全部拾う\n",
" # （LLM は説明文中に複数の座標を書くことがあるため）\n",
" mv_matches = re.findall(r'[a-h][1-8]', move_area)\n",
"\n",
" # 最終回答は「テキスト末尾に近い候補内の座標」と仮定．\n",
" # 末尾から探して，候補リストに含まれる最初の座標を採用する．\n",
" # （実装は Osero.java の llm() の座標抽出と同じロジック）\n",
" picked = None\n",
" for mv in reversed(mv_matches):\n",
" if mv in candidates:\n",
" picked = mv\n",
" break\n",
" if picked is None:\n",
" continue # 候補内座標が応答に無い場合 = フォールバックなど → スキップ\n",
"\n",
" # 選んだ手のリスト内順位（0-indexed）を記録\n",
" rank = candidates.index(picked)\n",
" selections.append((n, rank))\n",
"\n",
"# pandas DataFrame 化．以降の集計・プロットで使う\n",
"sel_df = pd.DataFrame(selections, columns=['n', 'rank'])\n",
"\n",
"# ── 集計結果の確認 ──────────────────────────────────────\n",
"# 総レコード数 = ログから抽出できた LLM の有効選択回数\n",
"print(f\"総選択数: {len(sel_df)}\")\n",
"# リスト長 n ごとに何回出現したかの分布\n",
"# （短い候補リストは終盤や角強制追加時に発生しやすい）\n",
"print(\"リスト長 n の出現分布:\")\n",
"print(sel_df['n'].value_counts().sort_index())"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "79597027",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAABJ8AAAOGCAYAAABC8zGsAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qd4U1UbB/A36YK2FFr23iAioCKiyBCUT8SBDAeiiICIbBAQECcyFGSJbJThZCgIiooDBAcgOBiC7D26oIxSur7nf8qtuclNmqRNm/H/PU9oybi5uUnvyXnPe95jyszMzBQiIiIiIiIiIiIPMHtio0RERERERERERAw+ERERERERERGRRzHziYiIiIiIiIiIPIbBJyIiIiIiIiIi8hgGn4iIiIiIiIiIyGMYfCIiIiIiIiIiIo9h8ImIiIiIiIiIiDyGwSciIiLyOZmZmeLtrl69KseOHVM/KbBdvnxZXYiIiAIVg09EREQ+Lj4+Pk+3FxsbK7Vr15Yvv/wyV9tZvHix3HfffTbXv/nmm/Lkk0/matsTJ06U1q1bS3Jyss1tjRs3lhdffNHlbR4+fFgSExN11504cUK++uort/bx+++/l7vvvlv+/vtvyQ8XLlyQu+66S+655x5JSEjIl+ckW++88476+7E0d+5cuemmm9z+LBEREfm64ILeASIiInLfokWLZNq0afLRRx/Jddddp65766235IcffsjOEEJQBYGQX375Rd57773sx549e1Z69+4tvXr1yvF5Nm/eLF27dnUq4ITgD6SmpmYHh2bNmiW//fab2l/NkSNH5H//+5/D7fXr10/69+9vc/3XX3+tOviFCxeWvIDspB49ekjZsmXlgw8+yL5+48aN8sorr0iRIkWkWbNmLm1z+fLlUrlyZbnlllskP7z00ksquwbPGxMTY3P7N998I5GRkXLHHXfkuK1WrVpJiRIlZOnSpZKfvvvuO+nbt6+88cYb8vDDD7u1DWc+V0ZWr14ttWrVyv5/vXr1HGatderUScaOHevUtgcNGiSnTp2Sl19+WerXry8VKlRwef+IiIh8GYNPRETk07SgyMCBA6VPnz4O7/vZZ5/JyJEjVXCmXbt2OWYvzJgxQwUdEMiJiopyuE1AgMedTiUCNF988YVs2LBB9uzZozKZTCaTFCtWTAWUmjRpova3aNGiNo9FB33lypXy7LPPyooVK1TAYPjw4eoCKSkpqrMLjzzyiLpoBgwY4PK+ItB1ww032Fz/zz//qECRPQiCZWRk6K6rVKmSLito2LBhKvNo/vz52dcFBQXZbOvPP/9UGUmjR4+WvDJz5kw5ffq0CpJZBxgQUEOQ4fPPPzcMdmmfFXuss2DsmTdvnjRv3tyNvRfZtGmTrF27VmWVlS9f3vA+r7/+ulSrVs2p4FNeBCIt4f7uZKPlxrvvviu333670/c3em+7desmTz/9tOH1GmQIDhkyJMe/f7x+vE/I2sPfERERUSBh8ImIiCiHqUzI1jHKvklLS7MJVrhq2bJlMmXKFBXkeuCBB9RPBJPQoUUQaseOHSrogfsgwPbUU0+pwJQmPDxcpk+fLg8++KDq0I4ZM0YmTZqkAmaFChVS90EQC0EcZMQgwBEREaGuR6DHMisHr/X8+fPZU7bw8/jx41KyZMns+yC4ZdTBjouLc/m143XgcuXKFRWcQlADASwEzMBsNktYWJjN4/B+IEMFgYUDBw7Y3I4gF16L0W2lS5dW2T+WkBE2Z84c9dyWmS8QHBwsEyZMkMcee0xlFuHYWuvSpYu0bdtWdx3eK2Qh4Xg7C1lX7kLw68Ybb5SHHnpIPA3BTGenjyEAhM8ypkjmt5CQEMPPjxH8fVj+XWnwWSlTpozN9fhcuAoBbGRA4XO0b98+qVmzpsvbICIi8lUMPhERETlw2223qWAHgj7W2U8IEiED59Zbb5UtW7a4dBwRuELmzrp162TEiBEqwwadXwQ3kIFRo0YNdcEUtp49e6oOPO7/77//yrhx43Tbqlixopp2p3VmEVRCZ3/w4MHq/wjmoLN78eJFFThasGBB9mN3796tMq/wnEuWLNFlZGDqEy7I/PEU7Pf48eNtnhPwetasWaO7Pwp4Y/rY5MmTZe/evfLoo48abhf3wcUaXl+bNm2y/49MMwSKUCvJXuYcgi3IJMN+InPI+n6Y4mY5zQ2fCxxvvI7q1atnBxnxOUIAUAsK5hUchz/++EMdk/yAz4r2uhw5d+6c/Pjjj1K3bl31N5LfnJlOqnn++eddur+7kMGIv3F8DrSMSSIiokDA4BMREZEDzz33nKoF9P7776sghXXWEzKOkDXhSvAJWT6jRo1SU3A+/PDD7FpNWrFvo+l1KNyNrKhnnnlGbr75ZhWsslSnTp3s37E/yJpCvRpkf2zfvl1lRHXu3FkFBBBsQgDk0qVLKqML2SnYBwRVcME+NG3aVAUztILhyEryFGRmWW8fU8SMjikylBCkQwYTMn0QeMHxRH2p0NBQw+1jmiWOGYp/W08VxPQpHDvcxyjzRYP7IQsMwSs8H+oSGUFdHwSpMNWuffv22dcjIIiAVHp6uuS1n376Sb3Pd955p3gT/H0g+wuBHVfh7yu3cjONUYPgstFn392V6/AZxfuE94zBJyIiCiQMPhERETmATCEEEZD9gwCEFhjCVDjUCEKwBgERVyALBtOWkAljGXiCQ4cOqSLVRtCRRscVnWrr4JMlBIxQJBsBJEyjw1S5J554Qlq0aKHqQiFog+l6CEAhu8je83kbZClh/zGtDscJq4chSIFjgro8CBJaQyANmV543yyDT6ivhRpTCBLhWGGKYU4rxOH9R5F2THNEUAKPs5zWhX1BthkCfLjNcioiss4Aj7euLaQF09yFGliYLqhNp/QGqOWFvxmsvOdOjSkES/E3gvcMmWruHB8Eap1lVOC8XLlyKgCKv3UESK2Pb3R0tLijQYMGKjsuKSnJbi05IiIif8PgExERkRPZT+gsYqU4BBeQZaNlPaFotiswBe7tt99Whb8bNmyouw3bxbQ6y4wZawggrV+/Xk6ePClbt27VTcG7//77VT0ZTNXDanDaql/IYNJWoJs9e7baBq5r2bJljvt75swZVd9GKxaO+kbOQoaQUcFwawjWGBXltq6Jg6LfON5YvU+Dfatatao6FkbBJwRmwHLaF1ZUQ7F1BCfwvNb1mhxBMW8ErfAeIrCHrDHNq6++qqa/gTbl0ZrllD8NMtp+//13cRcCWph66S2Q5YVsJ0xFxDFxBz7LqNuFKWoooo6VBhFwxSp8znymYO7cuU4Hvoy2qU3bxGcEGYII4OYF7b1CYJTBJyIiChQMPhERETkRcOjQoYOqiYQMG3RKEZTJaXU9I6iBg2CLUUd2586dakqcZRFwe0WpEXBA/Rht1T50yjGNDrCcO2rKWGbsWE8pw77jOhRTRnFyy4DR/v371e9YlQvPg0CbtuQ8skC0AswIfB08eFC3Oh0CKRoUEnemvpEz0+5QGwqBHaxKZ53R0qhRIzV90Qi2iyyvevXqZV+H4Bvuj8wpsAw+YSoUgnu//vqrzbaGDh2qpjCiBhcy1iyDY1jxDhltyGr566+/ZPXq1bri5QiEIGCFx1tm0OB1YqXD3EAGDeqD5SW83yj47s7jENhDViAy+yxrYblaaw1/cwhAIfD7ySefqILw+FvE32DHjh3V++oIPt/uFAb3NC3zDcFLIiKiQOF9LTIREZGXZj999tlnaoodsoqwqpg72Sa7du1Sq8ehcLU1LNWODn+TJk3sPh7BKXvLwlsGNHDRMp8WLlyYnfmEoACCLwjiWGY+IesKK3EhA0frFGOaH143Al5aMAv7rQWUkI2CQujYZwSQrDkbfEIw7vrrr9ddh0wrLaCC14GaTAhqGB03BJGQgYT7WU8hRPAJwSnLIATqI2mBJ2sIthmtbmYNUxq1YB32DccYgStM07RXD8pTkD2jfS7yAl4TspeMstFyyupDhhCChvgMWwb83IVg5pNPPqkuCAgiEIopcvj84rOJVQhRR0n7rLs77U6DAJflypb4DAMChwgwWmexvfbaay4/h/ZeGdV2IyIi8lcMPhERETkBARjUhMHUOwQv0PF1BwI7RrViEGxBjRsEhhzVksG0PEwR0jKg8gpeE1YwQ70oZPRg2hMCVtrzoHOPIIdlMOn2229XgQpkTiFLxRpqKDmT+ZJT5hNqViFTC8EE1FqyhmwjZLmgzpBl8AmBJBwvZMm4Ehx0Zjqi5XNg31FXCgEXTOnLbzg+WAUwr+zYsUPVrzIK9NmDDCUEbjD9EZ8FZHN17dpV1cdCsDUv4POGCzLgkJWHaZjIUsPfJIJ+KOAP+IxgFUQEjLSgq5YRiOxCZL1ZB2/x2cGqhtbZVHh/AYsNWG4Ln0V3A35Hjx5VP0uVKuXW44mIiHyR6/nUREREAap3794qywI1mdDZdQeyapBVYg1T+dBpfuqppxxmlqBTj6wde7VisCIbMlZw0TJBEATQrkNwS3st2nXIXoIhQ4aoKWhGWUxYGc46OwmdZxT7xrQ7rSaU9b64e5wsYZpar1697K5Gh2NRpUoVFTSx9PPPP+uylHKybds29d7YyzwzqmGFQtjIiHOUreZpKCCPIFtOwRAcD0wdzQmmVoKzq+cdOHBA1WNCAAeZSVjtD58J7XoEfPISPv+Yhom6ZdqKcXhfEOTCRQve4nOhXYfLiBEjVOF37KN2HTL+UNwc2U7Yf+ui4phWqmUBYlVE7YJMOnen9KEOGbL6LKeoEhER+TsGn4iIiJyEQAPqzwwfPtztY3bzzTerQsMI5mhQqwkdadRtQmaHEQR30ElGgMrRtC4Ee/bu3asuqC/UvXt3+fTTT7OvQ5AL9aYwhUm7DtlOjqCDjsCOUS2qZ599VgUZjOoWoTC4syvpIbBmeUlPTxdX3HDDDTZBjo0bN6qpkc7WQ0LABJla1tO3NAjuOJruWFAQGEGtpZ9++inX20JWET4vCLA4E1BD4A0ZgXi/EBDSgpv4HGM7CNaiSL1WvDsvaVl6zsJnEX9DCK7hJ4qhYzU+fN7wOu666y6bxyD7DsFYBDctITNMywLE9Lm6deuq15oTPBfeJ0xZJSIiCiQMPhEREbkAU9Nyk7GAQsoIlCALY/fu3SoIhawesFc/BlOqEORBQWtM97MXFNAKjl++fFlluCCLCdkuyNix7DQjw+Pee+9VdXOMsrCsYToT6jIhOGaUhYJgDerwYGqeBgXZcbFcZc4ebBtTniwvKDDtCgRLcCy1oBVeJ/bb2Sl0CCpi+iBWaQsLCzO8D+pllStXTvIKgnqnTp1yevU2R68dnylnspocwfHCdDK8fmQv2cs0AwRB8VlE5hECTjh+2A9LWIVQC2Rh2hqKrhc0TCfF9DsEyhBwmjdvnqrjhgLyRu8Pgqp4jHXxdfytaTWbkFmHbTkzjW7VqlWqQDwCdkRERIGENZ+IiMgvIMiCoIsRZL6gQLhm7dq1sm/fPsP7NmzY0KWaP+5AHZxhw4ap6XvIlkDGBTKftM4rgkUI3CBz6dtvv1V1hJBlgRo3mMZkbcWKFRIXF6eOAbKQUDvqt99+U4EBZHZYBhFwLBDYQWcZwQpkYb3yyisO9xfbR5AJ2R1GsF84vsjIQuFt1CDasGGDyhTTilbj8dp0PnTktc78I488ol4vpo2hzhOuR3AAj0PdHmchMFapUqXsQBtqD6G+Fl5/TvD6cAxQvNro+AKOL7LEjAJwrsJULgT/NHje3EK9JUylxHtvuXpfTnC8kN2DOkjITsJUtKlTp9oEkjQIVuI9fv/991XwBXWVEJyxB5lkuD+K2eO+mIqJY53bgJur8Fk4efKkCuTiPcaqefj7QBF7rAaJ98C6PhmOCQKjjz/+uO76+Ph4da7BNlyBoBOOLd57BLGJiIgCCYNPRETkF7BKGy5GENyxDD79+OOP6mJvWoyng0/otCLzAvVnMI3LuiM+YcIE1WFHIAZ1ltBxR5DGus4TOtII/KDgNVbiwjQ3dKIffPBBNdUJmSfocKM2jWXmBgIOmPaDqVF4vXv27FHTitChRnBBmxKIxyCgtW7dOlVQ2x7sF7KoMMUPGR2oqYPAGepXaYEvrVg0IPCGfUWwCfWmkDmDmjsoeg49evSQcePGqRXs8FqQJWYUrEAxaBS61qBAtpZ9hUwcBLtQ/wcBOQ2y1rQgH143ggGYnoeC5rhYBhgQeAAcwylTpqjj2K5dO4fvLVZ4QyDRUUF47CeCRBAZGamCdLmFzywCYzhuCKDa2yZeC4JNCALhfcb7hMLwKLSNFeUQQLRX8B77PGrUKPW5wHuLYJd1jSQjCJzOmDFDBXuQCYXP2aRJkySv4e8fWX2HDh1S/0dRchwPBHLxnNgPBCiROYjP3Jo1a9R+4bOLC2pc9ezZU9XQwjRTvOc4HggUYdorLlj9DsFjQIaeZXASAS5k3mEfjKbgYaofMvKGDh2a56+diIjI25kyLXPxiYiIqMBhehcykhA8QnDCHqzyhcAQgjha7RsEX5DZhA4wpkahQ4wOs1FBcEBwCEEVBLCWL1+uOuuAoBcCTggO7d+/36kl5REMQxAJmS3owKOjrQWUrCHItXjxYrUyGuoyGcE+IVukdevW2dchaIJgIqaFIYiiFcd2FrLNENybNm2amnKFgA0CDFqGlgbBPzwHAi0IWiCohKCBZcDBFZhyhswfBHucCdi4A8EyBFkRYPvggw+yp4VZH1MUoMfUOgQc8T4jKIhj6uizpgXkENRDINSdqaf4DCLIgwCevfccWX54P3DsjVZQdATv2erVq1VwEcE3TJHEBcFe1EKzt+oeXhemwyHQis8/gm9t2rRRwajRo0erzwCCuwhUAV47psFiiqIGfytvvfWW+h0BZUyltQxmIiCJ6X3YhuXnmYiIKFAw+EREROSjUGQawR1HtXnyG8a0vGl/7NGymoxW9vNlCPgh+wafC+s6RYDbkC3mb687ryGTCdNHLf/WUOcJgVoED42OrSNaLbL8nm5IRETkLRh8IiIiIiIiIiIij+Fqd0RERERERERE5DEMPhERERERERERkccw+ERERERERERERB7D4BMREREREREREXkMg09EREREREREROQxDD4REREREREREZHHMPhEREREREREREQew+ATERERERERERF5DINPRERERERERETkMQw+ERERERERERGRxzD4REREREREREREHsPgExEREREREREReQyDT0RERERERERE5DEMPhERERERERERkccw+ERERERERERERB7D4BMREREREREREXkMg09EREREREREROQxDD4REREREREREZHHMPhEREREREREREQew+ATERERERERERF5DINPRERERERERETkMQw+ERERERERERGRxzD4REREREREREREHsPgExEREREREREReQyDT0RERERERERE5DEMPhERERERERERkccw+ERERERERERERB7D4BMREREREREREXkMg09EREREREREROQxDD4REREREREREZHHMPhEREREREREREQew+ATERERERERERF5DINPRERERERERETkMQw+ERERERERERGRxzD4REREREREREREHsPgExEREREREREReQyDT0RE16SkpMjly5d5PIiISLl69apcunSJR4OIiLKxbXAPg09EAeaTTz6RBg0ayJ9//lnQu+J1fvvtN2nUqJF8//33Bb0rRET5hu2Cffv27ZOmTZvK4sWL+YkkooDCtsE+tg3uMWVmZma6+VgKELVr15ZXX31VOnfubPc+kyZNkq+++kp++OEH3fX4eB08eNCp5ylUqJCUL1/e4X3eeecdmTt3ruzYsUNcdf/998uxY8ckJCQkx/v26NFDnnvuOfEWH374oSxYsMDm+LrqyJEj0q5dOxk3bpy0bds2+/pWrVrJiRMnpHv37vLCCy8YfgYGDhwoffr0cfu5k5OT5YMPPpDvvvtO7QeyjKpUqSKPP/64dOzYUcxm41j4W2+9pd7vJUuWGN6O7c2ePVv+/fdfKVy4sOokDB06VMqWLZt9nyeffFK2bNlid9/69esn/fv3V78vWrRIbe/LL7+UmJgYt18vkT9ju1AwNmzYIMuWLZNdu3ZJfHy8lCpVSu644w4ZMGCAFC9e3OfahYyMDPnoo4/km2++Ud8VLly4IKVLl5aWLVvKs88+6/A14TvH4MGDbfZh+/bt8vHHH8sff/whZ8+eVefxhg0byqBBg6RixYq6bZw6dUqmT5+uBh4SExOlXLly8uCDD0q3bt3UdxLLdmbIkCHy+eefS/Xq1d1+vUT+jm1Dwfj999/l008/zT7vRUVFyXXXXafOoxhU9ec+A/qaX3zxhRogOHTokISHh0vdunWlb9++Ur9+/ez7oZ+AbW7evFnOnDkjkZGRcsMNN6i2AcdKgxkQ2nMfPXpUrly5ImXKlJH77rtPveaIiIjs+7JtcF2wG48hcikl0fKE5Qi+9P34448ePbqvvPKKdOjQQXwBTqaxsbEq8DJr1iwJDQ3N9TbxJfuWW24xfE8QlEOQq2vXrrrATV45efKkCuo88MADqvFAw/HTTz/J6NGjVVAQX+w16enp6rWjgUAnAo2DvREZBEbROD711FOSlJSkgnSPPfaY6iRowSNs+9y5czaPx/MMGzZMF5B84okn5LPPPpP58+fL8OHD8/w4EAU6tgvumzlzpvrC3LNnTylRooQK2Lz//vvyyy+/qC/fCMD7UruADgYGr/Cl/t5771XnbHQQMAjw888/q9cUFBRk87g9e/bIiy++aLhNDFSgvenSpYv6XoEAE45Rp06dZPXq1SpgB6dPn5b27dtLdHS0Op74+ffff8uMGTNk27ZtMm/evOxt3n333dKkSRN1rKZNm5bnx4GI2DbkBgIvCQkJ8sgjj6gg+/nz52Xp0qXquzFuwzneX/sMb7/9tvru/+ijj6rkAQxioH+Axy1cuDD7taM9weAEzvtVq1ZVAzgIMuGY4VhpAajjx4+r8z8GItBuoM1FX2zOnDlq1gieS8O2wXUMPpFHhYWFyd69ex3e5+LFi3LnnXeqP3JPGzt2rDpJOVKsWDGV9VLQMKpw1113Zf8/p6wwZ7a3du1auxlEeC4Ee9DYjB8/XvIaRrPXrVunyyZCo4IAEBpGZB9pATaM4KBBcwSNy5tvvqk6GC+99JJuROZ///ufarRGjRqlrrvpppsMt7FixQrVEUbHR4OOTq9evVQDh1ETyxEOIso9tgvumzhxolSqVEl3HYLzCJ7g/OpqO1rQ7QKyizDohMCPpk2bNipohOASvj9cf/31usdgIAHtBbKTEIyzhmwo62PUrFkz1YHCOV/LakbnBN8/kEGltUu4D4JTaFsQ2KtWrVr2Nnr37q0ywNHxsc6gIqLcY9uQu8F160xRfMdG0Pzrr792OfjkK30GDGAgwIQ+w8iRI3WzXe655x6VWau9dgSnnn/+eTGZTLr2BgEkBKHeeOMNdR3O7+vXr9d9/0fbgPYKbQ4Ce0WLFs2+jW2Daxh8ogK3fPlySU1NVRknnoYvs3mV+YQpgMhIQsolRkrxBRonxebNm6tGoEiRIrnaPr4AY1QB3nvvPTXSmxvYP5zMb775ZsPbEdnHCRRfupFWWrNmzVw9n9H2jWA6BIJ9mPKA/QN0NrTXjml3RjAyjdRY684WRmAQfEKjpQWfjKSlpakAFRoo644EAliAqRiWAUAiyh9sF4xZB1W0c6g2Uuxr7QKC/ZaBJw06B7hNy1LSoI3FiHeNGjXUVEOj4JPRMcJUOTyP5TFCpiw6ExhwslSnTh31E1MtLN14443ZGdo5DY4QkWewbTBmNEUZ51BMbcZ5y1/7DAg+oQ+JaXGWEDiqXLmyul1jNGiA4BayoCzbBnsZxGiX0Lez3je2Da5h8IkKFFJEEcBBamTJkiWdegyCBghIIFptOZfXGWPGjFEnSkdwckLj5gyc1JGSiX15+eWXVfE51KRCNB5zpDX4EosvzY4gpdTyhIdtWKaK5hZGKDACYhnxt4b3ASMKkydPVu+LoymBzqwKh7TcnKYLanW4LDsAOLlrrx2/IzvJKPPJXgNVq1YtWbNmjVqhyF7mEqZfILUWabTW8D6gwd26dSuDT0T5jO2C/XbB3jkU3Kn55E3tAs7zeO+R+YoMZdThwNRCS7geI/Joox3tszVkOCFjyvIYYWABgxyY9oeAVnBw1ldiTGGsUKGCakesob4W2gUGn4jyH9uGnNsG9DXw/fjw4cNqkBznMZSi8OW2wVGfAcEjzG7A1GpkuGJgAhCc2r17t8NBaK0fhzbFMsvVEvpvmJ63ceNGNR0cfT2jqeBsG5zH4BMVKEyDQ2E4rdizM/BHv3//fnXSQ5bLww8/rLKZrL+kGsH0rLyu+YR5wShsB6hZgUJ/CHxYBp+eeeYZhwWvtWl1uS0o7gjqXqAIoCM46WM0GQUEkVmkjajnNCXQmULeRhAcWrlypWrgkG7tCm0EA/O3rQvAah0MdDiMgk9onJH1hJRcew0ORlFQE4SI8hfbBdfaBQRQ8GUcWbe+3C7gSz1q9eG1IEvZepETTI9DQV3U5nA1sxhTL9AB0rJatc4CnnPChAlqhVMMJGG7eB502rRglHW78M8//7j03ESUN9g25Nw2WJatwPkOMyfQz/LltiGnPgPq8OGxqP+KZAD0xRCMQm0nnNcdwdRCBKos2wZLWv8NA91oK1q3bm14P7YNzmPwifIEspFcGYUEzCPGPGScIFw5MeKLKbKLcLLAF1V8qcScY5xkUPcCaZb5BSMPWuBJg4J1WI0IIzTaXGXUD9IydexxNfjiKjy/0fQGa5jGhmJ6GA1Gse+cpgQ6klOq7+uvv65GQ7A6nasaNGigjj32Ew3grbfeqkYwUAwQnwmwN4KCrCesnuGocCzeOzS+ROQetguebxeQpYPtYkUjbdqyr7YLmMKBuhqYYo5zM4p/a7VEtALjqHnl6mpzKGCO6Xl4DdbZ0ji+qB2FWiL4PoHvFrfddpvdwSy8d5iuR0TuY9vgubYBZSuQjYTBUwTrMeCOmkiu1qnzprYhpz4DBhaQ8TRixAj1utGvxEwUJCk46psiWQCJAlgNEIPRRvBeYEoe2iMsQoSC5gh0WWPb4DwGnyhPYGUyZ6fNwbfffqsiyPjCh6CBO3BSxDxjfHHE9vDlEtFuBKEQiccXcaTmY2RTy3bBl1ecSLSTFYIVRumTgG3lVJzciJYGazlVLKfRg/yAEV0E7JwJqKEgHzozGA02Gq2wnBLoLnzJX7VqlUyZMsVwekNO0KAgzRcjLpar0iEghUYWHQ6j0XF8DvA4LOVtubSqNaTZWhYUJCLXsF3wbLuAL9coro0FO9Dm+Xq7gGW0cUEGF44NFn5Ae47vCJg6gakjt99+uxr9toR6H7gO9Zus23Msp43lvlGPBNPuLaGjhAtG0vH60JagGDlWQEVhWhQntyx2C2wXiHKPbYPn2gac0xs3bqx+RxYQLugfuVoU3JvaBkd9BtR0Qs1gnLe1zCssIoSaVQMHDlSDyEhMsIaZEWgbcPyRwIDXYQTvBS7oM2BQAkXJkWFlHcxj2+A8Bp8oRzhhoZiaI0jzxJdCZyDbCScqfKFELSNEut394gw4YeDkiqg10idRDwpRam1pZS3lEoWlEazSpt0hOo4A07vvvqtSODW7du1SQal69eq5tT9GUXZ8MXam5pO9Ant5wZVpZOjMYCQAJ3mccK3h+ODEnROMzBiNzmDeNOaIo0OB98BdCDBiRAcdDLw2BEDxeULAEY2T0bQJTInEXHiMoDuC7XlD0JDIG7FdKNh2ASuxPf3002q0F+dSe1+cfaldsKR1VHbu3Km+K6BeE6aP4GINHStcMNqvdbogLi5ODU6h44Np1ghOWZo/f7767mB57KKiouTVV19VrxXT+5CNZQnHyrqwLRH9h22D9/QZcJ5FXwbnUX/tM3zzzTeqDlSLFi1012M/0O/DglBoByz7Azi+GNzA68MsHOtBBnvwGvFaUEvKOvjEtsF5DD5RjnKqkYRVB/BH58wSz6iPhBMIgk0YYUTGEqLVR48eVamPORWay+kEjpR9nHAsVzdwdGJF1BtLc+JLJr6YIrKOKVtIqXQ3+GQEX2ALuuYTTpr2lkw1ggAhRpoxKmwNwT1352/jGKOBeu2119Tocl5AEEqbcoLRI4y+GBWERaOBrKemTZs6LFaPtF7UknryySfzZP+I/A3bhYJrFzAFDQMpWJUNX6xzKkjuC+2CNQSbQMtkwjS8lJQUm/t16dJFHnnkETUSbTlYgNFudDgwpR9TQow6Fxi0MCqCq3XojKZd//zzz+rYE5Extg3e1WdA9pK9GR7+0GfAeRxwLrceYMC5HP1BtCfaVGpMm0bgCVPuMBXQlVIt1u2SJbYNzmPwiXIF0V+cEFB/x1HmE/7YUewbaZAIMiGVHv73v/+pEwJOtJhHi9FLVwuJWsMXcWe/jGPkeMeOHeoLLE5cCFwhG8vVudE58YaaT3htmOqIecvOrBKI1SPuvvtulY6aV/O30YCgI4AAZG4ynuzBVEottdhodQ8ESg8dOqTSZh3B5xSjSpaj6ETkHLYLnmsXUNMOX5xRLBsrt+ZmwMYb2gUU78bCIZarncInn3yiBpS07xWOBoPweMspHchsRYAInTMMNtjLDkB27Lp169TUDMvnx0g63HDDDTbHHgEpjPITkevYNnimbUBgHrM2sEqzpb1798off/zh1kBqQbcNzvYZtCl41pmqOCYbNmxQ29QWIcLUOPQ1kVWGKdf26iTiXI/BDOu+JNolHHfr48y2wTUMPpFbEElHhhCWqccfNlaGsVfU7bvvvlMrVKBQOE4O1nV28EeMkxK+LCIIhFR4nKjyA9IwcVLDMstYVhRfYPGFNa+5M30LGTwHDhzIjrbj/9oqO0Zf1nNSqVIltUoDRhEwWu4MHBfU5cqL+dv4vGDqw1NPPaVGJxDgsYTXpH02kBKLbDjtd8vXjtehrWCHQNKmTZtUFhtGMVBIHLWe8Bqt6zVpWU8YzXG072iU8Hh8Ft1ZIYQoULFd8Gy7gIK0GDDBORDTCTDSas1oyoM3twtodzH1HZnTmN6P8/RPP/2kpkcje9WdeoAoMosOAuqAbN261eZ2BLTQBqFoLVYy6tixo2qXMBD2119/qbYKtUMeeugh3ePQfqEDVKFCBZf3iSiQsW3wbNuAQAvOe82aNVNtAIItWBUc09Xw3RoDFq7ylT4DptthkYipU6eqfgPKqCBwh/7m8ePH1b5r/VMEp5CFhel7CITiYgltEOoJY6BaWz0PdWSRPYWSMWibMFvGOpOWbYNrGHwipyAIguKm+InpSEgHRZYJsksGDRpkOLKIL33IZMJ9cfJAKqW9jCQUA8WJBvfDCRT1mvIq+whf2BGYwMkDX3Rx4sHoJX7ixITVERCpR3FyZM0goIbXhS+Z7qwelFewz9ZffrX/Yz9zSm02ghFeZJ3hJO5MJwWrCuE5UXg1tzDiAGgMcbGG/cIoC2B+uvW0Oe21W9b1QAODkREUnMV7hYYXwUSjFTNQDwyfXxSddwRpxqgVwqkVRI6xXchfyM7FBdPuMGXcCEa6faldwPLWmLaPQBqKyaIThe0jO/Xhhx/OVVtjr5YkpmUjgIROygcffKAGJTCAhu8IaDvQUcMFA2YaZEj9+uuvhlNKiEiPbUP+wkApgiKYhod+FwasESBBKRKcB51Ztc5X+wyYpYAAGS4YtMDsFS076ZVXXtHVLMY2z58/rxaXMKL1L7BtDHrjeKJvikERTHPHQAmyuyyxbXCdKRMRBKIcoAAn0g0RacYynvjShuCMvSJt+Fhhbi7m0iLS7OzSyCdOnFABKHT8EYSyhi+IKDiKNFJnIUUeX9iRHYMvlvjSiQuCW9g/XLQvmQhUYbllfMFE5ovR1C1fh+AKRgiQbeZotbdAtH79eunbt69qvK2LFxKRHtsF/8F2wT4MhmDaCupTGn0vISI9tg3+g22DfWwb3MPgEzkFI4KYomY5EpgTTF9yp8gdos25rWNhCVkxrux3IMDoMt4bo9XgAhlGNxA4dedzSxRo2C74F7YL9tsFXNheEjmHbYN/YdtgjG2Dexh8IiIiIiIiIiIijzF7btNERERERERERBToGHwiIiIiIiIiIiKPYfCJiIiIiIiIiIg8hsEnIiLyKwsWLJBu3bq59JgNGzZIhw4dpF69etKsWTOZMmWKpKWleWwfiYiIiIgCCYNPRETkF65cuSKbN2+W999/3+Xlcvv27SvNmzeXpUuXyujRo2XFihUyefJkj+0rEREREVEg4TrreQBLs2dkZObFpohyZDab+HmjfPmcmUwmnzrSDRo0yP69Ro0aLmVKNW3aVAYNGqT+X6dOHUlPT5cRI0ZInz59JDIy0q39YdvgOp7fKL/xM+f/bYM38ed2gX9L3ofvifcx+2k/ztm2gcGnPIAPUELCpbzYFJFDwcFmiY6OkKSky5KWlsGjRR4TExMhQUG+1cFYvXq1+jl16lS5fPmy049DthSCTJaQBZWSkiLbt29Xv7uDbYNreH6j/MbPXGC0Dd7EX9sF/i15H74n3ifYj/txzrYNXht8wkj0xo0bZeHChU7dHx0E3Pevv/6SxMREKVu2rNx///3Sq1cvCQsLy77fk08+KVu2bLF5fIkSJeTnn3/O09dARET5p1atWupnVFSU08GnixcvSnx8vFSoUEF3PbKdihUrJkePHvXIvhIRERERBZJgb6zZgQASana4Mm1i3bp1qsMxZswYKVWqlPzzzz/y1ltvSVxcnLz22mu6+95zzz0ycOBA3XXBwV53KIiIyMMuXcoagQ4PD7e5LSIiQgWncjvKRc4JCjLrfhJ5Gj9zRERE+SfYX2p2DB48WEJDQ7P/f91110lqaqoKRr300ku64FKRIkWkevXqebjXREREtvPfkV5NromKKsxDRvmKnzkiIqIADD65W7PDMvCkKV26tFy9elVNwytZsmSe7icROZaRkSHp6Vyq3hcEBQWL2RyY2SbIbgKj9gZZUe4WG9dqe2BePzmfhYIgQFJSsqSn+1ctBHK+3UhLQ7uRmW+fucjIQnLx4hV+5nRM6tiYzUE2BWTxN+qL2YkbNmyQadOmyb59+9SU6g4dOkj//v0dznzA5/HTTz+Vjz76SI4dOyYxMTHSsmVL9Thsg4jyq0h/uvp79HUZGSa5ciVIrl5NkfT0zIDsMwT7Q80OR3WgihYtKsWLF8+jvSMiZ6SkJEtiYmy+dSAot5ChU1LCwgIv4wTBJXQoTpw4obse0+3OnTsnFStWzNX2/a2gZH5A4InHLfAUVLuBL9H+0KnxhNDQQhIVFSPBwSHiy3bu3Cl9+/aVnj17ytixY1UtP8yMwAyJ4cOH230cglUffPCBuk+9evVUAOrtt9+WXbt2ySeffJKvr4EoEKWlpcr58wmSmnpF/EVcnK+3ObnrM3hd8CmvxMbGqpGKRx991CY6t2bNGvnyyy9VjY9KlSrJY489Jg899FCuno91PSg/+EJ9CpxQz52LVV9aIyOLcklmHxhRunjxvHrPypat5PcZUOfPn5fk5GSVDRsUFKSua9y4sVrgokuXLtn327Rpk4SEhEjDhg0LcG+JAgPaDQSeCqLdwOo8vjoC7cl2AZnLFy+ek/j401KqVAWfbsuxiFHTpk1l0KBB6v916tSR9PR0GTFihFrp1F6GK7KesHAR+hJw/fXXS3R0tFq86PDhw1KlSpV8fR1EgXYewvkH30uLFi2hMm58+TzkD21O5rU+A9prtAvu9Bn8MviEqXaoAYXVizDSYalbt25SuHBhlS6L6Xjr169Xjc/p06eld+/ebj0f63pQfvPm+hRYNACNA/7G0JHwdTjRgtbg4QurFrTwF8HBJomLOyMRESFSqJDvvmdJSUnqJ0az8T5p/0cmrWb8+PHy+eefy/fff5+9wl337t2lc+fOarp3mzZt1Og2RsdxXW6m3RGRc7KmaGeqwFNo6H8rFOcHDB7mdaadf7QbYWqfExLOqOyDkBDb8ha+YvPmzSrIZKl58+aSkpKiZkngdyOYkoe+giVtcQouVETkWTjvZGZmSNGiJf2iP6G1DcHBmNKc6bNtA9rphASUR0gTs9n1dsHvgk94E4cOHao6D0uXLlWBJkt33XWX7v933HGH6qhgdMPd4BPrelB+8YWaKJjHnFXvyXenHPXo8aS8884c9SVz4cL5UrFiZbnrrtby66+b5Pfft0j//kPEn+C9wnt2/vxlSU5O99m6Ho0aNTL8/969ex0+rn79+jJjxgw1xWL+/PkqcNquXTubVVGJyLN8eVTbst1YtGiBX7QbJpNvtQFGMIU6Pj4+e7BBg4EFnOsxBc8e9AvGjRunSnh07dpV1QjENLx7773XZntE5Bm+fh6ybhuqVKkid955t8+2Dbltp/0q+IQilcOGDVNzu5csWaIKjjsDK9+tXLkyl8/tm51s8k3eXBPFV1NJjXz55Rdy7NhR2b0b9R0+ULWBihSJkpUrl8tDD3UyfExS0nnp1etpmT59lpQq9d85CI3Me+/NU7+XKFFCXnjhpeyCpWvWrJJVq1aoedSVK1eRoUNH2s1AWrz4Pdm4cb36vX79G6VPn4Fq1OTIkcMybtxr6jx4yy23ynPP9Vf32bfvX1m0aL688cZbTr133vq5ckZOQSaYMGGCulhDEVlciIjys93o16+Xqi+nZdTA5MkzVHDEUbthzV47kpAQL6+8MkplJaPUxOjRr6vOQ3x8nLp++vTZfj3dGgtHgOXx1SCYhOCUPU888YScOnVKli1bJvPmzVOrcGPF7JkzZ+Zqn/yxVIcvlIUINL7+nqA4t7+1DcePH5V//tklH320RKKjHbcNb701Vnbt2ilhYWFqgLh7917SpElT9fuoUUPlzJnTKlMY5/N+/QbLDTfUs9nG+fPn5NVXX1QlJ9BXQFIO2oZKlSrnum3A9EF3zmXB/lKzA1PtMJf70KFDqtZTmTJlbB6HTplRmizScWvWrJkv+05E3uuPP7bJggVz5ODB/TJ06AB5/fUJUqFCJXXbG2+8ok7uYG/E88MPF8nKlSvk7Nkzuuvj4uJk8uSJMmfOexITU1zWrl0jEyeOlbFjJ8revXtk+fJPZebM+erL8XvvzZV582ZJ//5Zz2Vpw4Yf5c8//5BZs95T5zIEmz7/fJl06vSYfPTRYnn66WfkttuayLPPPq2mEuM8OHv2DBk8eJhHjhcRUaDLbbsBw4aNkgYNbnS63bDmqB354ovPVQYWOjevvDJS/v77T2nQ4CaZO3em9OjxrF8HnnJr7ty5Kvi0bt06OXPmjMp6wgVZso4KlQdyqQ5vLgsRqHz1PcGqcCjO7W6Qo6Bt375N5s2brdqGYcMGyNixb0rlypXVba+//rIMGJCV8YSFbYxeX7t27WXUqJfU70ePHpHevXvKV1+tk8xMk3Tv/oxcf31dddvmzb/KO++8LQsWLLbZRqFCoTJkyDCpWrWa+j/6KO+9N0feeGOCrFmzUlq3vkc6dOgko0ePkF27/pIbb7xZ5s+fJb16PSehocF2g4JZdbjC3SrVEewvNTsGDBigRr0nTZqkRjkOHDiQfX+MUpQqVUq2bdumbn/kkUdUsAnBqFWrVskPP/ygGhgiCmw33dRQxo59Sx544H8yceJUNRqdkBCnbsPcZu13jEAb6dLlKXXp1OkB3fVbt/4mjRrdqjoQ0Lp1G5k2bZIavfjll42qY6CNyrZt+6AMGtTHMPj0888/yb333pcdRG/b9gGVwovgExZZKF8+63xYrlx5iYuLlf3790qVKlWlQoXcrdhGRESeaTfscdRuWAeMHLUjsbFnpW7dG9T15cpVUP/ft2+v+q6Mffd3yG4CoxW0cQzs1fXDYPaUKVPk22+/VQPd5cqVUwGnm2++WdWTRZ2o2267zeX98ddSHb5QFiLQ+Pp78l8ZD9/Myq9f/yZ54403Vdvw1ltZbUNcXKw6f6NtwPd2iI4uLkWL2r6+2rWvz37d//77r9SufV32/2vVqqN+Rw2p/fv3Z//fWlhYuFSsWEXdhrjHwYMHpVatrO0goF6nTl31e9my5eX06TPyzz//yIULF9W+2zvmeD+sS3W4Uq4j2F9qduBNOXnypDz++OM2t7Vv315Ns8Acy1q1aqlAE95wpJah1sfChQvl1ltvzeNXQkTe4OefN6pR4Jx07fq0tGjRSr755it1bpg16x31pf+vv/5Ut1+4kCQrV36mfi9evLi8/PIYp/cBX/aLF/+v44HgUeHC4Sod9uzZs1KvXv3s29BBiY0949R2SpQoqa4DBJ727/9XypYtp0ZIkBn67rtTZOTIV+TNN99QjfgttzSWe++93+n9JiIKRPnZbuBxU6a8pTokZcqUVdlI1avXcNhuYLqGJUftCNqGffv2SaNGt8mBA/ulRYuWMmvWDOnTZ4BMnTpRTTurVq2GPP74k+KPEFzC1McTJ07orsfrRmcQWQdGdu/erTpY1iU8sGoe/P33324Fn8AXO9L+UBYiUPnqe+KNZTzyom0wmbKSbZzpUyCrFRmrCIBPmjRdd9svv2ySt9+eICVLllLBLUdWr16psmGRLdW7d/88aRvcDQoG+0vNDmQv5QQNCFYwIqL8ZT5zWl0sZRQtJhmVqyCvVoL/3WPzmLT6WVMQgvbvE9PlrJoNmvSKlSQzOkZMcXFiSk+TjNK202w1d9zRTF2cgVGBzZt/k+rVa0rVqtXVnOgbbqgvt956m3TseL8a1cYow969/4i3efLJbjJx4jj5+GMUQ71PNmz4Qe6+u418/vlyadq0hZon3qdPDzUtz7rjQkQUKO2GM/Kz3UB9p5CQEPX7pk0/ybBhA2XFijWSVx58sIMagOjVq5s0bNhIBaoQ3Nq+fatUrFhJOnZ8VEaPHq6yoWrWrC3+qHHjxrJx40bp0qVL9nWbNm1Sx71hw6zsr4SEBFXCQyvboQWdfv31V2nRooUuKAXly5fP51dBRP7QNjRp0kTatWvrVJ8C2U6ffPK5ClphWvcHHyzLLviN7/VNmqyRb7/9Wl5+eYRMnWq/Ft0DDzwk99/fTj74YJEa7HjhhdEF1jZ4XfCJiPxPoUXvScQkfcD4SsdH5MKs+WI+eUKi77Zd5jj2bNaU2yL9e0vItq2625LenSspDz8mYas+E3N8nFwePipP9hPFWu+770FVuykrQyhTpkyZqDoRV64ky5w5M1Qh2QcfbO/SdjEqsWPHX7oGKTn5shQtWkxlKKG4n2Wdj5IlS9vdjv6+seo6QHHziROnZRc9f+GFIWp1jeHDB0uHDg+rxqpMmXJq9JfBJyIK1HYjr+W23dACT9C0aXNVZBYZU47aDWuO2hFk/owZMyG7pEX//s+qEfRZs6bLnXe2UtdjZT4sWuGvwafu3btL586dZerUqdKmTRu1IjYGo3GdNu0Oq5tu2bIlexAcQSlcRo4cKUOGDJE6deqoqXiTJ0+W66+/Xlq3bl3Ar4ooMPl629CkSROX+xSoCYisV2QjoZyQpWbNWsjkybYL6VhDPwCBs9dff6lA2wYGn4jI46481V2utmlrM0qhfpYrL4nf/WT3sRfemW04SgEp7TqozKe8ct11dVVtDDQUUKhQYbn99qaqmDfSZVNSUtToADKJXIHHYMWixMREiY6OlnXrvpabb26kplkgEwkZS6jbhFUo1q5dLXfckZXWDzjply5dRhX1a9y4ibq9VavWKgUXBWibNLEdgUFKcNeu3dU0DUy/OHHiuBrFOHnyhJqqR0QUqO1GXstNu3H58iUVCMHoNmDZbaxmFxVV1GG7ATivIxCFDkRO7YhmxYpP5Z572qrHoC3ANlDdAj+xDX+FEhszZsxQhcLnz5+vjnG7du1UwMlRRw0r3KFUB35iEQ9kQ7Vt21Z69+4toaGh+foaiMg/2oYPPliUY9tw4cIFlXF08823qP9v3br52up4ReT06VNqkBm1m+D777+RevUaZD/Wsm1AsXOsiKfVfv3++2919y2ItoHBJyLyOEyLszs1rlCh7HRYI+k17K9EmVmihOTljHCtKCucOHFMpk+fLM2a3SkdOz4iX321Rvr3HyIvvDBYncjbt7ddFvWzz5apaRNI3x8z5mWpWbOWDBjwvMpKGjBgsAwfPlBMJrPqSIwYkTXycP31N0i7dh3ViAO+7GK506FD/8vk6tKlk1ruFA1Qq1Z3y5Ejh9Rqdsi6rVu3vs1+IFiF+ne3336H+v/jj3eVsWNfVSsb3XLLrYYrgRIRBUq7kddy025gtHn69Lfl4sULqmOCjoW2mp2jdgMGDnxOLb2NhSdyakcAo+ZYMXXGjKx6JRhtx3LaX365Wg1O1HdwPP1By5Yt1cWeJUuWGBYrHzx4sLoQkXfw9bahU6dHZc2a1Q7bhszMDFm8+D01RQ61/ooUiZJx4yZltxtTp2KBtYvqsRigHjnyZcO2AQstjB//usqcDQoKVv0SPG9Btg2mTEw2pFwXcktI0EdRiTwBS3Fiid7ExEteWzwwNfWqxMefkuLFy0pIiG+ODPbo8aS8885s1Rn49defZcGC2erkPn7826omxLJlH8tjjz2hso/8gdF7FhMT4dSqFWQf2wb/O7+R/7Ub+NzlxefNH9sNtg15z1/bBZ6/vY+vvyf+0J8wbhvmqCxKX20b7L0vzvYbGHzKA/7akJD38YWGxF8ai0DCDoZnsG3wv/MbeYY/BJ/8EduGvOev7QLP397H198Tf+1PBPt4m5Pb4BOHtYmIiIiIiIiIyGMYfCIiIiIiIiIiIo9h8ImIiIiIiIiIiDyGwSci8giuZeA7+F4RkTfguci7YMUlIqKCxPOQf7XTwXm2J0REImopTxGTXLx4XiIji6pln8m7GxG8V3jPst47IqLAaTcyMkySns6Fn63bhfT0NLlw4ZyYTGYJDg7Jt/eDiAhw3sH55/z5eImMLKbaCX/oU2T4cJuTF30G9jSIKE+ZzVhdo6QkJsZKQkIyj65PMKn3DO8dEVEgtRt47owMZvgYCQ0tJFFRMX7R4SMi34LzTvHiZeT8+QQ5fz5O/IXZ59uc3PUZGHwiojwXFlZYSpWqoEZOyfth9IKBJyIKtHYjKMgkRYuGy/nzl312JNpT0CaYzUEMPBFRgWY/xcSUkoyMdB8P2PhPmxOUyz4Dg09E5MEvrqE8ukRE5JXtRnCwWQoVKiTJyemSlub7HRsiIn/MgELAIyhIfF4w2xwWHCciIiIiIiIiIs9hgQ8iIiIiIiIiIvIYBp+IiIiIiIiIiMhjGHwiIiIiIiIiIiKPYfCJiIiIiIiIiIg8hsEnIiIiIiIiIiLyGAafiIiIiIiIiIjIYxh8IiIiv7Fhwwbp0KGD1KtXT5o1ayZTpkyRtLQ0h4/JyMiQjz/+WB544AG58cYbpVWrVjJmzBg5d+5cvu03EREREZE/Cy7oHSAiIsoLO3fulL59+0rPnj1l7NixcvToURVESk1NleHDh9t93LRp0+SDDz5Q90HQ6tixY/L222/Lrl275JNPPuGbQ0RERESUSww+ERGRX1iwYIE0bdpUBg0apP5fp04dSU9PlxEjRkifPn0kMjLS8HGffvqp9OrVSx599FH1/+uvv16io6PlySeflMOHD0uVKlXy9XUQEREREfkbszd3Irp165bn0y1iY2Nl8ODBcsstt8hNN90kzzzzjBw5ciSP956IiPLb5s2bVfDJUvPmzSUlJUW2b99u93HBwcGSmJiouy48PDz7NiIiIiIi8rPg05UrV1QH4v3333drugU6GkuXLpXRo0fLihUrZPLkybq6Hs8++6ycPn1aZs6cqZ4jKChInn76aUlOTvbAqyEiovxw8eJFiY+PlwoVKuiuR7ZTsWLF1BQ8e3r37i2LFy+WWbNmyaVLl9R1mIZ377332myPiIiIiIhc53VDug0aNMj+vUaNGnk63WLTpk2yd+9eWb9+vZQsWVLdb+rUqdKiRQtZvXq1PPLIIx54RURE5Gla0EjLWLIUERGhglP2PPHEE3Lq1ClZtmyZzJs3T7U9RYoUUYMUuRUc7HVjPF4rKMis+0nEzxwREZH/8LrgE4JAWlDo8uXLTj8O2VIIMtmbboHfcZ/atWtnB56gUKFC0qhRI/n1118ZfCIiCkBz585Vwad169bJmTNnVNYTLihE7qhQeU7MZpNER0fk6b4GgqiowgW9CxRg+JkjIiIKwOBTrVq11M+oqCing0/OTrfAT6MpFLhuy5YtebL/RESU/5DdBEbtBrKi7BUbP3TokKoP+O2336pp2OXKlVMBp5tvvjl7Kvdtt93m1j5lZGRKUpLzgyiBDhlPCAIkJSVLenpGQe8OBQB+5lyHv1FmJxIRkV8Enzw53QI/y5QpY3MfdEq0bbglPV3Cdv2tuyqzWDHJqFwFRawkaO8e24c0uFH9NO/7V0xWnaWMSpUkMzpGTHGxYj5xQr/dyEjJqF5DPWfQzh22272+rkhIiJgPHRRTUpJ+u2XLSmap0mI6lyhmqyLrmYUKSUbt69TvQX//JZKZqd9urdoihQuL+dhRMSUk6LdbspRklisncuGCBB08oN9uSLBkXH9D1mvdvVNMqfoC8OnVqosUKSKmkyfFHHtW/9iYGMmoWEkkOVmC/t2rf6Emk6TXz5qiad67R0xXruj3qXJlySwWLaazZ8R86pR+u1FRklG1mkhqqgTt3mV7DG+oh2+kYj6wX0xWU3UyypeXzBIlxZSYIGarGjKZ4eGSUTMreBr015+228XxLVRIzEcOi+ncOf12S5eRTHw2k5Ik6NBB/XZDQyWjzvXq95B/dokUCpaQi1ckKCPrPUrH5yEyUkwnTog5Lla/3eLFJbNCRfTIJWjfv/odMpslvV79rF/3/COmlBT9Y6tUkcyixcR05oyYT1sdw6JFJaNKVZGrVyXon922rxXbNZvFvH+fmKz+tjIqVJDM4iXEFB8n5uPH9duNiJCMGjXRa5egHX/bbhfHITRUzIcPien8ef12y5SVzNKlxXT+nJgPH9ZvNyxMMq6ro35X283Qd2zT8b6Fh4vp+DExx8frt1uipGSWL48TiAQd2K/foeBgSa977fP9z24xXb2q3y4+Z1FRYjp9WsxnTvvUOcIUGSJSuJD4CpzHY2Ji5ITV8cB5/9y5c1KxYkXDx+3evVvVAyxdurTueq1w+d9//+128AnS0hhEcRUCTzxulJ/4mSMiIvI8vwg+5VamVaDFVeaLFySqpX6FJenSBRVrRfafErG+LetJpWvvQfLC0o+kbqI+YDC2YTNZV7G6PHTwHxn092bdbVtKlZPhTf4n4alX5asvP7LZbLt7H5PzYYVk7G/fyx2nj+lue/eGRrKsRl1pceKwvLZ1ve62f4vGSK+WD6rfv/1isYRadc67tWonh6OiZdgfP8t9R/bpbvuwZj2ZV7eh3Bh7Sqb+/I3utthC4fJwm6xaWsu+Xiolr+g70YPuuEf+LFlWntm1Tbrs03eUv6xcUybedIdUSUqUhT+s0t121WyW/z3YVf0+98cvpNZ5fUDslUZ3yobyVeTh/buk786tutt+LlNRXrztLimackVWrf3E5hi2ve9xuRwSKm/98q3cevak7rap9RvLymp1pPWxA/Lito2623ZFl5S+Le5Tv69fudBmu13u7iAnIqPkxd9/ktbH9QGmhbUbyMI6N0mjMydk4q/rdLediCgiXVp3VL+v/OpjkaspYpnD0ad5W9kdU0r67NgijxzQB4I+r3qdTGtwm9Q8Fy/z1mdNadVcCg6RB+/von5///uVUvWCPiA2qnEr+aVsJXn837+l1279SmHry1WWV29tKSWTL8myb5bZvNbWDzwpqUFBMnXjWrkx/ozutok3NpEvq9SS+w7/K8P+/EV325/FS8ugZvdKSHq6rFu9xGa7D9/zsMQWjpBXt/wod57UB1DnXn+zfFSrvjQ5dVTGbf5Bd9uhIsXk6bseUr9/ueZDiUhL1d3+zJ0PyL5ixWXgX79J+0P6QNDS6tfLzHq3yvUJZ2XmT1/pbjsXGibt23ZWv3+4boWUv3RBd/uw21vL1tLlpds/f0i3vX/pbltXoZqMvaW5lL+YJB9+95nNa73zoazVPt/d8GWeniPk7FmR6GIiT72Iec76295+W2TIEJHvvhJp2FCkWjXxJY0bN5aNGzdKF5x/r0Gtv5CQEGmI1yMiCQkJcvXq1eyBCC3ohKnXqP9nGZSC8gg8Evm5fsNGyvE4fTA6EJhNIkHBQZKeli7XxnMCSoUSUTJj4viC3g0iooBoz8w+0uZ4sm0wZeY28uIhKBSOVekWLrTtxFvDyDY6FnPmzJE777zTpjPSv39/VVAWP00mk0yfPl13nzfffFPVg/rsM9sOoDPSr6bKpV+2uJzV8GDX56R87c5S6Ko+IHMqurxcCC8mxS4mSKnz+oyTy2ERcrxEFTFnpEuNU7bbPVCmlqQHhUj5+KMScUXfEY6NKi2JRUpIkcvnpWyiPuMkJaSQHClVXf1e6wQ6XfqPxeFS1eVqSCEpk3hCoi7rgxQJkSUkrmhpCU+5JBXi9BknaUEhcrBMVjZQtdP/SnC6vtOP14LXVOL8GYm5GKe7LSm8mJyOLi+hqVekyll9RpWISf4tn5UNVPnsAQlL1Wc+nYquIBfCi0r0hTgpmaQPflwqVEROFK8kQempUv20VTaQiOwve51kmIPUa8FrsnS2aFk5FxkjRS6fk7KJ+gyLK6HhcrRk1WvH0Daj6nCpGnI1JEzKJhyXIsn6rJ34IiUlPqqUhF+5KBXi9UGV1OBQOVS6pvq9+qm9EpKJE9Z/78+xElUkOSxCSp4/LdEX9Vk75yOi5UyxchJ2NVkqx1plVJnMsq9cVjZQlTP7JTRNn/l0MqaiXCwcJTEXYqVEkj4r7WKhKDlZvKIEp12Vamf0wUjYV7aOZJrNUjH2kBS2+nxjf7BfRS8lSulz+uBecmi4HCtZVUwZGVLz1D822z1YuqakBYdKufhjEnlF37DERZWShCIlJTI5Scol6AOvV4PD5HDprAUMap78R0yZ+uDqkZLVJCW0sNof7JelxMjiElu0jBROuSQVrT7f6eZgOVC2tvq96pl9EpKmz3w6XryyXC4UKcWTzkrxC/oA0oXCReVUTAUJTU2RKmetMqoQEC5fV/2sFHso1+eIoD/fkymvj3Ip8ymqTAkx+1Dmk5al1LlzZ3nmmWekTZs2cuzYMXn99dfV7y+++KK6z5NPPqmmWWPxCUATiGDV4cOHZciQIWqxCkzFw0qpRYsWlU8//VRCQ0PdzqZISMhFVm2AQXF21MhKTLzEzKd89tDTfSWj6UgJNPhOiNpsmCLrpV+HPcq8abysfP9dlx4TExPBaXe54K/tAs/f3idQ3xNvbs9MPtLmeLJt8IvMJ2enW+AngkzW8LhKlSq5vwNBQZJSN2v6kg7+0INDJc3ObYh4HilRxXibmZmSGBGtLka3pZvMsrdcVvDF6PbjMRXt3pZUOEqSChs89tofwd5rAQmj208VK6cuRrddCg033qdr2z1wLYBidHtsVCl1MbotJTjM4XYPl7STnZGZKQmRxdXF6LY0c7DDY3iseGW7tyUVLqou9vbJ0XZPRpcXwcXgtkthEY6PYdnaxietzEw5G1VaXYweeyWkkMPtHroWeDS6PT6yhLoY3ZYaFOLwtR518Pk+F15MXYxuyzSZHG73REwFu7ddKFTE4Wv9t2zW9FKj208XLasuRrddzuHzfbCUndU5MzMlrkhJdTG6LSU41OF28+IcYT5YXH+Owrmpop3t4rbIomq6p6+pX7++zJgxQxUKnz9/vqr5165dOxk4cKDDLwJY4Q5Fx/ETgx7Ihmrbtq307t3b7cATERERERH5ePDp/PnzkpycrFatQ4FYZ6db4D6LFy+W2NjY7BXvsBoeRsEddU6IiMg3tGzZUl3sWbJkiWFtwMGDB6sLERERERHlvZxzo/JZUlKSuqSmpkp6enr2/y2NHz9e1ebA0tia7t27q+DT1KlTZc+ePWrJ7LFjx6opGNoqR82aNZOaNWuqQNPWrVvlr7/+Up0NjGw/+GBWvSMiIiIiIiIiIvLjzKdGjRoZ/l+rz5Gb6RZms1lmz54t48aNU9MpsMIRltNGXSltmW4iIiIiIiIiIvLj4FNOQSaYMGGCurg63QJQywMBKiIiIiIi8n8bNmxQ3//37dunBqg7dOigFiIKDs65K/Tdd9/Jhx9+KLt27ZJLly6p2RbPP/98vuw3EZE/8brgExERERERUV7YuXOn9O3bV3r27KlKchw9elTGjBmjSnwMHz7c4WOxIjZWw+7Vq5faRlhYmKSlpfGNISJyA4NPRERERETklxYsWCBNmzaVQYMGqf/XqVNH1ZUdMWKE9OnTJ7s2rLX169fLsmXLZNWqVVK+vMEqxURE5NsFx4mIiIiIiPLC5s2bVfDJUvPmzdWK19u3b3cYtEK2FANPRER5g8EnIiIiIiLyOxcvXpT4+HipUKGC7npkO6H2E6bgGbly5Yps27ZNTc3r0aOH3HbbbWql7aFDh8qZM2fyae+JiPwLp90REREREZHfQYFwCA8Pt7kNK10jOGXkyJEjamoeAlAPP/ywWj371KlT8u6770rHjh1lzZo1KnjljuBg/xv7Dwoy635SwQvU98RsEsk0mcTbmbx4H3EMPXWeYvCJiIiIiIjomgsXLqifWF27TJky6vf69evLTTfdJK1bt5aVK1dKt27dXD5eZrNJoqMj/PY4R0UVLuhdoAB/T4KCgyQT0RMvZvby/cMx9NR5isEnIiIiIiLyO8hugsuXLxtmRdkrNh4aGqp+JiYmZgefoFSpUlKzZk05ePCgW/uTkZEpSUm2++LrkF2DIEdSUrKkp2cU9O5QAL8n6Wnp6u/MmwNPGV68f9oxTEzMyhp1Fj5rzmTZMfhERERERER+B8GlmJgYOXHihO56TLc7d+6cVKxY0fBxWo0oTL/D6niWUKi8UKFCbu9TWpr/BgIQ5PDn1+eLAu09QVwnMzPT66faZXrpPmrH0FOfmcCaBEpERERERAGjcePGsnHjRt11mzZtkpCQEGnYsKH6f0JCgpw+fTr7dgSs6tatK8uXL9c9DkGsQ4cOya233ppPe09E5D8YfCIiIiIiIr/UvXt3FXyaOnWq7NmzR9atWydjx46Vzp07Z0+7Q0FxrGZnafDgwfLzzz/LmDFjZOfOnbJ+/Xrp3bu3qvvUqlWrAno1RES+i9PuiIiIiIjIL6FQ+IwZM2TatGkyf/58tUpdu3btVMDJkWbNmsmsWbNk+vTpsnTpUilSpIi0bdtWhgwZImYzx++JiFzF4BMREREREfmtli1bqos9S5YsMbz+zjvvVBciIso9hu2JiIiIiIiIiKjgg0/z5s1zePsnn3wi6enp0rVrV6+u3k5ERPmPbQgREbFtICIKXE4HnyZPnizJycnSq1cv3WoQgHnUM2fOlLi4ONm6dSuDT0RExDaEiIjYvyAiIten3SGjqVChQtKpUye1zChg5QeMaL/77rtSunRpBp6IiIhtCBERsX9BRETuBZ/Cw8PVig+PP/64vPjii+q6P//8U0aPHi033HCD+r/JZHJlk0REFCDYhhAREdsGIqLA5FbB8T59+mTX7xgwYIDKdsLSo8B6T0RExDaEiIjYvyAiIreDTydPnpTXX39dgoKCVKCpQ4cOMn78eGnUqJGrmyIiogDDNoSIiNg2EBEFHpeDT1euXFFT7dq3by///vuvvPbaazJx4kRJTU3Nvg+n3hEREdsQIiJi/4KIiJwOPqHGE/zwww9SrVo1Wb58udx///3q+hMnTkiZMmXk7Nmz8vTTT6v7PfHEE9KlSxd1ISKiwMY2hIiI2DYQEQU2p4JPDRo0UFPsXnrpJRk5cqRcvnxZkpOTxWw2y6RJk2Tx4sUSHx8vtWrVUvevXbu2XHfddepCRESBLT/bkA0bNqjp4PXq1ZNmzZrJlClTJC0tzanHfvfdd2oQ5dZbb5W6devK22+/7fLzExGRc9i/ICIKLMHO3OmFF16QhQsXytdff606Cs2bN5dixYrJJ598ItHR0TJo0CA5d+6c6lQsWrRIrX6HTgUREVF+tSE7d+6Uvn37Ss+ePWXs2LFy9OhRGTNmjJoWPnz4cIePffPNN+Wzzz6TXr16qW2EhYU5HbQiIiLXsX9BRBRYnAo+aYoUKaKmT2zfvl2tdofpdoDfb7vtNk/tIxER+QFPtyELFiyQpk2bqmAW1KlTR9LT02XEiBFqldbIyEjDx61fv16WLVsmq1atkvLly+d6P4iIyHnsXxARBQaXh5YxHQJf0LVOA0aJ//777zydnuDqtInjx4+r/bJ3eeedd7Lv26pVK8P7PPLII3m2/0RElP9tyObNm1XwyRKyrFJSUlTAy1HQCtlSDDwRERWM/OhfEBGRD2U+WU5PQP2OUaNGqWDOiy++KGvWrMmTle7cmTZRunRp+eqrr2yuz8jIUPU7rEe7u3btKo899pjuukKFCuVqv4mIqODakIsXL6q6URUqVNBdj/M/pvihLbG3guu2bdtUnacePXrIrl271JS7Ro0aybBhw1T7QkREnufJ/gUREflg8GnGjBmqLgbqdwCCOBipwMjxc889VyDTJkJCQqR69eo213/xxRdy6dIleeihh3TXo8aI0f2JiMizPNWG4FwP4eHhNrdFRESo4JSRI0eOqDYGAaiHH35YBg4cKKdOnZJ3331XOnbsqDo+CF65KziY9Q+dFRRk1v2k/GM2iWQGeOc+EIMbeN+95Rzl6f4FERH5UPAJIxGwb98+VZ8DKwFpBg8eLEOGDFHZStr9cjNtAkEme9Mm8LszkPU0e/Zs1Xgh2ERERAUnv9oQV124cEH9nDBhQvZ0j/r168tNN90krVu3lpUrV0q3bt3c2rbZbJLo6Ig83d9AEBVVuKB3IeAEBQdJJiIRAQp/q4H6vhf0Ocpb2wYiIirA4NPq1avVz2nTptnchukKWMUIGUhYrcjdle7cnTZhZO3ataoWVPfu3d3aFyIiyjuebkOQ3QSXL182zIqyV2w8NDRU/UxMTMwOPkGpUqWkZs2acvDgQXFXRkamJCXZ7g8ZQ8YTAk9JScmSnp7Bw5SP0tPS1ec1UANPgfra8b4nJmZljToLf6N5mZ2YH/0LIiLyseATvoRbwhSFhg0bZv9f+2L/1FNPqZ9bt25VNTPyY9qEUdbTzJkzpVOnTlKyZEmb2zGyMmfOHLW6RrVq1VSA6s4775TccCdtmWnulBuBOEWAfHdqhafbEDw+JiZGTpw4obse7ca5c+ekYsWKho/TBjsw/Q7TvC0h4za39QDT0hhEcRUCTzxu+Quxl0DMLLFsRwPx9eN9L+i/tfzoXxARkXdwujeCEz2+mGsjE88880z2bS+88ILN7yjqjSBQQcAoCToSlvuoef7559V0vI8++kgVNMdI97PPPps98pKbqRWuXpDujMfywmPgymdA+8zxwmPg7GdAm1rh0vkpj+vu5Ecb0rhxY9m4caPuuk2bNqlRc60zk5CQIKdPn86+HQErTPNYvny57nEIYh06dEiNvBMRkWf4Uv+CiIjyseD4L7/8kp2VZDlCtG7dOrVCheXv7owguTttwhKed9asWdKuXTspW7asze333Xef7v8tWrRQ0y0+/fRTeeCBByQ/p1YEcpo7uS+QpwiQ706tyI82BFmsnTt3lqlTp0qbNm3k2LFjapAB12ntBwqKb9myRfbu3aurK4JlvbGyavv27SUuLk4t7426T1hxiYiIPMfTbQMREflY8AmpySjcjRP/jTfeqK7DikAYfUBDYPn7yZMn3ZoS5O60CUvffPONHDhwQK2a4SysfGc9Wu4qd9KWAzXNndwX6FMEyHenVuRHG4JC4Tj3YwR9/vz5qlYgBiIQcHKkWbNmatBi+vTpsnTpUjUlu23btqrQLWuMEBH5dttAREQ+mPmk1ceYO3euJCcn60aErX93t3HQpk106dLF4bSJq1ev6orDAhomLI997733SuXKlW22nZaWJsHB+peMBg2j4NZzzomIKO95ug1p2bKlutizZMkSw+tR9y+3tf+IiMg72wYiIip4Ts2p+OmnnyQ1NVX9jqDQihUrpHDhwvLdd9+pNFgUZLX8/fvvv3c7KwPTJhB8wrSJPXv2qG0aTZvAdDlruC+Wan3uuecMt426Tk8//bR88cUXsmPHDvn111+lf//+qq6HvccQEVHu5GcbQkREvoFtAxFRYAl2di62NhKBFeRQ7A8jD+XLl1e32/vdHe5Om0BHBSvctW7dWmrUqGF328iiQmArNjZWwsLC5JZbbpGPP/5Yateu7fY+ExGRd7QhRETkG9g2EBEFFqeCTyNGjFAj1f369ZOVK1fKwoUL1bQ3THFD0Mfyd4xua/WWEAzCY/Jj2gQ6LNi3nGo7oYgsERHln/xuQ4iIyPuxbSAiCiymTCfnNmC5adRGgr///ltef/112blzp6qtVLx4ceONm0zy4Ycfir9LT8+QhATXVpKCh57uKxlNR3pkn8g/4W9KW+2O05LIWeZN42Xl+++6dMBiYiLydLW7QGxD3G0bAlVwsFmioyPUyowFXSA/0ATq95FAb1PZNuQ/f20XeP72PoH6nnhze2bykTbHk22D0wXHcYDq1KkjvXv3VlPgsCLQO++8I8uWLVPT2HAbERER2xAiImL/goiI3Ao+NWrUSI1Uh4eHq9odR44ckXvuuUcFpc6cOaNbfaJo0aJStmxZZzdNRER+jm0IERGxbSAiClxOB59+/vlnKVGihPodUyewKh0CUQg+WU+LwEp0kyZNyvu9JSIin8Q2hIiI2DYQEQUup4NP6enpcvz4calQoYL6/2233aZWozPCot5ERMQ2hIiI2L8gIiKXgk9paWnSunVrqVatmtx0001y+vRp+eijjwyLZe3atUs++eQTeeyxx3iUiYiIbQgREbF/QUQUwJwOPoWFhcm6devU6kTr16+X+Ph4VQOqUqVKUqtWLV0QqnDhwrJt2zYGn4iIiG0IERGxf0FEFOCcDj4hoFSqVClp1aqVuowePVpWrlwp8+bNU4GpESNGSMmSJT27t0RE5JPYhhARUUG1DRs2bJBp06bJvn37pFixYtKhQwfp37+/BAc73RWSl156Sa32jW2VKVOGbyYRkYucPuP+9ttvuv+HhobKI488Ig899JAqOJ6amurqcxMRUYAIyDYkPV2C//5Td1VG0WKSUbmKyJUrEvzvHpuHpNW/Uf0M2r9PTJcv6TdXsZJkRseIKS5Ogk4e192WGRkp6dVqZD3nrh22261TVyQkRMyHDor5QpJ+u2XKSWapUmI6lyhBR4/ot1uosKTXqq1+D97xl4jVVPu0mrXRexTzsaNiTkzQv9aSpSSjbDkxXbwgQQcP6LcbHCLp19fNeq27d4kpLVWCgswiUYUlKClZ0itXlczIImI+dVLMsWf1242OkYyKlUSSkyV43179CzWZJK1eg6zt/rtXTFeS9a+1UmXJLBYtprNnJej0Sf12i0RJRtVqIqmpEvzPLttjWLeeSFCQBB3cL6aLF/XbLVdBMkuUEFNiggQdO6p/reERkl6jZtYxtPo8qO3Wuk6kUCExHzks5vPn9PtUuoy6mC4kSdChg/rthoZJ+nV1sl7rrp1iSk/Tbxefh8hIMZ88Iea4WP12Y4pLRoWKIpcvS/D+f6XW+XjJOLE7a7smk+wrl7XdKmf2S2jaVd1jT8ZUkIuFoyTmQqyUSNJv92LhInIypqIEp12Vamf227zWfWWvk0yzWSrGHpbCVy/rbjtTrKycj4iWopcSpfS5U7rbkkPD5VjJKmLKyJCap2z/bg6WriFpwaFSLuGYRCZf0N0WF1VSEoqUlMjkJCmXoP+7SQ0Jk6Nls96bmif/EZPV5/tIyaqSElpYSp87KUUv6d+bxMgYiS1aRgqnXJKKcfq/m3RzkBwom/V3U/XMPglJ05/fjhevJJcLRUrxpFgpfkF/DC8UjpJTMRUkNDVFqpzV/93Av+WvVz8rxR6SQlf1n+/T0eUkKbyYFLuYIKXOn9bddjksXI6XqCLmjHSpcSrr78Z8Pj77M+nsOUIig9XfvC+1DZi10bdvX+nZs6eMHTtWjh49KmPGjFHbHj58uFPbWLRokaxZsybX+0JEFMicD/fbgUbi6aeftrn++++/V6sbvfzyy7l9CiIi8lP+3IaYLlyQ6Lub66670vERuTBrvgoIWN8GsWezOn1F+veWkG1bdbclvTtXUh5+TMJWfSZFRg7V3Xb1zlZyfulKFbAy2m7c7oMqOBL58kgJ+2at7raLr42T5Of6SchP66Voz6d0t6XWayDnvt+ofi92711iuqoPRCT8tFkFQMInvyWFP1ysu+3ygCFyafSrEvzXn1Ks/X2629LLlpOEv7KCCEU7d5SgU/8FgqJE5NznX0rqHc2k8IK5Ej59su6xyV26ysUpMyToyGGb15oZGipxx+OyjuFzPSUEATML5+cvkqsPtpdCK5ZK5CujdLel3HOvJC35VEznzxsfwwPHJbNIlESOGCqh63/Q3XZh/CS50qOXhH73rUT17aU/hg0bybm136vfjbYb/9sfklGtukRMeEPtl6VLQ0fI5eGjJHjrFin2WAf9MaxSVRK2ZL2+Yp0eEHN8vO72xC/XSVqjxlJ41gwJn/Ou/hg+3VMuvjlZBZ6wT+/jyk1fZT1nWITc/WrWZ2/sR4OlmlUAZNiTM2TT9a3k/m2fy3PfTNXd9sMN/5MXu0yV6EsJsmhGJ5vX2nzMn5JqDpURn78iNx/Sf77HdXhdVjfqJM13fy+jPtP/3W+v2kj69lokwRlphtt9cMQPKhDUd+3b0mrnt7rbZt0zSBbf2UtuPPS7TFzST3fbwVLVpevQL7PuN7erRKToA75P9Vuugj1PblggHX/7WHfbx3c8JdPvf0Gqn94n82Y/rrstMSJa2o7+Wf3+1uJ+UiHhmO72QU/Plc21mspDWz6Vnt/P1N329Y33y2uPvqWCR0av9fbxWUHC0ctGSb1j+s/3q49MkG9uelDu2vG1DP3iDd1tv9W8QwZ3n6cCVrrt3v2VS+eIoJZNRapVE19qGxYsWCBNmzaVQYMGqf/XqVNHLaSErKo+ffpIZGSkw8dv3LhR5syZI6NGjVKZWURE5B5TplHFcANdunSxfbDJJB988IHhKEbv3r3lueeek2effVb8XXp6hiQk6L+wOOOhp/tKRtORHtkn8k/4mzObTZKRkWlY7J/IiHnTeFn5vr7zmZOYmIisTJQ8EohtSPrVVEnaqB/VZ+aT48ynqKjCkpSULFeZ+ZSvmU9DXp0gGTd2D9jMJ7SpNU7sDrzMpz/fk8mvjnAp8ym6QkkJysPMp/xoG5o0aaKCTE888UT2dRcvXpSGDRuq6X3Nm9sGhTUHDhxQ+4gpe9C1a9dcTbtzt8/g7YKDzRIdHSGJiZckLS2joHeHAvg98eb+tclH+nGe7Dc4nfmEAuI4cZvNWRvFAZs7d67uPhhFwMjAu+++q1JbfbnTQEREeScg25CgoOxpdDYKFbJ/G47FtWlaRpCdkFaihOvPiaBD1Wpi7ysopqOlFYu2+1htOpvhditWypoKZ7TdyCKOX+u1IJQEm0WiIyQ98ZJkXvuijGl7uBgqXNjxdq9NFzTcp1KlJK1UKeMbQ0IcbxdBHXvbjY6RtOgYu7c7fG8qV7H/3hSJcrxPdW+wv91y5dXFUHi42u6/RYtLxrWghqXDpe2/VgR0cDGCQJAWJDGCQJI9CEDhYgSBK0fbReDLHgTMrB+rOgLXftcCbkbOFCunLkaSwyIc7tOh0vb/luOjSqqLkashYQ63e7RkVbu3nYuMURcjGeag7O2aDxW3+VzldI6Q0DDxpbYBQSYsklShQgXd9ch2Qu0nTMGz59y5cyrQNXjwYGncuLFs3rzZ5ddHRERuBJ/QQPfr1y+7cYD331eJ2uqk/tVXX8l7772n5k/PnDlTWrRo4eymiYjIz7ENISKi/G4bLl3KyjIKDw+3uS0iIkIFp4ykpaXJwIEDVVbUo48+mucZKf5Gy3jIy4xpyp1AfU/MpqwMXl8493nzMfTUeSpXNZ8wOtGuXTvZu3evVK5cWXr06CEdO3ZUK1cQERGxDSEiIl/rX8yaNUuthDdyZN5O38GUG0yF8leYOk3eJdDek6DgIMlE9MSLmb18/3AMPXWeynXBccyfvu2226RiRfupzkRERGxDiIgoP/sXyG6Cy5f1Nca0rCh7xcZPnDghv/zyi9SrVy/7Oq1GS6tWraRRo0ZqBTxXodZLUpLtvvg6y5p9qGtFBS9Q35P0tHT1d+atzNdqPnn7MUStMFfgs5anNZ/spYs9/PDDudkEEREFKLYhRETkybYBwaWYmBgVTLKE6Xao6WQvuIU6T927ZxXh1+zYsUOteIfV86xrSLnCn4s/I8jhz6/PFwXae4K4jrcW8zZZTLXz1n3UjqGnPjPB/jI3kYiIvBvbECIiyu+2AcXCN27cqFtZb9OmTRISEqJWvIOEhAS5evVq9ip2pUuXVhdLiYmJ6mfVqlXdXu2OiCiQOR18QnSuZcuWuuuSk5Plsccek+LFi6uTcP369eWWW26R8uXtrKpCREQBiW0IEREVRNuADKbOnTvL1KlTpU2bNnLs2DEZO3asuk6bdofi4lu2bFF1poiIqICDT+PHjzdsMDBfOikpSQ4dOiTz5s1ThfkwitCtWze566678np/iYjIB7ENISKigmgbELyaMWOGTJs2TebPny/FihVTBc0RcCIiIi8MPrVv3179XL58uXTq1En9jvnTf//9tzz55JPZ98N1WBb1pZdektWrV6tRBiIiCmxsQ4iIqKDaBmRXWWdYWVqyZIlT0/eYGUVE5L6cS5JbwUlfK5AVHh4uo0ePVumxGqTEPvPMM/LNN99I165dc7FrRETkb9iGEBER2wYiosDjVOYTRh60YoAIPCGopP0/LS1NFfCzXqrUbDbLPffcIzfffLMn9puIiHxEfrYhGzZsUFMr9u3bp6ZWdOjQQfr37y/BwcEuBciWLl2qtsWiskREnsH+BRFRYHHq23izZs2yf9+6das0bdo0u+MQHR0tu3fvVgX8LJ08eVLN40YxPyIiClz51Ybs3LlT+vbtKz179lTFZI8ePSpjxoyR1NRUGT58uFPbWLRokaxZs8bp5yQiIvewf0FEFFicCj716tUr+/fJkyeraXUYlQaMLj/66KPy9NNPqyVLNSgS+Mknn7i1U+6MXH/22WeqGKERFCps3ry5+j02NlbGjRunllxNT09Xq2dg6mDlypXd2lciIvKONmTBggUqsDVo0CD1/zp16qjz/IgRI6RPnz422VXW0C7MmTNHRo0apdoFIiLynPzuXxARUcFyfh7CNf369ctuGKBmzZpq5PrAgQNy3XXX/bfh4GAZMmSIyzuUm5HroKAgVYTQWtmyZdXPjIwMefbZZyUsLExmzpwpoaGhMnv2bNWwffnll1K4cGGX95eIiLyjDdm8ebMKMlnCwENKSops3749exDCCJ5/2LBhauCDiIjyl6f7F0RE5IMFxx9//HEVuMEqFLBr1y75/vvvZdWqVdn3uXz5sly4cMGtL/GWI9cYtUbND4xCf/DBB3Lx4sUcH1+9enWbCwqjw6ZNm9QqFdOnT5dbb71VbrzxRrVaBpZzNQpaERFR3vJUG4L2IT4+XipUqKC7HtlOyKDFQIY9586dk+eee04GDx6sVjMiIqL85en+BRER+VDmU6tWrdSIBKa3IZjz+uuvq2VRBwwYoBqHtWvXygsvvCDbtm1TGUvz589X0x1clZuRa2e2Xbt2bSlZsmT2dYUKFZJGjRrJr7/+Ko888ojb2yYiooJrQzCIANpgg6WIiAi7gxcoeD5w4EDVtmCKR14LDnZ5jCdgBQWZdT8p/5hNIpnX6rAFKq0OXaC97wV9jsqv/oXXSE+X4L//1F2VUbSYZFSuInLligT/u8fmIWn1b1Q/g/bvE9PlS/rNVawkmdExYoqLk6CTx3W3ZUZGSnq1GlnPuWuH7Xbr1BUJCRHzoYNivpCk326ZcpJZqpSYziVK0NEj+u0WKizptWqr34N3/IWVRLLO21GFJSgpWdKq1RQpXFjMx46KOTFB/1pLlpKMsuXEdPGCBB08oN9ucIikX18367Xu3iWmtFT9PlWrLpmRRcR86qSYY8/qtxsdIxkVK4kkJ0vwvr36F2oySVq9Blnb/XevmK4k67dbqbJkFosW09mzEnT6pH67RaIko2o1kdRUCf5nl+0xrFsPjZYEHdwvJqvvGenlKkhmiRJiSkyQoGP6AbDM8AhJr1Ez6xhafR7Udmtdh06qmI8cFvP5c/p9Kl1GXUwXkiTo0EH9dkPDJP26OlmvdddOkfAQ9Z5IekbWdvF5iIwU88kTYo6L1W83prhkVKiIKK8E7/9Xv12TWdLr1c/a7t49Ykq5on+tlatIZtFiYjpzRoLOnNJvN6qoZFSpKnL1qgTv2W37Wm+oj1VmJOjAPjFd+y6Xvd3yFSWzeHExxcdL0Ilj+n2KiJD06jUxtUmCd2YFraHW+XjJOLFbDpauIWnBoVIu4ZhEJl/QPTYuqqQkFCkpkclJUi5B/3dzNThUDpeuoX6vefIfMWVm6m4/UrKqpIQWltLnTkrRS/r3JjEyRmKLlpHCKZekYpz+7ybdHCQHy2VlcVY9s0+CU6/qbj9evJJcLhQpxZNipfgF/XtzoXCUnIqpIKGpKVLlrP7vBv4tf736WSn2kBS6qv98n44uJ0nhxaTYxQQpdf607rbLYeFyvEQVMWekS41T//3dmM/Hq8+lS+eIJreov/s8Cz5FRUWpaWn42a1bNzXf+urVq2rlIvwE/D5x4kS5++671fxsVxvy3IxcOwOPt9424LotW7bkattERFSwbYg7Zs2apaZx2KsZmBtms0mioyPyfLv+LiqKU+DzW1BwkGQiEhGg8LcaqO97QZ+jvLVt8BTThQsSfbd+IP1Kx0fkwqz5KiBgfRvEns3q9BXp31tCtm3V3Zb07lxJefgxCVv1mRQZOVR329U7W8n5pStVwMpou3G7D6rgSOTLIyXsm7W62y6+Nk6Sn+snIT+tl6I9n9LdllqvgZz7fqP6vdi9d4np2vsEUSKS8NNmFQAJn/yWFP5wse6xlwcMkUujX5Xgv/6UYu3v092WXracJPyVFXwr2rmjBJ3SB4LOff6lpN7RTAovmCvh0yfrbkvu0lUuTpkhQUcO27zWzNBQiTsel3UMn+spIQiYWTg/f5FcfbC9FFqxVCJfGaW7LeWeeyVpyadiOn/e+BgeOC6ZRaIkcsRQCV3/g+62C+MnyZUevST0u28lqm8v/TFs2EjOrf1e/W603fjf/pCMatUlYsIbar8sXRo6Qi4PHyXBW7dIscc66I9hlaqSsCXr9UU+dJ9IfLx6TzSJX66TtEaNpfCsGRI+5139MXy6p1x8c7IKPFnvU0ZkEYk/eEL9HtWzqwTv1QdJzy/+RK62aSuFPvlAIse+pj+GDzwkSQsWq2CX4ef7WKxIWJhEPj9QQn/ZpD+Gk9+RK088JWFr10iRIf11t11t0lTOr/xKBQYtt/s+/tn0lTw44gcVCOq79m1ptfNb3WNn3TNIFt/ZS2489LtMXNJPd9vBUtWly+CsGVGz5naViBR9QOypfstVsOfJDQuk428f6277+I6nZPr9L0j10/tk3uzHdbclRkTLfS/9on5/c3E/qRCvj2sMenqubK7VVB7a8qn0/H6m7ravb7xfXnv0LRU8WjSjk80xvH18VlBv9LJRUu+Y/vP96iMT5JubHpS7dnwtQ794Q3fbbzXvkMHd56mAlc127/7KtXPEgQMi1apJngWfUE9JK/iHEYfDhw9LgwZZUWTtJwq1YvoCaiihoXCVuyPXGuwXspgwko06Ty1atFDFC2NiYtTteLzRstkIbmnP7S53Ro440ki54ctfvijwRrc93YagjdCmZVjD+d1esfETJ07IL7/8IvXq1cu+TntujMijTcEKeO7IyMiUpCTb/SFjGDlH4CkpKVnSr43SUv5IT0tXn9dADTwF6mvH+56Y6Nr3X/yN5mV2Yn70L7xJZpEikvjdTzaZT+pnufI2t1m68M5sw8wnSGnXQdIa3ap/rmvtHrJsjLabWbSo+nnx9fFyedhIm6wGSG1+p81jkfmkUQGUa5lP2edvZHGhPR4yXK483VP/WkuWUj/TGtxou93g/wrLn/94hWHmEyT36CUpDz6k3250Vl8Pz23zWi2+LyPIZ5T5pAUBU+9oqt9ukajsY2V4DMOzvntcnDDJMPMJrt79P9vXeu1xYLRdfBbg0ojRqoOvu610Vl8W77fNdkPDsn+/uPJLiQoP0bWpKvMJx/C5fpLy8KM2mU/qPjVq2W7X9N/ffNL8xYaZT3DlsSckteVd+u1GZX3OMkqUNP58X/v7v/j2NMPMJ0i5935Jq99Av0/Xvvfh8ZbbHfLqBMm4sbskRmR9Jt6993lZdGcvm8wn+LPqLSqYZJ35pHmu12LDzCdY0qKHfHFLR5vMJzhQpqbNdpH5pHmh6wzDzCdYeeujsrFOK5vMJzhbtIzNdi298fA4w8wn+L5eG9lRKSuL0jLzCa6EFtZt1/znezL51REunSOiypaV/15hHhUcxwkfBQHPnz+vvpC/9NJLKriDFFg0CKjP1LJlSzWCYdQB8KT69evLO++8o4JOGCnZs2ePWuUOqxd9/vnnupUyjF5XQYxuB/pII7kvUEdpyXdHtz3dhiC4hIEGBJMsYdABnZaKFbO+wFhDnafu3bvrrtuxY4eqNYgahEbZsq5IS2MQxVX4kszjlr8Qe/H1Tn1uB3EC8fXjffeGvzVv7l/kuaCg7Gl0NgoVsn8bzo3XpmkZQXZCWokSrj8nPgdVq4m9TwGmo6UVi7b7WG06m2CAKzpC0hHMvPaZwjQ4NRXOaLuRRRy/1mvT7wz3t2w5dTFUuLDj7V6bLmi4T6VKSVqprOCYjZAQx9u9FtQx3G50jKRdC44ZcfjeVK5i/70pEuV4n+rekP2eWP+dI7ilBbhshIc73m7t/xYAsNmn0qUlrXRp4xtDQx1vF1Po7G23eHFJK54VHLNhNuu2+2/R4pJxbRoanIwx/v4HFwtHZU9ZM7KvXNYURiNnipVTFyPJYRGG2zVd+3modE27bU58VEl1MXI1JMzh/h69Fhgzci4yRl2MZJiDdNs1HyquO6ZOnSMsAp95EnzCKkCoj5SQkKBGkZFVhBRZTFfAihQYuaha1f4L9uTINdSoUUNdNA0bNlQj2Q8//LCaJ37bbbfZzXDC82nPnZ+j24E80kjuC+RRWvLd0e38aENQLBwDDl26dMm+DgtNYPABbQLg+TFAoWXBli5dWl0sJSYmqp/YH6NsWSIi8p22gYiIvIPTwSeMBANGHzA68eOPP8rkyfr5tpCRkaFbKjU/Rq7tqXZt3qHWkcDjUXTcGp6vUiXjyLyz3Bk5CtSRRnJfoI/Sku+ObudHG4IMps6dO6tVTNu0aSPHjh1TBWpxnTZ4geLiqPGHlU+JiEj8vm0gIiLv4PRZfPHixfLxxx+rIM2KFStU44Av+igQjp8IDmHaGwoCavO2HU11y2nk2pLRyPXp0/pq7ajzZE0LNNWqVSt72+hwxMb+V0Eeq+ihI8LltYmIPCc/2hBMv54xY4asX79eOnXqJK+99po8+OCDamSdiIi8T371L4iIyIcyn0qVKpU9NQ0nfRQFb9q0qezatUv93Llzp9x///1qmhu+9GOUuUiRIvk2co0lsrFUNgJU0dHR8tdff8m0adOkXbt2Ur16VoG6Zs2aqRRePB51PkJDQ1URQ/xEB4WIiDwjv9oQ1AXBxZ4lS5bkuA1toIKIiPyjbSAiooLncv7qp59+qpamxhQ2BIrQYOAnGgvMyUaBwJkzZ8rRo0elfHk7hcw8MHKNhgkZUs8//7wKRGF1oh49esi4ceP+e7Fms8yePVtKliwpvXv3Vku6IvNp4cKFuar5RERE3tGGEBGR72HbQETk/5zOfMJcbHQSDhw4oII4WAkIOnbsqKs/89RTT8myZcvk999/z54mlx8j11gNA5ecoLAsMqKIiCj/5GcbQkREvoFtAxFR4HA6+NSrVy/VObAseAx9+/ZVPzds2KB+YsWKm2++WV2/dOnSvN5fIiLyQWxDiIiIbQMRUeByOviEFeOeffZZmTRpUvbKcHfddZeatmYJhQCTkpJUAUHM4yYiImIbQkRE7F8QEQUup4JPycnJatQ6LCxMV+QPq8aNGDFCChcurLv/mjVrZN68eap+E1ekICIKbGxDiIiIbQMRUWBzKvgUFBSkCsG+/vrralqdJRQD11ah09x7771qdbq33npLXnzxxbzdYyIi8ilsQ4iIiG0DEVFgc2q1u9DQUBVIsg48YTU53GYN98P0PNSIysjIyLu9JSIin8M2hIiI2DYQEQU2p2s+GRk4cKDd26pXry6jR4/OzeaJiMiPsQ0hIiK2DUREgcGpzCciIiIiIiIiIqJ8z3wiIiIiIiIiCjT9ho2U43FJ4o3MJpGg4CBJT0uXjEzxWhVKRMmMieMLejconzD4REREREREROQCBJ4ymo70ymOWaTJJptkkGRmZqg6ztzq+iYGnQMJpd0RERERERERE5DEMPhERERERERERkccw+ERERERERERERB7D4BMREREREREREXkMg09EREREREREROQxDD4REREREREREZHHMPhERERERER+a8OGDdKhQwepV6+eNGvWTKZMmSJpaWkOH7N+/Xp55plnpGnTptKgQQO57777ZPHixZKRkZFv+01E5E+CC3oHiIiIiIiIPGHnzp3St29f6dmzp4wdO1aOHj0qY8aMkdTUVBk+fLjdx61evVqqVasm3bt3l6JFi8r27dtl0qRJcuXKFenVqxffLCIiFzH4REREREREfmnBggUqe2nQoEHq/3Xq1JH09HQZMWKE9OnTRyIjIw0fN378eAkNDc3+//XXXy+xsbGydOlSBp+IiNzAaXdEREREROSXNm/erIJPlpo3by4pKSkqm8key8CTpnTp0nLmzBmP7CcRkb9j8ImIiIiIiPzOxYsXJT4+XipUqKC7HtlOxYoVU1PwXIFgFabiERGR6zjtjoiIiIiI/M6lS5fUz/DwcJvbIiIiVHDKWf/++6+sXbtWRo8enat9Cg72v7H/oCCz7megMJtEMk0m8XYmL95HHMO8/Jvge+J974klBp+IiIiIiIjsuHDhggwcOFCaNGkijz76qNvHyWw2SXR0hN8e56iowhJIgoKDJBM9dS+Gz5y3H8O8/Jvge+J974klBp+IiIiIiMjvILsJLl++bJgVZa/YuKXk5GRVYDwkJESmTJkiZrP7GQEZGZmSlGS7L74OGU8IPCUlJUt6eoYEivS0dPWeenPgyZv3TzuGiYmX8nR73vyazX76nuDv35nMR68MPm3YsEGmTZsm+/btU/OxO3ToIP3795fgYPu7u379evnwww/ln3/+UaMTmNuNkYknnnhC10i0atVKTpw4YfP4Bg0aqNUriIjId3my/SAiIt+C4FJMTIzNd39Mtzt37pxUrFjR4eMRoOrdu7cKQC1cuNCpYFVO0tL8NziDwJM/vz5riCFkZmZ6/VQ7b91H7Rjm5WeG74n3vSdeHXzauXOn9O3bV3r27Cljx45VhQDHjBkjqampMnz4cLuPW716tSoA2L17dylatKgqCDhp0iS5cuWKzXKoXbt2lccee0x3XaFChTz2moiIyD/aDyIi8i2NGzeWjRs3SpcuXbKv27Rpk8pkatiwofp/QkKCXL16VcqUKZN9n/Pnz8uzzz6rBiEWL14sUVFRBbL/RET+wuuCTwsWLFDLoQ4aNEj9v06dOpKeni4jRoyQPn362B1xGD9+vG5J1Ouvv15iY2NVNpN15yE6OlqqV6/u4VdCRET+1n4QEZFvwcBC586dZerUqdKmTRs5duyYGqDAdVq7gHpOW7Zskb1792Y/DtmvQUFBMm7cONUm4GLZl0BGFRER+XDwafPmzaqTYKl58+aSkpKiRqPxuxHLjoOmdOnScubMGY/tKxEReQ9/aT/6DRspx+OSJNCgJiqKXKp6Dd47Q8BjKpSIkhkTxxf0bhD5nfr168uMGTPUlOz58+erKdnt2rVTAaecVreD9u3b29zWr18/NaWbiIh8NPiE+dfx8fGq3oYljEqgocAUClegs4GpFERE5N/8qf1A4Cmj6UgJNFiuOvNaIU5vrk/hKcc3MfBE5CktW7ZUF3uWLFlic51lFhQREflZ8AlF/SA8PNxwtQp0LpyF0Yq1a9fK6NGjbW6bN2+ezJkzR4oUKZJd5+POO+/M1b4HB5vdGuXFl22i3BYSJMrpXOPOOcqX5Ff74Sq2De4JxPNbQf6d8vsIP3NEREQBFXzKK1itCKm0TZo0USsWWXr++eelRIkSajQ8Li5OvvzyS1VMEMVlH3jgAbeXTIyOzlrK1RWYXoBRXiJ3PnNErpxr3DlHBSJH7Yer2Da4f9wCUUH+nQb69xF+5oiIiAIs+ITRabh8+bLhqLYzy5tiKVQUiMUKFlOmTLFZJvu+++7T/b9FixaSmJgon376qdvBJ0wRSEqy3eecqLoWgVjYgnL9JZmfG3L1XJOYmJUZ5KyoqMISFOQ72VL50X64im2D6wL5/ObO32lePnegHnd+5vy7bSAiIu/hVcEndA6wcsSJEyd012O6xLlz56RixYoOH48ORu/evVUHYuHChU51NgAr32EJ1txIS8tw+TH4nheIdS0ob6ai8LNDrpxr3DlH+ZKCaj9ywrbBeYF+fivIv9NA/T7Cz5z/tw1EROQ9vG7oonHjxjaBoE2bNqmR6IYNG6r/JyQkyOnTp3X3OX/+vPTo0UMtq7148WLD5U/T0tJsrsvIyFBLq9asWTPPXwsREflH+0FERERERH6S+QQo/t25c2eZOnWqtGnTRo4dOyZjx45V12kj0ajHgYCR5SoUTzzxhAQFBcm4ceMkNjZWXTTR0dGqM7F69Wr54osv1JKpVatWVSPiH3zwgRw6dEjGj+cqM0REvsyT7QcREREREflR8Kl+/foyY8YMmTZtmsyfP18tkd2uXTvVYchpdSJAYMlav379pH///mrbGAVHxwSdi7CwMLnlllvk448/ltq1a3vsNRERkW+3H0RERERE5EfBJ2jZsqW62LNkyRKb6yxHsR3Vdnr77bdzvX9EROSdPNV+EBERERGRH9V8IiIiIiIiIiIi/8HgExEREREREREReQyDT0RERERERERE5DEMPhERERERERERkccw+ERERERERERERB7D4BMREREREREREXkMg09EREREREREROQxDD4REREREREREZHHMPhEREREREREREQew+ATERERERERERF5DINPRERERERERETkMcGe2zQRERERERHlRr9hI+V4XJLXHkSzSSQoOEjS09IlI1O8UoUSUTJj4viC3g2igMbgExERERERkZdC4Cmj6UjxVpkmk2SaTZKRkSmZmd4ZfTq+iYEnooLGaXdEREREREREROQxDD4REREREREREZHHMPhEREREREREREQew+ATERERERERERF5DINPRERERERERETkMQw+ERERERERERGRxzD4REREREREREREHsPgExEREREREREReQyDT0RERERERERE5DEMPhEREREREREREYNPRERERERERETke7wy82nDhg3SoUMHqVevnjRr1kymTJkiaWlpOT5u5cqV0rZtW7nhhhvkrrvukvfff9/mPocPH5ZnnnlGbrrpJrnllltkyJAhEh8f76FXQkRE/tJ+EBGRb2LbQERU8Lwu+LRz507p27evNG/eXJYuXSqjR4+WFStWyOTJkx0+7vvvv1f3ffTRR2X58uVqG9OnT5cPP/ww+z6XL1+Wbt26SUhIiOpYzJw5U06ePCm9e/eWzMzMfHh1RETki+0HERH5JrYNRETeIVi8zIIFC6Rp06YyaNAg9f86depIenq6jBgxQvr06SORkZGGj5szZ47qODz11FPq/9ddd53ExcWp67t06aKuW7VqlVy5ckWNhIeFhanrpk2bJi1btpRffvlF7rjjjnx7nURE5DvtBxER+Sa2DURE3sHrMp82b96sOg+WMIqdkpIi27dvN3wMMpp27Nhh+LgzZ87IgQMHsrd96623ZgeeoHTp0lK7dm359ddfPfJ6iIjI99sPIiLyTWwbiIi8g1cFny5evKjqL1WoUEF3PUarixUrJkePHjV83LFjxyQjI8Pmcdr/tcfhZ/ny5W0ej/vZ2zYREXk/T7cfRETke9g2EBF5D6+adnfp0iX1Mzw83Oa2iIgI1YAY0a63fhw6HSaTKft2/MR2rOF+GOF2l9lskpgY2+3mZNn8SZJZqJjbz0uBySQirFBGLn1muk1y+RyF85ov8XT74Q62Da4L5PObO3+neSWQv4/wM8e2IT/bBn9uF7z9b8kT51hvf1+8/T3xxPvC98S7+w1eFXzKaygi7kwh8dwWG0cjFBTkeketXJlSuXpeIiLn8FzjqfbDEbYN5Ct/p/w+EqjYNuR328B2wb8+7zx3et/7wvfEu9sGr5p2p2UloQaH0ai2vWKx2vXWj9P+r92On9rouPX97G2biIi8n6fbDyIi8j1sG4iIvIdXBZ/wJT8mJkZOnDihux6prefOnZOKFSsaPg61Ocxms83jtP9XqlRJ/cTjre8Dx48ft7ttIiLyfp5uP4iIyPewbSAi8h5eFXyCxo0by8aNG3XXbdq0SUJCQqRhw4bq/wkJCXL69GndqMYNN9xg8zj8v2TJklKtWrXsbW/ZskWtfKSJjY2VvXv3qtuIiMh3ebL9ICIi38S2gYjIO3hd8Kl79+7qS//UqVNlz549sm7dOhk7dqx07tw5e/rDwIEDpUWLFrrH9erVSz799FNZtGiRetznn38u7777rvTs2VPNr4Z27dpJaGioDBkyRP766y/ZunWrDBgwQGrVqmWzzDYREfkWT7YfRETkm9g2EBF5B1NmbiuqesCPP/4o06ZNk/3796slshE0QocBgSN48sknVQYTMpYsrVixQubNm6em0ZUqVUp1OJ555hndfQ4cOCDjxo2Tbdu2SVBQkAo6vfjii+r+RETk2zzZfhARkW9i20BEVPC8MvhERERERERERET+weum3RERERERERERkf9g8ImIiIiIiIiIiDyGwSciIiIiIiIiIvIYBp+IiIiIiIiIiMhjGHwiIiIiIiIiIiKPYfCJiIiIiIiIiIg8hsEnIh+xYcMG6dChg9SrV0+aNWsmU6ZMkbS0tILeLSKiXOP5jQrCggULpFu3bjz4RLnA87d34vnNe2zfvl0GDBggLVq0kPr168s999wj77zzjqSkpEigYfCJyAfs3LlT+vbtK82bN5elS5fK6NGjZcWKFTJ58uSC3jUiolzh+Y3y25UrV2Tz5s3y/vvv8+AT5QLP396H5zfvs27dOomKipIxY8aoflzv3r3lo48+knHjxkmgMWVmZmYW9E4QkWODBw+W5ORkmT17dvZ1X331lYwYMUJ++eUXiYyM5CEkIp/E8xvlt9q1a2f/fvvtt8vChQv5JhC5gedv78Pzm/e5evWqhIaG6q5DEArBqD/++EOCg4MlUDDzicgHYIS2adOmuuuQBYV0TaRyEhH5Kp7fKL+tXr1aXe666y4efKJc4Pnb+/D85n2sA09QunRpFZRKTEyUQBI4YTYiH3Xx4kWJj4+XChUq6K5HtlOxYsXk6NGjBbZvRES5wfMbFYRatWqpn5gGcfnyZb4JRG7g+ds78fzmG7Zv3y5FixaV4sWLSyBh5hORl7t06ZL6GR4ebnNbRESEavyJiHwRz29ERL6J528i98TGxqqaT4888oiYzYEVjgmsV0tERERERERElM+uXr2qaqVhRgsWkwo0nHZH5OWQ3QRGUwMw6sRi40Tkq3h+IyLyTTx/E7kmPT1dhg4dKseOHVMFxwsXLhxwh5CZT0ReDsGlmJgYOXHihO56TLc7d+6cVKxYscD2jYgoN3h+IyLyTTx/EzkvLS1NBZ527twpS5YsUQXHAxGDT0Q+oHHjxrJx40bddZs2bZKQkBBp2LBhge0XEVFu8fxGROSbeP4mcm6q3YABA2TPnj2q1lOlSpUC9rBx2h2RD+jevbt07txZpk6dKm3atFHpmmPHjlXXcdodEfkynt8ovyUlJamfqampahqE9n+sfkdEzuP52/vw/OZ9EHjau3evTJo0SZVMOXDgQPZtRYoUkVKlSkmgMGVmZmYW9E4QUc5+/PFHmTZtmuzfv1+KFSsm7dq1k4EDB0poaCgPHxH5NJ7fKD/Vrl3b8Hp0DojINTx/exee37xPq1atbMqnaNq3by8TJkyQQMHgExEREREREREReQxrPhERERERERERkccw+ERERERERERERB7D4BMREREREREREXkMg09EREREREREROQxDD4REREREREREZHHMPhEREREREREREQew+ATERERERERERF5DINPFDAyMzMLehfIy126dEmuXr1a0LtBRPmE7QLlhO0CUeBh20A5YdvgHgafyC50wi9fvpyrIzR37lx58skn3Xrs559/Lj179tRd99lnn0m3bt1c3lZ6erq0aNFC1q5dq7v+p59+ktq1a0taWprkBRyve+65RwYMGMCGy0ucPn1avce//PJLjvd95ZVXpE2bNnLx4sV82TciX8N2wXVsF7wP2wWivMW2wXVsG7wP2wbPC86H5yAf9eKLL8qhQ4dUACkmJkbmzJkj33zzjbrt7Nmz0rVrV6lXr55MnDgxO8Bz4cIF+eGHH+xuE8GjkSNH2r395ptvlo8//lj9joBQSkqK+v2uu+6S2bNnZ9/v66+/VoEC7X6IPhctWjT79s2bN+u2u3XrVklMTJQmTZqIJ40fP17Cw8PVMTGZTNnX47i8/fbb8t1338n58+elatWqKrD24IMP5snznjhxQq5cuZLj/bBPeG7LfcsLY8eOlcWLF7v12JUrV0qdOnXU7+3atVMn/oiICIePwecCjfYff/yRfR2CfidPnrT7mF69etl93fg8lS9fXr1/jz/+uLzxxhsyYcIEt14PkT9ju+A6tguuY7tA5FvYNriObYPr2Db4PgafyK7XXntNnnnmGdVp//TTT1VAQAsKhISEqJ+FChXKvi41NVUFWXJSunRpwwDVu+++K7/99pvd9FfLFFhkp+AC06ZNk6NHj6rgjj2rV6+We++9VwUfEhISsq/XMlzOnTsnZvN/iYBBQUG6YJYzDhw4ICtWrJCPPvpIwsLCdPvep08f2b9/vzz77LNSpkwZ2bhxowwbNkw9z3333Se5NXjwYPnrr7+cui8CYBUrVtRdd//998u+ffucfj7LICH07t1bHnvsMRf2WOSll16S2NhYqVWrlu56fLYQwMuJdVaeFhjNDTw39guvpUePHlKzZs1cb5PIn7BdYLtgD9sFosDFtoFtgz1sG8gSg09kFwIA77zzjiQlJakgyZEjR6Rt27bSuXNndTv+j4BKkSJFZObMmdlBHAR3PvzwQ5kxY0b2tjDtCdkk2I764AXbfvQsgz/O6N69u8p8QRYMtnvTTTep60eMGCGPPvpo9v3i4+NlzZo1KjCEKYB79uyx2dYdd9xhEyDDlDxXvPfee9K4cWO58cYbdddv2rRJtmzZIh988IE0atRIXYfAGTKVEDDLi+DT0qVLc7zPU089pdKirQNPMG/ePKdrHU2aNEni4uJ01xUvXlxdrP35558q+Ka9NxoEGbdt2yZvvfVW9mfCMpD1xBNPONwHTKHr27ev4W34nOGYO2P58uUSGRmpu65+/fpy++23y4IFC5j9RGSF7QLbBSNsF4gCG9sGtg1G2DaQNQafyCFMt8NFCw5h6pqW5dSvXz81dQzZTpj6hoAS0iGRTYTAwHPPPSfz589XgYCFCxeqIAPqOOWV5ORkGTVqlDz88MPZ1z3yyCNq3ywtWbJEypYtK9WqVZNVq1Y53Oa6devk+uuvV1OwXIEAC7K5hgwZYnPbjz/+KOXKlcsOPGkeeughFRRDMOy6664TT9q9e7cK+CC7zAiOj7OQ6WYdfLIHz4fPDaZsahCcRNYXAn6YZmcNQctFixY53K6jKYaYEtqyZUt54YUX7N4HgdP//e9/kpGRYXg7MsHefPNNdburQVEif8d2wTlsF4yxXSDyT2wbnMO2wRjbhsDA4BM5DRk6qO2DDB4Efpo3b66KeC9btkzq1q0rVapUUYGJl19+WXXYtQumuhllOuUHBCIQyMAULQSlMB0OtaIw1atLly66+yLzB9PXkI3kavDp33//VUGVZs2a2dyG6WzVq1e3uV6b0oXbteAT9sE6eGYkp5pI1saNG6fqc919992Sn9DAWk5BRGASAUtky02ePNmwJpizK4zkdd0qSwiMIdCK9wZZe0RkjO2CfWwXjLFdIPJ/bBvsY9tgjG1DYGDwiQxNnTpVTTuCkiVLqqweTEdC7Sdcj5pFqLUECDY98MAD8sUXX+gCDZYQmEEACCcWBISsp2EBgi4IkLgSYEBhb0wNtHweyyLeU6ZMUdPBLOsDITUY07asg0///POP2oeGDRu6/KlAkWxkduFYWcO0PwTnrEVHR2ffrsGxdCY7bO/evU7vG96z7du3qylm+Q3HvVSpUur3U6dOSf/+/VXWEqYoFitWLPt+mH6HLDB3oJaXZRF7vAeoa4WLI5UqVbKb1YRtoP6TtuoFEbFdcBXbBWNsF4j8C/sMrmHbYIxtQ2Bg8IkMYcocaiqhULdWzwnToZCZguwVBBBatWqlrtcydVDHCMEiBKUQRELWyM6dO1UhbKxWh6wprEqHIJZWowhZU1glDc9jDVlAKGjuCKZvWU+702C6H6bRvfrqq/L8889nX4/gktHzoQYRsrdKlCjh8qcCdbFQoNy6fpH2OrQC7Za067QV/bR6R506dZK88vfff6saSAj6YDphfjtz5oyqg4WgIz5TSMnGVEzLwBMMHz5cBXlmzZqlVp7TINCJQuLO1LTSoGB4buFzjH3E+0pEWdguuIbtgjG2C0T+hW2Da9g2GGPbEBgYfCJDyGDCpXDhwtnXocYTLlrmE+o4aemjyHxC0EDLfEJgCtOWEGxArSVM1UNhZwSwLAtTIzAxevRoteqZddYQAlw5BZ9QyA4BCw2yqrTMJyxhim1bb7dBgwbq+TDygJXnNKiJhP1xR1RUlGpMjGoEhYaGGk6l066zzBZD8AuXvHDw4EG1yh6Kp2PFwvyGjK7jx49LnTp1VDAHdZ+QBeUomw3ZUVpBe60hQjBw7ty5qoi9No0TENDC52Pt2rXZxc1RaN6ZlfIsP2PdunWzqQ+F9xHF811d8ZDIn7FdcA3bBVtsF4j8D9sG17BtsMW2IXAw+EROQ40nLS0S2Tra/9PT09XP1q1bZ0+DQpCpRo0aKkCFQJW2otihQ4d0AR9MfapcubJ89dVXajU26xORdYaMtaFDh9rNfEKQDM+1efNm3WMQjML1O3bsyN4XFEz//fffVZaQOxDgwTYQ1MLvlhBs0wq1W9Ku0wq6A2ppOVPzCQ2XIwcOHFDHE6/v6NGjKgiFWlbWK7t5EqbRIfCmrSRofVzsFT7/+OOPbTKfEDxDcAkrCWqBNHy2tMCTpQ0bNuR4fDRY/dAI3ke8D5afVSKyxXbBPrYLttguEAUGtg32sW2wxbYhcDD4RE776doyosiowbS1AQMGqCwUBDoQIHj22WcNp51ZwspuzzzzjE0AAEGGxx9/XDc97eTJk7maKuYocIAaTLt27coOmCGwgcDP7bff7tZzoYA5AmW//vqrWsXOEoqNIyBibf/+/brC4/Daa6/luuYT6lkNHDhQbrnlFlXz6sSJE+qYo8YVMoicCQLlFrKG5s2bJ0888YRLxdGRKYWV5iy3g5UCAdcj061r166qgD2mbHbs2NHuthCIxKp2ls+PgBKy41ADy9F+/fzzzyooaPneEJEttgv2sV3QY7tAFDjYNtjHtkGPbUNgYfCJcoSMHkBwBvWZEMBAXSJkPCEIgA79qlWrVIAFNZgQ9DCCIAgCVdYFvRFAwNQ5TMvCtD7L4Ixl8XCbD29wsJpah4CEBllZ7dq1y/E1IaiFWlSW9aEwHU8rAu4qTAe78847VQaXdfAJ1yObZ+vWrdKoUaPs63HMECDTVrrLbc0nTBXDMUTW2WOPPSajRo1SwUAEv1B0HKvMISCDmkueDKqgEenbt6/KPsJPV1SoUEFXeFzLfNJqimH6Jl4XAkP4XFoXjbc2aNAg3TQ+fP7atm2b4358+eWX0rJlS4+uqEfky9gu5Iztwn/YLhAFBrYNOWPb8B+2DYGHwSeyC8EmdMJRywiFw5EtgswlBFIQtdcgeIJC5O+//76atqbVd7KGwAwCUxUrVtRdjxo948aNU1PDEJhC9hGe8/Dhw3YDWVpg4qOPPlKBFtT+wWp7uL+WKeNIkyZNpEiRItn/X79+vVNBCUd69Ogh7du3V6vmoc6RpkWLFnLzzTerTDFkh2FqGaYiYn8nTJigC3C4W/MJmVAorI73ByvHYYlb66mGeF9QFBIBGwT7LIOAmJqHGkrOQNF4IyisjsARCs4j8IT3x9lpfshGOnbsmCpmj+AmApXIgsKxREBKa6zx2vA+4bkQULO3uqIGgUkE4zTaFNGcirSj/hfeHyLSY7vgGrYLbBeIAgHbBtewbWDbEKgYfCJDyBDBCnEIWixZskRlsCBrBlkkKMKM4JD1FDtMh8LUOQQQEFBBRx9T5/A77v/ee+/J66+/bvh8yA5CZg4yf1CbCMGIpk2bZtfuQaABWUnIdsJ1CGRhaVdkwCC4g7pRqO2EaWtPP/20mspnXSxaq8kEKHyNFfgQ4IiLi1NBDhSdxv81yErC8zkLATlMDUMQCIEebQohXv/s2bPV60JgBceiatWqKvCEYFVuIGiE6W0I/mF+PY4LgltGEGxD1hPeS6xkOH36dHXstKwiZwIzGgTTLCUkJKhtaJ8D1GVCvSdnvfzyy6pwPbK08JoQgMPrQbYYgp4oDI7X9s4776jrUQgfrwGftw4dOqjjafR6UXDe6Bhjf/E+oK6YJQS18BlF9hr2hYj+w3aB7QLbBbYLRNbYNrBtYNvAtsFZpkxn0x0ooIwZM0b9REAGQQSsOobMpm3btqkAzYULF+wWxkaGCqY7TZ48WQVgRo4cqbKjFi1apAIejiAjB8+FxyMV0ygLCNPlUMsIQSYteKJBEfGZM2fKkCFDsqeWISiFgAjqVGFVPmd9++23KqjlCgTeMFXw1ltvVcElT8Nz4DUjownBOmcgwIIsMwTx8B4BAk+unAoQULMOPiJQdMMNN+hWSMwtbdodjimmRqKGlPY6USAen0lkmWG6prbaHfYjp4LjCKIiqIUAFT5LzZo1U68fBeyR+bRy5UqXalURBQK2C2wXHGG7QBSY2DawbXCEbQNZYvCJDCFLyJWsH9IfOwRzcpoSlhfwPDkVeTeCwCHeX3+qaYSgGjKaUFDd3deF9w7BU1yIyPbvg+2Ce9guFAy2C0Sex7Yhd8eOfYb8x7ah4DD4REREREREREREHsPhfSIiIiIiIiIi8hgGn4iIiIiIiIiIyGMYfCIiIiIiIiIiIo9h8ImIiIiIiIiIiDyGwSciIiIiIiIiIvIYBp+IiIiIiIiIiMhjGHwiIiIiIiIiIiKPYfCJiIiIiIiIiIg8hsEnIiIiIiIiIiLyGAafiIiIiIiIiIjIYxh8IiIiIiIiIiIij2HwiYiIiIiIiIiIPIbBJyIiIiIiIiIi8hgGn4iIiIiIiIiIyGMYfCIiIiIiIiIiIo9h8ImIiIiIiIiIiDyGwSciIiIiIiIiIvIYBp+IiIiIiIiIiMhjGHwiIrrm6tWrcunSJR4PIqIAdOXKFXUhIiLSXL58WVJSUnhA8gCDT0QB5pNPPpEGDRrIn3/+WdC74nX27dsnTZs2lcWLFxf0rhARFahAbCu++OILueWWW2Tnzp0FvStERF4pENuGOXPmqP7ByZMnC3pXfJ4pMzMzs6B3grxb7dq15dVXX5XOnTvbvc+kSZPkq6++kh9++EF3PT5eBw8edOp5ChUqJOXLl3d4n3feeUfmzp0rO3bsEFfdf//9cuzYMQkJCcnxvj169JDnnntOvMnvv/8u3bp1k3bt2snYsWPd2saRI0fU48eNGydt27bNvr5Vq1Zy4sQJ6d69u7zwwguGn4GBAwdKnz59JK906tRJWrRoIf3799ddv3nzZunatavDx+7du9fw+kOHDsnDDz8sN9xwgyxcuFB326lTp2T69Ony22+/SWJiopQrV04efPBBdUzx2dN89913MmTIEPn888+levXquXqNRIGEbUXB+Oyzz2TkyJGGtxUrVkydU321rVizZo0sX75c/vnnH5WViufHedwefA8ZPHiw4T788ccfMmPGDNm9e7ekpqZKtWrV1Pnf8vUBXvNPP/2kAlGhoaF58jqIAhnbhoJ14MABmT9/vvr+GxsbKxEREer8Vrp0aZ9tG/KqH4GfH374oXrMmTNnVH+gRo0aqm24++67dY/p16+fnD9/XpYsWZJnryEQBRf0DpD/T2Oy/mJnD4IBP/74o0f355VXXpEOHTqIr8EJESfttLS0XG0HX9oxqmv0niAohxMwTthly5YVT0DK6unTp1VnCQFENBrWatWqJbNnzzZ8/LfffiurV682vO3ixYvSt29f9dManrN9+/YSHR0tPXv2VD///vtv1RHZtm2bzJs3L/u+aGyaNGmijtW0adNy9XqJyDlsK3JvwoQJKthkyZnBFm9sK9DWDR8+XJ3z0Wajk2EymeTcuXN2H7Nnzx558cUXDW9bv369GlDCuR0dI2zr+++/V4EqdJieeeaZ7PuirUUQa9myZdKlSxePvD4icg7bhtxZt26dOs9hUBbnuRIlSqiBWl9tG/K6H7Fy5UrVH0BArUqVKpKcnCyrVq1S/Ym3335bJS5o0L7ce++9smHDBsPnJecw+EQeFRYWZjdLRYNgwZ133qmyUDwNGUM4mTiCL+9ffvmleFPDi6j+HXfcobKf3IUv2GvXrrUbsb/rrrtU5B8Ny/jx48UTkLWGgI8jCAy1bNnSsDOC98/oc4IMuxEjRqhGtWjRooYpwvicoUMRExOjrkPDWapUKXnzzTdVdh5GwTW9e/dWmX7IlKtYsaKbr5aInMW2Ivduv/12KVOmTK634w1txYIFC+Trr79WGay33nprjvdHUAqj0hitnjlzpmHbU6dOHTXQYDZnVZxAZwPn+kWLFumCT8gKQOcJ+8DgE1HBYtvgvqNHj8rQoUPV4Ovrr7+ugu6+3jbkdT8CA9LWmVoPPfSQtG7dWvUFLYNPCKjhscgiY/DJfQw+UYFDSj1S4J944gmPPxei1nmV+YQpgLNmzVLTtHAiRNZWenq6NG/eXGVYFSlSJE+eB1MeccIcM2aMiri7C/uHFNubb77Z8PbIyEj1RRzBGKTN1qxZU/Jax44dVQcJ0ElwBVKEMdf62WeftbkNnQ1MpcBnCaPW1pKSklQqrXVWADojYF1g9sYbb8zOxMspdZeI8gfbivxR0G0FzscIEmEAwJnAE9pdTJXGVIkBAwYYBp/QBlSoUCE78GTZBmzdutXm/hicwEAVsqmuu+66XL4iIvIktg3GcB5FX0TL9vT1tsET/YjixYvb3E9rJ9APsIZgFJ4X0++MBrspZww+UYFKSEhQAZzHH39cSpYs6dRjEIh56623pE2bNlK/fn2Xng8BHJwUHUGmCxoyZ2RkZKjpANiXl19+WRWsRlQedSIwH9ryyzS+IDuCk13hwoV11yF9FSd7pJdi9Cc3MBqBKQeOGiC8Dyi2PXnyZPW+2INMI6z8kBOk4FrWzMCJXDuZu9IQ4tghhRbBt8qVK9tMp8AoBI6VltVkNBqD21GbDJ2U4OCsU98vv/yiOiRI0bWGTDN0Shh8Iip4bCsctxWWUxJ8va349ddf5cKFC6pt1dpZ66CRJQSJMCKPdtvePqMNQCbTN998I/fcc0/2vuG5UKvEGtoFTMFAG8DgE5H3Yttgv23AFDNk6iAopH2XDgoK8tm2wVP9CG1/0O6gLUFbgePUq1cvm/s1atRI9SFQssOo7aCcMfhEBQrpj+Hh4TbF4hzBCWH//v3qBIcUSBSYRjYTplzl5KWXXsrzmk8YWahbt676HSe1s2fPqiKplsEnpPRv2bLF4XZQbN2yYDum2E2cOFEFs/Ji7jQKbqPgnyM4wWPkGKMkOLE2bNjQ8H44OePLfE4wDcKV99YezM9G+rD1iDbmrSOl+LXXXpPrr7/e7uMRSEJwEDVRUOcDnRqMBmEaHjLYtGCUJUxfQZFbIip4bCvstxWW9eqQRYwv66jvgekE1gVTfaGt2LVrl3oNqOeBbGUM6uD/GGzC4IHloBPO4Z9++qksXbrUYbYxto+2GfuMzgNGz7GiHTov+F5gBO0uaosQkfdi22DcNiDDB9OR8f0W5z0EjlB+AoH1J598UmWWuhqIKui2wRP9CKP9uemmm1QAzaggO9oMXM+2wX0MPlGeQDaSqymdmDOMmg7vv/++CkA5C19CEZDBimVYkeyjjz5S84sxpxlfto0i2p6CUQYt8KTBKCkKlWI0RsvEGT16tIqoO2I5Wq0VGH/++eedmnbgDDw/5kHnBKMkiPojS+jjjz82vA9qJSGTKCdGKauuwmgFRk8w/xrTKqwLjCOQ5Ey9MBxfpMo+8MAD6nODz9Btt91mN2iJ9w5TNYgo77CtyNu2AjC1AQEUZO2iM3H8+HG1XZwfp0yZ4vSiH97SVsTHx6vzPrJa0UnCNtAmojOAQSd8d0DnQCswjkGanFYmxag2jjEGINBBQ8AKWVCYfmG52qkltgFE+YdtQ962DXFxceonzqMYdEfAHZmxGzdulDfeeEPVOsWgrC+1DXndj7Denw8++ECtBojpeehTYlYFBnKssW3IHQafKE/gj9XZaXNaKii+BCIQ4G5wBSdAzClGQAHbQzQbmUc4YSDqjsg00vC1kytOPviiihO49mUU6fz2Iv/YVk7FyY1oKa8oFK7JaaTAGhoGjM6iwcDy0hrsM14HrkMjY5SxYw9GhRGwcyaghqAXvpQjS8hoZAIjG1jtIj9gtOLw4cOqE2UJdbYw3xodLMtjpE1vxHVaui4aP1ywqgVeH0ZksPLRsGHD5NFHH5UVK1bYTNlDB4jzuYnyFtuKvG0roF69eupiSVshDtMMXA0+FXRbgewtZB1Zj1D/73//U1PckW2M20aNGiWPPfaYqv9h2QZo28B1CCyhjcc5H+d4fD8AfO9A24F9R4YVBiOsoQ3Ii44PEeWMbUPetg04B2p1Yxs3bqw7j+K7MRbiQUaRM8Ekb2kb8rofYb0/6Hdp/b9HHnlElWkxKq7O/kHuMPhEOcKKBSjA7AimiGkF4HKCbCctowfRZXy5Q7DIXTjJ4Qsp6jhgFQbUg0K6KTKq8OVbqxuBInEIVmnT7pAyiRPMu+++q+Ywa5Dyj6CU9Zd5ZxllgOFLsDM1n7R52UiVxTQ9vB5ryNrBBe+LK1MIMY3M2TRRrD6IkzBO1EYrRuD4IPMoJwiQ5ab+iDZagVUlrKfV4Rht377dbuOFgohaui5GL/AZsawbEhUVpRplvFZM2UCRREs4VnmxchRRoGBbkf9thaMv0jhvYrU4VxV0W4EODkb8reE143sDFpfQ2oD33ntPXawhOIULsqUwzQTT86wDTFjhFAEoBKbQllgX0cUxwEg5EeUO24b8bxu0achG51Kcq5F1dOTIEZeCTwXdNuR1P8LR8UffAgE6o/3GFG72D9zH4BPlKKcAB5aixMnImalPGLFEEToEm5B5gowlZJ9gHi5qJFkWlXMVThYY4cVJLjk5Ocf748TRp08fGTlypAo+YIQUX04xjQ9BC3eDT0YQ2HCl5pO99NpBgwZl1/KoWrWqS/uARsDe8qhGECDEqDKyhawhuJcfc7Xx2cJoBbLkjI6pFli0zhrDSDfeV23UGlM2jAobao005rFb+/nnn1Wwkoicw7Yi/9sKRzBtOCIiwuV9KOi2AtMI0YYfO3ZMTSW0hPO4Nk1/2rRpahqJtS5duqhR63bt2qlsAdSI1B5rrw2w7lDhudH25NW0d6JAxrYh/9sGLJiADKd///3XZqVsrY/kSskTb2gb8rof4YhWL8saFqHAFNH8ytryRww+Ua5gBBLFnhs0aOAw8wlfglGTAiu3Icikpb4j/RM1d3BS7dGjhxqpdFQ01Nl0VXsrAVl7+umnVco9vqziiykCV8jGsv7Cm1uuztW2l16L4ByWBXXnpIfXhpPv33//7dQqgaipgWK1qKdVEHO1MbqA0QrUZcK+WEPDios1fH4QfLI8RljNbt26daqOVrFixbKvR80PsJ7T/eeff6qAFEZuiCj32FY4x52aTwiuWNexwLQAZBk3a9bM59oKnHfR1qFmCLJTNRhtRufriSeeUP93NECEaXtaG4AMJ3TCMA0fGbCWWQUYAMP/rWs3IusY3wOMVkIlorzDtsEzbQPOoViNDbWj0L+yzJbFokgoTWKv/pG3tg153Y8ArHhq3X/FFFBMFzTq1yKYhSBcbvuqgYzBJ3IL5vwiQ2jOnDnqxIAVw+wVHP/uu+/UahT48ocMI+tli5HqjhMQskwQBMIUKZyU8gOi2sjEwgo6WAkCX1YxcpDX3KnjkdcqVaqkphAguwv1kpyB44K6XHk1VxsndK0IIupX4f/ainJ16tTR3RfTJFAQ8ZVXXpHcwop4WHEQBRefeuopFfD866+/1GcYK3E89NBDuvtry7FiugYRuY9thefbCiwHjUxYdAzQdiJrB9PN0L4NHjzY59oK1GZCdjSK1SKzCdMl0FZgCiFqS6Ij5QrU7kPtEbyWrl27qowoHBtkCGAAAm2D5UIlmAqC44cRdyLyDLYNnm8bcP7HiuBYqAGLN+B8jIFYnPvQb7MsReELbYMn+hFoa5Bti2QIDFpgwY5FixapPi0ytyxhUBoJCjh25D4Gn8gpBw4cUMsd4ydqI2D0EX/0SKfEVDCj+hNITUQmE+6LDj/SJu1lJOEPH4EA3A8nSdRryqvsI8x3xogp0kwRYEKqJ04g+ImTzIgRI1RUHqOimJeOgBpeF4IPRsts+jJk/iDrDBloRnOwrWEFIQRmUJA7L2D+tGWDhRWHcIG9e/fqRivw2cFIBUYscgs1vbCKBUZA0Gjgs4CgKTptuCAwqkHDjJEQozRhInKMbUX+w/RxjGSj7UKHDsGW5s2bqy/V+DLti20FAkLIUkUQCMViUaMPUzTQmXJnIQh8/8B3Cgx0jRkzRn1/wfcOFJS1HnyYOnWqeg5XaioSkWNsG/IfBiXQt8IgOzKWMF0MGaPoY1kWIQ/kfgRKdGAQAoMbCGoho6lp06bqdVoOQKPNQFkP1EB2J6OY/mPKxNEkygFS3/EHjy+yKNiGzjyCM9YrhGnwscIqYhhNxJS6nJZB1pw4cUIFoJAFhSCUNQQOUFz0jz/+cPo9Qwo/ptShxhMCDjiZ4IIvotg/XLTgAwJVKOaNwAOysBCE8jeYr40v1/gSbp2FFuh27typRodQh8zo80dEjrGt8B+B2Fbgew4ytTFVJVBeM1F+YNvgPwKxbUAmLtoFZD75W2JCfmPwiZyCTBGkqVtmiDizwgBq77gKS4vmpvC40XKjrux3IMBUBrw3RsX0AhlGSnDhcSFyD9sK/xJobYW2mpQ7312IyD62Df4lENsGTMVzdaoi2WLwiYiIiIiIiIiIPIbhOyIiIiIiIiIi8hgGn4iIiIiIiIiIyGMYfCIiIiIiIiIiIo9h8ImIiIiIiIiIiDyGwSciIiIiIiIiIvKYwFgf0cMyMzMlIyNTfIXZbPKp/S0oPE48VoH8mcK+YllZ8q+2wZc+g7nF1+qf+L4W/PFn2+D77YI//B3xNXgHX38ffH3/veU1ONs2MPiUB/BmJyRcEl8QHGyW6OgISUq6LGlpGQW9O16Lx4nHKtA/UzExERIU5HvBpw0bNsi0adNk3759UqxYMenQoYP0799fgoNzbu6+++47+fDDD2XXrl1y6dIl6d69uzz//PN+0zb42mcwN/ha/RPf14Lnq22Dt/CGdsEf/o74GryDr78Pvr7/3vQanG0bGHwiIiK/sHPnTunbt6/07NlTxo4dK0ePHpUxY8ZIamqqDB8+3OFj33zzTfnss8+kV69eahthYWGSlpaWb/tOREREROTPGHwiIiK/sGDBAmnatKkMGjRI/b9OnTqSnp4uI0aMkD59+khkZKTh49avXy/Lli2TVatWSfny5fN5r4mIyBuzYjEgMXLkSMPb5s2bJ82bN/fgHhMR+R8Gn4iIyC9s3rxZBZksoXOQkpIi27dvt9tRQNAK2VIMPBER+Z/cZMUGBQXJ6tWrba4vW7asB/eYiMg/MfhERPkuIyND0tMDa0pTRoZJrlwJkqtXUyQ93bsKGwYFBYvZ7NuLn168eFHi4+OlQoUKuuuR7YRRbnQ2jFy5ckW2bdsmt956q/To0UPVe8KUu0aNGsmwYcOkdOnS+fQKiCintsGbz6N5raBfK9oEsznIL4qLu5sVq6levXo+7SkRGRfpT1ftg7+dZ33xNeS2z8DgExHlq5SUZElMjEVzEnBHPi7O7JHGM/dMEh1dUsLCCouvQoFwCA8Pt7ktIiJCBaeMHDlyRHVCEIB6+OGHZeDAgXLq1Cl59913pWPHjrJmzRoVvMpNIUhvERRk1v30Z3ytvufKlWSJjz+jOhr2mSQuTlvVx9/bkIJ/rWFhhSQ6uoQEB4dIIGbFElHBSktLlfPnEyQ19UoAfjf31teQuz4Dg09ElG9wYkTgKTS0kERGFvWLEVVXYBUIbxtZQUfv4sXz6n0pVaqCz2dAuerChQvq54QJE6RMmTLq9/r168tNN90krVu3lpUrV0q3bt3cXnYWK5B4m6go3w0yuoqv1TcgAHz69FH1ZTYqqqj6cksF3+lLSjon8fGnpVatWj7bNribFUtEBf/9FOcfnHuKFi2hMm480W/wxu/m3voa8qLPwOATEeWbrOkUmSrwFBoa5vNHXhuh1xpDdKBQH8JRFow3LuWK9yMhIVm9P2ZzqPgiZDfB5cuXDbOi7E2rCA3Ner2JiYnZwScoVaqU1KxZUw4ePOj2PiFjAUvfelM2EIIxSUl4r73vc5iX+Fp9y9WrVyUtLV2ioqIcnoNwqsV7i8+vwwQpH2sbvPG1hoaGSFSUWRISzkhc3HkJCcl6X3AO8aXsSXezYjV47zANG6ufos5TixYt5JlnnpGYmBifzYj1h8xQvgb/fx9SU69KZmaGFC1aUg1ae0J+n2cz86BtKOjXoPUZRDIcLthgD4NPRJTvfDnjqUePJ+Wdd+aoL7KLFi2QihUry113tZZff90kv/++Rfr3HyK+xpffDw2CS+gMnDhxQnc9Ohbnzp2TihUrGj5OGw3H9DvUAbGEKRmFCuXuC483BhvxBcUb98sT+Fp9gxYMzelcpH2x9sbAU163Dd7wWk2mrA4lzhcmU2CcMywhC/add95RQScESPfs2aNWudu4caN8/vnnEhIS4tMZsf6QGcrX4L/vA+oYxcaaJTg4yOMBW08GYrt16yIzZ85TbcN7782XSpUqyd13/09++WWTbNmyWQYNej5Pnie/gskZGeZr2WiF3fqOzOATEZEbvvzyCzl27Kjs3r1LPvnkAxX4KFIkSlauXC4PPdTJ5v4vvjhMjh8/pjK+0AANGzZKKlTICoh06vSAGvHX6mrgZD59+mzD512zZpWsWrVCTUupXLmKDB06Ut0/ISFeXnlllCqgjYZt9OjXVUcuPj5OXY/t+eq0CWc1btxYdQq6dOmSfd2mTZtUB6Fhw4bq/wkJCaoToWU54X2rW7euLF++XNq0aZP9OASxDh06pGpAEREVRNuAzsm8eXPU7yVKlJAXXnjJbg06tg15mxULNWrUUBcN2pF69eqp+oCoE3jbbbeJL2bE+kNmKF+D/78PKKCdtQhFpscGzPIjawjbxf6vWrVSjhw5LDt37pAPP1yS3TYsX77UsG2ApKTz0qvX0zJ9+iwpVaq0bnB0wYLZamAD55QHHmgnnTo9avMaPvtsmXz99Ze66/bu/Uc2bNjsdr8B7wfel/PnL0tycnr29c5mxTL4RETkhD/+2CYLFsyRgwf3y9ChA+T11ydIhQqV1G1vvPGK9Os3WP1uXVdC07Hjo2pFNTRAaAimTZskEydOy759woTJuobFyN69e2T58k9l5sz510ZQ5sq8ebOkf//B8sUXn6tRdjRgr7wyUv7++09p0OAmmTt3pvTo8azfB56ge/fu0rlzZ5k6daoKJB07dkwtq43rtA4GgklbtmyRvXv3Zj9u8ODB0qtXL7X0dvv27SUuLk7efvttVfepVatWBfiKiCgQ2oabb75F/W7ZNuA8NGnSmzJ79nsSE1Nc1q5dIxMnjpWxYyfabINtQ95nxdpTrVq17Kna7vKWzFN/yAzla/Df9yF/ahjpf3pT2/Dhh4tk5coVcvbsGZvbXn11lFSvXlPmz1+ivt/bK+vRocPD6mK9T5DbfoO7QUH/740QEeWBm25qKGPHvqXmZ0+cOFVSUq5IQkKcuqBWkvY7RhCMaJ0LqFatupw75/oX119+2agaCq12Rdu2D8rPP29Uv8fGnpXy5bMasHLlKqj/79u3V43sYt8DZYrEjBkzZP369dKpUyd57bXX5MEHH5Rhw4Y5fFyzZs1k1qxZ8scff6hA1ahRo1QW1Zw5cwIiaEdE3tc2/J+9+4CPqsoeOH5mUiAkhCRUaQqIAgIWFrFQBPQPuiqKuoAoSBGpgigICiqyWFFAUUTAArbFhotlXXQFwQKsrAoKiIgCQVoKIRBSJvl/zo0T5yUzIWVmMuX3/XzmM8mbzJs7703enXfeuedu3Pi1nH9+JxN4Updd1lu++Waj2xmN6BvKlhXryl1W7P79+y1/o3We3M2cp7QIOwD4qm8YOHCwvPnmP6Vu3XqW5frd/sCB/RW6sPzss0/JbbeNqdLzBjKfAFQp+4H95uYqv1aC5J96mg74lsiftpV4Tl77c8x9xM87xHa8sJiok6NJUylILFshUA3caPbQyQwaNES6deshH3/8oUlJXbDgaXNC8N1335rHjx7NkBUr3jE/165dW+67b2ap69MrGRdf3NVSV0OHXuiVo9NOayYjRoyWBg1OKfG8gwcPSrt27Yt+12EYhw4VXhHRDmTHjh3SseMFsnPnz9KtW3dZsGC+jB59u8yd+7i5ytu8+ely4403Syjr3r27uXmybNkyt8svueQScwMQ2H2DtGgeFn2DngjUrl2n6DEt7BoTU0OOHEmXxGLvg77BN1mx/fr1k65du5oAVWJionz33Xcyb9486dOnj7Ro0eKknw8AgX/eYGt2mkhN98OZA6VvcKUZStoXTJs2WQ4dOmSOYcOH3yZt2rST0vznP5+YLNB27c6u0vMGgk8AqlT1l1+Q2NmPWJaduO5vcnTBYrHvS5bES/8M0jgdOphh7muOGylR32y0PJbxzPOSfUP/Mr32xRd3Mbey0Cug69d/bdJcmzVrIU2bnipt27aX88+/QK677kpzVUNnsdCx1KV57713ZPfu32T8+LuKlr322lvmCqxe0daTjxkz7pUFC16Q8rj66r7y6KN/lxEjbpEOHTqak5EWLU6XTZs2SpMmTc3QDu2o9KpGy5ZnlmvdABAofUPWohfCpm/wBvqGP7NiNXC0ePFiUzdLA0gnq+l35ZVXyocffiivvfaayQZo1KiRDBs2zASzAITGecOx5xZLbt+/BWzfUJzWr9OarxMn3m0uSmzb9qPcffdEcy4RGxvnsS2LFy+QmTMfrfK+geATgCp1YvBQyel9Rcmr23rfsJGkffK5x+ceffo5t1e3fUGLfP/1r1ebMdiXX36ljhCXOXMeN53IiRNZsnDhfFNk9uqrr/W4jjfeeFXWrVsrjz02R6pVq1a03DljjqbP/vWvV8lzz813+/y6deuaQoBOWhOkbt3COlF65WPmzMLOODc3V8aNu01mz35KFix4Si65pLBukc6+pMUOCT4BCNa+wR6CfcPy5a+Z4uKufYMOtfjhh+8tJw9ZWcel1h/9oyv6Bt9kxQ4ZMsTcAITueYPJfArQvsGdOnXqyuHDh0zgSbVq1Ubq1asn+/btk5Yt3Q8H1vpO+ncaXHKqqvMGgk8AqlR+/Qbm5lb16kWpsu44Tm8p/tKq1Vly1lltTSdS2LQYufDCzvLaa0tNKq3OPKFXDjp37lbiuZrR9MwzcyUz86g5sDs7DKUdSFZWlrnKoFat+ljOOefcoseTk/eakw3tJC644CJ5/PGH5Prr+0tMTIx89NFKufjiziVe7+23/yG9el1hnqOdlK6jY8fCdek6ACBY+wZ7CPYNR4+W7Bv0OS++uMgUttYhX6tW/UvOO69jUY0P+gYA4cjb5w1arFt8UHi/Mn1DafR7vPYNAwceMBMV6WypGRkZZsa64n2DM1PqlVdekqefLiw07o4/zxuopAoAZaAdiFNy8h4ZP36UCRxdd93fzCwZ48ZNlK+++kLeffetEs/VsdQ6S92vv+6S0aOHmxRXvenVhOPHj8mDD06XW2650SzbsOFrmTJletFz9XU+//wz83ObNm2lT5/rzNWJW28dLHv37pbhw0dZXkvrgaxZ81nRlRS9/+STf5u/1xOb9qV0ygCAwOgb9KRiwoQ7ZfLk8WbZ6tWfyqRJU+kbACDE+wb1zjtvysSJ48xkCDNn3idPPfWEWa41/yZNukemT58it902RB57TGdBfUSqVate4rxBvfHGK3LRRZ2LiosX5+/zBluBDjZEpWiR4NRUawpfoNLobmJirKSlHQv66VV9ie3km22Vm5sjKSm/S+3ap0hUVLQEo2HDbpann37OXMHQTmPJkuekfv0G8vDDT0hOTo68+ebr0r//TRIREVHiuZ6mQq1q7vZLUlKsRERwfSKU+oZwOq7xXoNLefqGQD2OVqZvCNT3St8Qmv1CKBwfeQ+hvx/8dc7g6+OsL/qGquwrPO2Xsp43EHwKkY4knA7W/sB28s22CoXgU2VU9YmEJ5xghEffEE7HNd5rcAmF4JMvVPV7pW8IzX4hFI6PvIfAQPApMEQGUfCJy9oAAAAAAADwGYJPAAAAAAAA8BmCTwD8jlJzgYX9ASAQcCwKLOwPAFWN41Bo7Q+CTwD8xjlFtMORx1YPIM794dw/AOBP9A2BKScn29xHRERWdVMAhBlnAW7ncQihcc5AbwLAb+z2CImKqi6ZmemmU7HZwivYkZ9vE4cjsCYYLSjIl6NH0yU6urrZPwAQyH1DIB5HfaWq3qte2dYTvszMNImJiePCBIAq6Rf0+KPHIRUdXU1sNpvXXycU+pR8P70Hb5wzEHwC4DfaadSqlSQpKfslNfVA2G15vUqQnx94M8voiV58fJJPOnUA8GbfEKjHUV+o6veqJ37aNwBAVXAef5wBqFA8zgbbe6jsOQPBJwB+FRkZJfXqNZa8vNyw2vIREXpyVUOOHDkecFdYdJ8QeAIQ6H1DIB9Hva2q36sOtWMoNoCqvzBRW2rWTPRJyY6qPs4G43uo7DkDwScAfqcHraio6LDa8pGRdqlevbpkZTkkLy+4r7AAQFX0DeF0HA2n9woApdFAuN3u/fOGUDjORgbZewivgisAAAAAAADwq6ANPq1Zs0b69u0r7dq1ky5dusicOXMkL69s6XiffPKJDBkyRM4//3w566yz5IknnvB5ewEAAAAAAMJRUA6727Jli4wZM0aGDx8us2bNkt27d8vMmTMlNzdXJk+eXOpzH330UXnnnXdkxIgRZh3VqlUrc9AKAAAAAAAAYRB8WrJkiXTu3FkmTJhgfm/durU4HA6ZMmWKjB49WuLi4tw+b/Xq1fLmm2/Ke++9J40aNfJzqwEAAAAAAMJPUA67W79+vQk+ueratatkZ2fLpk2bSg1aabYUgScAAAAAAAD/CLrgU2ZmpqSkpEjjxo0tyzXbKSEhwQzBc+fEiRPyzTffmKF5w4YNkwsuuEC6desmd911lxw4cMBPrQcAAAAAAAgvQTfs7tixY+a+Ro0aJR6LjY01wSl3fvvtNzM0TwNQN9xwg4wfP15+//13eeaZZ+S6666T999/3wSvKjPNYTCIiLBb7sF24jPF/x4AAAAA+FLQBZ8q6ujRo+b+kUcekQYNGpif27dvL+eee65cdtllsmLFCrnlllsqtG673SaJibESTOLjY6q6CUGB7cS24jMFAAAAAGEWfNLsJnX8+HG3WVGeio1HR0eb+7S0tKLgk6pXr560bNlSfvnllwq3KT+/QDIySrYnEGnGkwZUMjKyxOHIr+rmBCy2E9sq3D9T2lYyJAEAAACEZfBJg0tJSUmSnJxsWa7D7dLT06VJkyZun+esEaXD73R2PFdaqLx69eqValdeXuCfTLrSk99ga3NVYDuxrfhMAQAAAEDlBGXhn06dOsnatWsty9atWydRUVHSoUMH83tqaqrs37+/6HENWJ111lny1ltvWZ6nQaxdu3bJ+eef76fWAwAAAAAAhI+gDD4NHTrUBJ/mzp0r27Ztk1WrVsmsWbNkwIABRcPutKC4zmbn6o477pAvvvhCZs6cKVu2bJHVq1fLyJEjTd2nHj16VNG7AQAAAOAra9askb59+0q7du2kS5cuMmfOHMnLyyvXOqZPny5nnnmm5eI2ACCEh905C4XPnz9f5s2bJ4sXLzaz1PXp08cEnEqjnc2CBQvkqaeekuXLl0vNmjXliiuukIkTJ4rdHpRxOAAAAAAe6AXnMWPGyPDhw83F6t27d5sL0bm5uTJ58uQybbeXX37ZzIwNAAiz4JPq3r27uXmybNkyt8svueQScwMAAAAQ2pYsWSKdO3eWCRMmmN+19qvD4ZApU6bI6NGjPU5W5KSjLRYuXCj33HOPTJs2zU+tBoDQQ7oPAAAAgJC0fv16E3xy1bVrVzPh0KZNm0p97s6dO2XSpElmmF7Tpk193FIACG0EnwAAAACEHJ0NOyUlpWjWayfNdtKyHToEzxOdRXvUqFGmZqxOdgQACNNhdwBQGWMnTZW9hzP8thHtNpGIyAhx5Dkkv0D8qnGdeJn/+MP+fVEACAO+6kv80WeEQ99w7Ngxc1+jRo0Sj8XGxprglDtajFxryWqGVL9+/bzapsjIqr32HxFht9wHI95DYAj2/VCV7R818W5J9krfYZOISLs48vJFxDudRaM68bLgyUfFFwg+AQhLerKQ33mq316vwGaTArtN8vMLpKDAv9GnvetC++QCAEKtL/FHn0Hf4JlOUBQZGSlTp3p339rtNklMjJVAEB8fI8GO9xAYgn0/VEX796cfk4Ku93plXeWbt/Pk9n/5iM+OUwSfAAAAAIQczW5Sx48fd5sV5anYeHJysnz55ZfSrl27omXOIGCPHj2kY8eOZga88tJgYkZGybb4k2Z56Ml2RkaWOByaLRF8eA+BIdj3Q1W236FZrV5Ka9WgtrfW5WxbWlph1mhZ6XYsSwYZwScAAAAAIUeDS0lJSSaY5EqH22lNpyZNmrh9ntZ5Gjp0qGXZ5s2bzYx3Onte8RpS5ZFnhsdUPT3ZDpS2VBTvITAE+36oivbnF/wZ0K4Mm81W9LO3smS1bb7aHgSfAAAAAIQkLRa+du1aGThwYNGydevWSVRUlHTo0MH8npqaKjk5OdKgQQPze/369c3NVVpamrlv1qxZ0d8BAMouOKuDAQAAAMBJaAaTBp/mzp0r27Ztk1WrVsmsWbNkwIABRcPutLh4t27d2JYA4ENkPgEAAAAISe3bt5f58+fLvHnzZPHixZKQkCB9+vQxAScAgP8QfAIAAAAQsrp3725unixbtqxMw/e2b9/u5ZYBQPhg2B0AAAAAAAB8huATAAAAAAAAfIbgEwAAAAAAAHyG4BMAAAAAAAB8huATAAAAAAAAfIbgEwAAAAAAAHyG4BMAAAAAAAB8huATAAAAAAAAfIbgEwAAAAAAAHyG4BMAAAAAAAB8huATACBkrFmzRvr27Svt2rWTLl26yJw5cyQvL69c65g+fbqceeaZsn//fp+1EwAAAAgnBJ8AACFhy5YtMmbMGOnatassX75cpk2bJm+//bY8+eSTZV7Hyy+/LO+//75P2wkAAACEG68HnxYtWlTq42+88YY4HA4ZNGiQFBQUePvlAQAByB99w5IlS6Rz584yYcIEad26tfTq1UvuueceeeWVVyQzM/Okz1+7dq0sXLjQPAcA4HucNwBA+PB68EmvMGdlZcmIESNKDFmYP3++PPvss3L48GHZuHEjwScACBP+6BvWr19vgk+uNAsqOztbNm3aVOpzd+7cKZMmTTLD9Jo2bVqh1wcAlA/nDQAQPnwy7E5PHKpXry7XX3+97Nq1yyxbvXq1ubrxzDPPSP369Qk8AUCY8WXfoJlNKSkp0rhxY8vyuLg4SUhIkN27d3t8bnp6uowaNUruuOMO6dSpU4VeHwBQMZw3AEB4iPTFSmvUqCFPPfWUuZJ97733ymuvvSbffvutqb/Rtm1b8zc2m80XLw0ACFC+7BuOHTtW9BrFxcbGehx2p8XIx48fbzKk+vXrJ94WGRk4pRUjIuyW+1DGew1Ngbhf7TaRAh9/p/XVd2ZteyAcozhvAIDw4JPgk9Po0aNl8ODB5ufbb79d3nrrLbniiivko48+IvMJAMJUIPUNCxYskMjISJk6darX12232yQxMVYCTXx8jIQL3mtoCqT9GhEZIQUaxfERPY74su2BdIwKpL4BABBEwad9+/bJ4sWLZfLkyabD0Kmvf/vtN7nqqqt89ZIAgADnq75Bs5vU8ePH3WZF6fA7d5KTk+XLL7+Udu3aFS1znuT06NFDOnbsaGbAq4j8/ALJyCjZnqqi2SJ60p6RkSUOR76EMt5raArE/erIc5j/dV8Fnny1bmfb09IKs0bLSre/LzLPOG8AgNDns+DTiRMnzHCKa6+9VubOnSszZsyQQ4cOyaefflr0Nwy9A4Dw4qu+QYNLSUlJJpjkSofbaU2nJk2auH2e1nkaOnSoZdnmzZvNjHc6e17xGlLllZcXGCfIrvSkPRDb5Qu819AUSPtVY0O+yMpxPQ76KutH2x4o25HzBgAIfV69dHHjjTea+//85z/SvHlzky575ZVXmuV6QtCgQQM5ePCgDBkyxPzdTTfdJAMHDjQ3AEBo8lffoMXC165da1m2bt06iYqKkg4dOpjfU1NTLbPtaZHzM844w3JzBpyaNWvmMWgFAKgczhsAILx4Nfh09tlnm6sz06dPN/UzdPiDTq1tt9tl9uzZsnTpUjMbkX65V2eeeaa0atXK3AAAoclffYNmMGnwSTOqtm3bJqtWrZJZs2bJgAEDiobdaXHxbt26+eR9AgDKjvMGAAgvXh12d/fdd8tLL70k//rXv8wJhc4epFNcv/HGG5KYmCgTJkwwwx/05ENraOgMR3ryAQAIXf7qG9q3by/z58+XefPmmbpS+hp9+vQxAScAQGDhvAEAwotPaj7VrFnTpNJu2rRJFi1aZIZUKP35ggsu8MVLAgACnD/6hu7du5ubJ8uWLSvT8L3t27d7pT0AgNJx3gAA4cFnaUc6bOK9994rOrkYMWKEfP/99/LEE0/46iUBAAGOvgEA4O++Yc2aNWZ2VZ3ZtEuXLjJnzhzJy8sr9TlffPGFjBw50vy9ZtZedtllZlh3dnY2OxAAAmm2O/Xoo4+aOh86a5BOWX3vvffK+++/bx5jpjsACE/0DQAAf/UNW7ZskTFjxsjw4cNNHcDdu3fLzJkzJTc3VyZPnuzxeR9++KE0bNhQBg0aZIaI63oee+wxSUtLMzO1AgACJPNJ62688847pt6G6t+/v9SuXdtMXQ0ACE/0DQAAf/YNuo7OnTub+oKtW7eWXr16mQDXK6+8IpmZmR6fd99995nbRRddZJ53ww03yK233momswAABEDwSa9YqB07dpg6HmeddVbRY3fccYe8+uqr5kqD8+8AAKGPvgEAUBV9w/r1603wyZVOfKHD57QGoSfVqlUrsUyfEx8fz44EgEAYdrdy5Upzr7MNFXf++eeb2Y6ioqLMrEbMdAcA4YG+AQDg775BM5tSUlKkcePGluVxcXFmRlQdglcWWVlZpgaUZkvp0D0AQAAEn1q2bGn5/ZtvvpEOHTpYDvZq8ODB5n7jxo3SsWPHChUO1I5Kr5Ro56FFBMeNGyeRkWV/S9OnT5fly5ebdTkLHAIAvM9ffQMAIHj4um84duyYua9Ro0aJx2JjY0sddue0dOlSE3DSTKj7779fLr30UqmMyEifVT0pk4gIu+U+GPEeAkOw74eqbL/dJlJQiVp27nirpra2zVfHKa8Hn7RD0AO5zg4xfvx4MzbamdJ69913m2KCrj9rEb8ffvihXFczKlo40NXLL79cVMQQAOBb/ugbAADBJRj6hquuukrOPfdc2blzpzz11FPmwveUKVMqtC673SaJibESCOLjYyTY8R4CQ7Dvh6pof0RkhBRolMdL9Njizbb56jjlk9nuvvzyy6IrDK5jtLVAn7MTcf5ckTHcroUDlRYBdDgcpiMYPXp00VUST9auXSsLFy40xQanTZtW7tcHAARe3wAACD6+7Bs0u0kdP37cbVbUyc4ZlM50p7d27dpJUlKSjBgxQoYMGSL169eX8srPL5CMjJJt8SfN8tCT7YyMLHE48iUY8R4CQ7Dvh6psvyPPYY4H3go8eWtdzralpRVmjZaVbseyZJB5Pfik6V56gNYO4pxzzjHLfv/9d8nPzzcdhuvP+/btq1B6mBYO1CCTp8KB+rMnetVi0qRJbseWAwB8wx99AwAguPi6b9DgkgaMkpOTLcs12yo9PV2aNGlSrvU1atSoqF0VCT6pvLzAOEnXk+1AaUtF8R4CQ7Dvh6pof36BNdheUa7HRG9duNW2+Wp7+CTzSWlhv+eff94U6OvRo0fR8uI/l7cTqUzhQO1kRo0aZWbP6NSpkwliAQD8x1d9AwAgePmyb9Dv/DrqYeDAgUXL1q1bZwqZO+tLpaamSk5OjqUGrJ5zFM+M0nOHiIgIadq0abnbAQDhzqvBp88//9zUXVJ6gNebjpHW2koaidMx08V/7tmzZ7leo6KFA/Py8sxYcs2K6tevn3hbVRcPDJfCcP7Cdgr9beWLQn9l5e/Aii8LBwZK3wAACC7+6huGDh0qAwYMkLlz50rv3r1lz549pmasLnMGl/QcYcOGDbJ9+/ai5/Xq1UtuvPFGueCCC0yxcS12rjWftPi5ZlMBAKow+KRjtp1XLK6//npTFFBPsjRFVXn62R8WLFhgZsLTqVq9LZCKB4ZLYTh/YTuF7rbydqG/qigIGAiFA4O9bwAAhHbf0L59e5k/f74pubF48WIzUqJPnz4m4FQaDYatXr3azHanWVHNmjWT++67T6655poKtQMAwp1Xg09a8Pvtt9+WsWPHyooVK+Sll14yB+tnnnnGXLVw/VmvdGhHoJ599lnzHF8WDtSx3trJabHA4uMitdPT2TZ0BryKCITigeFSGM5f2E6hv628WeivqgoCBkLhwEDpGwAAwcWffUP37t3NzZNly5aVWKb1ZYvXmAUAVJxPCo737dvX3L7//nt58MEH5emnn5ZTTz3VXHn44osvzN9pEEiDQeedd5589dVXZe5EKlo4UOs8adqtq82bN5sZ73T2vOI1pMor2IqsBXthOH9hO4XutvJWob+qLAgYCIUDA6VvAAAEH/oGAAgfXg8+6UlV69atZeTIkSaddfny5eYE48033zRjrfWxyqpI4UCdkaL4rBRpaWnmXtNoXQsMAgCCr28AAAQX+gYACB9eDz7p8DW9oq0FwXUc92+//WYK9mnncuDAAcvV/1q1askpp5zit8KBAICq4Y++AQAQXOgbACB8eD34pEMn6tSpY37W4I8GivRkQ08wXn31VcvfduvWTWbPnu23woEAgKrhj74BABBc6BsAIHx4PfjkcDhk7969RTWUdHpSDRC588QTT1T4dSpSONDd8D0yowDA9/zVNwAAggd9AwCED68Hn/Ly8uSyyy6T5s2by7nnniv79++X1157zW2B3R9++EHeeOMN6d+/v7ebAQAIIPQNAAD6BgAIX14PPlWrVk1WrVolW7ZskdWrV0tKSoqp89G0aVM544wzLEGomJgY+eabbwg+AUCIo28AANA3AED48nrwSQNK9erVkx49epjbtGnTZMWKFbJo0SJz8jFlyhSpW7eut18WABDA6BsAAPQNABC+7N5e4ddff235PTo6Wv72t7/JBx98IG3btpXc3FxvvyQAIMDRNwAA6BsAIHx5PfjkiQahhgwZIg0bNrQs//TTT82wPABA+KFvAADQNwBA6PP6sLuBAweWWGaz2eSVV15xeyX8zjvvlFGjRnm7GQCAAELfAACgbwCA8OX14JMWEB89erTY7YVJVVpg/Pnnny8xrerChQvlmWeekeHDh8ttt93m7WYAAAIIfQMAgL4BAMKX14NPmuU0duzYouCTevHFF829znz34YcfygsvvGBqPz377LPSrVs3bzcBABBg6BsAAPQNABC+vB58ckezn/r06SPbt2+XU089VYYNGybXXXedmf0IABCe6BsAAPQNABAe/BJ8UjfddJNccMEF0qRJE3+9JAAgwNE3AADoGwAg9EX6a7jFDTfc4I+XAgAECfoGAAB9AwCEhz8LM3n5hAIAAPoGAADnDQCASF/U8OjevbtlWVZWlvTv319q164tDRo0kPbt28tf/vIXadSoEXsAAMIAfQMAgL4BAMKX14NPDz/8sNuTjmPHjklGRobs2rVLFi1aJFOnTpUOHTrILbfcIj179vR2MwAAAYS+AQBA3wAA4cvrwadrr73W3L/11lty/fXXm5+Tk5Pl+++/l5tvvrno73TZhx9+KNOnT5eVK1fK3Llzvd0UAECAoG8AANA3AED48knNJ6VBJc14UjVq1JBp06aZ4XdOOuTu1ltvlY8//lgGDRrkq2YAAAIIfQMAgL4BAMKPVzOfNLPJWWxcA08aVHL+npeXJwMHDpS4uDjLc+x2u/Tq1UvOO+88bzYFABAg6BsAAPQNABDevBp86tKlS9HPGzdulM6dOxcFnxITE+XHH3+U3r17W56zb98+UwtkwIAB3mwKACBA0DcAAOgbACC8eTX4NGLEiKKfn3zySTOsTjOb1I4dO6Rfv34yZMgQiYqKKvo7LUL+xhtveLMZAIAAQt8AAKjKvmHNmjUyb948s96EhATp27evjBs3TiIjPZ8KrV69Wl599VXZunWrHD16VBo3bmzadNNNNxW1EwBQdj47co4dO9ZyYG7ZsqXJftq5c6fl7/SgP3HiRF81AwAQQOgbAAD+7Bu2bNkiY8aMka5du8ry5ctNHdq3337bBLxKoxMiNW/eXB5//HF5/fXXzSgNfc7ixYvZgQAQSMGnG2+8UZ599lkzy5364Ycf5NNPP5X33nuv6G+OHz9uriTolQgAQOijbwAA+LNvWLJkiSkFMmHCBGndurWpNXvPPffIK6+8IpmZmR6fp2VBpk6dKhdeeKG0adPGZDwNHjzYBLAAAAEQfOrRo4dceuml5sqEznL34IMPmuW33367uf/oo4/M/TfffGMO4ppK63A4vN0MAEAAoW8AAFRF37B+/XoTfHKlWVDZ2dmyadMmj8+Ljo4usax+/fpy4MABdiQABELwKT4+XurWrWvub7nlFnNFIScnx8x+p/dKf9YUVu1stBNxFiUHAIQm+gYAgL/7Bl1fSkqKqdfkSmff1tpPu3fvLtdO0WCVDsUDAFRxwXEVERFRVBhQr0z8+uuvcvbZZ5vfnfcLFy6U9PR0U0RQOxQAQGijbwAA+LtvOHbsmLnXrKriYmNjSx12V9xPP/1kMrG0ZlRlREZWbbHyiAi75T4Y8R4CQ7Dvh6psv90mUuDlBBxvJfRo23x1nPJ68Elpx6CFA48cOSIdO3aU6dOnmxkstECfdhw61rp79+4SExNjxm8DAEIffQMAIBj7Bq01NX78eLnooovMjHcVZbfbJDExVgJBfHyMBDveQ2AI9v1QFe2PiIyQAo3yeIkeW7zZNl8dp7wefJo0aZJUr15dUlNTzdWGbt26mVRaHcutM1foFY5mzZp5+2UBAAGMvgEA4O++QbOblLuglb6eDr87maysLBkxYoTJ0JozZ45lVr7yys8vkIyMqr3wrlkeerKdkZElDke+BCPeQ2AI9v1Qle135DnM8cBbgSdvrcvZtrS0wqzRstLtWJYMMq8HnzZv3mzu9SqFXsX47LPP3E5lmp+fX6mDNwAgeNA3AAD83TdocCkpKUmSk5Mty3W4nQ7la9KkSanP1wDVyJEjTQDqpZdeKlOw6mTy8gLjJF1PtgOlLRXFewgMwb4fqqL9+QWFWZ/eHGrnrXJG2jZfbQ+vR3+WLl0qr7/+ujRt2lTefvtt04kMHTrUFPvTez3QP/3006ZwoHN8t3OsNwAgNNE3AACqom/o1KmTrF271rJs3bp1Zj0dOnQwv2vm1f79+y1/o8MAhw0bZl5T26lBLABAAAWf6tWrVzSjhB7UtcCfTm9arVq1ovsrr7xS3nzzTdm5c6dJg61Zs6a3mwEACCD0DQCAqugbNIilwae5c+fKtm3bZNWqVTJr1iwZMGBAUSaT1nPSIX+ubrrpJjlx4oQpMH7o0CHz+s6bBqsAAOXjs3Fv//jHP2TBggUmnVUP+jrmWu+1U9Gx21pI8NlnnzVTnDZq1MhXzQAABBD6BgCAP/uG9u3by/z582X16tVy/fXXy4wZM+Tqq6829aZONrvd1q1b5dprr5UrrrjCcnv11VfZiQBQTl6v+aRjtrXD0KsCOjb7nnvuMcuvu+46y1jEwYMHm6sY//3vf4tSXgEAoclffcOaNWtk3rx5smPHDklISJC+ffvKuHHjTPFaT/SERE8k9CRDZzTSq/A6m5Fe9aY2IQAEf9+gs+XpzZNly5aVWLZ9+/Zyvw5C29hJU2Xv4QyvrEsnJ9NZxUzhaS+U6mlcJ17mP/6wN5oGBE/wSWeD0I7CtfiVGjNmTNGJgdKZLc477zyzfPny5RLUHA6J/P5by6L8WgmSf+ppIidOSORP20o8Ja/9OeY+4ucdYjturSbvaNJUChKTxHb4sETs22t5rCAuThzNTy98zR82l1xv67M0b1nsu34R+1HrwdHRoKFIwwYiaWkS8d2PIi5V/Quqx4jjjDPNz5Gbv9Pe3rrelmeKxMSIfc9usadZU43z69aT/FMaii3zqET8stPa3sgocbQ5q/C9/viD2PJyrW1q3kIK4mqK/fd9Yj900LrexCTJb9JUpxmRyB3FvgDYbJLX7uzC9f60XWwnsqzrbXqqFCQkiu3gQYnYv8+63prxkt+suUhurkRu/aHkNjyrnUikXWTHDolIPmjZTo6GjaWgTh2xpaVKxJ7d1vdaI1Ycp7cs3IbFPg9mvWe00g++2H/7VexH0q1tqt/A3GxHMyRi1y/W9UZXE0er1oXv9YctYnPkWdern4e4OLHvSxb74UPW9SbVlvzGTXSaF4n8+Sfrem12cbRrX7je7dvEln3Cug1PPU0KaiWI7cABiTjwu3W98bUk/7RmIjk5EvHDNhGd4SAjq2hb5bVtr1MvSMTOHWI7Vuzz3aiJFNSuLbaUFIlI3mNtU2ysOFq01MqiErnl+5LbsFUbkehosf+6S+wZR6zrrX+KFNSvL7Yj6RLx26/W9VarLo4zWxW+183fi60gX844kiL5yT+aZb/VbSbZ0TFSP32f1Dpm3TdpcUlyqFYDick+Jk0O/2Z9TXuE7Dyl8P+m2YEdElXs8723dlM5Xj1OamcckjqZh8Rus0l+QYH59zoaEy+/JzWW6NxsOe2g9f9G/dSojblvemiXVM+xfr73JzaUjBoJkpCZKvWOWGtUHK9WQ/bWOU3s+Q45/ffC/xv7kZSiz+TJjhEF9eqJLT1NJC7S/M8HU9+wZcsW87zhw4ebIRV6hXzmzJmSm5srkydP9vi8lStXSvPmzc1V9lq1asmmTZtk9uzZZriFthsA4Bthed6AoKWBp/zOU72yrgKbTQr+mKXMG4Wi964j8IQwDD6lpaXJbbfdZr64a/FA1bNnT8nOzrb8nRbvy8jIMAX8dLx3MLMdPSqJl3a1LDtx3d/k6ILFJiBQ/DF16GDhSV/NcSMl6puNlscynnlesm/oL9Xee0dqTr3L8ljOJT3kyPIVJmDlbr2Hf/zFBEfi7psq1T7+yPJY5oyHJHfc7SKffCLxf/ub5bHcdmdL+qeFxRgTLu8ptpwcy+Opn683AZAaTz4mMa8utTx2/PaJcmzaAxL53beScO1fLY85Tmkoqd8VBt9qDbhOIn63BoLS3/1Aci/uIjFLnpcaT1lnN8kaOEgy58w3gYTi77UgOloO7z1cuA1HDZcoDZi5OLL4Zcm5+lqp/vZyibu/8CqaU3avyyVj2T/EduSI+224c69ItQSRsWMl/t//tjx29OHZcmLYCIn+5N8SP8Z6UprboaOkf/Sp+dndelO+/p/kN28hsY/83bTL1bG7psjxyfdI5MYNktC/r3UbntZMUjcUvr+E668Se0qK5fG0D1ZJXsdOErNgvtRY+Ix1Gw4ZLpmPPmkCT8XblB9XU1J+KZz9JX74IIncbg2SHln6huT0vkKqv/GKxM2aYd2GV10jGUuWmmBXfPfOhetwefzQnkMi1apJ3J3jJfrLddZt+OTTcuKmwVLto/el5sRxlsdyLuosR1Z8aAKDbrfht1slv2EjiZt5v1RbucLyWOa990vW+Dsl6qsvpdag/pbH8s5sJWlrNxRuwz6Xiz3zqLyov6z70CwbPPYtE+y5ec0Sue7r1y3Pff3iwfLUlXdLi/07ZNFzN1oeS4tNlCumfWF+fmzpWGmcag2mTRjyvKw/o7Ncs+EfMvzTZy2P/eucK2VGv8dM8Ojl+deXeK8XPlwYGJv25j3Sbo/18/3A3x6Rj8+9Wnpu/pfc9c+/Wx77uuXFcsfQRSZgZVnvpR+W6RiRNWqsRH2+WiJ0vzZvLsHUNyxZssTUCJkwYYL5vXXr1mZ9U6ZMkdGjR3ucpejhhx+W6Ojoot/btGlj6nvoCQ7BJwDwnXA8bwCAcOXV4JNOQ6pf1LU4oGsxQP0Sr1/+Y4pdRX///fdl0aJFZix2MM94V1CzpqR98nmJzCdz37BRicdcHX36ObeZTyq7T1/J63i+9bX+OHnSLBt36y2oVcvcZz74sByfNLVEVkOE/nDppZLx2TozrWTR86r/uW9MAKVYBF6zYNTxiZPlxJDh1vdat/BLQN7Z55Rok2Y+OR15/W23mU8qa9gIyb76Gut6E5OKXrvEe3W5QqZBPneZT84gYO7Fna3rrRlftK3cbsMasYU/zJ8vGckHLdtJM59UzqX/V/K9Op+nX6bcrFc/C+rYlGnmBN/yWP0G5l73d4n1Rlcr+jn9rZXuM590G44aK9k39LOuN6l24d+cfkbJ9dr+LPmWsXip28wndaL/TZLbvad1vfGFn7P8OnXNZyk+PkYyMrL+3FZ//D9nPjHPbeaTyr78Sslrf7a1TbF/bMOoKPfbsE7dwvVOnyHHx0+0rrf+KeY+98KLSr7XatWLfk5/7yOT+TTxgUck/5yhRZlPalm3YfLPvxSm+rtmPqmdDVqaIJXlNe3mP8qYPGi+28wnteL8frKuTY8SmU/qYK0GJdbr6u83POQ280l92q63bG5amEXpmvmkTkTHFK3X/u0L8uQDU8p0jDDbsOsl4jilbuHxIoj6hvXr15sgk6uuXbuakxjNZtKf3XENPDnVr19fDhw4UObXBgCUT7ieNwBAuPJq8CkiIsIUBXzwwQdNeqwrLexX/Krz5ZdfbmaaeOyxx+Tee++VoBURUTSMroTq1T0/pid7fwzTckezE/Lq1Cn/a+pJerPm8mfIpJjERHGcfY7k5bn/C+dwNrfrbdK0cCicu/bG1Sz9vf4x/M7tek9paG5uxcSUvt4/hgu6bVO9epLn6QpZVFSp65WWLcVRp6Hb7aTDIvP+CI65U+q+OfU0j/umoGZ86e/1rLae19uwUVGAq4QaNUpf7x9D0ty2qX59yatf3/2D0dHmsySJseJIO1ZiW5khdJ7WW7u25NUuDI6VYLeXvg1Pa+Z5G9ZKKP29/jHU8KdatSX/j6FtTgcSGpqbO1nVYouGwrmzq77n95oSX1dSa9UTu5v06pyoaqWud/cfgTF30uOSzM2dfHtE0Xrtu2qX2CalHSN0yKq4BD2DoW/IzMw0U3M7Z01y0nVr7ScdglceGqzSoXgAAN8I2/MGAAhTXg0+6dVj7RCKGzZsmNsry9rRaJrt66+/Lvn5+RR2BQKoEGJVFUwsD4orBgd/9A3H/siw05mRitNithqcKiud4eijjz4y02tXisMh1X6w1i4rSPizHqDWWivxFA3m6v/Vjp/Edvy45bH8ps56gIfEnpxsXW9cnOS3KKwHGLFls9vgf0REpMjOnRKVfEAiXP5Z8085RQrq1Te1vuy/WeuaFVSvLvnOemnfl6wHaIL/f9QDtBWbelyzYgsaNhQ56qYeYFSk5LcpDKbbf9witty8klmxNWuKbV/JeoAFSX/WA9SafxY2mzjany0REXaRrVsl6lCa9b2e6qwHeEDsv1tr2RXE/1kPUGsUltiGbduZCz/2nT+LrdjnKb9RIymoU9fUA7QXC3QW1Kgh+S3PKNyG333rPvj/Rz1AW3rJeoAFDRqIZLirBxgt+a3bFL7X77+XqPRMy3t16OchLk5syW7qAdauLQV/1AOM2PFTieC/M0hv37ZVbMWGP+Wf9mc9QPv+Ytuwlks9wK0/lnyvul67Xexa77JYVmx+48ZSULuO2FIOi31vsXqXsbGSf3pLidCk502bJCrzhPW9tv6zHqAOqbest8Gf9QDtvxavB1hN8p01FTd/b+oNWtqr+61GDbHt3VNiyLtm4hY0aiSxjlxpuM/6Xh32yGL1AK2lDPbWPvWPeoAHpfZR6745GlOrqB5g80M7Tbasq58aneVSD9B6jPg9sZEcLaoHaN03x6vFutQDLDz2RGSkFB2jzAXCP+oB2jKs3yNcjxG2uCiRGGugqKI4bwCA8OL1mk/ujB8/3uNjLVq0qPwXfABeL4RYVQUTy4PiisEtEPsGne1O23XRRReZGe8qQ2uLOWuiFRk4UOSVV0R+/l2k+GPK+T80frTI119bH9PZmG66SeS1l0xNOov/+z+Rjz82QQq36z14UCQ+QeSmOyRu5UrrY088ITJxosgnH4oUqwco555rTvYLX6O7CSpYbNki0vAskUlPaNEt62NTpmhBLZHvNupUU9bHdKp0Z4Ch33UixYJp8tlnIpdcIvLYCyKPPGJ9bNgwkcWLRfb9WvK9ajDTGSy5ZKDE/e9/1se1UPENN4i8uELkzjutj111lcg//6ljftxvQw1qxMeK3DtZpFg9QB2mLVog+YN3RW6+2frYBReIfPVV4c/u1rtjh8gpp4uMe1ik+PTt998v8sADIhvWifTubX2sRQuRn38u/LlnT4k7XFgHsciXX4pceKHIzOdE5syxPqbDU595RmTX9pJt0uFPzuDD8MEiPxYLIr33nqaliDz3D5E/ZiYrcv31Im++KbI3zf17PXHC1AOUSRO0krT1sUWLRIYPF3n7dZFbb7U+1q2bTktZuG87dJAS1dv27BGpnygyYobIW8WGMT/0kMjUqSJrPxXp08f6WJs2Ij/8EWi8spcJlFp8843IeeeJTHta5Flr3T654w6RJ5+U049nyLNPX1+iHuBV9xfu80e1HmCKNSA5cdgi2XBmF7l2w3IZ+om1VuPH514lMwc8LvWPHpAXnrIOA1edHysMHE17c6q03W2tB/hg/8fk3+ddLZdu+ZdMXDHT8tj6My6WO4cvkRo5J+Ql1/Z2//DPY0Rigsjge3UWBs/HCJ1pzsdZoYHYN4TSJEUmYB0fI9K4uYgt4qQTkETsLn5RouonKYpIPWyZ7MZfkxS5Tlajfj7lTJNp3vjwr1Ij2xoM1rIKmp0efzxdGqRZ16ulEfbUK/w/OiP5h+KbUH6t18Jkxp+SuldqZln3TUrNuiajvsaJTMuxRSeXidi21a+TFDk/S7ak+iKx8SedpChyW8mLElU9SZH2g66TJrmbpMiy3tMLL0rY9aJEasmLEmYUSmamRP7ys7W9EZFFI1h0PxX/LLlOUlTyooTnSYq0Es3PTdp6bZIi14mKyjpJkTlGXPSXMk1UZCvw99liCNI6N6mp1n+WQBUZaZfExFhJczNECsG/na4ZMsbvwSedocbdcDJ/sK97WFa8aP3iHqjbKti2U1JSbOGXiiChmU06/fbChQvlEg1auOjUqZOMGzdObtLAzUnqj+iMd5pF9dprr3ksUF5WjpxcOfZlYaH7gMh8ql5N4g/tk8zkA+ZzGOqZT/HJv0rmoTTrew3RzKf4X3dIZnqm5b1WZebT2PF3SfVfSw513RGfZC5YNMnMkBiH9cTyQEysHImuLrVyTkj9LOt3qqyIKNkTFy+2ApEzj6VLvjlJ+PO9/lIzQfLsEXLKsaNSs1iW0eFqNSS1eozE5eZIw+PW4FKOPUJ+rVlYo/P0I6lilwKpmxAn90y8vcyZT/1uHC4NW14fnJlP374gcx68p1yZT/EN6ojdS5lP4Sg/JVXsdWq7n6Tol51S+4JzPU5SpBMCeZqkqPqS5z1PUnQ0Q+q0sA5JV+k/7ZLchNoSf3M/jxOQRP/zXamlQWgPkxTVaVzH4yRFcXeM9ThJUdQXa0udpCjp7FYeJymK/fsDnicp2rZVkrp28jhJUULPLh4nKdKJezxOUnT4sNRpUzLo2vP+DeZ/ec4Lt8oFOwonoHGaffU0efvCG6XX//4pDywvrLvptLnJ2XLbmDfM98J1k0uWvrjhzo9kb51T5f5/TJbe375veWxxz9Gy5NKx0umndTL3xREeJymq3bqZx0mKYqdP9TxJ0fffljpJUWKX80tMUpT56j8k67LLJWbeE54nKdqXLLXPKQyMiZtJimpdc4XHSYqqv/Ky50mKsrOlbpPCmrDuJimKHzbI4yRFMas+kriB/TxOUlS7eSNzIdGyDT/53ASE4+6eKDEvLrY8dvy2MXJs5sMSuXG9JP71Mus2rF1bUrbuMj8nnX+2RPxa+HPxSYqGfTLf4yRFjQ//Jm8+cbnbixLa/y98pr/HSYqu++o1j5MUaSDz0xnWOtOukxSV6Rixc2eZLkwQfPICgk+hh+BT6AZVnAg+hVbwSV144YUyduxYGajZRcWCUs8//7x00+wJDzTgNHLkSJP59MILL0hSkueabsHaNwTrca0ieK9Vy1fHV3/0N+XtV8LpvQZr3xBI9KJExtqvqzzzSSeKSWvcXPKCNPMpKvWwZbIbf2U+uU5W443MJ/0fP33PFu9kPn37gjzx0P1+z3zS/ZCeVF9ygzDzKepYhiSkHrBMmuSvzKc775lh+SxVNvNJ+4omB3/xTubTHxMVlSfzKf6iv0hEGTKf/DLszhfWrFkj8+bNkx07dphisn379jVXtiMjPb+l1atXy6uvvipbt241JxhamFaHVejV8LLUFAEABC7NcFq7dq0l+LRu3TozK5IGoFRqaqrk5ORIA80m+cORI0fMVN/aD+g03vHxhTMRAgAQcpMURdrNRDGSdkwkL/+kE5Dk6SQkHlTVJEWOJo3dT3bj40mK3E1Wo/QE3hM98ddbcTaXbEZPAWYNOFhDOX/SQIXrhDU6uYwz8OS3SYr++CwV/PFZOtkkRaWut4omKZLTGrmdNMm06Y+Am9v1Nm5SGKxzJy6u9PfaqrXHz5IGFvXmjrtJisyFCi9OUuRuoqIyHSPKOFFRUAaftmzZImPGjJHhw4fLrFmzzCxGM2fOlNzcXJk8ebLH561cudLMXqTDKmrVqmVmM9KitidOnDBTvQIAgpce23UmpLlz50rv3r1lz549po/QZc4hdFpLZMOGDbJ9+59XePQChM669NBDD5kpvvXmlJiY6JUsKAAAgFCanMjbkw4xkVDoC8rg05IlS6Rz584yYcIE83vr1q3F4XDIlClTZPTo0R7rdDz88MOWmZXatGljTjKWL19O8AkAglz79u1l/vz5Jit28eLFJiu2T58+pRavdc5up6699toSj+kwPs2qBQAACHbenJzI25MOMZFQ6AvK4NP69etNkMlV165dJTs722Qz6c/uuJvSu379+nLgwAGftRUA4D/du3c3N0+W6YxxxbhmQQEAACD0s7e8nbmlyN4KseCTFo9NSUkx9ZpcabaTXuXWIXjlocEqHYoHAAAAAABCP3vL25lbpm3rHvbKekJV0AWfdEYiVaNGjRKPxcbGmuBUWelQi48++kimTZvmlZl1goFzhhJmKgnN7aQRfD2QVhUteufv91vR/72q3FbBtJ0AAAAAIOyCT96is91pHZCLLrrIzHhXGTpNpk5fHUx0WkyE3nbS1FGN4FcF/T+oivdb0f+9qtpWwbadAAAAACDsgk+a3aSOHz/uNivKU7FxV1lZWabAuE6/PWfOHDO9dmVoql5GRsn2BCLN5NGASkZGljgcniZNRLBuJzNm2VuDlssZUKmK19X3m6bTu1bwuf5uczBtJ/38B1vmHwAAAIDAFHTBJw0u6bTXycnJluU63C49PV2aNGlS6vM1QDVy5EgTgHrppZfKFKwqi7y84AlQKA2oBFubq0KwbSeNa3hrzHJFhpD5+7X1/VZ0//h7WwXrdgIQeNNb+7pganEUUAUAAGEXfFKdOnWStWvXysCBA4uWrVu3zmQydejQwfyempoqOTk50qBBg6K/OXLkiNx2220m02np0qUSHx9fJe0HAADhxZvTW/u6YGpxFFAFAABhGXwaOnSoDBgwQObOnSu9e/eWPXv2yKxZs8wyZyaT1nPasGGDZQrtm266SSIiIuShhx6SQ4cOmZtTYmKiyagCAAAAAABAmAef2rdvL/Pnz5d58+bJ4sWLJSEhQfr06WMCTieb3U5de+21JR4bO3asjBs3zmdtBgAAAAAACEdBGXxS3bt3NzdPli1bVmKZaxYUAAAAAAAAfI+pjAAAAAAAAOAzBJ8AAAAAAADgMwSfAAAAAAAA4DMEnwAAAACErDVr1kjfvn2lXbt20qVLF5kzZ47k5eWV+fkPPvig3HvvvT5tIwCEOoJPAAAAAELSli1bZMyYMdK1a1dZvny5TJs2Td5++2158sknT/rcY8eOySeffCLvvvuuX9oKAKEsaGe7AwAAAIDSLFmyRDp37iwTJkwwv7du3VocDodMmTJFRo8eLXFxcW6fl5ycLD169GDjAoCXkPkEAAAAICStX7/eBJ9caRZUdna2bNq0yePz6tWrJytXrjS3tm3b+qGlABDayHwCAAAAEHIyMzMlJSVFGjdubFmu2U4JCQmye/duj8+NioqSM844w/xco0YNn7cVAEIdwScAAAAAIUdrNnkKHsXGxprglL9FRlbtwJOICLvlPhhV1Xuw20QKbDavr9fmhXVq28ry2eI9+G4fhNt7qAiCTwAAAADgY3a7TRITYwNiO8fHx0iw8/d7iIiMkAI9M/fyZ8JbbSvLZ4v34Lt9EG7voSIIPgEAAAAIOZrdpI4fP+42K8pTsXFfyc8vkIyMkm3xJ80W0qBNRkaWOBz5Eoyq6j048hxmH3ozYOCt9Wnb0tKOlenveA++2Qfh9h5c6f9jWTIRCT4BAAAACDkaXEpKSjIz17nS4Xbp6enSpEkTv7cpLy8wAj4atAmUtgTLe9Dz+4KCAq8PkfLGOrVtZdkWvAff7YNwew8VQfAJAW/spKmy93CGX19TMxc15dBEpb0XSC6TxnXiZf7jD/v3RQEAAEJQp06dZO3atTJw4MCiZevWrTMFxTt06GB+T01NlZycHGnQoEEVthQAQhvBJwQ8DTzld57q19fUAnAFf6QweiuKXFZ71xF4AgAA8IahQ4fKgAEDZO7cudK7d2/Zs2ePzJo1yyxzDrsbP368bNiwQbZv3170vPz8/KKC5Hl5eZKbmysZGRlit9v9PlwPAEIBwScAABBSma3+yF4lSxUIDu3bt5f58+fLvHnzZPHixZKQkCB9+vQxAafS7Nu3T3r27Fn0+6ZNm+S9996TRo0ayX/+8x8/tBwAQgvBJwAAEFKZrf7IXiVLFQge3bt3NzdPli1bVmJZ48aNLZlQAIDKOXlJcgAAAAAAAKCCCD4BAAAAAADAZwg+AQAAAAAAwGcIPgEAAAAAAMBnCD4BAAAAAADAZwg+AQAAAAAAwGcIPgEAAAAAAMBnCD4BAAAAAADAZyJ9t2oAAAAAQLgbO2mq7D2c4ZV12W0iEZER4shzSH5B5dfXuE68zH/8YW80DUApCD4BAAAAAHxGA0/5nad6ZV0FNpsU2G2Sn18gBQWVjz7tXUfgCfAHgk8AAITo1WFfXil2h6vHAAAAcIfgUwieYFT1yYcnnJQAgH+vDvvySrE7XD0GAACAOwSfQvAEo6pPPjzhpAQAAAAInXpJigvMAMqC4BMAAAAABKhArpekuMAMoCzsZforAAAAAAAAoAIIPgEAAAAAAMBnCD4BAAAAAADAZwg+AQAAAAAAwGcIPgEAAAAAAMBnCD4BAAAAAADAZwg+AQAAAAAAwGcIPgEAAAAAAMBnCD4BAAAAAADAZ4I2+LRmzRrp27evtGvXTrp06SJz5syRvLy8kz5vxYoVcsUVV0jbtm2lZ8+e8uKLL/qlvQAA36NvAADQNwBA4ImUILRlyxYZM2aMDB8+XGbNmiW7d++WmTNnSm5urkyePNnj8z799FOZNm2aTJo0STp16iQ//vijeV50dLQMHDjQr+8BAOBd9A0AAPoGAAhMQRl8WrJkiXTu3FkmTJhgfm/durU4HA6ZMmWKjB49WuLi4tw+b+HChdKvXz8ZPHiw+b1Vq1Zy+PBhs5zgEwAEN/oGAAB9AwAEpqAcdrd+/XoTfHLVtWtXyc7Olk2bNrl9zvHjx2Xz5s1un3fgwAHZuXOnT9sMAPAt+gYAAH0DAASmoAs+ZWZmSkpKijRu3NiyXLOdEhISzBA8d/bs2SP5+fklnuf83dPzAACBj74BAEDfAACBK+iG3R07dszc16hRo8RjsbGx5gTEHefy4s/ToJXNZvP4vLKw222SlBRb7ue9uXi2FFRPEH+ziUiB319VxHbLbLaTD7eT4jMV2NsqmP739LgWTOgbAuMzWN7Pmi//D3mvXtyW7FePwukzrOgbKnfeECjnDN7+bJXlsxTI76Gs/wu8h9DbD1XxvxAq76EifUPQBZ+8raCgwNwqQzuhiIjyn6g1bFBPwkvF3i/biW3l7c9U+H2uwum9egd9g38+a8H9f8h79YT9GiyC+f8vOPuG0D1nqBfk76FsbeM9sB/4LIXZsDvNbnLWcHJ35dtTsXHn8uLPc/7u6XkAgMBH3wAAoG8AgMAVdMEnDRIlJSVJcnKyZbmmv6anp0uTJk3cPk9rO9nt9hLPc/7etGlTH7YaAOBL9A0AAPoGAAhcQRd8Up06dZK1a9dalq1bt06ioqKkQ4cO5vfU1FTZv3+/5ap427ZtSzxPf69bt640b97cT60HAPgCfQMAgL4BAAJTUNZ8Gjp0qAwYMEDmzp0rvXv3NjPZzZo1yyxzDp8bP368bNiwQbZv3170vBEjRsgdd9xhspz0JGXr1q3yzDPPyO23327GYAMAghd9AwCAvgEAApOtoLLVtqvIZ599JvPmzZOff/5ZEhISpE+fPibgFB0dbR6/+eabSwSf1Ntvvy2LFi2SvXv3Sr169UzA6tZbb62idwEA8Cb6BgAAfQMABJ6gDT4BAAAAAAAg8AVlzScAAAAAAAAEB4JPAAAAAAAA8BmCTwAAAAAAAPAZgk8AAAAAAADwGYJPAAAAAAAA8BmCTwAAAAAAAPAZgk9hZM2aNdK3b19p166ddOnSRebMmSN5eXlV3ayAtWTJErnllluquhkBadOmTXL77bdLt27dpH379tKrVy95+umnJTs7u6qbFnA2b94sEyZMkEsuucT87/Xo0UNmzpwpR44cqeqmIcyEWx8Q6sfwcDoOh/Nx9LnnnpMzzzxT/vvf/1Z1UxACQqUfCNbjeygct0PxeByMx9n169ebNru7vf766xKoIqu6AfCPLVu2yJgxY2T48OEya9Ys2b17tzlQ5ObmyuTJk9kNLk6cOCHfffedvPjii3L66aezbdxYtWqVxMfHm89QvXr1ZOvWrfLYY4/J4cOHZcaMGWwzF5999plER0eb7VK/fn355ZdfzLb67bffZPHixWwr+EU49QHhcgwPp+NwuB5HdR8///zzVd0MhIhQ6AeC/fgeCsftUDseB/txdtmyZVK7dm3Lsrp160rAKkBYmDBhQsFtt91mWfbBBx8UtGvXruDo0aNV1q5AdMYZZxTdBg8eXNXNCUjZ2dkllv3jH/8oaNu2bUFubm6VtClQnThxosSy999/v6BVq1YFx44dq5I2IfyEUx8QLsfwcDoOh+NxdOvWrQXnn3+++T/Vz/LGjRurukkIcqHQDwT78T0UjtuhdDwO5uPs119/bdr8+++/FwQTht2FCU3N69y5s2VZ165dTZqnpoDiTytXrjS3nj17slk80CsexenVj5ycHElLS2O7uahWrVqJ7aH/d9WrV3e7HQFfCKc+IFyO4eF0HA6342hKSoqMHj1a7r33XjM0B/CGUOgHgv34HgrH7VA5HnOcrRoMuwsDmZmZ5h+scePGluVxcXGSkJBg0m7xpzPOOMPca1rs8ePH2TRlpF9catWqVSL1E3/SLxe6nXR8/1133SWRkRyC4Xvh1geE8zE8HI7DoX4c1fenQ6OuvPJKufrqq2Xv3r1V3SSEgFDpB0Lx+B7Mx+1gPR5znK06wfEJQaUcO3bM3NeoUaPEY7GxsaZDAirj0KFD8tprr0m/fv3Ebieh0p1PP/3UXMm22WwyceJEufHGG/nQwS/oA8JDOByHw+E4On36dHMSescdd1R1UxBC6AcCUzAft4P5eBxKx9mrrrrK1G3TDLqOHTvKqFGjpFGjRhKoCD4BqPTVAz1469U0vVoL9zp16iTvvvuuubq4YMECM1uIXikCgMoKl+NwqB9H33nnHVOA+I033jAndABCV7Aft4P1eBwqx9lTTz1VnnzyyaJsxp07d8oLL7wgf/vb3+TDDz802XSBiOBTGNDsJuUuPVWvhGjKLVARDofDpNnu2bNHli9fLjExMWxID/T/rE2bNubWsmVLueKKK+Tbb7+Vc845h20Gn6IPCG3hdBwO9eNocnKy7NixQ/7yl7+UeGzQoEHmarbOzASUF/1AYAmF43awHo9D5TjboEED+etf/1r0+9lnny1dunQxddw++eQTue666yQQEXwKA3pwSEpKMv9srnS4XXp6ujRp0qTK2obglZeXJ5MmTTJT9+o0n5ruibJxXqXQ/8lA76QR/OgDQlc4H4dD8Tiqw1Z69eplWXbw4EEZNmyYPPTQQ+bkAqgI+oHAEYrH7WA6HofycbZu3bqmHlogF68n+BQmNDVy7dq1MnDgwKJl69atk6ioKOnQoUOVtg3BmSo8YcIE2bVrlxmrrtF3uKdB3uLZhV9//bW5P+2009hs8Av6gNATTsfhcDmOag2S4kWHnfU69eSuWbNmVdQyhAL6gaoXCsftYD8eh8pxNi8vr0SB923btpnEEs1EC1QEn8LE0KFDZcCAATJ37lzp3bu3SfOcNWuWWcawO6uMjAxzr8XbNC3W+btGklHo9ttvl+3bt8vs2bPN0E0dZ+xUs2ZNqVevHpvK5QqLMw1WP0N6pWvOnDnmqstZZ53FdoJfhFMfEC7H8HA6DnMcBSovFPqBYD++h8Jxm+NxYBg7dqw0bdpULrroIvO5+emnn+Spp56S888/35xzBCpbQUFBQVU3Av7x2Wefybx58+Tnn38206r26dNHxo8fL9HR0ewCF2eeeabb7aGdBQr16NGjxDBOp2uvvVYeeeQRNtUfXn/9dVP4T79g6BcN7Sj69u0rN998c9BMSYvQEC59QLgcw8PpOBzOx9G9e/dKz5495dVXX3VbowQIp34g2I/voXDcDsXjcTAeZ1esWCFvvvmm/PLLLyYIq8M3L7/8chOUCuQaYgSfAAAAAAAA4DN2360aAAAAAAAA4Y7gEwAAAAAAAHyG4BMAAAAAAAB8huATAAAAAAAAfIbgEwAAAAAAAHyG4BMAAAAAAAB8huATwkZBQUFVNwEB7tixY5KTk1PVzQDgJ/QLOBn6BSD80DfgZOgbKobgEzzSk/Djx49Xags9//zzcvPNN1foue+++64MHz7csuydd96RW265pdzrcjgc0q1bN/noo48syz///HM588wzJS8vT7xBt1evXr3k9ttvp+MKEPv37zf7+Msvvzzp395///3Su3dvyczM9EvbgGBDv1B+9AuBh34B8C76hvKjbwg89A2+F+mH10CQuvfee2XXrl0mgJSUlCQLFy6Ujz/+2Dx28OBBGTRokLRr104ef/zxogDP0aNH5T//+Y/HdWrwaOrUqR4fP++88+T11183P2tAKDs72/zcs2dPee6554r+7l//+pcJFDj/TqPPtWrVKnp8/fr1lvVu3LhR0tLS5KKLLhJfevjhh6VGjRpmm9hstqLlul2eeOIJ+eSTT+TIkSPSrFkzE1i7+uqrvfK6ycnJcuLEiZP+nbZJX9u1bd4wa9YsWbp0aYWeu2LFCmndurX5uU+fPubAHxsbW+pz9HOhnfb//ve/omUa9Nu3b5/H54wYMcLj+9bPU6NGjcz+u/HGG+Xvf/+7PPLIIxV6P0Aoo18oP/qF8qNfAIILfUP50TeUH31D8CP4BI9mzJght956qzlp/8c//mECAs6gQFRUlLmvXr160bLc3FwTZDmZ+vXruw1QPfPMM/L11197TH91TYHV7BS9qXnz5snu3btNcMeTlStXyuWXX26CD6mpqUXLnRku6enpYrf/mQgYERFhCWaVxc6dO+Xtt9+W1157TapVq2Zp++jRo+Xnn3+W2267TRo0aCBr166VSZMmmdf561//KpV1xx13yHfffVemv9UAWJMmTSzLrrzyStmxY0eZX881SKhGjhwp/fv3L0eLRaZPny6HDh2SM844w7JcP1sawDuZ4ll5zsBoZehra7v0vQwbNkxatmxZ6XUCoYR+gX7BE/oFIHzRN9A3eELfAFcEn+CRBgCefvppycjIMEGS3377Ta644goZMGCAeVx/14BKzZo15dlnny0K4mhw59VXX5X58+cXrUuHPWk2ia7HfPAiS370XIM/ZTF06FCT+aJZMLrec8891yyfMmWK9OvXr+jvUlJS5P333zeBIR0CuG3bthLruvjii0sEyHRIXnm88MIL0qlTJznnnHMsy9etWycbNmyQV155RTp27GiWaeBMM5U0YOaN4NPy5ctP+jeDBw82adHFA09q0aJFZa51NHv2bDl8+LBlWe3atc2tuG+//dYE35z7xkmDjN9884089thjRZ8J10DWTTfdVGobdAjdmDFj3D6mnzPd5mXx1ltvSVxcnGVZ+/bt5cILL5QlS5aQ/QQUQ79Av+AO/QIQ3ugb6BvcoTlvYyAAAHNlSURBVG9AcQSfUCodbqc3Z3BIh645s5zGjh1rho5ptpMOfdOAkqZDajaRBgZGjRolixcvNoGAl156yQQZtI6Tt2RlZck999wjN9xwQ9Gyv/3tb6ZtrpYtWyannHKKNG/eXN57771S17lq1Spp06aNGYJVHhpg0WyuiRMnlnjss88+k4YNGxYFnpyuueYaExTTYFirVq3El3788UcT8NHsMnd0+5SVZroVDz55oq+nnxsdsumkwUnN+tKAnw6zK06Dli+//HKp6y1tiKEOCe3evbvcfffdHv9GA6f/93//J/n5+W4f10ywRx991Dxe3qAoEOroF8qGfsE9+gUgNNE3lA19g3v0DeGB4BPKTDN0tLaPZvBo4Kdr166miPebb74pZ511lpx22mkmMHHfffeZE3bnTYe6uct08gcNRGggQ4doaVBKh8NprSgd6jVw4EDL32rmjw5f02yk8gaffvrpJxNU6dKlS4nHdDhbixYtSix3DunSx53BJ21D8eCZOyeriVTcQw89ZOpzXXrppeJP2sG6DkHUwKQGLDVb7sknn3RbE6ysM4x4u26VKw2MaaBV941m7QFwj37BM/oF9+gXgNBH3+AZfYN79A3hgeAT3Jo7d64ZdqTq1q1rsnp0OJLWftLlWrNIay0pDTZdddVV8s9//tMSaHClgRkNAOmBRQNCxYdhKQ26aICkPAEGLeytQwNdX8e1iPecOXPMcDDX+kCaGqzDtooHn7Zu3Wra0KFDh3J/KrRItmZ26bYqTof9aXCuuMTExKLHnXRbliU7bPv27WVum+6zTZs2mSFm/qbbvV69eubn33//XcaNG2eylnSIYkJCQtHf6fA7zQKrCK3l5VrEXveB1rXSW2maNm3qMatJ16H1n5yzXgCgXygv+gX36BeA0MI5Q/nQN7hH3xAeCD7BLR0ypzWVtFC3s56TDofSzBTNXtEAQo8ePcxyZ6aO1jHSYJEGpTSIpFkjW7ZsMYWwdbY6zZrSWek0iOWsUaRZUzpLmr5OcZoFpAXNS6PDt4oPu3PS4X46jO6BBx6QO++8s2i5BpfcvZ7WINLsrTp16pT7U6F1sbRAefH6Rc734SzQ7sq5zDmjn7Pe0fXXXy/e8v3335saSBr00eGE/nbgwAFTB0uDjvqZ0pRsHYrpGnhSkydPNkGeBQsWmJnnnDTQqYXEy1LTykkLhleWfo61jbpfARSiXygf+gX36BeA0ELfUD70De7RN4QHgk9wSzOY9BYTE1O0TGs86c2Z+aR1nJzpo5r5pEEDZ+aTBqZ02JIGG7TWkg7V08LOGsByLUytgYlp06aZWc+KZw1pgOtkwSctZKcBCyfNqnJmPukUprru4us9++yzzevplQedec5JayJpeyoiPj7edCbuagRFR0e7HUrnXOaaLabBL715wy+//GJm2dPi6Tpjob9pRtfevXuldevWJpijdZ80C6q0bDbNjnIWtHd2RBoMfP75500Re+cwTqUBLf18fPTRR0XFzbXQfFlmynP9jN1yyy0l6kPpftTi+eWd8RAIZfQL5UO/UBL9AhB66BvKh76hJPqG8EHwCWWmNZ6caZGareP83eFwmPvLLrusaBiUBplOP/10E6DSQJVzRrFdu3ZZAj469OnUU0+VDz/80MzGVvxAVDxDpri77rrLY+aTBsn0tdavX295jgajdPnmzZuL2qIF0//73/+aLKGK0ACPrkODWvqzKw22OQu1u3IucxZ0V1pLqyw1n7TjKs3OnTvN9tT3t3v3bhOE0lpWxWd28yUdRqeBN+dMgsW3i6fC56+//nqJzCcNnmlwSWcSdAbS9LPlDDy5WrNmzUm3j5POfuiO7kfdD66fVQAl0S94Rr9QEv0CEB7oGzyjbyiJviF8EHxCmX3+xzSimlGjw9Zuv/12k4WigQ4NENx2221uh5250pndbr311hIBAA0y3HjjjZbhafv27avUULHSAgdag+mHH34oCphpYEMDPxdeeGGFXksLmGug7KuvvjKz2LnSYuMaECnu559/thQeVzNmzKh0zSetZzV+/Hj5y1/+YmpeJScnm22uNa40g6gsQaDK0qyhRYsWyU033VSu4uiaKaUzzbmuR2cKVLpcM90GDRpkCtjrkM3rrrvO47o0EKmz2rm+vgaUNDtOa2CV1q4vvvjCBAVd9w2AkugXPKNfsKJfAMIHfYNn9A1W9A3hheATTkozepQGZ7Q+kwYwtC6RZjxpEEBP6N977z0TYNEaTBr0cEeDIBqoKl7QWwMIOnROh2XpsD7X4Ixr8fASH97ISDO0TgMSTpqV1adPn5O+Jw1qaS0q1/pQOhzPWQS8vHQ42CWXXGIyuIoHn3S5ZvNs3LhROnbsWLRct5kGyJwz3VW25pMOFdNtqFln/fv3l3vuuccEAzX4pUXHdZY5DchozSVfBlW0ExkzZozJPtL78mjcuLGl8Lgz88lZU0yHb+r70sCQfi6LF40vbsKECZZhfPr5u+KKK07ajg8++EC6d+/u0xn1gGBGv3By9At/ol8AwgN9w8nRN/yJviH8EHyCRxps0pNwrWWkhcM1W0QzlzSQolF7Jw2eaCHyF1980Qxbc9Z3Kk4DMxqYatKkiWW51uh56KGHzNAwDUxp9pG+5q+//uoxkOUMTLz22msm0KK1f3S2Pf17Z6ZMaS666CKpWbNm0e+rV68uU1CiNMOGDZNrr73WzJqndY6cunXrJuedd57JFNPsMB1apkMRtb2PPPKIJcBR0ZpPmgmlhdV1/+jMcTrFbfGhhrpftCikBmw02OcaBNSheVpDqSy0aLw7WlhdA0dacF4DT7p/yjrMT7OR9uzZY4rZa3BTA5WaBaXbUgNSzs5a35vuJ30tDah5ml3RSQOTGoxzcg4RPVmRdq3/pfsHgBX9QvnQL9AvAOGAvqF86BvoG8IVwSe4pRkiOkOcBi2WLVtmMlg0a0azSLQIswaHig+x0+FQOnROAwgaUNETfR06pz/r37/wwgvy4IMPun09zQ7SzBzN/NHaRBqM6Ny5c1HtHg00aFaSZjvpMg1k6dSumgGjwR2tG6W1nXTY2pAhQ8xQvuLFop01mZQWvtYZ+DTAcfjwYRPk0KLT+ruTZiXp65WVBuR0aJgGgTTQ4xxCqO//ueeeM+9LAyu6LZo1a2YCTxqsqgwNGunwNg3+6fh63S4a3HJHg22a9aT7UmcyfOqpp8y2c2YVlSUw46TBNFepqalmHc7PgdZl0npPZXXfffeZwvWapaXvSQNw+n40W0yDnloYXN/b008/bZZrIXx9D/p569u3r9me7t6vFpx3t421vboftK6YKw1q6WdUs9e0LQD+RL9Av0C/QL8AFEffQN9A30DfUFa2grKmOyCszJw509xrQEaDCDrrmGY2ffPNNyZAc/ToUY+FsTVDRYc7PfnkkyYAM3XqVJMd9fLLL5uAR2k0I0dfS5+vqZjusoB0uJzWMtIgkzN44qRFxJ999lmZOHFi0dAyDUppQETrVOmsfGX173//2wS1ykMDbzpU8PzzzzfBJV/T19D3rBlNGqwrCw2waJaZBvF0HykNPJXnUKABteLBRw0UtW3b1jJDYmU5h93pNtWhkVpDyvk+tUC8fiY1y0yHazpnu9N2nKzguAZRNailASr9LHXp0sW8fy1gr5lPK1asKFetKiAc0C/QL5SGfgEIT/QN9A2loW+AK4JPcEuzhMqT9QPrttNgzsmGhHmDvs7Jiry7o4FD3b+hVNNIg2qa0aQF1Sv6vnTfafBUbwBK/n/QL1QM/ULVoF8AfI++oXLbjnMG/6NvqDoEnwAAAAAAAOAzXN4HAAAAAACAzxB8AgAAAAAAgM8QfAIAAAAAAIDPEHwCAAAAAACAzxB8AgAAAAAAgM8QfAIAAAAAAIDPEHwCAAAAAACAzxB8AgAAAAAAgM8QfAIAAAAAAIDPEHwCAAAAAACAzxB8AgAAAAAAgM8QfAIAAAAAAIDPEHwCAAAAAACAzxB8AgAAAAAAgM8QfAIAAAAAAIDPEHwCAAAAAACAzxB8AgAAAAAAgM8QfAIAAAAAAIDPEHwCENLy8/Pl2LFjkpubW9VNAQBUAYfDYfoBvQcAAFWD4BMAt9544w05++yz5dtvvw3qLZSXlyejRo2SG2+80fwMAPCutWvXSps2beSTTz4JyE2rgad+/frJ+PHjq7opAACELVtBQUFBVTcCoeHMM8+UBx54QAYMGODxb2bPni0ffvih/Oc//7Es14/hL7/8UqbXqV69ujRq1KjUv3n66afl+eefl82bN0t5XXnllbJnzx6Jioo66d8OGzbMBDaqyt69e6Vnz56l/s2nn34qjRs3Ltd6f/vtN+nTp4889NBDcsUVVxQt79GjhyQnJ8vQoUPl7rvvdvsZ0C/3o0ePlspkKr322mvy8ccfm8/E0aNHpX79+tK9e3e57bbbpHbt2pb9PH/+fLfrOeuss+Sdd94xP+s69P1ce+21Mm7cuAq3DYB30F9UnTVr1pj+8aeffpKIiAg544wzzLH14osvrtD60tPTTb85ePBgufXWW4uW33zzzbJhwwbp1auXPPXUUyWep/3JhRdeKLNmzarU+5kyZYq8++67bh9zfe3ff//dtPPee++Vvn37Vuo1AQBA+UWy0RAIcnJyLEGO0jRs2FA+++wzn7bn/vvvD4ovp3Xq1JHnnnvO7WObNm0yJxhlCaIVp1/W//KXv7jdJ7q+V199VQYNGiSnnHKKeFtWVpYJUv71r3+Vyy+/XJKSksxJ0ssvvyxffPGF/POf/zQnTE52u12effbZEuupWbOm5WcNlult4MCBZp0AghP9RcW9/vrr5iKRBmH69+9vhiOvWLHCXFCYM2dOmfthVy+88IIkJibKkCFD3PYXeiHh+++/l/bt24uv1K1bV2bOnOl2uZP2V2PGjJF58+aZ9x8dHe2z9gAAgJIIPiEgVKtWTbZv317q32RmZsoll1wiV199tc/bo1din3jiiVL/JiEhQT744AOpSpoFphlB7ixZskQuuOACkzVUHprZ9NFHH8myZcvcPq6ZVuvXrzcBqocfflh88Z40uKgnM069e/c2QUe9Yq2fEx3e4WSz2Txug+JXwOfOnWsCZ2Q/AcGL/qLi9GLFZZddZunfNCtUL7ZogL+8wafjx4+bY6pesImMLPmV8txzz5WUlBRzQWHp0qXiKzExMWXqB2666SZzseL9998PigtMAACEEoJPCBpvvfWWuUqrXx59zZtp+To0bMGCBaYWhg4R08CKFj3t2rWr+cLumqHjLRoc2rhxozmZKC9tnwaszjvvPLePx8XFyciRI+XRRx81V8tbtmwp3qRZTa6BJ9cgkz5Wr169Cq9bs6l0GCLBJyC00V+4l5GRIQ0aNLAs0+OqDoPctm1bhfoaraXnafi3rnvixIkm4+jzzz83/V5V0mwnDb7p0H+CTwAA+BfBJwSF1NRUE8DRotGuafSl0S/Ejz32mMmaKW+6v6bva3ClNE2aNDEnOGWtY3T99debttx3332yY8cOMyROvwhrXSWnEydOnHQ2Hh1mpld5S6NBLr3irJlPFTmZuOiii0ywxxPdD3oV+8knnzT7xROt5aVXxk9Gh2a4GwKhw2t03//3v/81V+onTJhghhq6ex0NTJ5sGIXWNNFtozWgfBH0A1D16C889xcaJNL6SNoX6dBq53FWj7EVySrW/kL7mtjYWI9/c+mll5q/0f6iS5cupfYtWhi8ov2F9rPa75elH3A3RA8AAPgWwScEBR0GV6NGjXJlrOgV159//tkESrTWww033GCudLoLXhQ3ffp0r18VXbRokSmCrbSW0cGDB03qv2vwSYu1aoHW0mix9eIF211pxpOuQ4NbFaFFWfUqeGn0y/3tt99uaih988030qFDB49D+E5WEF2NHTvW7b7VQJ2eKOnJhmajuStmr8G6du3ameCTnmRpxpYWPHeeWLnSz4EGqnTbE3wCQhP9hef+Qus9HTlyxGQQO4ex/+tf/zJDmSsyUYT2F2Wp/XfXXXeZensrV64sNcjlKePWlU4c8cgjj5SYfKNt27amP9Bje6dOnczkF1pMvTjN/NIi6XqxR4d5AwAA/yD4BL/Sq5KlXfV0R2sP6ZfjF1980QSgykoDFhqASUtLMwEMnUFN6xTpF9fhw4fLqaeeKv6iV5+dgSenVq1ayZtvvmmu0jsLYE+bNs1k5Zys3snJhvnpa3Xr1q1CbdXXdzfsrTg9gdC6UlrLQ4vYuqND5LQeyMloPSd3dHif1iDR4SBaJFaL1rrWmdKg14MPPmier0GlX3/91eznW265xQw5LB4Uc25nPfkCENjoL7zfX2h2kAaktPaTHjPfeOMN+eqrr2Ty5MkVmpxCX/9ks88qvRigwS49jmvWlafspLL0F8UvIGmtp44dO5ogmAaU9KLTK6+8Yi5W6Iynxft6136A4BMAAP5D8Al+dejQoTIPm1P//ve/zRXOq666Ss4///wKvaYGUrQ2kQYkdH1abFQzjzQIpdk7Wt9Ih89plo3SK6eaZaNf7JV+Qdcv7K4zrLnSdZ2sOLk7zqEQOuTB6WQZRyejQyd0GIQOLasovWqsAbuyBNTuvPNOM0W31lFyl+GkJxjuMpDK6rTTTjM3rROi22bEiBFmvzk/Czo80JX+nRbP1dpOixcvLhF80sK3qlatWhVuEwD/oL/wbn+hfZkeQ//v//7PBIKcgZvvvvvOLN+5c6epQ+iL/kJp7adrrrnGBLx0tlR3KtJf6GQSrnr06GH6ZZ3RTi9eOftyJw3gOScNAQAA/kPwCV6jGSnnnHPOSYMjF154YZnWp9lOGtzQQMM///lPk92iwaKK0mCJXnHVL6o6m5vWg9q3b5/JqNJ6THpT+oVVg1XOYXf79+83X2SfeeYZS7Djhx9+MEEpHfJVEe4ywLTeRVlqPmnRb3c06KTDDLTGRkXpkAR9z2WhJzB6xVmn6HY305BuH52l8GT06vzJMrqcJyVbtmwpNRCpgSV9/Mcff3Q7RES3X3lnAATgXfQX/u8vtP/93//+Z4Ylujr77LNNMEizZvViQvGC5KXRv/3pp5/K9LcaLNMLSVon0NOwdi2IfjKaoXWyuodak1GzxXbt2uW2H9DA08n6HAAA4F0En+A1J6uR9MEHH5igRlmKmmp9JC1OqsGmUaNGmYylSZMmye7du02NpJMVFD3Zl3gdyqXBkqysrDJ9udZaGFOnTpXly5ebNH0dzqfDu7RWUUWDT56GmVW05pPWXtLhE5qFVd6hja40mKRXi8tKA4T9+/eXFStWlHhMg3uVqfnkSmt0KE8ZaMVPYNwVwP3iiy+kdevWHoN3APyD/sL//cWBAwc8FvXWY6JmRunflCf4pP2F9oval54sIKS0DpNe/NGLPp7WV5GaT576AXcXGrQf0JpQAADAvwg+wS80C2XGjBnmCmtpmU/6ZVGLfX/22WcmyKRfMpUOE9A6D/ple9iwYWboXGULRusX5bJ8WVZDhgyRzZs3m4KpOnubBq40G0uvrnpTZWo+aWaWDlHTwFpl6HvTL/ZaX6ksswTqLEaaaaX1tLxR82nr1q2mdkfxIRE6VEODaq6fH63tcfrpp1v+ToeO6NBDzV5zFwDVK+8AAhf9hW/6C2fxba0d5Xps16DTJ598YvrDFi1alGtfOWdUXb16tckQPhkNhmktphdeeMFtjany1nzSQJrWbipeN1AvxPzyyy8l+gEdtrhq1SrzPQMAAPgXwSf4lNaC0AyhhQsXmi+HmtbvKStHv/zqcAD9QqpXUjVlvvgsOPrFVL9MahBIa/pocMMfIiMjTSaW1qzQwIYOAStLkdXyqmjNJx1KoVdzNWCnwywqo2nTpnLZZZeZ7K6y1o7S7eIuqFORmk+6fTWQphlyOoxTh+59/vnnZmZAHRriOnuR/o1mVnXu3NkEqzQYpYXGGzdubIrKu/r444/NVX2d/RBA4KG/8G1/ocdOvaCj/atmkuqxU2cJ1WOrZlBpvafyZoXq32vmq/bHOqS9LP2PXkTSOovuJn4ob3+hnxm94KJD6jWbSScl0SHxmr2r69IaU660EHl8fLypCwgAAPyL4BO8SrNOduzYYe43bdpkvtDqVVX9cjphwgS3X2w3btxoMpn0bwcPHmyGX3nKSGrZsqUJZunfaRBBU/e9lX2kRUgPHjxohg9oAESHjGltCL3XaZynTJlisnv0S7PWK9GAmr4vvdpb1TWENEikwTAttu0NOjRCT1I0A81dLafi9Gq5fsl/++23K/3aWixWh2dqMO29996T7Oxss/6///3vcsMNN5QIemmxc90veiKjV8Q1IKWfIdfMOM2oe/TRR+XWW28t00x+AHyP/sL/9AKPDj3WY7Vm/+iFFZ0dVS82VHSGVA30O2eUvemmm0769zrbnGYwu8uWLa/atWub47pmXq1Zs8ZkQmnmrGYr65B91+yq5ORkc2FDJxepyMx+AACgcmwFGhkAvOSBBx4ww6P0y1+bNm1MgW4NzjinNi5OP379+vUzUyHr1dCypvzrl0gNQGkWlLtMFs2w0rR+zQgqKy2erUPqtN6FZmlp9ozeNLil7dOb8wurBqr0y7bWOdIsLA1ChRq9cjx37lyTbVY8Cy2Y6DALPdHRK/z6XspSMwqA79FfhA69CKAXLZ577jmTiRpo9OKEDvfT7C/t1wAAgP8RfIJXadaQXkktz1VFna2nIgEBDSpUpvB4cRqc4GqolWYd6b7RfRrM8vLyzPuoTCF2AN5FfxFatE/WY2wg9qN6ocv5XYN+AACAqkHwCQAAAAAAAD5TucrEAAAAAAAAQCkIPgEAAAAAAMBnCD4BAAAAAADAZwg+AQAAAAAAwGcIPgEAAAAAAMBnCD4BAAAAAADAZyJ9t+rwUVBQIPn5BVXy2na7rcpeO5TaqGgn2zJQVcVnU1/TZrP59TVDjb/7hkA8hgVam2gP2yjUPkP+bhN9AwCgogg+eYF2+Kmpx8TfIiPtkpgYKxkZxyUvL18CUTC0UdFOtmWgqqrPZlJSrEREBF/wac2aNTJv3jzZsWOHJCQkSN++fWXcuHESGem5u3vnnXdk6tSpbh9btGiRdO3aNeD7hkA8hgVam2gP2yjUPkNV0aZg7RsAAFWP4BMAICRs2bJFxowZI8OHD5dZs2bJ7t27ZebMmZKbmyuTJ08u9bkRERGycuXKEstPOeUUH7YYAAAACA8EnwAAIWHJkiXSuXNnmTBhgvm9devW4nA4ZMqUKTJ69GiJi4sr9fktWrTwU0sBAACA8ELwCYDf5efni8ORV6VbPj/fJidOREhOTrY4HIFVv8Pf7YyIiBS7Pfjnn1i/fr0JMrnSIXPZ2dmyadOmCg+fA1A1fUOgHacDrT2+bJP2CXZ7BLX/AABeQ/AJgF9lZ2dJWtohLcdc5Vv+8GG7OdkJdL5vp00SE+tKtWoxEqwyMzMlJSVFGjdubFmu2U5a+0mH4AEIvr4h0I7TgdYeX7YpOrq6xMcnSWRklNfXDQAIPwSfAPiNfjnWkwv9QhsXV6vKr6hq0dRAuXpdVe3UGdkyM4+Y/VKvXuOgzYA6dqywsHeNGjVKPBYbG2uCU6XR4XkdO3aUvLw8U+epW7ducuutt0pSUlKliwH7Q0SE3XIfCAKtTbQncLeR9g3p6SX7Br1zzuRWEACH6kBrj6/apP2CZqBlZqZLSsp+adiwaZX31wCA4EfwCYDfFA6nKDAnF9HR1ap8y2tgIFBmLKrKdur+SE3NMvvHbo+WcNO+fXt5+umnTdApJydHtm3bZma5W7t2rbz77rsSFVWxq/56QqizUPlTfHzgZa8FWptoT+BtoxMnTpjghmYpagAKgSE6OkpSUg5IjRqRUr06+wUAUDkEnwD4XahcQdWrw67vR7NndNa0YBMK+0Ozm9Tx48fdZkWVVmz89NNPNzenDh06SLt27eSGG26Qb775Ri644IIKtUkzEXT6c3/QTBUNGGRkaBAxMAKqgdYm2hO420jrFRXWexJLoF0PTdombUsgZBqVtT3+7Bt8uY10JJ/ulyNHjktWlsMs089HoGQzAgCCC8EnACiHYcNulqefXmiGd7388hJp0uRU6dnzMvnqq3Xy3/9ukHHjJrI9q4AGl3SIXHJysmW5DrdLT0+XJk2alGt9zZs3N/dpaWmVape/M+v0BDTQsvkCrU20J/C2kadhxc5gSiAEnk7WnqrqG/yxjXT/BNL/MAAgOHHpAgAq4IMP/il79uyWjz/+UG69dbCsWPG2HDlyRFaseMvjczIyjkj//n3l4MEDbh/XE5Ru3Tp5fPzIkXS5444xMnToTeY1b799pOze/Zt5LDU1RcaNu80snzlzetGV95SUwzJ27IiAK5DrC506dTJD5VytW7fODJvTbCaVmpoq+/fvt/yN1nlyN3OeOuOMM3zaZgChxVt9gwbOJ04cK0OG3Ci33jpIpkyZaALpnnTu/BcZMeKWotuMGdPMcvoGAECgIPMJAMrgf//7RpYsWSi//PKz3HXX7fLgg49I48ZNzWN///v9MnbsHebn4rOtOb366svmJMRTYEmDSLr++Phang/YkZEyfvxdctppzczv7733jixZ8pzMmPGw/POf75qr7Ndcc73cf/9U+f77b+Xss8+V559/VoYNuy1oC4mXx9ChQ2XAgAEyd+5c6d27t+zZs0dmzZplljmH3Y0fP142bNgg27dvL3pev379pGvXriZAlZiYKN99953MmzdP+vTpIy1atKjCdwQgXPsGPWaPGDFaWrVqY35/6aXF5nXuvPNut+vRYX3PP/9SieX0DQCAQBH6ZyMA4AXnnttBZs16zNTuePzxuZKdfUJSUw+bmxbqdv6shXPdGThwsLz55j+lbt16JR7LyMiQhx6aIdOnPyjVqnkuxB4bG1cUeNJsnd9+2yVnntna/H7o0EFp1Kjw5KZhw8bm9x07tpt6R9r2cCkcPn/+fFm9erVcf/31MmPGDLn66qtl0qRJpT7vyiuvNBlSd955pwlEvfzyyzJs2DB56KGH/NZ2AMHJV32DDt9zBp5Us2YtJD29/MOA6RsAAIEiaDOf1qxZY65M79ixw8yO0rdvXxk3bpzJDCir6dOny/Lly826GjRo4NP2AnDPfmC/ubnKr5Ug+aeeplMgSeRP20o8J6/9OeY+4ucdYjt+zPKYo0lTKUhMKtPmXrfuc1m0aOFJ/27QoCHSrVsPM4xCC8guWPC0JCXVlu+++9Y8fvRohqxY8Y75uXbt2nLffTPLvLs1iPTgg9Nk5Mix0rBhozI9Z+XKFbJo0QJp0+YsGTlynFmmgSc9HnbseIHs3PmzdOvWXRYsmC+jR98uc+c+boZwNG9+utx4480Syrp3725unixbtqzEsiFDhpgbgMDrG0xx6z+Kn/urb/jii7XywgvPeyzw7ayv5Mu+wZUOo9ZM1169Li/170aOHGr6lFatWsutt46SWrUS6BsAAAEjKINPW7ZskTFjxsjw4cPNkIrdu3fLzJkzJTc3VyZPnlymdeiV7ffff9/nbQVQuuovvyCxsx+xLDtx3d/k6ILFYt+XLImXdi3xnEMHM8x9zXEjJeqbjZbHMp55XrJv6F+mzd65c1e54ILOZfpb/UK/fv3X0qJFS3MFumnTU6Vt2/Zy/vkXyHXXXWmueOsJwvbtW6U85s+fK5dc0lPOOee8Mj/nqquukSuv7COvvPKyzJnzmNx99zS5+uq+8uijfze1Pjp06CgHDx6UFi1Ol02bNkqTJk3luuv6ybRpk002VMuWZ5arjQAQTn3DxRd3MTd3IiPtluLbvuobXOnw6Zo1a8r//Z/n4NMnnxTWt9P26PC8uXNny/33/52+AQAQMIIy+LRkyRLp3LmzTJgwwfzeunVrk+48ZcoUGT16dKlTaistSLtw4UK55557ZNq0woKMAKrGicFDJaf3FZZlenXb3DdsJGmffO7xuUeffs7t1W1feO+9t+Wvf73a1Oe4/PIr9Vq0zJnzuDnBOHEiSxYunG+KzF599bXlWq8+58cft5i6HM4C4VpY9vbb7yw1IKVX2fXk6MEHp5vf9bg3c2bhiZoG4rX4+OzZT8mCBU/JJZf0MMt19qXffvuV4BOAoOkbNPNJZ98Lt75BadBKL1CkpaWaYdl63PdEA09KRwD07v1Xue++KeZ3+gYAQKAIyuCTzkKkQSZXWiw2OztbNm3aZH72ZOfOnab+hw7ZA1D18us3MDe3qlcvGkbhjuP0luIvrVqdJWed1dacYBQ2LUYuvLCzvPbaUjPMQo8/mnHUuXO3cq33iSeesvx+/fVXySOPPCn16tU3vycn75XatROlevVYU9A2OrqaNG7cxDz26af/lnbtzi6xzrff/of06nWFOemoU6euWUfHjoXruuCCiyqxFQDAz31DsUyjcOkb9HkPPfSANGrUxG3gSY/nOqxOj/M6AiAqKrqobtQnn3xsJpwojr4BAFCVgq7guNYtSUlJKTFriHa+WvtJO2BPdIraUaNGyR133GGm5AaAstKTC6fk5D0yfvwoOXz4kFx33d9M/Y9x4ybKV199Ie++63467XfeeVMmThwnqampMnPmffLUU0+U6XX1dVav/sz8fPz4cZkx414z9fbw4YPMFNqjRhXWfHI6ciRd1qz5rOgqu95/8sm/zZTfekW8fSknbACAwOgbNmz4Sr78cp38978b5Lbbhpgh1XrT78HOvuHzzwv7Bu0L7r77Dhk6dKDceusgOXz4cFE9QPoGAECgCLrMJ525yTkLSHGxsbFFnXJxOgZep9jWrCidzcjbtAaAv5kinC73gSgY2qhop3+2ZX6+5yED/ua8iOxaPLastLj3vHkLzAnFqFHDpEmTJmaWuscemytvvvm6GQas01676tv3BnM7mbfeWmn5/e23VxYNO9E6IosWLS31+XolfMGCJUW/165dR+bPd184t7iICFuVHMsAIBR4s2/o0uUSWbVqbZn6inPOOVdeeOFVn/UNAACEZfCpohYsWGCu+k+dOtXr67bbbZKYGCtVJT4+RgJdMLRR0U7fbssTJyLk8GF7QAU5yhsYffnlP7/gd+vWzdycIiOry+DBvpk1zZcBXA0K2u12qVWrhlSvXt1nrwMAoWrJkmUeC5ZHR0fLwIGDq6hlAAAEhqALPml2k3P4ibusKE/FxpOTk+XLL7+Udu3aWQo5qh49ekjHjh3NDHgVkZ9fIBkZJdvja3oyqif4GRlZRcU4A00wtFHRTv9sy5ycbMnPzxeHo6BkDQ8/04wnZ0ZReTOfQq2duj90vxw5clyyshxmme7DQM9YBAAAABAcgi74pMGlpKQkE0xypcPttKaTpji7o3Wehg4dalm2efNmM+Odzp5XvIZUeVXlibSelFb1iXwotFHRTt9uSw1yBApnICeQA0/+bmcgBAUBAAAAhJ6gCz4pLRa+du1aGThwYNGydevWmWlmO3ToYH7Xwo05OTnSoEHhLFr169c3N1dpaWnmvlmzZkV/B8D3nFmHCAzsDwCBgGNRYCko4GIEACDMg0+awTRgwACZO3eu9O7dW/bs2SOzZs0yy5zD7rS4+IYNG2T79u1V3VwAf4iI0EOOTTIzj0hcXK0SU0f7m9Y6CqRsrKpop57s6f7Q/VK4fwAgcPqGQDtOB1p7fNEm7Rccjjw5ejRdbDa7REZGeW3dAIDwFZRnGu3bt5f58+fLvHnzZPHixZKQkCB9+vQxAScAgUuLWicm1pW0tEOSmpoVEO3RWkeBzvft1EkT6prXAYBA6hsC7TgdaO3xZZuio6tLfHxSlV8oAgCEhqAMPqnu3bubmyfLlv0560hpw/fIjAL8q1q1GKlXr7G5qlqVdMY9nd1Ni2wH2lVsf7dTsw4IPAEItL4h0I7TgdYeX7ZJ+wS7PYLAEwDAa4I2+AQgeBV+qY2u0jZERtqlevXqZna3QC6yHSztBABv9w2BdvwLtPYEapsAAHCHMRYAAAAAAADwGYJPAAAAAAAA8BmCTwAAAAAAAPAZgk8AAAAAAADwGYJPAAAAAAAA8BmCTwAAAAAAAPAZgk8AAAAAAADwGYJPAAAAAAAA8BmCTwAAAAAAAPAZgk8AAAAAAADwGYJPAICQsWbNGunbt6+0a9dOunTpInPmzJG8vLxyrWP69Oly5plnyv79+33WTgAAACCcEHwCAISELVu2yJgxY6Rr166yfPlymTZtmrz99tvy5JNPlnkdL7/8srz//vs+bScAAAAQbgg+AQBCwpIlS6Rz584yYcIEad26tfTq1UvuueceeeWVVyQzM/Okz1+7dq0sXLjQPAcAAACA9xB8AgCEhPXr15vgkyvNgsrOzpZNmzaV+tydO3fKpEmTzDC9pk2b+rilAAAAQHgh+AQACHqa2ZSSkiKNGze2LI+Li5OEhATZvXu3x+emp6fLqFGj5I477pBOnTr5obUAAABAeIms6gYAAFBZx44dM/c1atQo8VhsbKzHYXdajHz8+PEmQ6pfv35e3xGRkf65xhMRYbfcB4JAaxPtYRuF2mcoUNsEAIA7BJ8ABKWxk6bK3sMZFX6+3SYSERkhjjyH5BdUvB2N68TL/McfrvgKUKUWLFggkZGRMnXqVK+v2263SWJirPhTfHyMBJpAa1M4tGfQyAmy+8AR8aem9WvJ0ufm+mTd4bDPQrFNAAC4IvgEIChp4Cm/c8UDBgU2mxTYbZKfXyAFBRWPPu1dR+ApEGh2kzp+/LjbrCgdfudOcnKyfPnll9KuXbuiZc7PQ48ePaRjx45mBryK0M9WRkbJ9viCZj3oyWdGRpY4HPkSCAKtTeHUnl3JqeLofE+Fg6b62S33a657SNLSCjMQvSWc9lmwtElfiywrAEBFEHwCAAQ9DS4lJSWZYJIrHW6nNZ2aNGni9nla52no0KGWZZs3bzYz3unsecVrSJVXXp5/T1D15NPfrxlsbQqH9mjsqCJBdZvNVvRzeZ+vr+mr7RoO+ywU2wQAgCuCTwCAkKDFwteuXSsDBw4sWrZu3TqJioqSDh06mN9TU1MlJydHGjRoYH6vX7++ublKS0sz982aNSv6OwAAAAAVR3VCAEBI0AwmDT7NnTtXtm3bJqtWrZJZs2bJgAEDiobdaXHxbt26VXVTAQAAgLBC5hMAICS0b99e5s+fL/PmzZPFixdLQkKC9OnTxwScAAAAAFQdgk8AgJDRvXt3c/Nk2bJlZRq+t337di+3DAAAAAhfDLsDAAAAAACAzxB8AgAAAAAAgM8QfAIAAAAAAIDPEHwCAAAAAACAzxB8AgAAAAAAgM8QfAIAAAAAAIDPBG3wac2aNdK3b19p166ddOnSRebMmSN5eXmlPueLL76QkSNHmr9v3769XHbZZTJ37lzJzs72W7sBAAAAAADCSaQEoS1btsiYMWNk+PDhMmvWLNm9e7fMnDlTcnNzZfLkyR6f9+GHH0rDhg1l0KBBkpiYaNbz2GOPSVpamsyYMcOv7wEAAAAAACAcBGXwacmSJdK5c2eZMGGC+b1169bicDhkypQpMnr0aImLi3P7vPvuu0+qVatW9Ls+TwNPL730EsEnAAAAAAAAHwjKYXfr1683wSdXXbt2NcPnNm3a5PF5roEnJ31OfHy8T9oJAAAAAAAQ7oIu8ykzM1NSUlKkcePGluWa7ZSQkGCG4JVFVlaWqQH1yiuvmKF7AAAAAAAA8L6gCz4dO3bM3NeoUaPEY7GxsSY4dTJLly41ASfNhLr//vvl0ksvrXS7IiP9n0QWEWG33AeiYGijop3Bty3tNpECm80r67JVYj3aDl/+/wfLZxMAAAAAQib45A1XXXWVnHvuubJz50556qmnZMeOHaZeVEXZ7TZJTIyVqhIfHyOBLhjaqGhn8GzLiMgIKdDITyXp/29l2+GP//9g+WwCAAAAQNAHnzS7SR0/ftxtVpSnYuOudKY7vbVr106SkpJkxIgRMmTIEKlfv36F2pSfXyAZGSXb42uaCaEnpBkZWeJw5EsgCoY2KtoZfNvSkecw/3uVDTxVdh3ajrS0wozMUPps6muSbQUAAAAgIINPixYtkltvvdXj42+88YbccMMNJtjz8ssvl3u4iwaXNGCUnJxsWa7D7dLT06VJkyblWl+jRo2koKBAfv/99woHn1ReXtUFVvSEtCpfP1TaqGhn8GxLjRnp/25FuR57KrMebYc/PtvB8tmsqr4BAAAAQODyehGRJ5980hTz1myi/fv3Wx6bP3++PPvss3L48GHZuHFjhU/4OnXqJGvXrrUsW7dunURFRUmHDh3M76mpqSVe3109KJ05LyIiQpo2bVqhtgAAAqNvAAAAABCYfFLBVk8cqlevLtdff73s2rXLLFu9erW58v3MM8+YDKPKnFwMHTrUBJ/mzp0r27Ztk1WrVpkC4gMGDCgadjd+/Hjp1q2b5Xm9evUyr//NN9/Ili1b5MUXX5THH39cBg8ebLKpAAC+4+u+AQAAAEAY1XzSmei0kLdeyb733nvltddek2+//VamTZsmbdu2NX9TmSEV7du3N1fK582bJ4sXL5aEhATp06ePCTiVZuDAgeZER2e7y8nJkWbNmsl9990n11xzTYXbAgAIjL4BAAAAQBgWHB89erTJKlK33367vPXWW3LFFVfIRx99VOmr2927dzc3T5YtW+a2PXoDAH8ZO2mq7D2cUeHn62R8OqOeKbBewcNm4zrxMv/xhyVQ+LJvAAAAABBGwad9+/aZrKTJkyebk4m+ffvKb7/9JldddZWvXhIAAo4GnvI7T63w8wtsNin4Y1a+igZm9q4LnMATfQMAAAAQfnxS80mdOHHCDKe49tpr5aeffpIZM2aY+kq5ublFf8PwCgAIL/QNAAAAQPjxavDpxhtvNPf/+c9/pHnz5mYoxZVXXmmWJycnS4MGDeTgwYNmKm110003mTpMegMAhCb6BgAAACC8eTX4dPbZZ5thIdOnT5epU6fK8ePHzdTadrtdZs+ebQp9p6SkyBlnnGH+/swzz5RWrVqZGwAgNNE3AAAAAOHNq8Gnu+++2wyl+9e//iXR0dHStWtX+fDDD+WNN94wWVD79++X9PR0E5hSOsORBqr0BgAITfQNAAAAQHjzSc2nmjVrmmEWjRo1MlNpt2jRQpKSkmTRokVy5MgRX7wkACDA+aNvWLNmjZngol27dtKlSxeZM2eO5OXllfqcL774QkaOHGn+vn379nLZZZfJ3LlzJTs72yttAgAAAMKdz2a70yF17733nhlyp0aMGCG33nqrPPHEE756SQBAgPNl37BlyxYZM2aMDB8+XGbNmiW7d++WmTNnmokudOZVTzRDt2HDhjJo0CBJTEw063nsscckLS3NTJYBAAAAIECDT+rRRx81NaDuuece6dGjh9x7773y/vvvm8eY6Q4AwpOv+oYlS5ZI586dZcKECeb31q1bi8PhkClTpsjo0aMlLi7O7fPuu+8+qVatWtHv+jwNPL300ksEnwAAAIBAHXan5s+fL++884706dPH/N6/f3+pXbu2OTkAAIQnX/YN69evN8EnV1p7UIfPbdq0yePzXANPTvqc+Pj4SrcJAAAAgA+CT3o1W+3YscPU8TjrrLOKHrvjjjvk1VdfNUMgnH8HAAh9vu4bMjMzzWyqjRs3tizXbKeEhAQzBK8sdIbWTz75RF555RW56667KtQWAAAAAD4edrdy5UpzP2/evBKPnX/++WYmvKioKDPjnbPmBwAgtPm6bzh27Ji5r1GjRonHYmNjTXDqZJYuXWpqRWkm1P333y+XXnqpVFZkpH/6uYgIu+U+EARam8KpPXabSEElhrBWZAisvqa3P+/htM9CqU0AAPgl+NSyZUvL799884106NCh6HdnzY3Bgweb+40bN0rHjh293QwAQAAJhr7hqquuknPPPVd27twpTz31lMnS0npRFWW32yQxMVb8KT4+RgJNoLUpHNoTERkhBRoNqsRntyKv6avPezjss1BsEwAAPg0+6cmCXmHWaavHjx9vZjFy1tq4++67TaFZ1591dqEffviBLCgACGG+7hs0u0kdP37cbVaUp2LjrnSmO721a9dOkpKSzEx8Q4YMkfr160tF5OcXSEZGyfb4gmY96MlnRkaWOBz5EggCrU3h1B5HnsN8/ioaeKrIc/U109IKMxC9JZz2WbC0SV+LLCsAQMDMdvfll18WDX1wrd+xatWqohMM58/UfgKA8ODLvkGDSxowSk5OtizXgFd6ero0adKkXOtr1KiRacPvv/9e4eCTysvz7wmqnnz6+zWDrU3h0B6NHVXk+5XrULvyPl9f01fbNRz2WSi2CQAAnwaf9IuLXjnWk4dzzjnHLNMv7/n5+UVf5J0/79u3r1LTagMAgoM/+oZOnTrJ2rVrZeDAgUXL1q1bZ2pJOYf4paamSk5OjjRo0MASoCqeGaUz50VEREjTpk0r8a4BAAAA+CzzSemMQ88//7yZOahHjx5Fy4v/TPAJAMKHL/uGoUOHyoABA2Tu3LnSu3dv2bNnjykgrsucwSUd8rdhwwbZvn170fN69eolN954o1xwwQWm2LjWm9KaT1p/SrOpAAAAAFSOV6fG+Pzzz81U2UqvPL/99tsSExNjpq3WoRTVq1e3/Pzpp58y7A4AQpy/+ob27dvL/PnzZfXq1XL99dfLjBkz5Oqrr5ZJkyaV+jxt05o1a2T06NFy8803m5n57rvvPpk8eXKF3zMAAAAAH2U+aT0P59Vs/eKvBWP16rXWzlCefgYAhC5/9g3du3c3N0+WLVtWYpkGnfQGAAAAIAgyn3RK6po1a8rYsWPl66+/NicaWlvjmWeeMVejXX/Wq+B6r5599llvNgMAEEDoGwAAAIDw5tXgk/Oqdd++fWXp0qWyePFiadWqlTz99NNmGIMOifjiiy/MVXCdylrvzzvvPPnqq6+83QwAQAChbwAAAADCl9cLjmudjtatW8vIkSNNYdfly5eb4NObb75pisDqYwCA8ELfAAAAAIQvrwefOnbsKA8++KDUqFHD1Pj47bffzExCeuJx4MABywxGtWrVklNOOcXbTQAABBj6BgAAACB8eT34pMPq6tSpY37W6ax16msNRGnw6dVXX7X8bbdu3WT27NnebgIAIMDQNwAAAADhy+vBJ4fDIXv37pXGjRub3y+44AJT+8mdJ554wtsvDwAIQPQNAAAAQPjyevApLy9PLrvsMmnevLmce+65sn//fnnttddM5lNxP/zwg7zxxhvSv39/bzcDABBA6BsAAACA8OX14FO1atVk1apVsmXLFlm9erWkpKSYGlBNmzaVM844wxKEiomJkW+++YbgEwCEOPoGAAAAIHx5PfikAaV69epJjx49zG3atGmyYsUKWbRokTn5mDJlitStW9fbLwsACGD0DQAAAED4snt7hV9//bXl9+joaPnb3/4mH3zwgbRt21Zyc3O9/ZIAgABH3wAAAACEL68HnzzRINSQIUOkYcOGluWffvqpGZYHAAg/9A0AAABA6PP6sLuBAweWWGaz2eSVV15xeyX8zjvvlFGjRpX7ddasWSPz5s2THTt2SEJCgvTt21fGjRsnkZGe35LWoHr11Vdl69atcvToUTMjX79+/eSmm24Su91vcTgACDv+6hsAAAAAhEHwSQuIjx49uiiYowXGn3/++RJTbi9cuFCeeeYZGT58uNx2223leg0tZj5mzBjz3FmzZsnu3btl5syZZkjf5MmTPT5v5cqVZha+oUOHSq1atWTTpk0ye/ZsOXHihIwYMaKC7xgAEAh9AwAAAIAwCT7pleyxY8daMolefPFFc68z33344YfywgsvmEDRs88+K926dSv3ayxZskQ6d+4sEyZMML+3bt3anLRoMXM9uYmLi3P7vIcfftgM8XBq06aNHDp0SJYvX07wCQB8yB99AwAAAIAwCT65o1e4+/TpI9u3b5dTTz1Vhg0bJtddd52Z/agi1q9fb4JMrrp27SrZ2dkmm0l/dsc18ORUv359OXDgQIXaAQAInL4BAAAAQBgHn5TWVbrgggukSZMmlVpPZmamuUqu9ZpcabaT1n7SIXjlocEqHYoHAPA/b/UNAAAAAMI8+KTDLW644QavrOvYsWPmvkaNGiUei42NNcGpsvrpp5/ko48+kmnTplW6XZGR/i9YHhFht9wHomBoo6Kdwbct7TaRApvNa8eoyrSjtP//QGjnydpYVbzZNwAAAAAIs+BTZU7k/EVnuxs/frxcdNFFZsa7yrDbbZKYGCtVJT4+8IeoBEMbFe0Mnm0ZERkhBRpVqST9/61sO0r7/w+Edp6sjf4SDH0DAAAAgCAIPmkNj+7du1uWZWVlSf/+/aV27drSoEEDad++vfzlL3+RRo0alXv9mt2kjh8/7jYrylOx8eLt0dntoqKiZM6cOZYCuBWRn18gGRkl2+NrmlmiJ/gZGVnicORLIAqGNiraGXzb0pHnMP97lQ3oVHYd2o60tGMB3c6TtdEd3YfezF7zdd8AAAAAIIyCTzqjnLuTDg0MZWRkyK5du2TRokUydepU6dChg9xyyy3Ss2fPMq9fg0tJSUmSnJxsWa7D7dLT009aN0TbMXLkSHPS89JLL5UpWFUWeXlVF1jRE/yqfP1QaaOincGzLTUWo8cWb2ThVGY92o7S3mcgtPNkbfQHX/cNAAAAAMIo+HTttdea+7feekuuv/5687MGir7//nu5+eabi/5Ol+nU2tOnT5eVK1fK3Llzy/wanTp1krVr18rAgQOLlq1bt85kMulJi0pNTZWcnBxzNd3pyJEjctttt5lMp6VLl0p8fLxX3jMAoOr7BgAAAACByWcVaPXEwXmVXouDa1FvzTZy0mEVt956q3z88ccyaNCgcq176NChJvikJyXbtm2TVatWyaxZs2TAgAFFmUxaz6lbt24lZlU6ceKEacuhQ4dk586dRTcNVgEAfMuXfQMAAACAMMh80qvXziEienKhJw7O3/Py8kymUvFhbpqF1KtXLznvvPPK/DpaF2T+/Pkyb948Wbx4sSQkJEifPn1MwOlks9u5XoF3NXbsWBk3blyZ2wAACKy+AQAAAEAYBJ+6dOlS9PPGjRulc+fORScYiYmJ8uOPP0rv3r0tz9m3b5+pBaJZS+WhhWuLF691tWzZshLLtm/fXq7XAAAEV9+wZs0ac2Fix44d5sJE3759zYWFyEjP3d3q1avl1Vdfla1bt5qZUBs3bmxmQdVs2cpOSAEAAADAy8EnnUHO6cknnzRDJ5xf3PVEQL/MDxkyxNRmctJCs2+88Qb7AgBClL/6hi1btsiYMWNk+PDhZij27t27ZebMmZKbmyuTJ0/2+DytLdW8eXMzpLtWrVqyadMmmT17thmm7dp2AAAAAAFScNx1GJvrFeOWLVuaK9xaX6lVq1Z/NiAyUiZOnOirZgAAAogv+4YlS5aYrKoJEyaY31u3bi0Oh0OmTJkio0eP9ji7qWZYRUdHF/3epk0bUxdw+fLlBJ8AAAAAL/DZeIIbb7xRnn32WTOTkfrhhx/k008/lffee6/ob44fP26GOOgQCQBA6PNl37B+/XoTfHLVtWtXyc7ONtlMnrgGnpzq168vBw4cKNfrAwAAAPBT8KlHjx5y6aWXmqvWOpPRgw8+aJbffvvt5v6jjz4y9998842pp6HDLPTKNAAgdPm6b8jMzJSUlBRTr8mVZjtp7ScdglceGqzSoXgAAAAAAnDYXXx8vMTExJj7W265xdTsyMnJMTMc6b3Snx9//HFzIqInGM7CswCA0OTrvuHYsWPmXgNbxcXGxprgVFnpzKgaDJs2bZpUVmSkfwqWR0TYLfeBINDaFE7tsdtECir53aq83830Nb39eQ+nfRZKbQIAwC/Bp4iIiKKisXrV+tdff5Wzzz7b/O68X7hwoaSnp5sCs3qyAQAIbcHSN+hwv/Hjx8tFF11kCqFXht1uk8TE2HI/b9DICbL7wBHxp6b1a8nS5+b6ZN3x8TESSHzRnkDbZxGREVKg0aBKfHbLS1+zIp/3suAzFHz/9wAA+KXguJ40aFHZI0eOSMeOHWX69OlmdqPFixebk4pevXpJ9+7dzVVwre0BAAh9vuwbNLtJuXueZkV5KjbuKisryxQY1yDZnDlzLIXRKyI/v0AyMsrfx+1KThVH53sqFDDQ16yIXesekrS0wuwxb9FMDA0aZGRkicOR79V1B1p7Am2fOfIcFV5vRdukr8lnyP+focrss4r83+v/EFlWAICACD5NmjRJqlevLqmpqeYLf7du3cwwC63zobMa6dXvZs2aeftlAQABzNd9gwaXkpKSJDk52bJch9tpNlWTJk1Kfb62aeTIkSYA9dJLL5UpWFUWeXnlD3LoOWR5M79ch0hVJGtMX7MibS0LDfT4at2B0p5A22cVaU9l28RnqHJCbZ8BAFCc1weIb968WTZu3Cinn366LFq0SB544AG3f5efT2cHAOHCH31Dp06dZO3atZZl69atM5lMHTp0ML9r8Gv//v2Wv9FMrGHDhpnhgEuXLjVBLAAAAAABnPmkX9z1i74OpXj77bfl/PPPl6FDh5pZiPRer0A//fTTZmjE3Xffbb7sO+uAAABCkz/6Bl3PgAEDZO7cudK7d2/Zs2ePzJo1yyxzZjJpPacNGzbI9u3bi56ns+tp5tVDDz0khw4dMjenxMREglEAAABAoAWf6tWrV1R7Q08cdOahzp07yw8//GDut2zZIldeeaXccMMNcv3115sTgpo1a3q7GQCAAOKPvqF9+/Yyf/58mTdvnqkjlZCQIH369DEBp5PNbqeuvfbaEo9pjapx48aVqx0AAAAA/FBwXP3jH/8wwxu0zoZejX7llVfMvV791roeevX72Weflf79+0ujRo181QwAQADxdd+gBcv15smyZctKLHPNggIAAAAQBMEnna1Ir27v3LnTzBR0zz2FM3dcd911lmKIgwcPljfffFP++9//FtXiAACEJvoGAAAAIHx5Pfik01RrgMl19g01ZswYc79mzRpzr7MenXfeeWb58uXLvd0MAEAAoW8AAAAAwpfXg09paWly2223yezZs6Vp06ZmWc+ePSU7O9vyd1pMNiMjwwy10FogAIDQRd8AAAAAhC+vBp+ysrLM1e1q1apZCsXqzEFTpkyRmJgYy9+///77ZsptLRLLjHcAEJroGwAAAIDw5tXgk05VrQVjH3zwQTOsztXVV19dNNW10+WXX26mwH7sscfk3nvvlaDlcEjk999aFuXXSpD8U08TOXFCIn/aVuIpee3PMfcRP+8Q2/Fj1tU1aSoFiUliO3xYIvbttTxWEBcnjuanm9eM+OF7kfgYicjIEnHkF6639Vk6lZTYd/0i9qMZ1vU2aCgF9eqJLT1NInb/Zl1v9RhxnHGm+Tly83danMva3pZnisTEiH3PbrGnpVrfa916kn9KQ7FlHpWIX3ZaHrNXjxa5uFPhe/3xB7Hl5Vrb1LyFFMTVFPvv+8R+6KB1vYlJkt+kqZ65SuSOYgWBbTbJa3d24Xp/2i62E1nW9TY9VQoSEsV28KBE7N9nXW/NeMlv1lwkN1cit/5QuI4Ie9G2zGt1li6QiF9+FltmpnW9DRtLQZ06YktLlYg9u63bsEasOE5vWbgNi30ezDY8o5WONxX7b7+K/Ui6tU31G5ib7WiGROz6xbre6GriaNW6sJ0/bBGpEWXd5/p5iIsT+75ksR8+ZF1vUm3Jb9xE5Phxifz5J+t6bXZxtGtfuN7t28SWfcL6Xk89TQpqJYjtwAGJOPC7db3xtST/tGYiOTkSue1Hy2NmW3a9sPDnnTvEdqzY57tREymoXVtsKSkSkbzH2qbYWHG0aCmSny+RW74vuQ1btRGJjhb7r7vkjCMpkp/852sfjq8rqTXrSlxWhjRMtf7f5ERGy6/1Tzc/t9y3VWxmaLCI3WaT/IIC+bVOM8mOjpH66fuk1jHrvkmLS5JDtRpITPYxaXLY+n/jsEfILuf73rZVbDnFMjz1cyYitTMOSe2j1n1zNCZefk9qLNG52XLaQev/jfqpURtz3/TQLqmRm2Xa6fy33J/YUDJqJEhCZqrUO7Lf8rzj1WrI3jqniT3fIaf/Xvh/Yz+SUvSZLOsxQuIizf+8N4Rt3wAAAADA+8Gn6Ohoc7JQ3LBhw8xjxelJiA7Pe/311yU/P98UKA9GtqNHJfHSrpZlJ677mxxdsNgEBIo/pg4dLDzpqzlupER9s9HyWMYzz0v2Df2l2nvvSM2pd1key7mkhxxZvsIErOK7dzbL4l0eP/zjLyY4EnffVKn28UeW52bOeEiyRo2VqM9XS63hgy2P5bY7W9I/XWt+Tri8p9hyciyPp36+3gRAajz5mMS8utTy2PHbJ8qxaQ9I5HffSsK1f7U8pkEp2Zdsfq414DqJ+N0aCEp/9wPJvbiLxCx5Xmo89aTlsayBgyRzznyJ+O3XEtuwIDpaDu89XLgNRw2XKA2YuTiy+GXJufpaqf72com7v7DovVN2r8slY9k/xHbkSIn16rY8vHOvFNSMl7gpd0n06v9YHj/68Gw5MWyERH/yb4kfM8K6DTt0lPSPPjU/u9vnKV//T/Kbt5DYR/5u2uXq2F1T5PjkeyRy4wZJ6N/X8pjjtGaSuqHw/cVd81eRlBTLPk/7YJXkdewkMQvmS42Fz1i34ZDhkvnokybwVLxN+XE1JeWXwn0TP3yQRG63BkmPLH1DcnpfIdXfeEXiZs2wbsOrrpGMJUtNsMvde9Wgq2nvneMl+st11m345NNy4qbBUu2j96XmROsU9jkXdZYjKz40gUG32/DbrZLfsJHEzbxfXlz3oYje/rCg1wRZeskIOWfXf+XxZWMtz/ulXgsZeMfKwr97fpDEZlsDYoPHvmWCPTevWSLXff265bHXLx4sT115t7TYv0MWPXej5bG02ES58pIrzc+1BvWXiF+doahC6W+8Y+6v2fAPGf7ps5bH/nXOlTKj32MmePTy/OtLvNcLHy4MrE17c6q03W39fD/wt0fk43Ovlp6b/yV3/fPvlse+bnmx3DF0kVTPybKu99IPy3WMiNDjS/PC4FllhWvfAAAAAKCQrcA5/RwqzJGTKxlrv/Z75lO1bT9IfHyMZGRkiSOAM59qXdxJ0tKOScH3mwM688m5LbMDOPOp2vYfJb5GlHWfB2DmU3zXCyXtSJYUbN/us8ynuyZOlfxzhlZ95tPOd2TFi894zHzqc/tUSWw/vMKZT6ce/rXymU/fviBPPjClXMeIxMZ1JcJLmU/hSv9HU1Otn/+yuGbIGMnvPLVcz9FJPux2m+Tn6+ek/N26fd3D5nPsTZGRdklMjDXH/7y8wuNVVfJlewJtn1WkPZVtE5+hygmWfZaUFFuY4QwAQFUXHA9LERFFwaQSqlf3/JienPwRrHBHgxx5dep4fE3H2eeIJMaKw80XaQ2uePpqrUGZvIREj6/rDOq4o8EgExByt964miXeq37Zd3K0Ocvzek9pWJgl5U5MTOnb8I+gmds21asneZ4K2kdF/blebecf21L+2JYmyOdpvYlJkpeY5PHx0tqrQUmP+6ZmfOnv9ay2nvd5w0bm5laNGqWv98xWHh8rqF9f8urXd/9gdHTJ9eq2/CNTxQSSPK23dm3Jq13b/YN2e+nb8LRm8lOt2pL/R4DGVWZMfFHgxp0dDVt7/MJ+IKGhubmTVS3W7Xrtf8SNnAFCd1Li65qbOzlR1Upt7+66zTyeWKTHJZmbO/n2iKL12nfVLrE9T3aMkOhqHtsEAAAAAOXBpQsAAAAAAAD4DMEnAAAAAAAA+AzBJwAAAAAAAPgMwScAAAAAAAD4DMEnAAAAAAAA+AzBJwAAAAAAAPgMwScAAAAAAAD4DMEnAAAAAAAA+AzBJwAAAAAAAPgMwScAAAAAAAD4TKQEqTVr1si8efNkx44dkpCQIH379pVx48ZJZGTZ3tKDDz4o2dnZMmvWLJ+3Fb43dtJU2Xs4o8LPt9tEIiIjxJHnkPyCirejcZ14mf/4wxVfAQAAAAAAISYog09btmyRMWPGyPDhw03waPfu3TJz5kzJzc2VyZMnl/rcY8eOyVdffSXvvvuuXHHFFX5rM3xLA0/5nadW+PkFNpsU2G2Sn18gBQUVjz7tXUfgCQAAAACAoA8+LVmyRDp37iwTJkwwv7du3VocDodMmTJFRo8eLXFxcW6fl5ycLD169PBzawEAYcnhkMjvv7Usyq+VIPmnniZy4oRE/rStxFPy2p9j7pse2iXVc7Isj+1PbCgZNRIkITNV6h3Zb3ksq3qs7KvXTOz5Dmmxr+R6dzZoKY6IKGmUsltiT2RaHjsUX0+OiIgtPU0idv9meaygeow4zjjT/By5+TuRYsH5vJZnisTEiH3PbrGnpVoeszVoIJLYUuToUYncscO63sgocbQ5y/wc8eMPYsvLtW665i2kIK6m2H/fJ/ZDB63bMDFJ8ps0FcnKksgd261v1GaTvHZnF673p+1iO/HnNoyIsIuc3UZEosV28KBE7N9nXW/NeMlv1lwkN1cit/5QYhvmndVOVyIRv/wstkzrNkzIPiH67uOPp0uDNOt6T0THyO66zczPZyT/6NpUsdts8kvdFpIdGS2npO6VmlnWDN6UmnUlJb6u1DiRKY1Tdlu30dH0P9/bD1vE5sgr+v2MIynyW/YxyaoWK3WP7JfETOu+ORKbIAcSGkq1nCw59dAuS5v0Pf7UoJX5/bQDP0t0Xo7lufuSGktmTLwkHT0kdTIOFS23H0kR+6+7JP+0ZiI5ORK57ceS27BtexG7XSJ27hDbsWPW99OoiRTUri22lBSJSN7z5z6LjxG7wy5yWguR/HyJ3PJ9yfW2aiMSHW1e355xxLre+qdIQf36YjuSLhG//Wp5rKBadXGcWfheIzZ/L7aCfOt6Tz9DpEYNse/dI/bUlKL2RGRkSX5ibclv2EgkM1Mif/nZut6ISHGc1bZwvdu2ii0n29qmZs2loGa82A/sNzfnPstP/lGOxsTL70mNJTo3W047uLPEe/2pURvLMcL5OcovKJDfEzwfI45XqyF765xmjhGn/769aJ85j1F5rc8SiYoS+65fxH7U+jl0NGgoBfXqmWOExEWa/3kAAMIi+LR+/XoTZHLVtWtXM4xu06ZN5md36tWrJytXrjQ/T51a8SwZAABOxnb0qCReau2PTlz3Nzm6YLHY9yWXeEwdOlh40jftzXuk3Z7vLI898LdH5ONzr5aem/8ld/3z75bH1re8WO68dYk5GX15/vUl1nv5veskPS5Jxn/wqHTZ+pnlsXlXTJblNpGoz1dLreGDLY/ltjtb0j9da35OuLyn2HKsgYjUz9eLo1VrqfHkYxLz6lLLY1kT7hSZM1siv/uf1LzammnsOKWhpH5XGCSrNeA6ifjdGrBJf/cDyb24i8QseV5qPPWkdb0DB0nmnPkmkFB8GxZER8vhvYfNzzVHDZcoDZi5Wr5c5NIrpPrbyyXu/nssD2X3ulwylv1DbEeOuN03h3fuNQGDuCl3SfTq/1ge63HW+fKWiFy4/XN5YPkUy2Obm5wtI0a/bn52t29uuOtfsrd2Uxmx6inp/e37lscW9xwtSy4dK+12fytzXxxheWxvjZpFPydcf5XYU1KKfn9RRG5te5NsOfUcGbD2ZRnwxcuW5759wQCZ3We6CTwVb9OxarFy2Yz/mp9nvXaHNC8WAJl083xZ16aHXPnNuzLq47nWbTgzWjKWLBX74UPuP997DolUqyZxd46X6C/XWR47+uTTcuKmwVLto/el5sRxlsdqXNxZct790AQG3a035dutJhAUN/N+qbZyheWxzHvvl6zxd0rUV19KrUH9LY/lndlK0tZuKNyGfS4Xe+ZRy+Npn3xuAsI1np4jMS8uLloer8Gc28bIsZkPm0Bl4l8vszwvv3ZtSdlaGNTT14z49c8An0p/4x3J7XGpVH/5BYmd/UjRPpN1H8q/zrlSZvR7zASP3H1eLnz4xwodI75uebHcMXRRyWPEpR+au8M//iIFdepI3H1TpdrHH1m34YyHJGvUWHOMiOjeWaR58xLtAgDgZGwFlRljVAUyMzOlQ4cOsnDhQrnkkkssj3Xq1MnUfbrppptOup6bb75ZmjZt6pWaTw5HvqSmWq/g+UNkpF0SE2MlLe2Y5OVZr9YFCn+18ZohYyo17M5ms4ndC8Pu7OselhUvPiO+wj4Pvn0eCO2syOcyKSm28Co/KsyRkysZa78ud+aTfmYan9m/QplPkpdXscyn7xbJe3P+7vXMp4SzWkra7v0iAZL5FH92G0mTaHHs2+/VzKebHnlaUnvO8G/m0/cvy5y3XnWb+TTxgUfkt0tnVCrzSY835cp8+vYFmf3kw17PfIqPj5EjDrvkBEjmk7YnIyNLcr2c+aT7LP+cof7NfPr2BXnygSnlynxKbFxXIsh8AgCEQ+aT1mxSNWrUKPFYbGysCU5VBQ0K+JvzxDCQTxD91UYtGK51m7xBT/Yr0w5ffhbY58G3zwOhnb7+XMKDiIiiYXQlVK/u+TGRomCFO5rBpLcSQUoNoNgjik5O3Umu3dTtcn1uQUKi5CUkenyuM6jjjgaDTEDIRdFnrmbNUt+rMwjldr2nNDQ3t2JiSl/vH0GzPxtkF0mMFUk7Zk6k8+rVc//EqKjS19v89BLL0qtVN/d64q83T1z3jWtgWYN6GnD43cPzjlePK7Ff7bv+fB1noKPodWrVlvxqsebnQ7UamJs72dExbtvknHnj1/ol36tTas265vZne2oXBp5UdHTp27BFS4+PaQAqr3Ztyz7LTzsmohew7PZS16uv7+kyV0GthNLb1K695/U2bmJuzvY40o5JvvOCWlxc6ett1drzeus3MLeifeayL3KiqpX6v+w8Rri7QOHuGFH0mi7HCN1nxduuAViP21CPD9HVPLYJAICQCj4FIu30NbunquhVuEDn6zbqTHVaMLyyzJfuSrbDH58F9nnw7PNAaKe/PpeBgJlQAQAAgMATdMEnzW5Sx48fd5sV5anYuC/p1aaMjJLt8TXX9G8d+heI/NVGR56j8OpxJRRdga5kO3SIoa+wz4NvnwdCOyvyudT/20DOqnSHmVABAACAwBR0wScNLiUlJZmZ61zpcLv09HRp0qRJlbSrKmsuaVAnUGs++auNhaMWCrwynKky69F2+GNfsM+DZ58HQjv99bmsasyECgAAAASm4Lqs7VJYfO3awtl3nNatWydRUVGmGLlKTU2V/futxRYBAKFLZ0Lt3Lmzx5lQPXHOhKq3tm2ttXMAAAAAhGHmkxo6dKgMGDBA5s6dK71795Y9e/aYWet0mXPY3fjx42XDhg2yffufM+Hk5+cXFSTPy8uT3NxcycjIELvdXiXD9QAA3qHH9pSUFGncuLFluR7bExISZPdu60xhrvTCxRlnnOFxMgsAAAAAYRh8at++vcyfP1/mzZsnixcvNicWffr0MQGn0uzbt0969uxZ9LteCX/vvfekUaNG8p///McPLQcA+EIozYRa2RkSKzIroi9mRAy02Tl92Z5A22femGWzvG3iM1Q5obLPAAAIqeCT6t69u7l5smzZshLL9Iq4ayZUVRs7aarsPZxR4efrlwadxcoUNK5gSZnGdeJl/uMPV7gNKB/2ORA+KjoTamVmSKzorIi+nBEx0Gbn9EV7Am2fVXaWzYq0ic9Q5YTaPgMAIGSCT6FAA0/5nadW+Pl6hazgj1mwKlqIeO86Ak/+xD4H/r+9+wCTqrrfOP5bmkoRREETAcVCEbAhIEhR0IhYiGhUUEooIkWKCIKiCUGQKKFIEUEgBIWgUTG2JGgIQhIQQQUUUIpSVBQQaQFhd/7Pe/K/m5nZ2d3ZXYY5s3w/zzPPsnd3Zs7Mvdyz951zfscSojCthJrfFRILsipiIlbq9G11zkS2x7d9VpBVNvPbJo6hgkmVfZaKK6ECAPxA+AQASHmFaSXU/KyQWNBVERO5IqJvq3Mmoj2+7bP8rrJZkDZxDBVMYdtnAABE46MLAEChwEqoAAAAgJ8InwAAhYJWQl28eLFbCXXdunW2YMGCmCuhNmvWLOJ+WglVK5/qFr4SarKKlAMAAACFDdPuAACFAiuhAgAAAH4ifAIAFBqFYSVUAAAAoLBh2h0AAAAAAAAShvAJAAAAAAAACUP4BAAAAAAAgIQhfAIAAAAAAEDCED4BAAAAAAAgYVjtDkAWvQcOsW079+brnSmSZla0WFFLP5puGaH8v7mVzjjVJj71BHsHAAAAAFIc4ROALBQ8ZTQekq93JpSWZqEiaZaREbJQKP/p07YlBE8AAAAAUBgw7Q4AAAAAAAAJQ/gEAAAAAACAhCF8AgAAAAAAQMIQPgEAAAAAACBhCJ8AAAAAAACQMIRPAAAAAAAASBjCJwAAAAAAACQM4RMAAAAAAAAShvAJAAAAAAAACUP4BAAAAAAAgIQplriHRmHRe+AQ27Zzb77uWyTNrGixopZ+NN0yQvlvQ6UzTrWJTz2R/wcAAAAAAABJQfiEXCl4ymg8JF/vVCgtzUJF0iwjI2ShUP7Tp21LCJ4AAAAAAEhFTLsDAAAAAABAwhA+AQAAAAAAIGEInwAAAAAAAJAwhE8AAAAAAABImJQNnxYtWmRt2rSxOnXqWJMmTWzs2LF29OjRXO83f/58a9WqldWuXdtatGhhM2fOPC7tBQAkHn0DAAAA4J+UXO1uzZo11qtXL+vatauNGDHCtmzZYsOHD7cjR47YoEGDsr3fu+++a0OHDrWBAwdagwYN7NNPP3X3K1GihN19993H9TUAAI4t+gYAAADATykZPk2fPt0aN25s/fr1c9/XrFnT0tPTbfDgwdazZ08rXbp0zPs9++yzduedd1rHjh3d9zVq1LCdO3e67YRPAJDa6BsAAAAAP6XktLtly5a58Clc06ZN7fDhw7Zy5cqY9zl48KCtXr065v127NhhGzduTGibAQCJRd8AAAAA+Cnlwqf9+/fbrl27rFKlShHbNdqpXLlybgpeLFu3brWMjIws9wu+z+5+AAD/0TcAAAAA/kq5aXcHDhxwX0uWLJnlZ6VKlXIXILEE26Pvp9AqLS0t2/vFo0iRNCtfvlSe7/fSc6MtdHI5K4g0MwsV5P6dRufa9oK2s6BtjKedPryXqdJO9vmxey8L0z6PdV5LJfQNBTtO8nOM5PqY/38IlS17ioUK+h/N8/b4ts8Kct7Jb5s4hgomVfZZqvUNAAB/pFz4dKyFQiF3KwiFV0WL5r0z/ulZFS35KhaKdvrRxlRpJ/v8eL6fqbLPcaL3DYl7ziJF/BpknYj2+LbPfGtPQXEMJQp9AwDg+PHrL8I4aHRTUMMp1iff2RUbD7ZH3y/4Prv7AQD8R98AAAAA+CvlwieFROXLl7ft27dHbNe0uT179ljlypVj3k+1nfTJWfT9gu+rVKmSwFYDABKJvgEAAADwV8qFT9KgQQNbvHhxxLYlS5ZY8eLFrW7duu773bt32zfffBPxqXjt2rWz3E/fV6hQwc4777zj1HoAQCLQNwAAAAB+SsmaT507d7a2bdvauHHjrGXLlm4luxEjRrhtwfS5vn372vvvv2/r16/PvN+9995r/fv3d6OcdJGydu1amzRpkvXp08fV5gAApC76BgAAAMBPaaGCVlRNkoULF9r48eNtw4YNVq5cOWvdurULnEqUKOF+3r59+yzhk7z88ss2bdo027Ztm1WsWNEFVt26dUvSqwAAHEv0DQAAAIB/UjZ8AgAAAAAAgP9SsuYTAAAAAAAAUgPhEwAAAAAAABKG8AkAAAAAAAAJQ/gEAAAAAACAhCF8AgAAAAAAQMIQPgEAAAAAACBhCJ9S1KJFi6xNmzZWp04da9KkiY0dO9aOHj1qvpk+fbp16tTJfLRy5Urr06ePNWvWzC6++GK7/vrrbcKECXb48GHzyerVq61fv3529dVXu/3dvHlzGz58uP3www/msylTplj16tXtgw8+MF8sW7bMtSnWbe7cueaj5cuX23333WdXXnml1apVywYMGJDsJsEzvvYHPpz/fTzP+35OT/a52+fztC/n4+zeH90GDx6clDYBAJCbYrn+BryzZs0a69Wrl3Xt2tVGjBhhW7ZscX+4HjlyxAYNGmQ+OHTokH388cc2c+ZMu+CCC8xHCxYssFNPPdW9dxUrVrS1a9fak08+aTt37rRhw4aZLxYuXGglSpRwbTrzzDNt06ZNrp1ffvmlPffcc+brezt16lTz1ezZs+3000+P2FahQgXzzfPPP2+jR4+2zp07W8eOHa1s2bK2d+/eZDcLHvGxP/Dp/O/jed7nc7pP527fztM+nY/feuutmNsVhpUuXfq4twcAgLiEkHL69esX6t69e8S2N998M1SnTp3Qvn37Qj6oVq1a5q1jx44hHx0+fDjLtnnz5oVq164dOnLkSMgXhw4dyrLtjTfeCNWoUSN04MCBkG/Wrl0bql+/vjsmtf+XL18e8sXSpUtdm77++uuQ7/Q+6v/0qlWrkt0UeMzH/sCn87+P53lfz+m+nLt9PE+nwvl4xYoV7hjasGFDspsCAEBMTLtLQRqS3rhx44htTZs2ddMINMXAB6+//rq7tWjRwnylT56j6VPoH3/80b7//nvzxUknnZRlm/b1ySefHPM1JNOuXbusZ8+e9sgjj7gpLsi/WbNmWevWrd20HCCV+gOfzv8+nud9PKdz7k798/GkSZPsuuuus/PPPz/ZTQEAICbCpxSzf/9+90dipUqVIrZrmHW5cuXclAsfVKtWzd003SGV6GJNQ+mjh/r7QhdMS5cudTVLHnzwQStWrJhXbdP0n5tuusluueWWZDcn5S1evNhdjN5///0uXLjqqqusR48etnHjxmQ3DZ7wtT/w/fzv03neh3M65+7UPx9/9NFHtmTJEtcmAAB8RfiUYg4cOOC+lixZMsvPSpUq5S5GkD/fffedzZkzx+644w4rUsS//xrvvvuu+9RVBXzbtm1r7dq1M588+uij7mKuf//+5rubb77ZLr30Uld8eOjQobZ9+3bzif4f63jURbKKEusT7ccff9xtv/322+2LL75IdhPhAfqD1D7P+3JO9/Xc7ct5OhXOxxMnTnRtq1mzZrKbAgBAtvwZNgEkkT751R/eGkGg0Ts+atCggb366qtuNMMzzzzjVkzSp+U+eOWVV1wh3z/+8Y+WlpZmvjrnnHNszJgxmSNF9Kn1jBkz3IWoCrhqNIQPghB5yJAhdsUVV2Rub9iwoV177bWu8K0uxgCk7nneh3O6j+du387Tvp+PV61a5UZmzZs3L2ltAAAgHoRPKUajm+TgwYMxPwVnlZO8S09Pd9Mdtm7dai+++KKdcsop5iPt24suusjdLrzwQmvVqpUbaq9PhpNNn0h//vnnEX+YBzp06GBnn322W0Up2c466yy78cYbM7+/5JJL3NL0qpHzzjvv2G233WY+COq+7NmzJ2K7pn3UrVvXNm/enKSWwSf0B6l9nvfhnO7judu387Tv52ONelIQ5sPfAgAA5ITwKcXoj9Xy5ctnGX6uT+b0h1HlypWT1rZUdPToURs4cKBbrlzLOqsQbSoIPhHWceDDH5yaLqKpEeG+/fZb69Kli40cOdJdPPhKS3erNo1PReZPO+00Fyxo6fXsChMD9AeF5zyfrHN6qpy7k3me9vl8rNFyixYtcgXRAQDwnX+FbRDXUH0NsQ6nQpPFixd3n8Ih/ikYffr0sXXr1rkaIFWqVPHyrYtVx0sFauXcc881H6heSFBkOLgFbdNFVdWqVc2Xi9Bo2v8KbjXywBea/qKitpqSk5GREXEsfPjhh1avXr2ktg/+oD9IvfO8T+d0H8/dvp2nfT4fq/7UZZddZldeeWXS2gAAQLwY+ZSCOnfu7IqTjhs3zlq2bOmmEYwYMcJt82Xa3d69e93XI0eOuOkOwfc+rX6kC5L169fb6NGj3ZTF8FVrypQpYxUrVjQf6JPpYMqB3j99ej927Fj3aXWtWrWS3byU0rt3b3fx2ahRI7d/P/vsM3v66aetfv367v31iWrSqMbJgAEDXEFiTbWdPHmyu1jUdsDX/sCn87+P53nO6al3nvbxfPzJJ5/YwoULberUqUl5fgAA8iotFAqF8nwvJJ3+4Bg/frxt2LDBLandunVr69u3b2ZtgmSrXr16zO26CPBF8+bNs10959Zbb7VRo0aZD+bOneuKrOqiSRdP+qO8TZs21r59+6Qsyx2vbdu2WYsWLeyFF16IWU8kGebPn28vvfSSbdq0yV0Qa/rNDTfc4C52fKgBE031X3TRrKkV+r+tY/ahhx5yU28BX/sDn87/Pp7nfT+nJ/vc7et52rfzcY8ePWzHjh2uaDwAAKmA8AkAAAAAAAAJQ80nAAAAAAAAJAzhEwAAAAAAABKG8AkAAAAAAAAJQ/gEAAAAAACAhCF8AgAAAAAAQMIQPgEAAAAAACBhCJ8AAAAAAACQMIRPOGGEQqFkNwGeO3DggP3444/JbgaA44R+AbmhXwAA4NggfEK2dBF+8ODBAr1DU6dOtfbt2+frvq+++qp17do1Ytsrr7xinTp1yvNjpaenW7Nmzeztt9+O2P7ee+9Z9erV7ejRo3Ys6P26/vrrrU+fPlzUeOKbb75x+/hf//pXrr/7q1/9ylq2bGn79+8/Lm0DUg39Qt7RL/iHfgEAgOOvWBKeEynikUcesc2bN7sAqXz58vbss8/aX//6V/ezb7/91jp06GB16tSxp556KjPg2bdvn/3973/P9jEVHg0ZMiTbn19++eU2d+5c928FQocPH3b/btGihU2ZMiXz9/7yl7+4oCD4PX0yWbZs2cyfL1u2LOJxly9fbt9//701atTIEumJJ56wkiVLuvckLS0tc7vel9/97nf2zjvv2A8//GBVq1Z1wdott9xyTJ53+/btdujQoVx/T23Sc4e37VgYMWKE/eEPf8jXfefPn281a9Z0/27durW7KChVqlSO99FxoQu6Dz/8MHObQr+vvvoq2/vce++92b5uHU9nn32223/t2rWzxx9/3EaNGpWv1wMUZvQLeUe/kHf0CwAAFD6ET8jWsGHDrFu3bu6ifd68eS4QCEKB4sWLu68nn3xy5rYjR464kCU3Z555ZsyAatKkSbZ06dJsp0aET4/Q6BTdZPz48bZlyxYX7mTn9ddftxtuuMGFD7t3787cHoxw2bNnjxUp8r+BgEWLFo0Is+KxceNGe/nll23OnDl20kknRbS9Z8+etmHDBuvevbudddZZtnjxYhs4cKB7nhtvvNEKqn///vbxxx/H9bsKwCpXrhyx7aabbrLPP/887ucLDwnlvvvus7vuuisPLTZ79NFH7bvvvrNq1apFbNexpQAvN9Gj8oJgtCD03GqXXkuXLl3swgsvLPBjAoUJ/QL9QnboFwAAQE4In5AtBQATJkywvXv3upDkyy+/tFatWlnbtm3dz/W9ApUyZcrY5MmTM0MchTsvvPCCTZw4MfOxNO1Jo0n0OO7AK5b10AsPf+LRuXNnN/JFo2D0uJdddpnbPnjwYLvzzjszf2/Xrl32xhtvuGBIUwDXrVuX5bGuuuqqLAGZpuTlxYwZM6xBgwZ26aWXRmxfsmSJvf/++/b8889bvXr13DYFZxqppMDsWIRPL774Yq6/07FjRzdlJjp4kmnTpsVd62j06NG2c+fOiG2nn366u0X76KOPXPgW7JuAQsYVK1bYk08+mXlMhAdZ99xzT45t0BS6Xr16xfyZjjO95/H405/+ZKVLl47YdvHFF1vDhg1t+vTpjH4CotAv0C/EQr8AAAByQ/iEHGm6nW5BOKSpa8Eop969e7upYxrtpKlvCpQ0VF6jiRQM9OjRw5577jkXBPz+9793IYPqOB0r//nPf+zhhx+2X/ziF5nb7rjjDte2cLNnz7af/OQndt5559lrr72W42MuWLDALrroIjcFKy8UsGg01wMPPJDlZwsXLrSf/vSnmcFT4Oc//7kLxRSG1ahRwxLp008/dYGPRpfFovcnXhrpFh0+ZUfPp+NGUzYDCic16kuBn6bZRVNoOWvWrBwfN6cphpoSes0119hDDz2U7e8oOP3Zz35mGRkZMX+ukWC//e1v3c/zGooChR39QnzoF2KjXwAA4MRE+IS4aYSOavtoBI+Cn6ZNm7oi3i+99JLVqlXLzj33XBdMPPbYY+6CPbhpqluskU7Hg4IIBRmaoqVQStPhVCtKU73uvvvuiN/VyB9NX9NopLyGT5999pkLVZo0aZLlZ5rOdv7552fZHkzp0s+D8EltiA7PYsmtJlK0kSNHuvpc1157rR1PuvgKn4KoYFKBpUbLjRkzJmZNsHhXnzrWdavCKRhT0Kp9o1F7AGKjX8ge/UJs9AsAAJyYCJ8Q07hx49y0I6lQoYIb1aPpSKr9pO2qWaRaS6Kw6eabb7Y///nPEUFDOAUzCoD0R6cCoehpWKLQRQFJXgIGFfbW1MDw5wkv4j127Fg3HSy8PpCmjWjaVnT4tHbtWteGunXr5vmoUJFsjezSexVN0/4UzkU77bTTMn8e0HsZz+iw9evXx9027bOVK1e6KWbHm973ihUrun9//fXXdv/997tRS5qiWK5cuczf0/Q7jQLLD9XyCi9ir32gula65aRKlSrZjmrSY6j+U7AiEgD6hbyiX4iNfgEAgBMT4RNi0pQ51VRSoe6gnpOmQ2lkikavKEBo3ry52x6M1FEdI4VFCqUUImnUyJo1a1whbK1Wp1FTWpVOIVZQo0ijprRKmp4nmkYBqaB5TjR9K3raXUDT/TSN7te//rUNGDAgc7vCpVjPpxpEGr11xhln5PmoUF0sFSiPrl8UvI6gQHu4YFuwol9Q7+j222+3Y2XVqlWuBpJCH00nPN527Njh6mApdNQxpek6mooZHjzJoEGDXMjzzDPPuJXnAgo6VUg8nppWARUMLygdx2qj9iuA/6JfyBv6hdjoFwAAODERPiEmjWDS7ZRTTsncphpPugUjn1THKZhaoJFPCg2CkU8KpjRtSWGDai1pqp4KOyvACi9MrWBi6NChbtWz6FFDCrhyC59U5FSBRUCjqoKRT1reWo8d/biXXHKJez59Kq2V5wKqiaT25Mepp57qLjRi1QgqUaJEzKl0wbbw0WIKv3Q7FjZt2uRW2VPxdK1YeLxpRNe2bdusZs2aLsxR3SeNgsppNJtGRwUF7YOLFIWBU6dOdUXsg2mcokBLx8fbb7+dWdxchebjWSkv/Bjr1KlTlvpQ2o8qnp/XFQ+Bwox+IW/oF7KiXwAA4MRF+IS4qcZTMGReo3WC79PT093X6667LnMalEKmCy64wAVUCqqCFcU2b94cEfho6tM555xjb731lluNLfqP1OgRMtEefPDBbEc+KSTTcy1btiziPgqjtH316tWZbVHB9A8++MCNEsoPBTx6DIVa+nc4hW1BofZwwbagoLuollY8NZ90UZOTjRs3uvdTr2/Lli0uhFItq+iV3RJJ0+gUvAUrCUa/L9kVPp87d26WkU8KzxQuaSXBIEjTsRUET+EWLVqU6/sT0OqHsWg/aj+EH6sAsqJfyB79Qlb0CwAAnLgInxC39/5/iWmNqNG0tT59+rhRKAo6FBB079495rSzcFrZrVu3blkCAIUM7dq1i5ie9tVXXxVoqlhOwYFqMH3yySeZgZmCDQU/DRs2zNdzqYC5grJ///vfbhW7cCo2rkAk2oYNGyIKj8uwYcMKXPNJ9az69u1rV1xxhat5tX37dveeq8aVRhDFEwIVlEYNTZs2ze655548FUfXSCmtNBf+OFopULRdI906dOjgCthryuZtt92W7WMpiNSqduHPr0BJo+NUAyundv3zn/90oWD4vgGQFf1C9ugXItEvAABwYiN8Qq40okcUzqg+kwIM1SXSiCeFALqgf+2111zAohpMCj1iUQiioCq6oLcCBE2d07QsTesLD2fCi4dnOXiLFXNT6xRIBDQqq3Xr1rm+JoVaqkUVXh9K0/GCIuB5pelgV199tRvBFR0+abtG8yxfvtzq1auXuV3vmQKyYKW7gtZ80lQxvYcadXbXXXfZww8/7MJAhV8qOq5V5hTIqOZSIkMVXWD06tXLjT7S17yoVKlSROHxYORTUFNM0zf1uhQM6biMLhofrV+/fhHT+HT8tWrVKtd2vPnmm3bNNdckdEU9IJXRL+SOfuF/6BcAAADhE7KlsEkX4aplpMLhGi2ikUsKUvSJbkDhiQqRz5w5001bC+o7RVMwo2CqcuXKEdtVo2fkyJFuapiCKY0+0nN+8cUX2QZZQTAxZ84cF7So9o9W29PvByNlctKoUSMrU6ZM5vf/+Mc/4golctKlSxe79dZb3ap5qnMUaNasmV1++eVupJhGh2lqmaYiqr2jRo2KCDjyW/NJI6FUWF37RyvHafnz6KmG2i8qGKzARmFfeAioqXmqoRQPFY2PRYXVFRyp4LyCJ+2feKf5aTTS1q1bXTF7hZsKKjUKSu+lAqngQk6vTftJz6VALbvVFQMKJhXGBYIporkVaVf9L+0fAJHoF/KGfoF+AQAA/BfhE2LSCBGtEKfQYvbs2W4Ei0bNaBSJijArHIqeYqfpUJo6pwBBgYou9DV1Tv/W78+YMcN+85vfxHw+jQ7SyByN/FFtIoURjRs3zqzdo6BBo5I02knbFGSNGzfOjYBRuKO6UartpGlrv/zlL91Uvuhi0UFNJlHha63Ap4Bj586dLuRQ0Wl9H9CoJD1fvBTIaWqYQiAFPcEUQr3+KVOmuNelYEXvRdWqVV3wpLCqIBQaaXqbwj/VXtH7onArFoVtGvWkfamVDJ9++mn33gWjiuIJZgIK08Lt3r3bPUZwHKguk+o9xeuxxx5zhes1SkuvSQGcXo9Giyn0VGFwvbYJEya47SqEr9eg461Nmzbu/Yz1elVwPtZ7rPZqP6iuWDiFWjpGNXpNbQHwP/QL9Av0C/QLAADkV1oo3uEOOKEMHz7cfVUgoxBBq45pZNOKFStcQLNv375sC2NrhIqmO40ZM8YFMEOGDHGjo2bNmuUCj5xoRI6eS/fXMP1Yo4A0XU61jBQyBeFJQEXEJ0+ebA888EDm1DKFUgpEVKdKq/LF629/+5sLtfJCwZumCtavX9+FS4mm59Br1ogmhXXxUMCiUWYK8bSPRMFTXk4FCtSiw0cFRbVr145YIbGggml3ek81NVI1pILXqQLxOiY1ykzTNYPV7tSO3AqOK0RVqKWASsdSkyZN3OtXAXuNfJo/f36ealUBJwL6BfqFnNAvAACAnBA+ISaNEsrLqB9EvncKc3KbEnYs6HlyK/Iei4JD7d/CVNNIoZpGNKmgen5fl/adwlPdAGT9/0G/kD/0C8lBvwAAgD8InwAAAAAAAJAwfLwPAAAAAACAhCF8AgAAAAAAQMIQPgEAAAAAACBhCJ8AAAAAAACQMIRPAAAAAAAASBjCJwAAAAAAACQM4RMAAAAAAAAShvAJAAAAAAAACUP4BAAAAAAAAMInAAAAAAAApB5GPgEAAAAAAMAS5f8AqXV1x9+ytdQAAAAASUVORK5CYII=",
"text/plain": [
"<Figure size 1200x900 with 9 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Small Multiples（小さいグラフを並べる方式）でリスト長 n ごとに選択順位の分布を可視化\n",
"# 各 subplot の意味：\n",
"# 横軸 = 候補リスト内の選択順位（0=リスト先頭=スコア最高，n-1=リスト末尾）\n",
"# 縦軸 = 選択確率（その順位が選ばれた回数 ÷ そのリスト長での総局面数）\n",
"# 赤点線 = 一様分布の期待値（= 1/n．完全ランダムならどの順位もこの値）\n",
"# 解釈：\n",
"# バーが赤線より高い順位 = LLM がその順位を選びやすい\n",
"# バーが赤線より低い順位 = LLM がその順位を選びにくい\n",
"# 全バーが赤線とほぼ同じ → LLM はランダム相当\n",
"\n",
"# 出現したリスト長を昇順に並べる（n=2,3,4,... 各 subplot 1 枚ずつ）\n",
"ns = sorted(sel_df['n'].unique())\n",
"n_plots = len(ns)\n",
"\n",
"# subplot のグリッド配置を決める（横 3 列固定，行数はリスト長の種類数から計算）\n",
"ncols = 3\n",
"nrows = (n_plots + ncols - 1) // ncols # 切り上げ除算\n",
"\n",
"# Figure と Axes 配列を作成．axes は 2 次元配列なので flatten() で 1 次元化\n",
"fig, axes = plt.subplots(nrows, ncols, figsize=(4 * ncols, 3 * nrows))\n",
"axes = np.array(axes).flatten()\n",
"\n",
"last_idx = -1 # 使用した最後の subplot インデックス（後で余白を消すのに使う）\n",
"\n",
"for i, n in enumerate(ns):\n",
" ax = axes[i]\n",
" # 該当リスト長の選択レコードだけを抽出\n",
" sub = sel_df[sel_df['n'] == n]\n",
" total = len(sub) # この n での総選択回数\n",
"\n",
" # 順位 0..n-1 の出現回数を集計．欠損順位は 0 で埋めて全順位を確実に並べる\n",
" counts = sub['rank'].value_counts().reindex(range(n), fill_value=0).sort_index()\n",
" # 確率に変換（縦軸を確率にすることで n 違いでも比較しやすい）\n",
" probs = counts / total\n",
"\n",
" # 棒グラフ描画（青）\n",
" ax.bar(counts.index, probs, color='#1976D2', alpha=0.85,\n",
" edgecolor='black', linewidth=0.5)\n",
"\n",
" # 一様分布の期待値線（赤点線）．完全ランダムなら全バーがこの高さに揃う\n",
" uniform = 1.0 / n\n",
" ax.axhline(uniform, color='red', linestyle='--', linewidth=1,\n",
" label=f'一様 {uniform:.1%}')\n",
"\n",
" # 軸の体裁\n",
" ax.set_xticks(range(n)) # x軸ラベルを 0,1,...,n-1 に固定\n",
" ax.set_xlabel('選択順位（0=スコア最高）')\n",
" ax.set_ylabel('選択確率')\n",
" ax.set_title(f'リスト長 n={n}（N={total}）') # N は該当局面数の参考表示\n",
" # 縦軸範囲：観測最大値か一様線の高い方を基準に 30% 余白を確保\n",
" ax.set_ylim(0, max(probs.max(), uniform) * 1.3)\n",
" ax.legend(fontsize=8, loc='upper right')\n",
" last_idx = i\n",
"\n",
"# subplot グリッドが余った場合は，使わない領域を非表示にする（軸の枠を消す）\n",
"for j in range(last_idx + 1, len(axes)):\n",
" axes[j].axis('off')\n",
"\n",
"# 全体タイトルとレイアウト調整，画像保存\n",
"plt.suptitle('LLM の選択順位分布（リスト長別）', y=1.00, fontsize=14)\n",
"plt.tight_layout()\n",
"plt.savefig(\"../img/llm_rank_distribution.png\", bbox_inches='tight')\n",
"plt.show()\n",
"plt.close()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4382beee",
"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に選んでもらうという方針には無理があったのか．
あるいは，もっと別のやり方があるのか．
検討して何か思いついたらまた実験してみたいと思います．
また年単位で投稿が止まったりしないことを祈る…．