今回の目標
前回で，オセロAIの思考時間をかなり短縮することに成功しました．
具体的には，10試合を1分強で行えるくらいには高速化しました．
しかし高速化した分やはりある程度性能は落ちています．
今回の記事では，この速度を保ったまま性能を向上させることを目標とします．
ここから本題
いくつかの案を総当たり対戦させてみよう
まず考えたのは，複数の改善案を総当たり対決させてみることです．
思いついた案をとりあえず対戦させて，最も強いものが何かを探ります．
LLMに渡す盤面情報を削る
LLMには，LLMに渡す合法手全てにおいて，「ここに置くとこうなりますよ」な情報も一緒に渡しています．具体的には以下の五つの情報を渡しています．
- 自分の石の数がどうなるか
- 相手の石の数がどうなるか
- そこに石を置くことで反転する石は何か
- 次のターンでの相手の取れる合法手一覧
- そこに石を置くことで安定石はいくつ増えるか
この渡す情報量を適宜削ってみて，それで強くなるか弱くなるかを考えてみます．
不要な情報を渡してしまって判断ノイズになっている可能性がありますし，逆に必須な情報なら残すべきですよね．
具体的に，対戦するメンバーは以下の情報を与えたものになります．
分かりやすいように番号を振ります．
- 上記五項目から変更なし(比較用)
- 上記五項目から，自分の石の数，相手の石の数を除外する．盤面からなんとなくわかるので
- 上記五項目から反転石リストだけ除く．今の盤面と置く位置から自明なので
- 上記五項目において，相手の取れる合法手一覧を，相手の取れる合法手の数に変更する．次のターンで相手に角を取られることを阻止したいが，X位置とC位置を避けるだけで十分かも
方針としては，「上記五項目から何か減らす」です．ただし，「安定石の増加数」に関しては盤面から予想が難しく，なおかつシステムプロンプトでも安定数を見るよう指示しているので絶対に必要な情報．これは削りません．
また，「次のターンでの相手の合法手一覧」も本質的には削らず，削るとしても「相手の取れる合法手の数」にナーフ．一覧じゃなくても数さえ分かればいいかもねという理由です．
これら項目を総当たりで十試合ずつ戦ってもらいます．総試合数は3x4x10の120試合ですね．一試合につき片方8秒かかるとして一試合16秒，全試合通して32分で終わる計算です．
実際の対戦結果がこちら．
[V0_all vs V1_noStones] 完了 黒 4勝5敗1分20 (8%) | 経過 2m32s 残り約 27m52s
[V0_all vs V2_noFlip] 完了 黒 5勝5敗0分20 (16%) | 経過 4m59s 残り約 24m55s
[V0_all vs V3_oppCount] 完了 黒 5勝4敗1分20 (25%) | 経過 7m23s 残り約 22m09s
[V1_noStones vs V0_all] 完了 黒 5勝5敗0分20 (33%) | 経過 9m50s 残り約 19m40s
[V1_noStones vs V2_noFlip] 完了 黒 8勝2敗0分20 (41%) | 経過 12m18s 残り約 17m13s
[V1_noStones vs V3_oppCount] 完了 黒 1勝9敗0分20 (50%) | 経過 14m44s 残り約 14m44s
[V2_noFlip vs V0_all] 完了 黒 5勝4敗1分20 (58%) | 経過 17m10s 残り約 12m15s
[V2_noFlip vs V1_noStones] 完了 黒 6勝4敗0分20 (66%) | 経過 19m37s 残り約 9m48s
[V2_noFlip vs V3_oppCount] 完了 黒 7勝2敗1分20 (75%) | 経過 22m03s 残り約 7m21s
[V3_oppCount vs V0_all] 完了 黒 4勝5敗1分120 (83%) | 経過 24m25s 残り約 4m53s
[V3_oppCount vs V1_noStones] 完了 黒 7勝3敗0分120 (91%) | 経過 26m47s 残り約 2m26s
[V3_oppCount vs V2_noFlip] 完了 黒 6勝4敗0分120 (100%) | 経過 29m09s 残り約 0m00s
かかった時間は大体予想通り．面白そうな結果になっていますね．
それぞれの勝率をグラフ化してみるとこんな感じ．
一応一番強かったのは四番目の，「次のターンでの相手の合法手一覧」を「次のターンでの相手の合法手の数」に変更したやつですね．
逆に一番弱かったのは自分の石の数と相手の石の数を渡さなかったもの．
ただまあ勝率に激的に違いがあるわけじゃないので，正直全力で信用していいグラフかどうかは怪しいですね．
相性問題とかもあるかもしれないので，ヒートマップ的に表示もしてみます．
グラフに書いている勝率は黒側の勝率です．
こう見ると，かなり相性問題はあるようですね．
他の対戦相手に安定して勝っている，または負けているというものは特にないように見えます．
ただどの対戦相手に対しても安定して勝率がある程度あるのはV2の「反転リストを渡さない」に見えますね．これについては設計思想的にも強くなって当然のように思うので，一旦これが一番強いとして結論付けてもいいと思います．
本当だったらもっと対戦回数を増やさないとはっきりしたことは言えないかなという気もしますが，いかんせん時間がかかりすぎるので…．
LLMに渡す合法手の削り方を調整する
前回の記事では，LLMに渡す合法手は，単に「合法手全てのうち，スコアの上位半分」としていました．
しかしこれでは，スコアに圧倒的な差があるときは不要な手まで渡してしまい，スコアにあまり差がなく均等な場合は有効な可能性のある手を排除してしまっていました．
これを修正し，「スコアの標準偏差が大きい時は上位数件だけ渡す．小さい場合は多めに渡す」と調整することで，有望な手を排除しないように配慮することが出来る…と考えられます．
LLMに渡す情報量を削った時と同じように，こちらも何パターンか用意して総当たりで戦ってもらいます．
メンバーは以下．
- スコアの上位半分を渡す(比較用)
- スコアが平均点以上のものだけ残す．一つだけ突出しているみたいな状況ではそれだけが残る
- 最大スコア-標準偏差よりも大きい物だけ残す．こちらも上記と同様，突出しているものがある場合はそれだけ残る
- 合法手からX位置とC位置を除く→スコアの上位半分のみにする→合法手に角がある場合はそれを含める．最初の方針と同じようにしつつ，システムプロンプトで指定している戦法を取りやすくする
という事で実行してみました．
結果がこちら．
[M0_topHalf vs M1_mean] 完了 黒 4勝4敗2分20 (8%) | 経過 2m24s 残り約 26m24s
[M0_topHalf vs M2_stddev] 完了 黒 4勝5敗1分20 (16%) | 経過 4m48s 残り約 24m00s
[M0_topHalf vs M3_strategic] 完了 黒 0勝10敗0分0 (25%) | 経過 7m19s 残り約 21m57s
[M1_mean vs M0_topHalf] 完了 黒 6勝4敗0分20 (33%) | 経過 9m43s 残り約 19m26s
[M1_mean vs M2_stddev] 完了 黒 3勝6敗1分20 (41%) | 経過 12m01s 残り約 16m49s
[M1_mean vs M3_strategic] 完了 黒 1勝9敗0分20 (50%) | 経過 14m24s 残り約 14m24s
[M2_stddev vs M0_topHalf] 完了 黒 7勝3敗0分20 (58%) | 経過 16m46s 残り約 11m58s
[M2_stddev vs M1_mean] 完了 黒 3勝7敗0分20 (66%) | 経過 19m06s 残り約 9m33s
[M2_stddev vs M3_strategic] 完了 黒 0勝10敗0分0 (75%) | 経過 21m30s 残り約 7m10s
[M3_strategic vs M0_topHalf] 完了 黒 10勝0敗0分20 (83%) | 経過 23m56s 残り約 4m47s
[M3_strategic vs M1_mean] 完了 黒 9勝1敗0分120 (91%) | 経過 26m18s 残り約 2m23s
[M3_strategic vs M2_stddev] 完了 黒 6勝4敗0分120 (100%) | 経過 28m39s 残り約 0m00s
さっきと違い，明確に強弱が分かれていそうですね．
結果をグラフでまとめてみます．
つ，つえー！！
M3強すぎですね．
弱い手を事前に削っておくのはかなり有効のようです．
ただし，M0はあまり強くないですね．
つまり，M3のカスタムとして，X位置やC位置以外の通常の合法手の削り方として「平均値以上」や「最大値から標準偏差を引いた値以上」を採用すればさらに強くなる可能性がありそうです．
LLMに渡す合法手を削るその2
という事で今回の対戦メンバーは以下の通り．いずれも，合法手を以下の方法で削る前にX位置とC位置を削ります．また，以下の方法で削った後に角は問答無用で足します．なお，平均スコアなどはX位置とC位置を除いた状態で計算します．
- 先ほどのM3と同様，スコア上位半分
- 平均スコア以上
- スコアが最大値-標準偏差以上
- 最少スコアと最大スコアの中間値以上
一番下の中間値に関してはさっきの実験にはありませんでしたが加えました．
せっかく今まで四つで総当たりしてきたので今回も揃えます．
ちなみに補足ですが，C位置とX位置以外に置ける場所がない場合はC位置とX位置を全合法手として渡し，そこから平均値などを計算してもらいます．
今回の対戦ではお互いにC位置とX位置を避け続けるので，「どちらが相手にX位置とC位置を押し付けるか」みたいな戦いになってそうですね．
その実行結果がこちら．
[M3a_topHalf vs M3b_mean] 完了 黒 6勝3敗1分20 (8%) | 経過 2m30s 残り約 27m30s
[M3a_topHalf vs M3c_stddev] 完了 黒 5勝5敗0分20 (16%) | 経過 4m55s 残り約 24m35s
[M3a_topHalf vs M3d_midpoint] 完了 黒 6勝4敗0分20 (25%) | 経過 7m20s 残り約 22m00s
[M3b_mean vs M3a_topHalf] 完了 黒 7勝3敗0分20 (33%) | 経過 9m42s 残り約 19m24s
[M3b_mean vs M3c_stddev] 完了 黒 4勝6敗0分20 (41%) | 経過 11m50s 残り約 16m34s
[M3b_mean vs M3d_midpoint] 完了 黒 4勝6敗0分20 (50%) | 経過 14m11s 残り約 14m11s
[M3c_stddev vs M3a_topHalf] 完了 黒 2勝8敗0分20 (58%) | 経過 16m33s 残り約 11m49s
[M3c_stddev vs M3b_mean] 完了 黒 4勝6敗0分20 (66%) | 経過 18m30s 残り約 9m15s
[M3c_stddev vs M3d_midpoint] 完了 黒 4勝5敗1分20 (75%) | 経過 20m51s 残り約 6m57s
[M3d_midpoint vs M3a_topHalf] 完了 黒 6勝4敗0分120 (83%) | 経過 23m14s 残り約 4m38s
[M3d_midpoint vs M3b_mean] 完了 黒 2勝7敗1分120 (91%) | 経過 25m36s 残り約 2m19s
[M3d_midpoint vs M3c_stddev] 完了 黒 6勝3敗1分120 (100%) | 経過 27m56s 残り約 0m00s
ちなみに，ちょいちょいLLMから有効な手を取得できませんでした．
割と勝敗は分かれていそうですね．ではグラフ化してみます．
う～～～～む．
グラフ化してみると，明確に「これが強い」と言えるようなものはないですね．
商率が最も高かったのはスコア上位半分を残すフィルタですが，ヒートマップを見てみるとどの相手に対しても安定した勝率になっているとは言い切れません．
逆にトータルでは最も勝率の低かったスコア中間点フィルタですが，これもヒートマップを見ると全ての相手に押し負けているというわけでもなく，非常に評価が難しいです．
結果を見るに，「X位置とC位置を事前に除外しておく」が強かっただけであり，それ以外の合法手のフィルタについては誤差程度の違いしかないというのが結論だと思います．
スコア上位半分フィルタよりも他のフィルタの方が強いと仮定していましたが，それを証明するほどのデータは得られなかったということになりますね．
実際に対戦してみよう
さて，これまではオセロAI同士で対戦して強いものだけを生き残らせてきました．
いわばこれは蟲毒とも言えます．
その蟲毒を生き残ったM3_topHalfと実際に対戦してみましょう．
まずは僕が黒でAIが白から．
対戦結果がこちら．
a b c d e f g h
1 B B B B B B B B
2 B B B B B B B B
3 B B B W B W W B
4 B W B B B W W B
5 B B B W B B W B
6 B W B W B B B B
7 W W W B B B W B
8 B B B B B B B B
黒の手番
置ける位置:
黒 はパスします
=== 終局 ===
黒(HUMAN): 50 石
白(LLM): 14 石
→ 黒の勝ち！
結果だけ見ると楽勝に見えるかも知れませんが，結構強かったです．
次に，僕が白でAIが黒のパターン．
対戦結果がこちら．
a b c d e f g h
1 W W W W W W W W
2 B W W W W W W W
3 W B W B B W B W
4 W W B B B B B W
5 W W B W B W B W
6 W W W B W W B W
7 W W B W W W W W
8 W B B B B B B W
白の手番
置ける位置:
白 はパスします
=== 終局 ===
黒(LLM): 22 石
白(HUMAN): 42 石
→ 白の勝ち！
結構強かったですが，白でやってもらった時ほどは強さを感じませんでした．
「ここに置かれると嫌だな～」と思ったところに置いてくることは多かったんですがね．
フルバージョン
Osero.java
Osero.java
import java.io.*;
import java.net.URI;
import java.net.http.*;
import java.util.*;
import java.util.function.BiConsumer;
import java.util.regex.*;
/**
* オセロAIクラス．
* ほぼ Qiita 記事の実装に準拠 (https://qiita.com/tt_and_tk/items/22641b036d3b1e5fdbca)
* 記事と異なる点: DataGen 用に thinkAndGetMove() メソッドを追加している．
*/
public class Osero extends OseroBase {
/** 思考方法の識別子． */
public enum PlayMethod {
/** ランダムに置く */
RANDOM,
/** n手先で，自分の石数が最大になる位置に置く */
N_HAND,
/** n手先で，相手の取れる手数が最小になる位置に置く */
N_LEAST,
/** n手先で，自分の取れる手数が最大になる位置に置く */
N_MOST,
/** n手先で，自分の安定石増加数が最大になる位置に置く */
N_STABLE,
/** 経過手数に応じてスコア関数を切り替えるハイブリッド戦略 */
N_HYBRID,
/** 人間が手を選ぶ */
HUMAN,
/** ツールを利用した LLM(Ollama 経由)が手を選ぶ */
LLM,
}
/** LLM に提示するシミュレーション情報のフィールド識別子． */
public enum SimField {
/** 自石数 */
MY_STONES,
/** 相石数 */
OPP_STONES,
/** 反転した石の座標リスト */
FLIPPED,
/** 相手の次の手一覧（座標リスト＋手数） */
OPP_MOVES,
/** 相手の次の手数のみ（OPP_MOVES が未設定のときのみ有効） */
OPP_MOVES_COUNT,
/** 安定石増加数 */
STABLE_GAINED,
}
/** 探索深さ．[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 に提示するシミュレーション情報のフィールドセット（デフォルト: V2_noFlip，反転リスト除外）． */
private EnumSet<SimField> currentSimFields = EnumSet.of(
SimField.MY_STONES, SimField.OPP_STONES,
SimField.OPP_MOVES, SimField.STABLE_GAINED);
/**
* LLM プレイヤーが使用するモデル名を返す．
* @return 現在設定されているモデル名
*/
public static String getLlmModel() { return llmModel; }
/**
* LLM プレイヤーが使用するモデル名を設定する．
* 設定できるモデルは {@code ALLOWED_LLM_MODELS} に含まれるものに限る．
* @param model 設定するモデル名
* @throws IllegalArgumentException 許可されていないモデル名の場合
*/
public static void setLlmModel(String model) {
if (!ALLOWED_LLM_MODELS.contains(model)) {
throw new IllegalArgumentException("許可されていないモデル名: " + model
+ " 使用可能: " + ALLOWED_LLM_MODELS);
}
llmModel = model;
}
/**
* LLM の API 往復ログの出力先を設定する．
* @param w ログの出力先
*/
public void setLogWriter(PrintWriter w) { this.logWriter = w; }
/**
* LLM の API 往復ログの出力先をリセットする(null に戻す)．
*/
public void resetLogWriter() { this.logWriter = null; }
/**
* LLM に提示するシミュレーション情報のフィールドセットを設定する．
* @param fields 出力するフィールドの集合
*/
public void setSimFields(EnumSet<SimField> fields) { this.currentSimFields = fields; }
/**
* 候補手の選別戦略（デフォルト: 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);
}
/**
* ビットボードをテキスト形式に変換する．
* 盤面・手番・置ける位置の一覧を含む．
* @param board ビットボード
* @param turn 手番(false=黒, true=白)
* @return 盤面テキスト
*/
public String boardToText(long[] board, boolean turn) {
StringBuilder sb = new StringBuilder();
sb.append(" a b c d e f g h\n");
for (int row = 0; row < SIZE; row++) {
sb.append(row + 1).append(" ");
for (int col = 0; col < SIZE; col++) {
long bit = 1L << ((row << ROW_SHIFT) + col);
if ((board[0] & bit) != 0) sb.append("B ");
else if ((board[1] & bit) != 0) sb.append("W ");
else sb.append(". ");
}
sb.append("\n");
}
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 (canPlace(row, col, board, turn)) validMoves.add(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.boardToText(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);
}
/**
* 候補手のシミュレーション結果を「全合法手」として 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);
sb.append("- ").append(coord).append(": ");
List<String> parts = new ArrayList<>();
// currentSimFields に含まれるフィールドのみ出力
if (this.currentSimFields.contains(SimField.MY_STONES))
parts.add("自石" + res.myStones);
if (this.currentSimFields.contains(SimField.OPP_STONES))
parts.add("相石" + res.opponentStones);
if (this.currentSimFields.contains(SimField.FLIPPED))
parts.add("反転[" + String.join(",", res.flipped) + "]");
if (this.currentSimFields.contains(SimField.OPP_MOVES))
parts.add("相手の次の手[" + String.join(",", res.opponentValidMoves)
+ "](" + res.opponentValidMoves.size() + "手)");
else if (this.currentSimFields.contains(SimField.OPP_MOVES_COUNT))
// OPP_MOVES が無いときのみ手数カウントのみを出力（V3 用）
parts.add("相手の次の手(" + res.opponentValidMoves.size() + "手)");
if (this.currentSimFields.contains(SimField.STABLE_GAINED))
parts.add("安定石+" + res.stableGained);
sb.append(String.join(", ", parts)).append("\n");
}
return sb.toString();
}
/** JSON 文字列内の特殊文字をエスケープする(llm() のリクエスト組み立て用)． */
private String escapeForJson(String s) {
return s.replace("\\", "\\\\")
.replace("\"", "\\\"")
.replace("\n", "\\n")
.replace("\r", "\\r")
.replace("\t", "\\t");
}
/**
* 指定位置を開始点とする JSON オブジェクト文字列を抽出する．
* 文字列リテラル内の括弧を読み飛ばし，対応する '}' を正確に判定する．
* @param s 検索対象の文字列
* @param start '{' の位置
* @return '{' から対応する '}' までの部分文字列
*/
private String extractJsonObject(String s, int start) {
int depth = 0;
boolean inStr = false;
for (int i = start; i < s.length(); i++) {
char c = s.charAt(i);
if (inStr) {
if (c == '\\') i++;
else if (c == '"') inStr = false;
} else {
if (c == '"') inStr = true;
else if (c == '{') depth++;
else if (c == '}' && --depth == 0) return s.substring(start, i + 1);
}
}
return s.substring(start);
}
/**
* 文字列中の指定キーに対応する JSON 文字列フィールドの値を返す．
* エスケープシーケンス(\n, \r, \t, \\, \")をデコードして返す．
* @param s 検索対象の文字列(エスケープ済み)
* @param key 検索キー(例: "\"content\"")
* @return フィールドの値(デコード済み)，キーが存在しない場合は空文字列
*/
private String extractStringField(String s, String key) {
int keyIdx = s.indexOf(key);
if (keyIdx < 0) return "";
int colonIdx = s.indexOf(":", keyIdx + key.length());
if (colonIdx < 0) return "";
int quoteIdx = s.indexOf("\"", colonIdx + 1);
if (quoteIdx < 0) return "";
StringBuilder sb = new StringBuilder();
for (int i = quoteIdx + 1; i < s.length(); i++) {
char c = s.charAt(i);
if (c == '\\' && i + 1 < s.length()) {
char esc = s.charAt(++i);
if (esc == 'n') sb.append('\n');
else if (esc == 'r') sb.append('\r');
else if (esc == 't') sb.append('\t');
else sb.append(esc);
} else if (c == '"') {
break;
} else {
sb.append(c);
}
}
return sb.toString();
}
/**
* SimulateResult を LLM に返す JSON 文字列に変換する．
* @param res シミュレーション結果
* @return JSON 文字列
*/
private String buildSimulateResultJson(SimulateResult res) {
StringBuilder sb = new StringBuilder();
sb.append("{\"board\":\"").append(escapeForJson(res.boardText)).append("\"");
sb.append(",\"my_stones\":").append(res.myStones);
sb.append(",\"opponent_stones\":").append(res.opponentStones);
sb.append(",\"stable_gained\":").append(res.stableGained);
sb.append(",\"flipped\":[");
for (int i = 0; i < res.flipped.size(); i++) {
if (i > 0) sb.append(",");
sb.append("\"").append(res.flipped.get(i)).append("\"");
}
sb.append("],\"opponent_valid_moves\":[");
for (int i = 0; i < res.opponentValidMoves.size(); i++) {
if (i > 0) sb.append(",");
sb.append("\"").append(res.opponentValidMoves.get(i)).append("\"");
}
sb.append("]}");
return sb.toString();
}
// ── LLM ツールサポート ────────────────────────────────────
/**
* simulate_move ツールの戻り値を格納するデータクラス．
*/
protected static class SimulateResult {
/** 着手後の盤面テキスト */
String boardText;
/** 着手側の石数 */
int myStones;
/** 相手の石数 */
int opponentStones;
/** ひっくり返した石の座標リスト("d4" 形式) */
List<String> flipped;
/** 着手後に相手が置ける位置一覧 */
List<String> opponentValidMoves;
/** この着手で増えた自分の安定石の数 */
int stableGained;
}
/**
* 指定座標に石を置いた場合の結果をシミュレートする(実際の盤面は変更しない)．
* 座標は "d3" 形式(列 a〜h + 行 1〜8)で受け取り，内部で行・列インデックスに変換する．
* @param board ビットボード(board[0]=黒, board[1]=白)
* @param turn 手番(false=黒, true=白)
* @param coord 座標文字列(例: "d3")
* @return シミュレーション結果
* @throws IllegalArgumentException 座標が不正または石を置けない場合
*/
protected SimulateResult simulateMove(long[] board, boolean turn, String coord) {
if (coord == null || coord.length() < 2)
throw new IllegalArgumentException("無効な座標形式: " + coord);
int col = "abcdefgh".indexOf(coord.charAt(0));
int row = "12345678".indexOf(coord.charAt(1));
if (col < 0 || row < 0)
throw new IllegalArgumentException("無効な座標: " + coord);
if (!canPlace(row, col, board, turn))
throw new IllegalArgumentException("置けない位置が指定されました: " + coord);
int my = turn ? 1 : 0;
int opp = turn ? 0 : 1;
int before = countStableStones(board, turn);
long[] boardCopy = {board[0], board[1]};
place(row, col, boardCopy, turn);
SimulateResult res = new SimulateResult();
res.myStones = countStones(boardCopy, turn);
res.opponentStones = countStones(boardCopy, !turn);
res.boardText = boardToText(boardCopy, !turn);
res.stableGained = countStableStones(boardCopy, turn) - before;
// 着手前に相手の石だったもので，着手後に自分の石になったもの = ひっくり返した石
long flippedBits = board[opp] & boardCopy[my];
res.flipped = new ArrayList<>();
for (int r = 0; r < SIZE; r++)
for (int c = 0; c < SIZE; c++)
if ((flippedBits & (1L << ((r << ROW_SHIFT) + c))) != 0)
res.flipped.add(coordToStr(r, c));
// 着手後に相手が置ける位置
res.opponentValidMoves = new ArrayList<>();
for (int r = 0; r < SIZE; r++)
for (int c = 0; c < SIZE; c++)
if (canPlace(r, c, boardCopy, !turn))
res.opponentValidMoves.add(coordToStr(r, c));
return res;
}
// ── 探索フレームワーク ────────────────────────────────────
/** 盤面評価用インターフェース */
@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;
import java.util.stream.Collectors;
/**
* 複数の LLM モデルを既存 AI アルゴリズムと対戦させ，速度と勝率を比較するクラス．
*
* 使い方:
* javac *.java
* java Evaluator
*/
public class Evaluator extends Osero {
private static final int GAMES_PER_MATCHUP = 10;
private static final int READ_GOAL = 3;
/** 比較対象の LLM モデル名の一覧 */
private static final String[] MODELS = {
"gemma4-osero-e2b",
};
/** 対戦相手として使用する AI メソッドの一覧 */
private static final PlayMethod[] OPPONENTS = {
PlayMethod.N_HAND, PlayMethod.N_LEAST, PlayMethod.N_MOST, PlayMethod.RANDOM, PlayMethod.N_HYBRID
};
/** LLM に渡すシミュレーション情報フィールドの組み合わせを表す設定クラス． */
private static class SimInfoConfig {
final String name;
final EnumSet<SimField> simFields;
/**
* @param name 設定識別子（CSV・ログ出力に使用）
* @param simFields LLM に提示するシミュレーション情報フィールドの集合
*/
SimInfoConfig(String name, EnumSet<SimField> simFields) {
this.name = name; this.simFields = simFields;
}
}
// ─── Stage 1: 案2（シミュ情報削減）の評価設定一覧 ────────────────────────
// Stage 2 実施時はここを案3（候補手選別）の設定一覧と入れ替える
private static final SimInfoConfig[] SIM_CONFIGS = {
// V0: Phase 4 ベースライン（全 5 項目，変更なし）
new SimInfoConfig("V0_all",
EnumSet.of(SimField.MY_STONES, SimField.OPP_STONES, SimField.FLIPPED,
SimField.OPP_MOVES, SimField.STABLE_GAINED)),
// V1: 石数（自石・相石）を除外（盤面テキストから把握可能）
new SimInfoConfig("V1_noStones",
EnumSet.of(SimField.FLIPPED, SimField.OPP_MOVES, SimField.STABLE_GAINED)),
// V2: 反転リストを除外（座標と着手前盤面から自明）
new SimInfoConfig("V2_noFlip",
EnumSet.of(SimField.MY_STONES, SimField.OPP_STONES,
SimField.OPP_MOVES, SimField.STABLE_GAINED)),
// V3: 相手合法手一覧を手数カウントのみに変更（角チェック能力が失われる点に注意）
new SimInfoConfig("V3_oppCount",
EnumSet.of(SimField.MY_STONES, SimField.OPP_STONES, SimField.FLIPPED,
SimField.OPP_MOVES_COUNT, SimField.STABLE_GAINED)),
};
// ─── Stage 2 で使用するシミュ情報設定（V2_noFlip に固定）────────────────────
private static final EnumSet<SimField> SIM_FIELDS_V2 = EnumSet.of(
SimField.MY_STONES, SimField.OPP_STONES,
SimField.OPP_MOVES, SimField.STABLE_GAINED);
/** LLM に渡す候補手の選別戦略を表す設定クラス． */
private static class MoveFilterConfig {
final String name;
final MoveFilter filter;
/**
* @param name 設定識別子（CSV・ログ出力に使用）
* @param filter 候補手の選別戦略
*/
MoveFilterConfig(String name, MoveFilter filter) {
this.name = name; this.filter = filter;
}
}
// ─── Stage 2: 案3（候補手選別戦略）の評価設定一覧 ────────────────────────
// X_C_POS / CORNER_POS は Osero.java の protected 定数を継承して使用する
private static final MoveFilterConfig[] MOVE_FILTER_CONFIGS = {
// M0: Phase 4 ベースライン（上位半分）
new MoveFilterConfig("M0_topHalf", sorted -> {
int k = (sorted.size() + 1) / 2;
List<int[]> r = new ArrayList<>();
for (int i = 0; i < k; i++) r.add(new int[]{sorted.get(i).row, sorted.get(i).col});
return r;
}),
// M1: 全候補の平均スコア以上の手を残す（取りこぼしが少ない静的基準）
new MoveFilterConfig("M1_mean", sorted -> {
double mean = sorted.stream().mapToDouble(m -> m.score).average().orElse(0);
List<int[]> r = new ArrayList<>();
for (ScoredMove m : sorted) if (m.score >= mean) r.add(new int[]{m.row, m.col});
// 全手同スコアで空になった場合は全候補を返す
return r.isEmpty() ? sorted.stream().map(m -> new int[]{m.row, m.col})
.collect(java.util.stream.Collectors.toList()) : r;
}),
// M2: 最高スコアとの差が 1σ 以内の手を残す（局面に応じて適応的に絞る）
new MoveFilterConfig("M2_stddev", sorted -> {
double max = sorted.get(0).score;
double mean = sorted.stream().mapToDouble(m -> m.score).average().orElse(0);
double var = sorted.stream().mapToDouble(m -> (m.score - mean) * (m.score - mean))
.average().orElse(0);
double sd = Math.sqrt(var);
List<int[]> r = new ArrayList<>();
for (ScoredMove m : sorted) if (max - m.score <= sd) r.add(new int[]{m.row, m.col});
// σ=0（全手同スコア）の場合は全候補を返す
return r.isEmpty() ? sorted.stream().map(m -> new int[]{m.row, m.col})
.collect(java.util.stream.Collectors.toList()) : r;
}),
// M3: X/C 位置を除外 → 上位半分 → 角を強制追加
new MoveFilterConfig("M3_strategic", sorted -> {
// X/C 除外後に上位半分を選ぶ
List<ScoredMove> safe = new ArrayList<>();
for (ScoredMove m : sorted)
if (!X_C_POS.contains(m.row * 8 + m.col)) safe.add(m);
// X/C 除外後に手がなくなった場合はフォールバック（全合法手の上位半分）
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;
}),
};
/**
* X/C 位置を除いた安全な手のリストを返す．全手が X/C の場合は全合法手にフォールバックする．
* @param sorted スコア降順にソートされた全合法手
* @return X/C を除いた手のリスト（フォールバック時は sorted をそのまま返す）
*/
private static List<ScoredMove> safeMoves(List<ScoredMove> sorted) {
List<ScoredMove> safe = new ArrayList<>();
for (ScoredMove m : sorted)
if (!X_C_POS.contains(m.row * 8 + m.col)) safe.add(m);
return safe.isEmpty() ? sorted : safe;
}
/**
* 結果リストに含まれていない角を全合法手から探して末尾に追加する．
* @param result 選別済みの候補手リスト
* @param sorted スコア降順にソートされた全合法手（角の探索元）
* @return 角を強制追加した候補手リスト
*/
private static List<int[]> addCorners(List<int[]> result, List<ScoredMove> sorted) {
Set<Integer> added = new HashSet<>();
for (int[] rc : result) added.add(rc[0] * 8 + rc[1]);
List<int[]> out = new ArrayList<>(result);
for (ScoredMove m : sorted) {
int pos = m.row * 8 + m.col;
if (CORNER_POS.contains(pos) && !added.contains(pos))
out.add(new int[]{m.row, m.col});
}
return out;
}
// ─── Stage 3: M3 の内部フィルタ比較（X/C 除外 + 角強制は共通）────────────────
private static final MoveFilterConfig[] MOVE_FILTER_CONFIGS_3 = {
// M3a: 安全な手の上位半分（前回 M3_strategic と同じロジック，比較基準）
new MoveFilterConfig("M3a_topHalf", sorted -> {
List<ScoredMove> safe = safeMoves(sorted);
int k = (safe.size() + 1) / 2;
List<int[]> r = new ArrayList<>();
for (int i = 0; i < k; i++) r.add(new int[]{safe.get(i).row, safe.get(i).col});
return addCorners(r, sorted);
}),
// M3b: 安全な手の平均スコア以上
new MoveFilterConfig("M3b_mean", sorted -> {
List<ScoredMove> safe = safeMoves(sorted);
double mean = safe.stream().mapToDouble(m -> m.score).average().orElse(0);
List<int[]> r = new ArrayList<>();
for (ScoredMove m : safe) if (m.score >= mean) r.add(new int[]{m.row, m.col});
return addCorners(r, sorted);
}),
// M3c: 安全な手の最大値 - 1σ 以上（σ は安全な手のスコアから算出）
new MoveFilterConfig("M3c_stddev", sorted -> {
List<ScoredMove> safe = safeMoves(sorted);
double max = safe.get(0).score;
double mean = safe.stream().mapToDouble(m -> m.score).average().orElse(0);
double sd = Math.sqrt(safe.stream()
.mapToDouble(m -> (m.score - mean) * (m.score - mean)).average().orElse(0));
List<int[]> r = new ArrayList<>();
for (ScoredMove m : safe) if (max - m.score <= sd) r.add(new int[]{m.row, m.col});
return addCorners(r, sorted);
}),
// M3d: 安全な手の (min + max) / 2 以上
new MoveFilterConfig("M3d_midpoint", sorted -> {
List<ScoredMove> safe = safeMoves(sorted);
double max = safe.get(0).score;
double min = safe.get(safe.size() - 1).score;
double mid = (min + max) / 2.0;
List<int[]> r = new ArrayList<>();
for (ScoredMove m : safe) if (m.score >= mid) r.add(new int[]{m.row, m.col});
return addCorners(r, sorted);
}),
};
/**
* 1ゲームを実行し，勝者を返す．
* @param black 黒番の思考方法
* @param white 白番の思考方法
* @return 1=黒勝ち, -1=白勝ち, 0=引き分け
*/
/**
* 1ゲームを実行し，勝者を返す．
* @param black 黒番の思考関数
* @param white 白番の思考関数
* @return 1=黒勝ち, -1=白勝ち, 0=引き分け
*/
public int runGame(BiConsumer<long[], Boolean> black, BiConsumer<long[], Boolean> white) {
this.initBoard();
BiConsumer<long[], Boolean> blackPlayer = black;
BiConsumer<long[], Boolean> whitePlayer = white;
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 ? whitePlayer : blackPlayer).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 model 現在実行中のモデル名
* @param opp 現在の対戦相手
* @param bDone 現在の対戦相手での黒番完了ゲーム数
* @param wDone 現在の対戦相手での白番完了ゲーム数
* @param done 全体完了ゲーム数
* @param total 全体ゲーム数
* @param startMs 開始時刻（ミリ秒）
*/
private static void printProgress(String blackCfg, String whiteCfg,
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 ",
blackCfg, whiteCfg, gameDone, GAMES_PER_MATCHUP,
done, total, done * 100 / total,
formatTime(elapsed), formatTime(remaining));
}
/**
* 評価のエントリーポイント．
* MOVE_FILTER_CONFIGS の各設定同士を総当たりで対戦させ（自分同士はスキップ），結果を CSV に保存する．
* シミュ情報は Stage 1 の結果を受けて V2_noFlip（反転リスト除外）に固定する．
* 外ループが黒，内ループが白となるため，各設定が黒・白の両役を自然に経験する．
* @param args 未使用
* @throws IOException CSV ファイルの書き込みに失敗した場合
*/
public static void main(String[] args) throws IOException {
Evaluator ev = new Evaluator();
ev.setReadGoal(READ_GOAL, READ_GOAL);
setLlmModel(MODELS[0]);
LocalDateTime now = LocalDateTime.now();
String startTs = now.format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
String date = now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
String filename = "../csv/compare_" + startTs + ".csv";
// 自分同士を除いた総当たり: 4 × 3 × GAMES_PER_MATCHUP ゲーム
int n = MOVE_FILTER_CONFIGS_3.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_filter,white_filter,model,date,games_per_matchup,black_win,black_lose,black_draw");
// 外ループ = 黒設定，内ループ = 白設定（自分同士はスキップ）
for (MoveFilterConfig blackCfg : MOVE_FILTER_CONFIGS_3) {
for (MoveFilterConfig whiteCfg : MOVE_FILTER_CONFIGS_3) {
if (blackCfg == whiteCfg) continue;
int blackWin = 0, blackLose = 0, blackDraw = 0;
// 各手番前に moveFilter と simFields(V2_noFlip 固定)を切り替えるラムダで対戦
BiConsumer<long[], Boolean> blackPlayer = (board, turn) -> {
ev.setSimFields(SIM_FIELDS_V2);
ev.setMoveFilter(blackCfg.filter);
ev.llm(board, turn);
};
BiConsumer<long[], Boolean> whitePlayer = (board, turn) -> {
ev.setSimFields(SIM_FIELDS_V2);
ev.setMoveFilter(whiteCfg.filter);
ev.llm(board, turn);
};
for (int i = 0; i < GAMES_PER_MATCHUP; i++) {
String ts = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
String logBase = "../log/eval_" + blackCfg.name + "_vs_" + whiteCfg.name
+ "_" + (i + 1) + "_" + ts + ".jsonl";
try (PrintWriter lw = new PrintWriter(new FileWriter(logBase))) {
ev.setLogWriter(lw);
int r = ev.runGame(blackPlayer, whitePlayer);
if (r == 1) blackWin++;
else if (r == -1) blackLose++;
else blackDraw++;
}
ev.resetLogWriter();
doneGames++;
printProgress(blackCfg.name, whiteCfg.name, i + 1,
doneGames, totalGames, startMs);
}
System.out.printf("\r[%s vs %s] 完了 黒 %d勝%d敗%d分%n",
blackCfg.name, whiteCfg.name, blackWin, blackLose, blackDraw);
csv.printf("%s,%s,%s,%s,%d,%d,%d,%d%n",
blackCfg.name, whiteCfg.name, getLlmModel(), date,
GAMES_PER_MATCHUP, blackWin, blackLose, blackDraw);
}
}
}
System.out.println("結果を保存しました: " + filename);
}
}
analysis.ipynb
analysis.ipynb
{
"cells": [
{
"cell_type": "markdown",
"id": "5e8b3d52",
"metadata": {},
"source": [
"# import"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "3f33f96d",
"metadata": {},
"outputs": [],
"source": [
"import glob\n",
"\n",
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n",
"import pandas as pd"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "3fcb138d",
"metadata": {},
"outputs": [],
"source": [
"sns.set()\n",
"# 日本語フォントの設定(Windows: Meiryo)\n",
"plt.rcParams['font.family'] = 'Meiryo'"
]
},
{
"cell_type": "markdown",
"id": "13abf2f6",
"metadata": {},
"source": [
"# LLMに渡す情報量を絞った状態で対戦させてみる"
]
},
{
"cell_type": "markdown",
"id": "9d452dd9",
"metadata": {},
"source": [
"## 元々渡していた情報(5種類)\n",
"\n",
"各合法手について以下を提示していた:\n",
"\n",
"1. **自石数** — この手を打った後の自分の石の数\n",
"2. **相石数** — この手を打った後の相手の石の数\n",
"3. **反転石リスト** — この手でひっくり返す相手の石の座標一覧\n",
"4. **相手の次の合法手一覧** — この手の後に相手が置ける座標一覧（および手数）\n",
"5. **安定石増加数** — この手によって増える自分の安定石の数\n",
"\n",
"---\n",
"\n",
"## 今回渡した情報のバリエーション\n",
"\n",
"4種類の設定を総当たり（自分同士を除く全12マッチアップ × 10試合）で比較した．\n",
"\n",
"| 設定名 | 渡す情報 | 変更の意図 |\n",
"|--------|----------|------------|\n",
"| **V0_all** | 上記5種類すべて | 比較用ベースライン |\n",
"| **V1_noStones** | 反転リスト・相手次手一覧・安定石増のみ（自石数・相石数を除外） | 石数は盤面テキストからおおよそ把握できるため |\n",
"| **V2_noFlip** | 自石数・相石数・相手次手一覧・安定石増のみ（反転リストを除外） | 反転石は盤面と着手位置から自明なため |\n",
"| **V3_oppCount** | 自石数・相石数・反転リスト・相手次手カウント・安定石増（相手の次の合法手を座標一覧→手数のみに変更） | X位置・C位置を避ける指示だけで十分な可能性があるため |"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "44621d8d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"読み込み: ../csv\\compare_20260504_110404.csv\n"
]
},
{
"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_config</th>\n",
" <th>white_config</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>V0_all</td>\n",
" <td>V1_noStones</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>4</td>\n",
" <td>5</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>V0_all</td>\n",
" <td>V2_noFlip</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>5</td>\n",
" <td>5</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>V0_all</td>\n",
" <td>V3_oppCount</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>5</td>\n",
" <td>4</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>V1_noStones</td>\n",
" <td>V0_all</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>5</td>\n",
" <td>5</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>V1_noStones</td>\n",
" <td>V2_noFlip</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>8</td>\n",
" <td>2</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>V1_noStones</td>\n",
" <td>V3_oppCount</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>1</td>\n",
" <td>9</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>6</th>\n",
" <td>V2_noFlip</td>\n",
" <td>V0_all</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>5</td>\n",
" <td>4</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>7</th>\n",
" <td>V2_noFlip</td>\n",
" <td>V1_noStones</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>6</td>\n",
" <td>4</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>8</th>\n",
" <td>V2_noFlip</td>\n",
" <td>V3_oppCount</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>7</td>\n",
" <td>2</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>9</th>\n",
" <td>V3_oppCount</td>\n",
" <td>V0_all</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>4</td>\n",
" <td>5</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>10</th>\n",
" <td>V3_oppCount</td>\n",
" <td>V1_noStones</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>7</td>\n",
" <td>3</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>11</th>\n",
" <td>V3_oppCount</td>\n",
" <td>V2_noFlip</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>6</td>\n",
" <td>4</td>\n",
" <td>0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" black_config white_config model date games_per_matchup \\\n",
"0 V0_all V1_noStones gemma4-osero-e2b 2026-05-04 10 \n",
"1 V0_all V2_noFlip gemma4-osero-e2b 2026-05-04 10 \n",
"2 V0_all V3_oppCount gemma4-osero-e2b 2026-05-04 10 \n",
"3 V1_noStones V0_all gemma4-osero-e2b 2026-05-04 10 \n",
"4 V1_noStones V2_noFlip gemma4-osero-e2b 2026-05-04 10 \n",
"5 V1_noStones V3_oppCount gemma4-osero-e2b 2026-05-04 10 \n",
"6 V2_noFlip V0_all gemma4-osero-e2b 2026-05-04 10 \n",
"7 V2_noFlip V1_noStones gemma4-osero-e2b 2026-05-04 10 \n",
"8 V2_noFlip V3_oppCount gemma4-osero-e2b 2026-05-04 10 \n",
"9 V3_oppCount V0_all gemma4-osero-e2b 2026-05-04 10 \n",
"10 V3_oppCount V1_noStones gemma4-osero-e2b 2026-05-04 10 \n",
"11 V3_oppCount V2_noFlip gemma4-osero-e2b 2026-05-04 10 \n",
"\n",
" black_win black_lose black_draw \n",
"0 4 5 1 \n",
"1 5 5 0 \n",
"2 5 4 1 \n",
"3 5 5 0 \n",
"4 8 2 0 \n",
"5 1 9 0 \n",
"6 5 4 1 \n",
"7 6 4 0 \n",
"8 7 2 1 \n",
"9 4 5 1 \n",
"10 7 3 0 \n",
"11 6 4 0 "
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 最新の CSV を自動選択\n",
"csv_path = sorted(glob.glob(\"../csv/compare_*.csv\"))[-1]\n",
"print(\"読み込み:\", csv_path)\n",
"df = pd.read_csv(csv_path)\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>config</th>\n",
" <th>wins</th>\n",
" <th>losses</th>\n",
" <th>draws</th>\n",
" <th>total</th>\n",
" <th>win_rate</th>\n",
" </tr>\n",
" </thead>\n",
" <tbody>\n",
" <tr>\n",
" <th>0</th>\n",
" <td>V3_oppCount</td>\n",
" <td>32</td>\n",
" <td>25</td>\n",
" <td>3</td>\n",
" <td>60</td>\n",
" <td>0.533333</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>V2_noFlip</td>\n",
" <td>29</td>\n",
" <td>29</td>\n",
" <td>2</td>\n",
" <td>60</td>\n",
" <td>0.483333</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>V0_all</td>\n",
" <td>28</td>\n",
" <td>28</td>\n",
" <td>4</td>\n",
" <td>60</td>\n",
" <td>0.466667</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>V1_noStones</td>\n",
" <td>26</td>\n",
" <td>33</td>\n",
" <td>1</td>\n",
" <td>60</td>\n",
" <td>0.433333</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" config wins losses draws total win_rate\n",
"0 V3_oppCount 32 25 3 60 0.533333\n",
"1 V2_noFlip 29 29 2 60 0.483333\n",
"2 V0_all 28 28 4 60 0.466667\n",
"3 V1_noStones 26 33 1 60 0.433333"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 各設定の総合勝率を集計（黒として + 白として）\n",
"configs = df['black_config'].unique()\n",
"records = []\n",
"for cfg in configs:\n",
" b = df[df['black_config'] == cfg] # この設定が黒の試合\n",
" w = df[df['white_config'] == cfg] # この設定が白の試合\n",
" wins = b['black_win'].sum() + w['black_lose'].sum()\n",
" losses = b['black_lose'].sum() + w['black_win'].sum()\n",
" draws = b['black_draw'].sum() + w['black_draw'].sum()\n",
" total = wins + losses + draws\n",
" records.append({'config': cfg, '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": 9,
"id": "5b100662",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 800x500 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# 総合勝率の棒グラフ\n",
"fig, ax = plt.subplots(figsize=(8, 5))\n",
"\n",
"colors = ['#4CAF50' if r > 0.5 else '#EF5350' if r < 0.5 else '#9E9E9E'\n",
" for r in summary['win_rate']]\n",
"bars = ax.bar(summary['config'], summary['win_rate'], color=colors, alpha=0.85, width=0.6)\n",
"\n",
"ax.axhline(0.5, color='gray', linestyle='--', linewidth=1, label='50%')\n",
"ax.set_ylim(0, 0.75)\n",
"ax.set_ylabel('勝率')\n",
"ax.set_title('シミュ情報設定ごとの総合勝率(黒白合算，60試合)')\n",
"\n",
"# 値ラベル\n",
"for bar, row in zip(bars, summary.itertuples()):\n",
" ax.text(bar.get_x() + bar.get_width() / 2,\n",
" bar.get_height() + 0.012,\n",
" f'{row.win_rate:.1%}\\n({row.wins}勝{row.losses}敗{row.draws}分)',\n",
" ha='center', va='bottom', fontsize=9)\n",
"\n",
"ax.legend()\n",
"plt.tight_layout()\n",
"plt.savefig(\"../img/winning_rate_sim_info.png\")\n",
"plt.show()\n",
"plt.close()"
]
},
{
"cell_type": "code",
"execution_count": 10,
"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_config', columns='white_config', values='black_win_rate')\n",
"\n",
"# 行・列を設定名の定義順に並べる\n",
"order = ['V0_all', 'V1_noStones', 'V2_noFlip', 'V3_oppCount']\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.png\")\n",
"plt.show()\n",
"plt.close()"
]
},
{
"cell_type": "markdown",
"id": "5dd37a35",
"metadata": {},
"source": [
"# LLMに渡す合法手を削ったうえで対戦させてみる"
]
},
{
"cell_type": "markdown",
"id": "d9d0029f",
"metadata": {},
"source": [
"## 実験の前提\n",
"\n",
"前回の実験（LLM に渡す情報量を絞る）の結果，**V2_noFlip**（自石数・相石数・相手次手一覧・安定石増加数の4種類）が最も安定して強いと結論づけた．\n",
"今回はこのシミュ情報設定に固定したうえで，**LLM に提示する候補手の絞り方**を比較する．\n",
"\n",
"## 候補手の選別について\n",
"\n",
"Phase 4 では，全合法手をスコア関数で評価し上位半分だけを LLM に提示している． \n",
"「全て渡す」「1手だけ渡す」はどちらも弱くなると既に分かっているため，今回は上位半分を基準に以下の4バリエーションを比較する．\n",
"\n",
"| 設定名 | 選別ロジック | 変更の意図 |\n",
"|--------|------------|------------|\n",
"| **M0_topHalf** | 上位半分 ⌈n/2⌉（現行） | 比較用ベースライン |\n",
"| **M1_mean** | 全候補の平均スコア以上の手のみ | 平均点以下の手を除外．正規化不要でシンプル |\n",
"| **M2_stddev** | 最高スコアとの差が 1σ 以内の手のみ | 局面の難しさに応じて自動的に絞り込む |\n",
"| **M3_strategic** | X/C 位置を除外 → 上位半分 → 角を強制追加 | 危険マスを除き，最重要マス（角）は必ず提示する |\n",
"\n",
"### エッジケース処理\n",
"\n",
"- **M1**: 全手が同スコアの場合は全候補を残す\n",
"- **M2**: σ = 0（全手同スコア）の場合は全候補を残す\n",
"- **M3**: X/C 除外後に候補が 0 件になった場合は除外をスキップして全合法手の上位半分を使う\n",
"\n",
"### 座標の定義\n",
"\n",
"- **角**: a1, h1, a8, h8\n",
"- **X 位置**（角の斜め隣）: b2, g2, b7, g7\n",
"- **C 位置**（角の縦横隣）: a2, b1, h2, g1, a7, b8, h7, g8"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "155dca9a",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"読み込み: ../csv\\compare_20260504_164131.csv\n"
]
},
{
"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_filter</th>\n",
" <th>white_filter</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>M0_topHalf</td>\n",
" <td>M1_mean</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>4</td>\n",
" <td>4</td>\n",
" <td>2</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>M0_topHalf</td>\n",
" <td>M2_stddev</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>4</td>\n",
" <td>5</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>M0_topHalf</td>\n",
" <td>M3_strategic</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>0</td>\n",
" <td>10</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>M1_mean</td>\n",
" <td>M0_topHalf</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>6</td>\n",
" <td>4</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>M1_mean</td>\n",
" <td>M2_stddev</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>3</td>\n",
" <td>6</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>M1_mean</td>\n",
" <td>M3_strategic</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>1</td>\n",
" <td>9</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>6</th>\n",
" <td>M2_stddev</td>\n",
" <td>M0_topHalf</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>7</td>\n",
" <td>3</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>7</th>\n",
" <td>M2_stddev</td>\n",
" <td>M1_mean</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>3</td>\n",
" <td>7</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>8</th>\n",
" <td>M2_stddev</td>\n",
" <td>M3_strategic</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>0</td>\n",
" <td>10</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>9</th>\n",
" <td>M3_strategic</td>\n",
" <td>M0_topHalf</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>10</td>\n",
" <td>0</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>10</th>\n",
" <td>M3_strategic</td>\n",
" <td>M1_mean</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>9</td>\n",
" <td>1</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>11</th>\n",
" <td>M3_strategic</td>\n",
" <td>M2_stddev</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>6</td>\n",
" <td>4</td>\n",
" <td>0</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" black_filter white_filter model date \\\n",
"0 M0_topHalf M1_mean gemma4-osero-e2b 2026-05-04 \n",
"1 M0_topHalf M2_stddev gemma4-osero-e2b 2026-05-04 \n",
"2 M0_topHalf M3_strategic gemma4-osero-e2b 2026-05-04 \n",
"3 M1_mean M0_topHalf gemma4-osero-e2b 2026-05-04 \n",
"4 M1_mean M2_stddev gemma4-osero-e2b 2026-05-04 \n",
"5 M1_mean M3_strategic gemma4-osero-e2b 2026-05-04 \n",
"6 M2_stddev M0_topHalf gemma4-osero-e2b 2026-05-04 \n",
"7 M2_stddev M1_mean gemma4-osero-e2b 2026-05-04 \n",
"8 M2_stddev M3_strategic gemma4-osero-e2b 2026-05-04 \n",
"9 M3_strategic M0_topHalf gemma4-osero-e2b 2026-05-04 \n",
"10 M3_strategic M1_mean gemma4-osero-e2b 2026-05-04 \n",
"11 M3_strategic M2_stddev gemma4-osero-e2b 2026-05-04 \n",
"\n",
" games_per_matchup black_win black_lose black_draw \n",
"0 10 4 4 2 \n",
"1 10 4 5 1 \n",
"2 10 0 10 0 \n",
"3 10 6 4 0 \n",
"4 10 3 6 1 \n",
"5 10 1 9 0 \n",
"6 10 7 3 0 \n",
"7 10 3 7 0 \n",
"8 10 0 10 0 \n",
"9 10 10 0 0 \n",
"10 10 9 1 0 \n",
"11 10 6 4 0 "
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 最新の CSV を自動選択\n",
"csv_path2 = sorted(glob.glob(\"../csv/compare_*.csv\"))[-1]\n",
"print(\"読み込み:\", csv_path2)\n",
"df2 = pd.read_csv(csv_path2)\n",
"df2"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "f099e352",
"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>filter</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>M3_strategic</td>\n",
" <td>54</td>\n",
" <td>6</td>\n",
" <td>0</td>\n",
" <td>60</td>\n",
" <td>0.900000</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>M2_stddev</td>\n",
" <td>25</td>\n",
" <td>33</td>\n",
" <td>2</td>\n",
" <td>60</td>\n",
" <td>0.416667</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>M1_mean</td>\n",
" <td>22</td>\n",
" <td>35</td>\n",
" <td>3</td>\n",
" <td>60</td>\n",
" <td>0.366667</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>M0_topHalf</td>\n",
" <td>15</td>\n",
" <td>42</td>\n",
" <td>3</td>\n",
" <td>60</td>\n",
" <td>0.250000</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" filter wins losses draws total win_rate\n",
"0 M3_strategic 54 6 0 60 0.900000\n",
"1 M2_stddev 25 33 2 60 0.416667\n",
"2 M1_mean 22 35 3 60 0.366667\n",
"3 M0_topHalf 15 42 3 60 0.250000"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 各設定の総合勝率を集計（黒として + 白として）\n",
"filters = df2['black_filter'].unique()\n",
"records2 = []\n",
"for cfg in filters:\n",
" b = df2[df2['black_filter'] == cfg]\n",
" w = df2[df2['white_filter'] == cfg]\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",
" records2.append({'filter': cfg, 'wins': wins, 'losses': losses,\n",
" 'draws': draws, 'total': total, 'win_rate': wins / total})\n",
"\n",
"summary2 = pd.DataFrame(records2).sort_values('win_rate', ascending=False).reset_index(drop=True)\n",
"summary2"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "287d7bd4",
"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",
"colors2 = ['#4CAF50' if r > 0.5 else '#EF5350' if r < 0.5 else '#9E9E9E'\n",
" for r in summary2['win_rate']]\n",
"bars2 = ax.bar(summary2['filter'], summary2['win_rate'], color=colors2, alpha=0.85, width=0.6)\n",
"\n",
"ax.axhline(0.5, color='gray', linestyle='--', linewidth=1, label='50%')\n",
"ax.set_ylim(0, min(1.0, summary2['win_rate'].max() + 0.12))\n",
"ax.set_ylabel('勝率')\n",
"ax.set_title('候補手選別設定ごとの総合勝率(黒白合算，60試合)')\n",
"\n",
"for bar, row in zip(bars2, summary2.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_move_filter.png\")\n",
"plt.show()\n",
"plt.close()"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "f1653564",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAo0AAAJHCAYAAAD13myfAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAnpxJREFUeJzt3Qd4U2UbBuC3G+iihbJX2UOWgAgyZKjspewpgiLIVKY4UbaAiqAIKKCA8IvsIXtvFNkbyihQ6KKldP/X85UTkjahLTRN0jy3Vyw5OUlPRpMn77ccEhMTE4WIiIiI6Ckcn3YhERERERFDIxERERGlCSuNRERERJQqhkYiIiIiShVDIxERERGliqGRiIiIiFLF0EhEREREqWJoJCIiIqJUMTQSUZYTHR0tUVFRcv36ddm5c6fYm4SEBOG6DUSU0RgaiTJR165d5Z9//jF5+cGDB6VMmTIq9AACz6lTp9S/Fy1aJL/++qtu30mTJsn27dvl1q1b6jrXrl2TS5cuSUREhNi7mTNnyo8//iiOjo4yduxYCQ8PF3sIigEBAerfu3fvlpdeekn9Oz4+Xk6cOJGm2zh//rzutURElJxzii1EZDanT5+WBw8epHn//fv3y5UrV+Snn34Sb29v+eGHH6RXr15y584dWbBggbRu3VpcXFzUvqisff311+Lv7y9ffvnlU293165d0rdvX1m/fr2UKFFCMhuOc9OmTeo49MXFxYmzs7OsXr1a6tSpI76+viYDUkxMjNofoQgnbbuDg4N07NhR2rdvL927d5cGDRrIunXrpHPnzkZva9SoURISEqIe4+eBsB4ZGSleXl6SPXv2p+5bs2ZNdfyurq66bfiigG2enp4G+4aGhqoAjPuhQbBzd3dX/8bvPHfunPoCMW7cONm8ebPcu3dP/Pz81OXY/vnnn8vff/8tOXLkUNvatWun+zJizOuvv250O15bGzduTNPjQURZD0MjkZl9//33un/HxsaqQHT8+HF1/r333jMIDsn16NFDXnvtNdXM2rBhQ1VBu3v3rvz2229Sq1YtKVu2rC6EPnr0SD777DNp27atCk0VKlSwqef2/v37qhK7cuVKFYKOHDmSIvzi8dq7d696HJND2ERlEcGrXLlyMnXqVMmWLZt88sknumBtDB5/LXSmF57HhQsXyp49e1S4c3JyUrdVpEgRefXVV9XzV7hwYaPXRZBD6NfMmTNHhdtVq1bptiEUm3oe8TpC0GzWrJk6j9fHjBkz1BeBixcvqscA8OVi8ODBusAIK1asUAEbj5c+PFZ4HmbNmpXi9+GLSt68edP9GBFR1sHQSGRm+h/WQ4cOlYcPH6rwhwCEKmKrVq1SXKdSpUpSuXJlmTZtmgoeqFAi3IwePVpOnjwpS5culbfffls1TefLl09V11BprFKlivzvf/+TPHnyqAoUqlEIWFqzpX4AgBs3bpg87gIFCqRaMctIuXLlUk2qv/zyi7z77ruqoor7pH8MI0aMUKEQ2xAI3dzcdD8RNBEU8fONN96Ql19+WYW41OC66Q2NCGsItKiWIqD//PPP8sEHH8jAgQOladOm6jlC+MNzi2M2VuWcMGGCfPvtt7rzCP+4vwh/z1LlbNSokfr3+PHjJSwsTD33qEjmzJlTPS44ofsDbNu2TVUvZ8+erR53NN8j+G7dulXWrFmjHo9Dhw6pLyba/njtItQWKlQo3cdHRFkDQyORmb3zzjsp+o0hNCL04QP9v//+0112+PBhtT+qbAgzy5Yt01WUcEIgbNOmjbRs2VJVkP766y9dMyVCCwIVPvCxDR/yXbp0UcFSq0Ylh3BmCvpPaqEhs7z//vsq4KIpHvctOVNN6aicIWD3799fhaGnVRaNhXqEteQhDBVNhKxPP/3U4DI8D3iOUKlDiNKqbwh9aJr28PBQgRUnVH3x5QAhF8+bPnwBeJ5K41dffaWOAfA7tUCIfrAIjgh/ffr0kSZNmqjXQfLmcbx+UNlFX1n8zilTpqjmbYRIPPdz586VDRs2SGBgoIwcOVI14zMwEtk3hkYiM0OYOHv2rNSoUUOdv337tgp1Pj4+6jyqYWhaBS3soKqoNVsXLFhQBZfg4GAVGlHNwoc3KkF169ZVAXL48OHSokULVZXUQqSmaNGiqvqmD2EUlTIE1uRNlKh+ImiYG5pz0ZyK34VmdsifP786pRduAyf9qm5aIeihKovqHPoDou8f+pIi6L3yyisqQCKUadAFANVbNEsj2AO6DKCCnLz5FpVTNA1j0BKeH+151pqnEe6S92lEoEsLDPDBdRASEThx0ropoPJcu3ZtdZxHjx5VgVo7drxe8BrB/jgG/E6E4MuXL6uwWKpUKVUB/e6771T/SvSjHTBggMk+oURkPxgaicwMAeTDDz+U6dOnS+PGjdXoaS0koUkQg0JQYUoe3jRomq5Xr56uqtSpUye1r9YHsHz58qrfHJoYEQYw8hXBB0HA1G1evXpVhVFjl2u/Rz/gmAMC8r///qvCCwZYYOAKqnGovqbXs4RFDUIWgjICIgIrniMMEnrxxRdTNG+jDyOeK/Qb1AIj4EsBFC9ePMXto5qIpmjc1+rVq6ttWlVQn7FKY1qhYowTwimef/0+iQiXCMT6fWsBx4/jwtQ8CJn4EoGqKKqSuC08HoAKIxERcModIjPDSFRUdNBcvGPHDlUZQhUIXnjhBTXIJfkoYn0IhbgczdSA/ow4j6ClQWjE7QCaZ/ft22cyMMKxY8dUv0ljtEEm+qEIwQH949Jzwgjdp0ETNCpbeDxQhZs/f74aPIJmVzSJmgp4zzpoJTlU1nr27KmaYdEv8Y8//lCVRjTFoipsrD8kBumg72DywS0IgQiMqFomh4oytmv9SJ+XqfkX0bUBgRPhD5VCNK9rzx2m3EEzdHIIux06dFBTNeFLAr5IICwOGjRIPX/oJoHXCr7YoCJJRPaNlUaiTPDmm2+qZmp8GOPDF4MSAFW1+vXry/Lly1Vgelbo97ZlyxZVlUQ/tD///NPkvjdv3lQVs27duhm9HNPPgP50N8OGDVPVt/TAAJW0wNQw6MuI21+7dq0anIFgjIoq+ihqx4EKKM4jRH/00UfyPDANDe4TRqZj8IepqX2SQzO/seloEDaf9vyhz6RWDf3iiy9UQDUWBnEfcf+MQSBE07EW6vH8aQEa4Q9dFFDNzp07twri6JuIAIimdTQ19+7dW30RQEgMCgpSUwzhdYLtGO2NLgt4XHAb6PqA6+N1iiZ0BFAET4RRjqAmsl8MjUSZBKOBMQoVzdMY4KBBkywCjLFJudGnDCEO4UZrNka/Ra0Kps3phzkNUVHCSF30oXva3IuorKH6ZWouPlT5cPsYla3BaGyczAmVLm2QDyp66IeHJniEGC00IRR/8803z/V7UFUbMmSICvDJBymlBiEt+SAbVBnRJPzWW28ZvQ5GUiPoIfBp/QpxetbmafS/RBUZXxLwezHICV8UJk6cqAaz4P4hpF64cEE9VgijOI+QiMExCI1oxsbrDaERFVJUvrEfqr943BE88RrC6HDM+YgvNQil6E+LcElE9omhkSiToBqEpj5UBdF3DB++qLKh0og+cvqDLfT7w2kjbDEQBqOZMQAj+ShWhECEPPxEOMW+6KdXrVo1g/1QQUKVC03ApuaHPHPmjJpux9x9Gk1BYEVlFtPmaEEZELjRjK0NIHpWGDWMOQzTGxgBFTmt/yLg+FDFw8TbpUuXNnodDCSpWrWqes4Q2tD8bUxqlUZAaEaQRqjTf37Q9QEwUAoBFc877id+L0brI4jjtaNVQ1E91H/+0Z0BMOE3Krx4PaIJfsyYMbp9MOI/o5rYicg2MTQSZQKMckUVEIMMUOFCHzp80OODHR/exiaARlVLGzihD8EJAxcATYioOKHPJPZH5QmhAVUmhJnff//doGkVvxvXN9XfEMEFTZQIG5aWPESjOpsR/eowCMhUf87UYAodNKWjSluxYkU1+huVPWPdAVDJwxQ2Bw4ckMWLF6ttCG844csDQiSqt7g++jxqK7gglOIy3H/cZwRNNDNrlV48t1rV0hj0d0U1FP1ltX6gCOJaSMSAKW0kvykYDGQKmvM59Q6RfWJoJDIzVI8wJx8+tNEXDz/RNwyBDpeZmoAa2/XXqdYqjej3p/+hPXnyZFWBQrjACGTMWYiAoT8pNvq4oXkRzZAY1KAfJNGvEtU79LnEYBQMqEEl0tqgWRVzUaJvICp7qPohbKGfHh4rBHM0wyKsYVojzE+JibaTV1QR0DFoBOE6PfM5Ah4/BH9UihHSURXEYB4MIAE8n6jsIcgvWbJEHRseU211Fu15xPyJeD4wjQ1WYcGXA3RRQGjHfUSlFeEUXw5QWcYgKEx6rj1nCKymmq4RZDH6WbtveCzw5UL7ooHHzNQSgtiOxxnN3Xh8jbFUBZqILI9//URmhEoRQgE+jDF6VQswJUuW1PVrQ9BAwAFUoNBf7WkjnzWouqH5EKOA582bp8IfqpcYaIEqE5owAQNLMAUL+qNhsIkWHgABA82++oNXEHAxMbW1QVBEf0yENEz8jXkeTUFYQ3DGtDnJq7holkYTLAIbpizC9Eeo6iF44rFBmMRjiwCG/nzYrj/IBc3L/fr1U/to1UHAvljNBdfH44/Qh/CXfFUdPD8IZAhngLk2EQoRGvH7EfzxWkGwRPDD/qhMo+kZ/SbRxQD74vdjQIsG/8aXEkwbhInjEUBRZcSXjORN56aCn/a60587lIhIw3cFIjPCqFo0JyIEmBpIgmCpDXTBhzUCTVoqYBiAgcoaKpZaMMGgCARUjD7GHHyASa+bN29utHKEQIlggX5y+P0YGfu0tbAtDZVWbZUaVBQx/yBCGo4djxmOHY+FsalvNBj4gWosAigGnyCw4zFIDreFgSGoLiYfGY3tySGkY8AIqsDJJ1jXYBJwhEsMWtEqzJjCB6vgaEsmousA1o5GRRLPB5rSEQJRMcQ23Gf0WUSQxOTsCJ2YWByBEs8/vjjg2DGdEJrGcSzaYCIioufhkGhq0i8iyhCoCGVEEEMwQtMxmkJZBcpYCO5obsZJ6/+nX5G1hddT8pVrEEJxv9Ccn5Y1uImIUsPQSERERESp4oowRERERJQqhkYiIiIiShVDIxERERGliqGRiIiIiFLF0EhEZMKNGzfUFDdkfpjwHhOnYx5MjGInIuvD0Eh2ATNLde/eXc23h7nu9GGeP6yqguXcKGmS6DJlyqh5IM0BIQwrlmCOQXPBHIypzU2IibixaospWGGmR48eau3orAD3B48J1ha3NlgnHXNlYrlFrJ6DpRAxXRD+ZjHPKI6diCyPk3uTXfjtt99USMGHkq+vr8Fl06ZNUytyYKUQGDVqlFpxxBQEz59++um5jmfSpElqwu/kk0BjlRNMTK2/IgwmbsZqKFhL+llglRAsMWgKlqlbuXKlCoq9evUSc8MSewikeAzMBRN2h4SEPNdt4PFGgF61apU66T8f+KKB+2FqDWYs+YfJxrt162by9mvWrCmffvqpmng9OawPrb/ay9NgVZqnTWauwVyNeN3imPWXNTQXTFiOxyktMP+oNvcoJjjHCedRfcR631i5CBVIIrIshkbK8rCmMiosqBpVqFDB4LL169erIIn1gbE+L3z55Zdq6T9TMmpibaw3jCXxNAgJderUUSFO/0MdoQ8TOj+r8ePHq6XosP70iBEjVBUHy+zpLx04c+ZM3f3PSDju5OsHIKC2bt1aTTptrIKkf2zpgRCnVdHwBQGVq++//16dr1+/vlpZJa3+/vtv9br4448/1PrS+oERla833njDZGAELPmHJQSf1bp16+Tzzz9P074DBgyQQYMGpbofXrdYyQYr0mjw3KDyi+o7JgY3tWrRs8AXkJs3b6Z5/wIFCqhmabwOtWUs8QUPK9xgaUuslFS0aNEMOz4iSj+GRsry0ASJyh3W8tWHJd/GjRunKo1Ylk2D1TYyYyk9rDONJlKN1o8L60Pr/35UzLBU3LPS7g8CFdZETl5pNSdUb7FWcnLYhkBmzOHDh9NUOUsO9xFBFJo2bap7jrEWc+PGjdVaz8ePHze4DoIZTvjyUKJECbVt3759KlxPnTrVIDACXi8ILrjcFFQJsQwgKomAUIbVWZJDYENlGcsDAgKdthwk1sXG6WkQvlF9a9WqVYrL0NUCS0MiDGo/cULlD38PuL84j9eW9rrD2uQffPBBqhVchLu00F/TPDW4D3htGntccdnPP/+sqrdpDdJEZB4MjZTlYR3mFi1aGKwXjCX5UJlCfzUEMlSWUOHTmhUzw4svvmi00ogPyIysNOqvg42QgLWNNaVKlTJrMzH069dPVYtSgyZrVIOfVb169dQpecUOzy8eT3RR0K96omKIUNu+fXtdSMdjNGbMGPUaQIDS7yaAcIXzWF6wcuXKahtuD83DqN5qEM5xe6VLl9YFTVPdA1DVxgmwVrj+c/M0+L14rSIMFytWLMXlWJcaARFfEPRP+Bvw9PRUjzMqetp2rJutBVb9qirWrta+2ODf+OKFvxX94Ii+h2hC/uyzz1T1/FmgeRrVW2PwmOM5QmsBKo7PWokmoufH0EhZ2rVr11QTGfoEJv8g0volYs3eiRMnqgCBD+PIyMhUbxcfXGjuw/74cE0NQkjy6uWRI0d01Sh9+EA31qfxeaDChj5mCBo+Pj5qG/qJoQqVFs9zPzMTmuARErXH786dO2qtbq1Pn/4azAh/OK+FEDxGaMrHIBq8HmrXrq2qbxoMyqhVq5b0799ftw1Vu9mzZxscAwZ1FClSRPflAxVLnNLTpzE1f/75p1y4cMFk4N+zZ4/qdpAcwjuap996661Uf8fdu3dV0zdeM2guxvH6+/urxwfHrQkMDJTz58/rXlfphecIr62n9bPE6x+hGtV5PAdEZBkMjZSloRkU4U7rI2UMmrwqVqwoXbt2VX3g0L8vNbgOmg8RSBs1apTq/qha6QcQNCsm79hvqk9jRsAHPT549UMqqo5VqlRJ0/Wf9X5mdt9V9N2sWrWqGg2PplQEJDyWqBKiyRpVP2NBHVA9REUQffueB0JUWptwnzVkTZkyRX25KFu2rNF9jAVGQHURAS8tUMF8/fXXVSjG3w9CNr5Y4TH+8MMPdYO4Tp48qX6fsYpnWoM+Qj6eN1PQJQDhH3/PDI1ElsPQSFkaPsDR/GaqSWvBggUqKGiDFhB4jIUehEpUV9BMpg8DB37//fdUj8OcISI1qKDt2LFDNT+iuojmYlR2Tpw4oRsxnhpbuJ9odsWIdFQE0YyJPnIIGqj6AQIW7oOp0Aj6gRFBG03aGlSk8ZjhNaNBtwH83uThNfm2jILfh0EvefPmlcGDB6f7+giNpqrLqCajP6Z+N47evXurvqDoI4k+n2jSR3P62rVrVRO41gcUQU6/ipsemzZtUoExtUol7rPW/5OILIOhkbI0dPZHnzNjNm7cqPo0osJkbKBCWqApNr39uBDinjbIwdSo27fffluGDx+e7mNE0ygqQ+gzhiY+NIdi4A8GjSTvA5iR91Pz448/qlNmQEicN2+eenwRRvT7SGJAxZAhQ9RrIi2DgTCXJJpn09s8jT5+qMplNNwunv9///1XVaOT90E0BWEQVWU0N+O+Y/DNnDlz1HmcULnET1S6cZsYiKTB3wYqiBgNjso4Kor44qR1VUBXDgyqQT/QZ4EuGmhKR2U4Nfg7Tmt3CiIyD4ZGyvL0+wdqjh49qj7oZs2apUahPuvkwRhQgwpUalDp1Kqd+CA+ffp0in205mn0V8vI5mkEY200MuYexIjisWPHqlCU1v6Hz3I/M3sgjAb97jDXJkKO/nOPaXfQpIrBLlqVzBTc12etFuKxRoU7oyuMGFm8e/duVZUbNmyYel6NdS/A4B8EOS0Ioolemy8RzzdCJEY2I2DjhNtAIMPJ2JQ7CM7600yhiqtBZRdBEwPN0guPMbp54LXesmXLNL0GiciyGBopS8uZM6fRSZIxchnhCU1uCI3PCv3m0tvXD03dT1sm7Wnz+2GgRps2bdJ1jMmnr9m/f796XDC1jznvp6UgXGCORYQrDHYqWbKkCiUYmIJpflKb6w+hCs2gX3/9tTrpQ586TDidvNlUH5p3ky89iEodRspjYBaOA03mqNIlX53IGFQJ8ZhevnxZNZdjxDu+8CBgo0KHJmN9CIa4fVSGEQK1MIgT+jMiMCOsmeoPmZyxKX0ATdaosn788cfpHtGMaidGYqPKiefE2Be75BB+ta4GRGQZDI2UpeXLl081aaFpT79aguZDbV6+5/Esff3QLw6hBB+YqDpqc/VpH+I4XmzTju/UqVPqAxOVsue1bNkyVYnSrz5qFSNb79Oo0Zpe0e8OTdWoqiJo4fFNy2ANhDNMDI6RuslX7EnOWPM05oXESHX9kI65QFHVxryPeC2iEonJrxEkESgxCAvT7SSfOB7HgCmXcByYOkoLTRgIg7CK5nZUVfVX8nnttdfUyRhtAnf9Cb6fBUaIo7+jNv9leqAKii8/2rRBxYsXT/MXl5deeukZj5iIMgJDI2VpqCiiaQ59p542gvpZPWtfP0yVghHJCHFoLkWzMeb6Q5hFEMHgnA0bNqgKDPqYYQALljZE06t+GMH9wjx6yVe6MQa/ByNf0ScPH/aZcT+1yl9amv9NLTmXnvu5detW1X8SYQyDWlChQ6U5PdMA4fHHSPPUAqMp+CKA6iCqiqhqov8fApI21yaeYwQgfDHAYBs0g6N6ifkdMdch4DoI9ghVqJKiMpi8DyPCJOZXxPRAuI9p6e/6vKERTcqo4uLYsKqP/tQ7T4P7itcf+mKi2omqNV6LpvobJ4fJ0vElC3/PRGQ5DI2UpaHChA/W7du3pzs04kMKH5L4wMvIwQ0YyYxBGqgcAQajoBqGpe8QODCHHqpSmIoE4QUDMBAYsbQhKoLacaCKhgmXU+ufB/iwRlBFP0ZTo24RdNBceu7cOXX+WUfDGqv84fSs0no/8RwjSKGKpfX1Q+j+6quvdPugiotBT2g+xv1NPpE7+pquWLFCBSNTUIXUlsfDc5a8Oli4cGFV0cSE1QiNCEgIkOgLiOshQKJyi+ZZbSQ3mtERrnHbqDzi8cLjj+mf9FcNSg4VRoRbhDe8TjGy+WnPGwY/IXymZ0AJKq8I7qh6IpSjkoqJtp92XNrrHM/J2bNnVXUdzwVe688yCTj6YOK5etYvLkSUMRgaKUtDwMKatQhoCEvaMnNpgWqKttQdBgzUqFEjQ44JVbP3339ftxYymhkx2lerxqFJHYECQRUQAlCVwRySqBChOoOqHAbzoGKY2nrBqLqhYoVq5tP6JSIQoH8aYHBCRg3GSetAGDwu6GepH87Tej9RmUM4RLPt06qoGD2urc6Cqm3y0eNoRkaT79P6+yH4NWvWTP1bWzkmOXwp0IemXJy0aqqxVYcQqtDsi8CI/opdunRJ0+sVo5lxXQTMGzdupNpnE2tmm6rqGoPAjscMfXFRGcXI+7R8gUL1E8eDAI/7joCMvrTphWNFRR4V1+edQ5OIno9Dov66WkRZEKpnqIogvOCUFSBIIVRgYERqYRaVNfyZpycw2+L9RPPv865GkxG38bwwSOpZqrzWcOzmgC98+NKE4IpBTURkOakPWSOycZiTD5UurOl89epVyQpQ/cHaxmmpfqI50hYDY3rvZ0YEJmsIXc/aLcAajj2joe8n+nui8srASGTYbUd/AFxaoMsTBtyh1QDLraKbidailVYMjWQX8KGDkatoFsaKHbYOYeppE4RnFfZyPykldNfAHJEY5Z+W7g1E9uDRo0dqTlt0OUoPLPeJvyd0yUF3D/Sjx5zA6JKTHmyeJiIiIrIBZcqU0f0bK1Shz3pa4IsXuirpr86F6a8wZReWAk1rf2FWGomIiIhswJo1a9QpLYst6EN1EiuO6UPVERV9zIyQVhw9TURERJRJGqUS+DCThSno4w3otqGtAZ8aTB2HabYwc4I+VBcxo4H+YgSpYWgkIiIieszh/YxfCEJfQ3m2hQOeFZYsBWMDIjHPK0JlWtl1aAwKsv0BEWnl7OwoPj7uEhISKXFxCWIv/Pw8JfHaVEsfBmUCh6If8bm2k+d5scOTfl2UdXVJTFpoIKvZ+pRKorWz69BIREREpM/BMWNW/7IW2pKoxpqzUYVMz6T5HAhDRERElEV5eHio+Yq15U812jK5WPo0rRgaiYiIiPQqjeY8mVtYWJjcvn1brS6lwTKeu3fvNthvz549aklTLA2aVgyNRERERDYgPDxcnbAmO0Khdl7fhAkTpH79+hIYGKjbhvXfERpnzJghZ8+elc2bN8vXX3+tFk9IT/M0+zQSERER2UCfxhrJllTVzp879/RBQ5UqVZKZM2eqZTnnzp2rptpp3bq1DB48OF2/n6GRiIiIyAacSyUcwsSJE9UpuQYNGqjT82BoJCIiIrKBSqOlMTQSERERPebgwNBoCgfCEBEREVGqWGkkIiIieozN06ax0khEREREqWKlkYiIiOgxVhpNY6WRiIiIiFLFSiMRERHRY6w0msZKIxERERGlipVGIiIiosdYaTSNlUYiIiIisp3QuHLlSrl+/bqlD4OIiIjsvNJozpMts5rQOH78eAkLC1P/btSoEQMkERERZTqGRhsIjVjr8eHDh+rfN2/elLi4OEsfEhERERFZ20CYWrVqyVdffSWdOnVS55cuXSo+Pj4m9+/Xr18mHh0RERHZA1tvQraL0Pj555/L1KlT5ffff1dVxw0bNoizs/HDw+UMjURERER2GBpz5sypKo3QsGFDWbBggRQuXNjSh0VERER2BIUpsvLQqG/btm2WPgQiIiIissbQ+OOPP6ZrfzZPExERUUZjn0YbCI3Lli1L877s00hERERkp6GRTdJERERkaaw02sA8jURERERkvaym0pjcvn37ZO/evRIcHGz08gkTJmT6MREREVHWxkqjjYXGP//8U8aOHSsvvPCCnDp1SipVqiTZs2eXqKgo+e+//+Tll1+29CESERFRFsTQaGOhcdGiRTJkyBB57733pGrVqmri77Jly6rL+vbtK61atbL0IRIRERHZFavs03j9+nWpXbu2+re7u7uEhYXpLuvVq5csXLjQgkdHREREWbnSaM6TLbPK0JiQkKCbkb1gwYJy7tw53WVYj/ry5csWPDoiIiIi+2OVoTF//vxy8eJF9e/q1avLr7/+KufPn5fo6GhZsmSJ+Pn5WfoQiYiIKAtipdHG+jR2795d9+/evXvL33//La1bt1bnMSBmxowZFjw6IiIiIvtjlaGxc+fOun/nypVL1q5dK/v375e4uDipUqWK5M6d26LHR0RERFmTrfc7tLvQmJybm5u8+uqrlj4MIiIiIrtlNaHxk08+Sdf+48aNM9uxEBERkX1ipdEGQuPVq1dTbDty5IhUqFBB9WPUp42sJiIiIiI7C42Y0Ds5BMaJEydKyZIlLXJMREREZF9YmLKB0EhERERkaWyetrF5GomIiIjIurDSSERERPQYK42msdJIRERERLZTaVyzZo3R7Tt27JAzZ86k2N6yZctMOCoiIiKyJ6w02kBoHD58uNHtU6dONTqyiaGRiIiIyA5D49mzZy19CERERGTnHNlxzyQ+NERERERkO5VGY6vB/PLLL3Lu3Dm5f/+++Pj4SJ06deS9996TggULWvrwiIiIKAty4qpzthUaly9fLp999pnUqlVLOnbsKF5eXnL37l3ZuHGjtG3bVq0eU6ZMGUsfJhEREWUxTo5cqtimmqdnzZolffv2lXnz5qmfCI4DBw6UtWvXSvXq1eWrr76y9CESZYrg0Chp2G2JvN7rD4PtMTHxMv2Xw+qyis3nSZPey2ThXyclMTHRYL+AW+HSe9R6qd7mV2ncY6nMW/5fit9x7kqwvNj6V7lzP9Ls94eM4/Nsf7LnzyO1f5sqb947IB0i/5XX9/8h+V57JcV+2Nb0n5XS/sEx9TP/63VS7FN6QFdpcnRFJh052TOrrDQGBwfL66+/bnTUdM+ePeXdd9+1yHERZaa4+AQZ8vVWCQyKkML5vQwu+2TGbtm854r07VhZihfxkeNn7sqknw7Io+g4ebdTFd1+w8Zvldi4BPlsUB25HBAqU34+KMULe0uDl4vq9pk+/7B0bVVe8uZyz9T7R0n4PNsfp2xu0nDbAnF0cZbjH8+QmOAwKdq5uby67ifZ2rCnBO05qvZz8/OVen/NlFvrd8npiXOk8JtvSN0V38sq/0YSHRScdFs5skuFse/LgV6jLXyvsg42T9tYaKxcubIEBgZKhQoVUlzm5uam+jcSZXWT5xxUFajGrxSTc5eTPiAA4W/11gsy4aP60ua10mrbG3X9xcXFUX5c8q90aVVePHK4yq27EXLy/D2ZN6GpvFKtkNrvwL+3ZMveq7rQeOzUbXWaNOJVC91L4vNsf/x7tBHPEoVlbdmmEnH5utoWsHyDNN69WCqNGyxbG/RQ2wo0qSsOzs6yv9coiX8YJTfWbJe3Qg5J/jfqytXfVql9yg7pKeHnrkjgpt0WvU9kH6yyebp///7y448/Snx8fIrLDh48KI0bN7bIcRFlllVbLsjKzedl5uevi3t2F4PLth8MEGdnR2lav7jB9taNS8nDqFg5dDxQnb/7uLm5YD5P3T4F8nrI3fsPdeenzTssvdtXEm9PNzPfIzKGz7N9KtiygQTt+0cXGDVXF60Sv7rVxSVnUstC9gJ5JPpeiAqMgJ/R90LVdnD18ZZyH/WW46OnWeBeZF1OjuY92TKrrDS+8847KjCi4pgctqOZeunSpbptJ0+ezOQjJDKfUxfuyRff7ZHpYxtJsYLeKS6/eC1ECufzEjdXwz9f/0Le4uzkIOevBkvDWkV1QfBBRIxun/AH0ZLTK5v6965D1+XqzTCZ83UTPp0WwOfZfnlXKCWBG1NWBsNOXRRHJyfxLldC7u3/R6KDw8TF2+PJDg4O4uLlLjH3Q9TZ8iP7qqZs7Etkt6GRA13IXqE5euAXm+XdzlWk/ktFjO5zPyRKfLxTVgbxZQqBMDj0kTpfKJ+X5MvtLgtWnJAR774sl6+HyqH/AmV0v1pqwAwG0vTrUlX1eRw1ZYccO3VHfLyzydtvVpQm9QyrmMTnmTJOtry5VAUxOW1btjy+6icCoXOO7FJmUA+5tnSdFOvaUpyyZ5OgvcfUQJpSA7rI5tqdVQitOnWkeJXxV03V/3w0ScJOXeBT9ozYp9HGQiOm1ckMaOKzF06Pa+LaT7LeAREvlPaTfp2rmtwvJjZeXJydjF7m4uyoBsNo//5ySF35aOI2Wbv9ktrWqFZRafdGaVm/47KER0RLh2ZlZchXW9W/v//sNTlz8Z4MG79NDbypUCq3me6pfePzTI5urpIQE5vigYiPSWoVQDCE8DOX5L9PvpWq00ZJtW8/loT4ePlv7AwJP3tZasz+Qm6u2ibh569I66vbJOCPDXJs2AQp9V4nabj1V1lVtIEkRD9pZSDKsqERoqOj5a+//pLDhw9LaGiomquxRo0aKlBmz549Q36Hj4/9jRb18sqYx44y3pI1p+XOvUj5ZnRDiYx68oESH5+oKoPY5uLkKK4uThIZZfzDAFXDbG5P/qzrvVRYdi/tKldvhKkqZN7c7iq0fLfgiAzsUU31gdx+4Jpqoi7j76tOS9acUf0pGRrNg88zIcw5uhr2VQYnV9ekv/mopNYCODX+Rzk/a7F4FCsoEVduSGzYA/EoUUT8e7SW9RVbSoGm9cQtV045/vF0iYt8qH6W6t9Zbb+xcgsf7GfASqONhcagoCDp0aOH3LlzR1588UXJlSuXWhVmypQpsmDBAlm4cKHkzZv3uX9PSIj9zEuHCiMCY3h4lMTHJ4i9sKUvBqHh0XLtZrjU7fS70curtf5V2rxWSnxzZpMbtx+kuBzBMuxBtPh6J1UpNOj7WKZ4Lt35/204p4Jnq0al5Ozl+4KpHQvmfTJYpmBeD7l5JyJD7xs9weeZHt29L265U84Com17FGTYdB0bGi4h/4brzmOE9ZUFK9VAmoKtGqpmbQRGwM/o+6HiXowrp5GdhMZJkyapaXWWLVsmnp6eBvM3YhnByZMnyzfffPPcvycuzn7CkwaB0R7vty14s0kZqf1iyjf6n5b8qybgnjamoeTyya6mzFm345Ka4NvV9UkzNQa1oNJYsqjpKanQdD3r92Py6QeviKOjgyQkJE0Grv2E+ISkyiaZB59nCj99SbzKl0jxQGBbYkKCapY2JWflsmr09drSSQPYHBwdxcHJsLsKzqOPMz0brghjmlV2cNu1a5cMGDDAIDCCr6+vDBo0SHbv5nxUlPUUyOMh1V7Il+KEyqKbq5P6N0ZT13+psMTGJsj6nYYfLKu3XJTsbs7ycpUCJn/Hb6tOSX4/DzX3I+DfgOZrDQbM5M+jN2KT+DxThrq5bof41a4qHsULG2z379ZKTcUTE/Lk7zG5KuOHyYUfFktU4F11PjIgUFxz5RRX35y6aqWrr7faTs/GycG8J1tmlZXGmJgYk/0Wc+TIoS4nslelivlK8wYl5Mvv90rg3QgpUTRpRRiMksZoaA/3pH5RyT2IjJGf/zgu345tpNuGymWtqgVk2vzDqn/j6Uv35cLVEPlicN1MvEdkDJ/nrOvyLyvUpNwN/p4vZybPlZiQcCnaqZnkfuVF2f5ab5PX86tTTXLXrir7ug3XbQvcsEviwiOk1q8T5OritVKsWyvV79HYlD5EWTI0VqxYUZYvX676MyaH7bicyJ6N/7CezFx0TP5Yd1buh0VJAT8PGfbOS2q6HFPmLTsuFUrmlperGjaBTxz+qnw6Y7d8OXOv+ObMLp8PqiMvVnj+PsP0/Pg8Z00Y6LKlQQ+pOmWEVJ4wTI2WDjtxXna17Cd3th8web3KEz6UM1PmGVQi0YdxR4t+Uv27j+Wln8fJg3NXZGeLfro+jpR+bJ42zSHRCjsvHT9+XK0xXaZMGWnUqJFuIMzWrVvl7Nmz8uuvv0rVqqanJEmroKCUgwmyKkwvhEEhGPxjT30a/fw8JfHaVEsfBmUCh6If8bm2k+d5sUMZSx8GZYIuiecs8jjXXNLJrLd/sPOTxUlsjVVWGrESDAbBzJo1S42W1p9y5/PPP5dy5cpZ+hCJiIgoC+KUOzYWGm/duiUlSpSQGTNmpLgsMjJS7t27J7lzc+JhIiIiIrsePY0m6YCAAKOXYbLvLl26ZPoxERERkX30aTTnyZZZZWh8WjdLjKq+ezdpqgEiIiIisrPm6YiICAkPfzLjPYKhm5ub7nx8fLyEhYXJTz/9JIULG85tRURERJQRbH0uRbsIjRgRPXPmTDWLPU69evUyWoHEBN8ZsRoMEREREdlgaHzzzTelVq1aKhh269ZNpk6dKvnz5zfYByOoixYtKq6PF3UnIiIiyki23u/QLkIjAqIWEjEfY758+cQp2XqayWFKnk6dOqnqIxEREdHz4pQ7NjYQpmDBgqkGRi00BgcHZ8oxEREREdkzq6k0PgsrXMyGiIiIbBgrjTZWaSQiIiIi62LTlUYiIiKijOTEcppJfGiIiIiIKFWsNBIRERE9xj6NprHSSERERERZu9KIlWOIiIiIMgon986ilUZOuUNERERk55XGqKgoiYiIUP/28PCQ7Nmzp9jnn3/+4ZKCRERElGHYp9FGQuPZs2dl3rx5sn//frl//77BZbly5ZKaNWtK7969pUKFCmob16AmIiKijMQpd2wgNO7Zs0fef/99efnll+W9996TQoUKqQojmqAfPnwoN2/elN27d0vHjh3V8oH16tWz9CETERER2Q2rCY3Tp09XVcShQ4ea3Kdr164yY8YMdWJoJCIioozG5mkbGAhz4cIFadq0aar7NWnSRC5evJgpx0REREREVlZpzJkzp9y4cUPKli371P2wj7e3d6YdFxEREdkPTrljA5XGNm3ayLhx42TLli2qD6Ox0dSbN29W+7Ru3doix0hERERkSTt37pR27dpJxYoVpW7duqp7X1xc3FOvk5CQIEuWLJGWLVtKlSpVpGHDhipPhYaG2malcdCgQRIdHa36NMbHx6vKY44cOdRlCJG4Y05OTtKpUycZPHiwpQ+XiIiIsiBr7tN48uRJGTBggPTp00e+/vprCQgIUOEvNjZWRowYYfJ63377rfz2229qH4TN69evyzfffCOnTp2SpUuX2l5odHZ2ltGjR8vAgQPl2LFj6oHQn6excOHCUq1aNfVvIiIiInszb948qVOnjgwZMkSdL1eunCq0jRo1Svr3728yI/3xxx/y7rvvqhlooHz58uLj4yPdu3eXq1evSrFixWwrNB4+fFj3b0zkXaZMmRT7nDlzRvfvGjVqZNqxERERkX2w5nkaDx48qMKhPswmg5ZaFNxMzSyDwlxISIjBNq01F5elldWERqRdbS3p1JYHxH76AZKIiIjIFjRq1Oipl2/dutXodrS+YuETzGOtD9VFdOlDC60p/fr1k/Hjx6uBxD169BB3d3fVXI1Za5Lfnk2Extq1a8uhQ4ekRYsWKkDmzp3b0odEREREdsZa+zRGRkYaVAj1IQRqXfqM6datmwQGBsry5cvl559/lpIlS4qnp6daLCU9rCY0zp8/Xy0jiJ8Ijc2bN1eTffv7+1v60IiIiMhOOJk5M241UUk0pzlz5qjQiFlo7ty5o6qMOGGAzNMG0CRnVS33mKNx8uTJsn79elVu7dChgyqpHjlyxNKHRkRERGQxqCaCsWkJUYU0NQjmypUraloezE6DWWgKFCigguK0adPUwJoDBw7YZmjU5MuXT0aOHCnbt2/Xje7ByGoiIiIic3J0cDDr6VkhFPr6+srNmzcNtqNZGtMSYpYZY06fPq3macybN6/BdozChv/++8+2QyOgf+OHH34oa9euVRN/v/POO5Y+JCIiIiKLqVmzpuzevdtg2549e8TFxUVNSwjBwcFy+/Zt3eVaWNy/f3+KMAkFCxa0vT6N2qjpjRs3yty5c9UoIMwn9OWXX6ZIx0RERES22KfxeWCsR+fOnWXGjBnSpEkTNUk3JvnGNq15GgugoPB27tw5dR5hEie02A4bNkzN7YgmazRPY77G1157zfZCIzpkLliwQE1SieHg7du317XfExEREdm7SpUqycyZM9UAFhTYMNUOllZ+2kp5mKYQI6YxGAY/UYVEMa5Zs2Zq3Iirq2uaf79DYmqTImbiIBiUV7EmIn6mBqOsn1dQ0AOxF87OjuLj4y4hIZESF5cg9sLPz1MSr0219GFQJnAo+hGfazt5nhc7pFz8gbKeLolJlbLMNnRXX7Pe/vR6P4utsppKI/otapN7ExEREZF1sZrQOHHiREsfAhEREdk5a+7TaGlWExqJiIiILM3RkanR5qbcISIiIiLrwUojERER0WNsnjaNlUYiIiIiShUrjURERESPsUujaaw0EhEREVGqWGkkIiIieox9Gk1jpZGIiIiIUsVKIxEREdFjjlydziRWGomIiIgoVaw0EhERET3GPo2mMTQSERERPcYpd0xj8zQRERERpcquK41+fp5ib3x83MXeOBT9yNKHQJmEz7V96JJ4ztKHQFmYEwfCmGTXofF86FRLHwKZWemcH0lQ0AO7eZydnR3VF4OQkEiJi0sQe/sSmLDibUsfBpmZY7tf5EyVsnyc7UC5f89a+hAoGbsOjURERET62KfRNPZpJCIiIqJUsdJIRERE9Bin3DGNlUYiIiIiShUrjURERESPObKcZhIfGiIiIiJKFSuNRERERI9xnkbTGBqJiIiIHuOUO6axeZqIiIiIUsVKIxEREdFjnHLHNFYaiYiIiChVrDQSERERPcY+jaax0khEREREqWKlkYiIiOgxTrljGiuNRERERJQqVhqJiIiIHmOfRtNYaSQiIiKiVLHSSERERPQY52k0jaGRiIiI6DFHBwc+FiaweZqIiIiIUsVKIxEREdFjbJ42jZVGIiIiIkoVK41EREREj7FPo2msNBIRERFRqlhpJCIiInqMlUYbDY03btyQe/fuSUJCQorLXnzxRYscExEREZE9ssrQePbsWRk2bJhcuXJFEhMTU1zu4OAgZ86cscixERERUdbFSqONhcZPP/1UvLy8ZP78+VKwYEFxcnKy9CERERER2TWrDI3nz59XgZFN0ERERJSZHB04RtimQmPhwoUlPj7e0odBREREdobN06ZZZZzu2rWrLF682NKHQURERETWXGk8ceKEbNmyRYYMGSKenp5G9xk3blymHxcRERFlbaw02lhoDAgIkCpVqsj9+/fVydjoaSIiIiKy89C4aNEiSx8CERER2SFWGm2sTyMRERERWRerrDTC8uXLZe/evRIcHGz08oULF2b6MREREVHW5sh6mm1VGufOnasb6HLkyBHJmTOnFClSRPz8/NT5QoUKWfoQiYiIiOyKVVYaV6xYIWPGjJFOnTpJ1apV5f3335dy5cqpyxwdHaV8+fKWPkQiIiLKgtin0cYqjYGBgVK5cmX1b0y5ExISorusQ4cOsmzZMgseHREREWXl0GjOky2zytCIamJsbKxudZiTJ0/qLnNzc5Pr169b8OiIiIiI7I9VNk+jz+LZs2elUqVKUrt2bbUOdalSpVS/xh9//FGKFStm6UMkIiKiLIhrT9tYaBw4cKCqNkLPnj1lz549ql8jJvXOkyePzJw509KHSERERGRXrDI0Nm7cWPdvDw8PWbJkiVy8eFE1WZcoUUJcXV0tenxERESUNdl6v0O769MI0dHRav3pefPmqYEwJUuWVP0bjx49ajAwhoiIiIjstNKIgS5vv/22Wnf60aNHUr9+ffHx8ZEcOXLIlClTpF69ejJkyBBLHyYRERFlMaw02lilcdKkSWrKncOHD+v6NgL+3atXL9m+fbtFj4+IiIjI3lhlpfHYsWNqsIuzc8rDK126tAQEBFjkuIiIiChrY6XRxiqNUVFRki1bNqOX3bx5kwNhiIiIiDKZVYZGNE1jjenkEhIS5Oeff1ZLCxIRERGZY55Gc55smVU2Tw8ePFj69esnLi4uam5GjJg+ePCgmnrn2rVr8vvvv1v6EImIiCgLchROuWNToRGVRKz8Mm3aNElMTJTPPvtMhccXXnhBTcGDlWLsUUR4tKz47T85sOuq3A2MUNs+/OJVqfWqv26f2Jh4WTLvmOzYeFFC7j+UvPk9pdmb5aVlxwrqMdQE3giXWZP2yPlTd8XTO5vap103w8f16sVgGdF3tcxe1l5y+bln4j0lytpuBD+S3/cHyu7zoRIYGi3Ojg5SNHd26VQzr7Srnle3X0xcgszael1W/xsk9x7ESkEfN+n8cj7pXju/wd9zwP1H8sXKS/Lf9QjJmcNZ7dO7XkGD33n+dqR0nn1CNnz4ouTx4ly3luBavISUWLFOLjZrJLG3bhpc5uDiIrnfGyDezVqKU24/dXnIssUSsniRwX4uhQpLvo8/l+wvVJL4sFAJWbZEghfON9jHrWRpKbpgiVxu01Tigu5myn0j+2CVoVELjosWLVLzNYaGhoqnp6eacsde3bgWKmMHrBcnZwdp0racFCziLaHBUeLtk91gv5kTdsu+7VfkrR6VpVAxHzl38q7M++6AREfHSfueVXT7TR67VeJiE+T9kXXkxpVQ+eX7g1KomLe8VKeobp+Fsw9Ls7fKMzASZbCdZ0Nk25kQaV45t/jnzi6JIrLl1H35+M9Lci8iVt59tZDa79MVl2TzqfvSp35BKZEnhxwPeCCT11+V6NgE6ft4H/hwyTmJjU+Uz9oUl0t3o2TKhmvi75ddGpTz1e0zfVOAdKmVn4HRAhy9vMWtmL/kGTrc5D75Ph0nXo1ek3vzf5aYK5cle6XKknfYSHF0yyb3f/lZt1/BSdPEwdlFbo//Qtz8i0veYSPU/hG7d+j28Rs4VEL++J2B8VmfL07ubXuhUYPVX/z8/HR9GjX6U/FkdXFxCTJx9BbJ6Ztdxs9uLjncjVcJrl8Nle0bLsiQT+tLw2al1bZXGvqLs4ujLP/1X2n+Vnl13bu3I+TimXvy5XdNpWrNpA+e/47ekgM7rupC4+njt9Vp2GevZuI9JbIPzSrnVtVAR8cn1cJWVf2k208nZf3xeyo0Xr77UFUYx79VUtq8mEft8/oLucTFyUF+3H5DBUB3Nye5FRotJ29Gytze5eWVUjnVfgcvh8mW08G60Hjsarg6TexQykL32L75L10hrgUMK7/6XIv5i3fzVhL46WgJW7tKbXuw9W9JjI2VXH36ScgfiyXhYaQ458sv2StUlIB+vSXywD61X46XXhbPho11oTF7laqSo+qLcmvsyEy6d2RPrDJ5BQYGyqBBg6RWrVpSvnx5qVChQoqTPdmz9bIEXA6R/qPqmAyMcHhPgDg5O0qdRsUNtjdsVkqiHsbKiaOB6nxwUKT6iaZrjV8+D7l/76Hu/MJZh1VztYeXmxnuEZF983F3MQiMGhQ48udM+pvbcTZENVs3rZjbYJ/WL+aRhzEJcvBSmDp/NzxG/UTTtaZATjcJerwdpm0KUM3V3tmtvk6QJd38aLBc7dVFgmZ/b/Ryj3oNJDEuTsL/3mCwPWzNKnFyd5ccNV5S5539kr48xOg1bccG3tJthzwDh8n9BfMl4UG4me5N1seBMKZZ5TvIqFGj5NatW2owTO7cuY3O12hP9m+/KsVK+krp8kkV1/j4BHFySpn3ESzzFfQSVzfDxwtN2U5ODnLtcrDUrFdUPL2TPlwiIp58qEQ8iBYv76Rpjo7suy43A8Lk8xlNzHzPiCjiUZzcCY+R5YfuqOriL32SvhRfvPtQCvtmEzcXw7/1YrmzqTB54c5DaVjeVxcEH0TF6fYJj4pTfRth17kQuXYvSua8XY4PtoU8On1S/XTJm8/o5W4lSkrsjeuSGPPkPRlirl1R1Ub0UYzYuV0SwpK+KDh5ekrs432cPL1U30Zwf6WuuBYtJsED3jXr/SH7ZZVp7L///pMZM2ao5QNJ5NK5e1KkuI/MnbFf9m67IvfvRopvbnfV9Ny574vi4ZkUAtHH0etxINSHDvMY7BIW/Eidz1vAS3LncZfVS09I70Evy42roXLyWKD0GVJLDTxaNPuwdOxdVfV5nD5lh5w5fke8cmaTtl0qyivJqphE9HxqfHFI/Szul10FxtL5kgadYeCLj7uz0b9nBML7EUmxoZCvm+TzdpWFewNleDM3uRIUJYcuh8voFsXU3/OMTQHSr0Eh1edx9PILcuzqA3W7b9ctIG8kq2KSZTjnyiXxoSFGL0MgdPZN6mYQc+uGxN4OFN+uPeXutMniWqy45Kj+ktyZMkFdnmfgULn3849qUE2+MZ9KjiovSlxIiAQv+kUebNmUqffJlrFPo42Fxnz58omHh4elD8NqIAyieblwsZzSd2gtVUm8eCZIjaQ++U+gTPuljWqWjo2NF2cXJ6O3gX6NGAyj/u3sKANG15Wpn26TnZsuqW2oQDZuWVp2b76sqo5vtCkrk0ZvlYiIaBkz6TW5fP6eTB67Tb4p6CUly9rWBw3ur73QKtDGKtFknRa9+4IER8bKjrPB0mnWCZnepYzUL+ujQp6LiecR/Rqj45L6eGOfL9qWkOFLz8va4/fUtkblfaVttTyy/r/7Ev4oTtq/lFeGLj4n4Y/i5fvuZeT0rUgZtuS8LPPNJhUK8r3W0hxcXFVF0Rhsd3B7vNhFXJwEjvtUCk6YqkZZw4PtWyR01QrxeqOZOHp6Scify6TQlBnq3zeGDZRsZcupwTNXu7aXR2dPZ+bdoizIKkNjhw4d1MjpatWqWfpQrEJcbLzqX9il75PHo3rtwipEThyzVQ7tDZBa9YuJi4uTRD2MMXEbCeKm12yN6y9c11U1Q6NZOlced4mPS5DffjoiXd+tJo8exsqhPddUEzWaxnFa/78zsm3deZsLjT4+9jddkJeX4ah6sl7V/b10g1yiYhJk3OrLUr9sNRUMH8bEG70OAqWb3pehemV8ZNeYGnL1XpSqQub1dpO4+ET5bnOAfNC4sLqd7WdDZE6vcqqSidOSA7dl1bEghkYrkBgbI445jL9PoWqYGJ3USgSRe3fLhcZJzdCoQsbdvYtvieI3YJDcm/29OObIIR71G8j1Ae9K9MXz6uTTobN4t2rD0JhGrDTaWGjs2rWrzJ8/X4YNG6aWE0QTS3ITJiSV4+1BDg9XCQt58qahqVGniOo4j+ZlqS/i7ZtN7gQ+SLEfHj/M8ejlY7g0IyqW/qVy6c7/vfqcuLg6yatNSsmVC/cFD3sevcEyefJ76OaHtCUhIUkDf+wBKowIjOHhUarvqz3JCl8Oqhfzko0n7ktIZKzk8nCRm9ejjf49h0XFia+Hi8F29H0sk//JY/DnkTvi6uwgrar4ydnbkervuaDeewAGztw08r5CmS8uOFiyF3gyhZI+J29viQsJNtiGvo/RF87rzuds85YkxMRI2LrV4la6rDg4OhrMA4mBMy75TY/eJrLp0PjVV19JUFCQnD17VnLlymX3A2GKlvCVa5cM3zQgJjpefRBkz5H04VHE30d2/X1JTfCN8Ke5dT1MTduDfpGmRD+Kk6Xzj0m/4a+oUZ2JCUlBPSH+SWBPSEgU/GdrcN/tDQKjPd5vWxf68HEXEicHNS/juuP31ATfrnpVxav3HqlKY8k8pqvJj2LjZda2G/JJK/+kv+fHf7bxj/+uATOY2d5fc9YUffmieDVpnlRV1Gumdi1STDVdR1+6aPK6Dm5ukvu9/nJ7wpf4RqECo6LXtcHBySlpaD6lia0v9WdOVvnIrFu3TkaOHCnr169XzdS//PJLipM9wYCXU//eVqu36Nu56aJ6H6hcI+kbZPVXCqtm6N1bkvoparavvyhu2ZylcrUCJn/H2uWnxC+Ph2rmhtx5k/o53byeNFpPm2Dc7/F2Inp22nQ5+qJi4mX1P0HyQkF38czmrOvXuP6/pH6KGuyT3cVRXi7hbfL2f9t3Ww2OaVwhqSUB/wY0X2suB0VJfiMD5yjzRezeKY6urqpfoj7vFq0kIeqhPDx0wOR1fTp3k7jbgRKxfas6j4EygOZrDQbMaNspbc3T5jzZMqusNGLN6Zo1a1r6MKzGG63LyubV5+SLYZvkze6VxS+fu1rpZd3y09KmSyXVtxGKFveVeq+XkNmT90rQ7Qgp7J+0IsyqJSfUaGg0cxsTGREjfy48LiMnNNJtw0TilWsUUPM1on/j5fP35dqlEBkwqm6m3W+irGriuiuq+te8Sm4pmiu7mlNxycHbcvdBjEzskDTlTqm8OdSKMeNWXVZLDaoVYa4/kIV7AtVoaI9sxt++HzyKk7k7b8qMrmV023J5uKqQiVVhMMfjmVsRasqeL9pyNoTMWj4QVUSX/AV05x09PSU+LEwFvphLFyVsw1o14hkTeMdcvqRWhMEo6Xtzf5SESONdbBw9PCRXr75yc/hg3bb4kGA18Tfma3TMnkOylS0v2UqVlttffZYp95WyNodEYx0GLezTTz8Vf39/efvtt836e86HThVb8SDskSz68Yjs33FV9U/MX9hLWnZ4QZq2M5x7LSY6ThbPPSY7N16U0JAoVRnEPm26VDRYq1bfoh8Py/lTQTLue8NvuZjaB8sSYmUYLFfYtmulFL/P2pXO+ZEEBaXs55lVYaQ4+vahH6e9NU/7+XlKwgrzvmdklK2ng2XNP0Fy8maEBD2IkWzOjlKjuLcMbFzYoF8ilgucufW6rP03SE2xg4m/sT51rzoFTP49z/g7QP67/kDmv2O4CMKdsGj59K9LasodX3cX6V2vgHSsaXzeQGvm2O4XOVOlrNiSEuu3Gl0RJnT1X2oVGHBwdZXc/T5IWnvaN5fE3b4lIcv/UNPlmOI3YLBkq1hJrvd7x2C7c548kv+TLyV7lWoqRGKy79A//xBbU+7fsxb5vSfvTzTr7b+Qa5TYKqsMjZs2bZLPP/9cJk2aZHLqnRdffNGuQiM9G4ZG+2FLoZHsKzTSs2FoNG7nzp3y7bffyoULFyRnzpzSrl07GThwYJrGf2zZskV+//13OXXqlERGRkrv3r3lww8/FJtunh48OKnU/u67xme1xzfsM2fOZPJRERERUVZnzf0OT548KQMGDJA+ffrI119/LQEBATJu3DiJjY2VESNGPPW6KMStWLFCZSvchpubm8TFPVlJymZD49atSR16iYiIiCjJvHnzpE6dOjJkyBB1vly5chIfH6+WX+7fv7/J1tkdO3bI8uXLZdWqVVKw4LNPv2SVoTGtd2js2LEyaNAgyZPnyWLtRERERFlxyp2DBw+qcKivXr16Eh0dLceOHVP/NhU2UZ18nsBotaExrVauXCm9evViaCQiIiKb0KjRk5lK0tPaGhERIffv35dChQwngkd1EX0b0VRtzKNHj+To0aPy0ksvyTvvvKP6M6JpukaNGjJ8+HDJmzdvmo/deuN0GljhGB4iIiKyYdY6T2Pk46mXcuTIkeIyd3d3FSqNuXbtmmrCRnDEoJk5c+bImDFj5Pz58/Lmm29KaGiofVQaiYiIiGzJ1kwet/HgQdK0cxMnTpR8+ZKm2apUqZJUrVpVXnvtNV2rbVowNBIRERE95mClfRrd3ZPmcH348KHRKqSpQTCurkkLe4SEhOhCI2A8SKlSpeTy5ctpPgbrfGSIiIiILMDRzP89K4RCX19fuXnzpsF2NEujiblw4cJGr6f1gUQzdXIYQJMtW7Y0HwNDIxEREZENqFmzpuzevdtg2549e9Tyy9WqVVPng4OD5fbt27rLETQrVKgg//vf/wyuh/B55coVNUAmrRgaiYiIiPSap815eh5YwQWhccaMGXL27FnZvHmzmuS7c+fOuuZpLJBSv359g+sNHTpU9u7dqyYCxwThmLexX79+ql9jw4YN0/z72aeRiIiIyAZUqlRJZs6cqZYRnDt3rppqp3Xr1rqV9EypW7euzJ49W7777jtZtmyZeHp6SrNmzWTYsGHi6OhoH6Exd+7caVprkYiIiMjWJ/eGBg0aqJMpixYtMrr91VdfVafnYdOJC4t2ExEREZH5WXecNjGz+ejRoy19GERERJQFOYijWU+2zOaOPjY2Vk1ESURERESZx2qap9esWZPmSiMRERGRPfZptCSrCY1YC/HixYtpWlPa4TnWbiQiIiIiG680zpo1S77//ntZu3atlCxZ0uh+4eHhanJLIiIiooxm6/0OzcmqHpkuXbqkqcqY2j5EREREz9o8bc6TLbOqo8cklRMnTjRYUDs5rJE4YcKETD0uIiIiIntnNc3TmjZt2jz1cqyv2LZt20w7HiIiIrIfz7vUX1ZmNaHx8OHD6dq/Ro0aZjsWIiIiIrLS0Ni9e3fdqOi09Gs8c+ZMJh0ZERER2QtH6+q5Z1WsJjTWrl1bDh06JC1atFABEutKExEREZF1sJrQOH/+fDl79qz6idDYvHlz6d27t/j7+1v60IiIiMhOsE+jaVZVgy1btqxMnjxZ1q9fLx4eHtKhQwfp16+fHDlyxNKHRkRERGTXrCo0ajDlzsiRI2X79u3i4+OjKo+jR4+29GERERFRFsd5Gm2geTo59G+cN2+e7Nu3T03D884771j6kIiIiIjsllWFRoya3rhxo8ydO1cCAgKkY8eO8uWXX0revHktfWhERERkBxzEydKHYL+hMTY2Vk3InZrffvtNFixYIPHx8dKjRw9p3769uLu7m/vwiIiIiHRsfak/qwmNMTEx0rRpU/VvX19fWb58earXefnll2XHjh3i6en51P2++uorFS6rVKkiu3btUqenwShrIiIiIrLSSuPNmzfl22+/FTc3N4PtM2fOlA8++CDF/qgc4pQa9FvUJvcmIiIisgQH6xwjbJuhEcHujTfekGnTpsmrr76q2/7DDz8YDY3YPy1hcOLEiek9FCIiIiLKJM8cp3/++WeD86aW/sN2Jyd2KiUiIiLrxyl3zBAak4dEY9VE7IN+kGkZCENEREREdjp6OjQ0VAXG5P0fiYiIiKwRlxHMgNB4+PBhNX2OvtOnTxtUHJOfv3z5shQpUiStv4KIiIiIbD00Yim/5M3Qb775pkFIbNeuncF1sO/rr7+eMUdKREREZGaOHD39/KHx2LFjEh0dLbVr19ZtwxJ/pqAq2alTJ6lXr15afwURERGRRbF5OgNCY44cOcTZ2XB3Hx8fk/svWrRI4uLipGXLlmn9FURERESUVQfCoPoYFhYm2bJlEy8vL7VtzZo1MnXqVPnuu+/E1dU1I46TiIiIyOy4jKAZQ+PWrVtl2LBhqv8i5mPMnz+/3LhxQwYPHiz169d/3psnIiIiIlsOjX379lU/GzVqJFu2bFEVx7t378q5c+dk06ZNMnv2bHF0dJR33303I4+XiIiIyGy4jGAGhkaMlv79998lX7586jzmYCxUqJD6d4kSJaRWrVrSq1cvOXTokIwaNUqCg4PVTyIiIiKykxVh0ARdo0YN2bhxo6ommlo6EF566SVZvny57N69WwICAjLiWImIiIjMissIZlClEau7YFR0WuXKlUsNikEzNRERERHZrmdKc+PHj5fOnTvLwoULn7rfP//8o1aFISIiIrKVPo3mPNmyZzp6rPzSo0cPmTdvnjqP6XU2bNggMTExBvt9++230r9//4w5UiIiIiKyrdBYtmxZadq0qWquhrlz58rnn38udevWVf0YITAwUA2G6dq1a8YeMREREZGZsE9jBvVp7NKli66aiCl29NehxoAXDI6ZMGGCXLhwQe2XN29e6dChQ3p+BREREZHFcBnBDAqN58+fl4EDB6p/IzBWrVpV928sMYglA6tXry49e/ZUE3z//PPPkj179vT8CiIiIiLKCqOnEQifxt3dXS0piCDp6ekp1qx0zo8sfQiUCfz8rPt1aA4+Pu5ijxzb/WLpQ6BMUO7fs3ycyWwcEs39C8R+lxHUICSeOnVKPvzwQ/Hx8ZEhQ4bIxx9/LKtXrzZoxrYmi88NsPQhkJl1KfODJKx4m4+znQTGoKAHYi+cnR3Vl4OQkEiJi0sQe/oSuNihjKUPgzJBl8RzfJxteSDMo0ePVL/Gjz76SLZt26bbjkm++/TpI506dZJXX31VFixYoEZXBwUFyfr1681x3EREREQZLzHBvCd7CY1jxoxRo6YxafeXX34pw4cPl4SEpAcA/Rsx7Q6WDHR1dVXLCzZo0ECWLVtmrmMnIiIiImtsnm7fvr3u30OHDlXzMEZGRsoHH3ygTslhHWrM4RgXF6cGyhARERFZNRuvBppTupIcmpqbNWsmrVu3llWrVknDhg3VYJdq1aoZ7KPB8oG7du3K2CMmIiIiIutunp48ebJu4m747LPP1E/9ZuoRI0bI7Nmz1WnkyJEZf8RERERE5sI+jSY9V5sxBsAklzNnTlmzZo36d40aNZ7n5omIiIgoK4TG1KbSsdapdoiIiIiMYp/GjAmNWmUx+U99wcHB8sYbb6h/R0REqH9jeUEiIiIiq/e4ux09Z2j866+/1M+6deuqn9p0OuvWrVODXmDevHnpuUkiIiIiymoDYXx9fdXPadOmqZ/aMoHe3t5y6dIl9e++ffuqqXZwwoCZY8eOZfxRExEREZkDB8JkTKVx586dKbbVr19f/cQ0PCdPnlRN1vfu3VOjqA8ePChvv80l3IiIiIhsXbpC43vvvacb4IJwiJ9nzpxJsd+ePXskNDRUlixZIpUqVcq4oyUiIiIyJw6EyZjmaR8fHzl16pTkz59f/USztDGtWrWS//3vfwyMRERERPY65Y6Tk5OqMOKnKdqgmPj4eLl//77kyZPn+Y6SiIiIKDOw0pgxlca0wnrUP/74ozRo0EC++eYbc/wKIiIiIrKVyb1NuXHjhvz555/SrVs3adeunTl+BREREVHG4zyNGRMaw8PDpW3btnL37l31E5N346fWFI1/Yw3qMmXKyObNm9Nz00RERESUVZqnXV1dpWnTppI9e3b108XFRf3ECf0YtZ/6oqOjM/qYiYiIiMyD8zRmTGjMli2bvPvuu2pSb/x0c3NTP3HC4Bj8BAx+mT59ujRv3ly++OKL9PwKIiIiIsthaMzcPo1oxj5y5Ii0bNlSGjVqZI5fQURERES2Hhr9/f3l999/f+brDxgwQDp27Cj16tXL0OMiIiIieipOuZMxzdMxMTGyZs0aiYqKUj9jY2ON7odlBP/44w+1asyzwByQCI4NGzaUWbNmyZ07d57pdoiIiIjIAqHR2dlZvv76azVCGj8xEMbUlDuTJ0+WN998Uy5cuJDug/ruu+9k9+7d0qtXLzUKG03c/fr1k+3btz9zECUiIiJKTWJivFlPdhMaDx48KAcOHDA4aTp06KD7d5UqVVTYK1y4sHz55ZfPdGA5c+aUHj16yF9//aWWJCxSpIiMGTNGTRg+c+bMZ7pNIiIiIrLwijCffvqp+jlp0iT109fXV7799luZNm3ac9922bJlVVisUaOG3L59W00cTkRERGSWyb3NebJhGT4QpkWLFgbn/fz8nvm2AgMDVUBEtRH9GuvXr6+WJ+QAGSIiIqIsMHr6ea1fv16FRTR/58uXT9566y3VPzJPnjyWPjQiIiLKyjh62rZC44gRI9TI6Z9++knq1Klj6cMhIiIisntWGRp37dql+kQSERERZSpWGs0/ECYjITAiOPbv31/1kQwICFDbQ0NDZfTo0XL06FFLHyIRERFlRVxG0LZC44YNG2TQoEGSO3duuXz5sppUXJuGBxN/L1myxNKHSERERGRXrDI0zpkzR0aOHKnmeHRwcDC4DJVHVhqJiIjILFhptK3QePXqValatarRy9zd3dUyhURERERk5wNhEAwfPHhg9LLjx49z6h0iIiIyDxufgNvuKo2vvfaaLF26VHdea6L+559/1LrUjRs3tuDREREREdkfq6w0Dhs2TN5++23p2LGjJCQkyMSJEyUkJEROnTolpUuXloEDB1r6EImIiCgr4pQ7thUaPT091Qjp1atXS6FChVRgLFiwoLRr106tDOPm5mbpQyQiIiKyK1YZGsHFxUUFRJyIiIiIMgUrjdYfGleuXJmu/du0aWO2YyEiIiI7xdBo/aHx448/NjifmJiYYo5GQB9HTPDN0EhERERkh6ERg1w0kyZNEi8vL3n//fcN9omLi5Nu3brJ0KFDLXCERERElOVZ+ZQ7O3fulG+//VYuXLigVsrDeA8MEHZ2Tnuk++STT2TZsmXqtvLly2fbU+78/fffUqtWrRTb8YC8++678sMPP1jkuIiIiIgs5eTJkzJgwACpV6+eCn1jx46VP//8U6ZNm5bm21iwYIGsXbv2mX6/VYZGrPiirTedXN68edUE30RERET2tIzgvHnzpE6dOjJkyBApV66cvPHGGzJmzBj57bffJCIiItXr7969W3766Sd1nSwTGitVqqQeAGM2b94svr6+mX5MRERERJZ08OBBFRr1oeoYHR0tx44de+p1L126JMOHD5fp06dLkSJFbLtPoz4k4B49ekjLli2lWbNmqroYHh4uBw4ckF27dsmnn35q6UMkIiKirMjMo6cbNWr01Mu3bt1qdDsqiffv31fzV+vz8PBQfRsDAgJM3mZoaKgaJ4IxITVr1lThM8uERpRc//rrL9V3EZN8BwcHS65cuaRMmTIyd+5cqV27tqUPkYiIiCjTREZGqp85cuRIcZm7u7vJ5mkMIh48eLCqSGKlvedhlaERkKQnTJhg6cMgIiIie2Lm0dNbTVQSzWX27NlqIPHo0aOf+7asJjTeunUrXfsXKFDAbMdCREREZE3c3d3Vz4cPHxqtQqKZ2pibN2/Kvn37pGLFigZzYUPDhg2lRo0aakS1TYVGHLixybxNOXPmjFmPh4iIiOxQQlKgsjYeHh5qIDBCoD40S6PPYuHChY1eD/0Ye/fubbDtxIkTavwIRmMn7yNpE6Hx999/16XfFStWSGxsrHTq1ClFu/yoUaNU2zwRERGRPU3uXbNmTTVtTteuXXXb9uzZIy4uLlKtWjV1HuNAMG2hNmk3BhPjpC8kJET99Pf3T9fk3lYTGrU7C1999ZWMHDnSYJumf//+6gGzp2UEZ/TZI2F3H5m8vPXg8lKlUQGJi02QnUsvy4kdtyUiJFpy5s0u1ZsWkpotCxtUcYMDH8q62Wfl5vkwye7pKjWaFZLabYsa3OadqxEyf+Rh+WBWbfHM5WbW+0dP3Ah+JL/vD5Td50MlMDRanB0dpGju7NKpZl5pV/3JH31MXILM2npdVv8bJPcexEpBHzfp/HI+6V47v8FzHXD/kXyx8pL8dz1CcuZwVvv0rlfQ4CE/fztSOs8+IRs+fFHyeLny6SDKBNnz55GqU0ZI/iZ1xCl7Ngn975z89+l3cnvzXoP98r32ilSdPFw8ShaRiIsB8u/IqRL49x6DfUoP6CrFe78pG6u143OXxfXu3Vs6d+4sM2bMkCZNmsj169fl66+/Vtu05mkU1g4dOiTnzp3L8N9vNaFR35UrV3Rt98mhTX7KlCliT1oPLC+xMfEptkdFxMmqb0+Jk3PSdJtrZ56R0/vvSp03i0ruwu5y41y4/D3/gsTFJEidt4rprvfnlJMSH5cgzd8vJ0HXI2XzLxckd6EcUrqGn26fbYsuqjDJwJi5dp4NkW1nQqR55dzinzu7oJFky6n78vGfl+ReRKy8+2pSM8KnKy7J5lP3pU/9glIiTw45HvBAJq+/KtGxCdL38T7w4ZJzEhufKJ+1KS6X7kbJlA3XxN8vuzQo92Su0+mbAqRLrfwMjESZxCmbmzTctkAcXZzl+MczJCY4TIp2bi6vrvtJtjbsKUF7jqr93Px8pd5fM+XW+l1yeuIcKfzmG1J3xfeyyr+RRAcFJ91WjuxSYez7cqDX8w9yIOuvNFaqVElmzpyplhHEbDKYaqd169aZ1gJrlaGxYMGCsm3bNvXgPG2NanvhX9n4ZObbF18StxzOUrpGbrl3I1KO7wiUNoPLS+WGSYOEytfOK07ODrJ7+RUVALFvWNAjuXUxXLp9UVVKVM2l9rv6X7Cc2R+kC40Bp0PVqc3QCpl4LwmaVc6tqoGOjk+qha2q+km3n07K+uP3VGi8fPehqjCOf6uktHkxj9rn9RdyiYuTg/y4/YYKgO5uTnIrNFpO3oyUub3Lyyulcqr9Dl4Oky2ng3Wh8djVcHWa2KEUnwCiTOLfo414ligsa8s2lYjL19W2gOUbpPHuxVJp3GDZ2qCH2lagSV1xcHaW/b1GSfzDKLmxZru8FXJI8r9RV67+tkrtU3ZITwk/d0UCN+3m82cnGjRooE6mLFq0KE3N3M9SibTKFWE++OADmTNnjowbN06OHj0qN27ckNOnT8v8+fNl/Pjx0qpVK7F3jyJi5eCa6/JSi8IqDJ4/fE+cnBykQh3DfguVG+SXmKh4uXoiqf/Cg/vR6iearjXeebJJRHDSdti68KJqrs7u4ZJp94eS+Li7GARGDVqc8+dM6iaw42yIarZuWjG3wT6tX8wjD2MS5OClMHX+bnjSUpxoutYUyOkmQY+3w7RNAaq52ju7VX5/JMqSCrZsIEH7/tEFRs3VRavEr251ccnppc5nL5BHou+FqMAI+Bl9L1RtB1cfbyn3UW85Pjrt6w5TGgfCmPNkw6zykwKrwDg5OalmaAyQQR8tDJDx9PSUbt26qVBp7w6suS6JCYnycsukpYCCAiLEJ192cXZ1MtgvV8Ec4ujkIHevRUiZmn6S3TPpKX8UGavb51FEnGT3TAqIF47ek/u3HkrXz6tm6v2hlCIexcmd8BhZfuiOqi7+0iep8nvx7kMp7JtN3FwMv/MVy51NhckLdx5Kw/K+uiD4ICpOt094VJzq2wi7zoXItXtRMuftcnz4iTKRd4VSErgxZWUw7NRFcXRyEu9yJeTe/n8kOjhMXLz1plFxcBAXL3eJuZ9UBCg/sq9qysa+RHYbGgGLcON07do13Yow+fPnVyOE7N2jyDg5uDpADXLRwl5EaIzkMDKIAYEb+0SGxegqjF653eTg6uvy2tvZVLP21ZMh8kaf0iqYb1t4Uep18Fd9HlfOOKuaqd29XaVWmyJS/hXDKiaZV40vDqmfxf2yq8BYOl9SP18MfPFxdzb6XCMQ3o9I+kJQyNdN8nm7ysK9gTK8mZtcCYqSQ5fDZXSLYuq5nrEpQPo1KKT6PI5efkGOXX2gbvftugXkjWRVTCLKONny5lIVxOS0bdnyJHUfQSB0zpFdygzqIdeWrpNiXVuqQTNBe4+pgTSlBnSRzbU7qxBadepI8Srjr5qq//lokoSdusCnLAv2abQ0qwyNWJfx119/VXMOFS1aVJ0027dvV+31aKq2VwfXBKiR0rXbPHlc4mMTVP9FY7A9NibpjwCDZloMKCcrpp6UEztvq22oQFZtVEBO7b6jAmm1NwrK8kn/qX93HFNZbl8Ol/9NOSF982WX/CWSmk3I/Ba9+4IER8bKjrPB0mnWCZnepYzUL+ujQp6Lk/GeJejXGB2X9Fxjny/alpDhS8/L2uP31LZG5X2lbbU8sv6/+xL+KE7av5RXhi4+J+GP4uX77mXk9K1IGbbkvCzzzSYVChqfKNaaOT8eFGYPnB6/BrSfZDsc3VwlIeZJa48mPibpyz2CIYSfuST/ffKtVJ02Sqp9+7EkxMfLf2NnSPjZy1Jj9hdyc9U2CT9/RVpf3SYBf2yQY8MmSKn3OknDrb/KqqINJCH6SVcUoiwbGjFxJeZkNMbb21v+/fdfsVfRD+PkwOoAefGNguKe80ll0cnFUfVdNCY+LlFcXJ98sJSqlls+XFBX7t98KNm9XMQrVzZJiE+Q7b9fkle7FJeYR/Fy7vA96fpZVclbzEOdDq+/If9uC2RozETV/b10g1yiYhJk3OrLUr9sNRUMHxoZTQ8IlG56waleGR/ZNaaGXL0XpaqQeb3dJC4+Ub7bHCAfNC6sbmf72RCZ06ucqmTitOTAbVl1LMgmQ6OPj/FZF7IyL68n/ZPJNiDMObqmbDVzck16T4+PejLF2qnxP8r5WYvFo1hBibhyQ2LDHohHiSLi36O1rK/YUgo0rSduuXLK8Y+nS1zkQ/WzVP/OavuNlVsy9X5lGaw02lZoBFOrw2zYsEG8vLzsusoY+yheXmlnOK8impBD7yQNgNCHZsioiFjJ4W3YdI2+j3n9PXXnj22+pYJnpVfzy+0rDwRzveTMk/RtV2vWDruT1BmbMl/1Yl6y8cR9CYmMlVweLnLz+pOBS/rPdVhUnPgmG8CEvo9l8j8JU38euSOuzg7SqoqfnL0dKVhNqqDPk+caA2duhpieF9SahYREir1AhRGBMTw8SuLj7ac5LSt8MXh097645fZJsV3b9ijIsOk6NjRcQv4N153HCOsrC1aqgTQFWzVUzdoIjICf0fdDxb2Y4XysRFkqNGLdw4ULF+oCY8+ePdUC25qEhAQJCwuTqKgoNfG3/VYZr0vlRgVUdVCfX2F3Obnrtmq2dtYbIBF866EkxCVKniKm32hjo+Nl19Ir0qxfGXFwxKCjpO0YaKNJjE9UcwaSZYQ+TKq8Ozs5qHkZ1x2/pyb4dtWrKl6990hVGkvmMV15ehQbL7O23ZBPWvmrUdracx2v91zjS7atPtdxj5vm7QkCoz3eb1sWfvqSeJUvkWI7tiUmJKhmaVNyVi6rRl+vLd1EnXdwdBQHJ8MBkDifnmV5KRkbH+FsF6GxQoUK8tZbb6lqyXfffacGwfj4GH4TQ4WxSpUqal97dGjtdRUc67z5ZKJuTakauWXLgotyavdt3TyNcHz7bXFxcxT/Sr5PvV0Mjin7ctI0Dt65kwIpRlH7FUlqorx3M1KKVkj5zZgyFqbLqVnC22BbVEy8rP4nSF4o6C6e2ZxVv8ZvNl6T9f/d083TCNgnu4ujvJzs+vp+23dbDY5pXCFpjk78G9B8XTJvDvXvy0FRUuNx0zgRZbyb63ZItRljxKN4YYNpd/y7tVJT8cSEpGw10lQZP0wu/LBYogLvqvORAYHimiunuPrmlJjgUFWtdPX1VtvpGbF52vpDY/Xq1dUJMEr6tdde0y2JQyIxUXGyf1WAVKyXT02tk1yeIh7yQr28su7Hc2oCb7/CHnLjXJjq/1i3g7+ay9EYDHbZu+KatB9RUbcNfSUxoTjma0Q/ycDLD+TutUhp0Z9Ts5jbxHVXVPWveZXcUjRXdjWn4pKDt+XugxiZ2CHpy1KpvDnUijHjVl1WSw2qFWGuP5CFewLVaGiPbMaf6weP4mTuzpsyo2sZ3bZcHq4qZGJVGMzxeOZWhJqy54u2xc1+X4ns1eVfVqhJuRv8PV/OTJ4rMSHhUrRTM8n9youy/bXeJq/nV6ea5K5dVfZ1G67bFrhhl8SFR0itXyfI1cVrpVi3Vqrfo7EpfYiyTGjUV65cOVmzZo106NBBzdf46NEj+f777+Xq1avy6quvSvv27cXeHFp3Q82tWKd9yiqjpvWg8rJjyWU5uummRIbGiLdfNmnUo6SaLseUfX9dlfzFPVOsOtNmSHlZ+8MZWf/TWTWVT/P+ZaVwuaRVRch8PmhcRNb8EyR/HLwjQQ9iJJuzo9Qo7i3fdCpt0C/x6zdLysyt12XZoTtqih1M/D2sSRHpVedJlTm5ebtuSfmC7ikqkRPbl5RP/7qkQqivu4t83qa4VC3KSiORuWCgy5YGPdTa05UnDFOjpcNOnJddLfvJne0HTF6v8oQP5cyUeQaVSPRh3NGin1T/7mN56edx8uDcFdnZop+ujyM9AzZPm+SQiPZgK9OvXz+19vQ333yjzn/++eeyfv16qVOnjuzevVs++ugj6dix43P/nsXnBmTA0ZI161LmB0lY8balD4MygWO7XyQo6IHdPNaYXgiDQjD4x576NPr5ecpihyfVcsq6uiSmf5m7jJB4dKxZb9+h2ldiq6xygq8TJ05IixYtdANg1q5dqwa/TJs2TT755BP57bffLH2IRERElFX7NJrzZMOsMjRGRkaqfo1w/vx5db5+/frqfJkyZdRa1ERERERk56GxSJEi8t9//6l/b968WQoWLCi5cycta4YlBdF0TURERJThWGm0rYEwvXr1ks8++0xWrFghJ0+elEGDBukuQ99Ge51yh4iIiMhSrDI0tmvXTi0XuH//fvVvbbQ0JvfGCRN/ExEREWU0c48PdhDbZZWhERo1aqRO+hAkMfG3ZuzYsaoKmSfPkwmOiYiIiMhO+jSm1cqVKyU8/Ml6nERERETPhX0aba/SmBZWOMUkERER2TIbnxbHnGy60khEREREmcOmK41EREREGYrLCJrESiMRERERpYqVRiIiIiIN+zSaxEojEREREaWKlUYiIiIiDSuNWbPSiPWonZ2Ze4mIiIjMzeYS16NHj+TEiRNSo0YN2blzp6UPh4iIiLISjp62jdD477//yv/+9z+5c+eOFC9eXDp06CAlSpQw2OfWrVvSo0cPOXPmjMWOk4iIiMjeWE3z9J49e6Rr165y6dIl8fDwkM2bN0vr1q3l559/tvShERERkb3gMoLWX2mcOXOmCo1jxoxR5xMSEuSPP/6QSZMmybVr12TcuHHi4OBg6cMkIiKirIwDYay/0njx4kVp2bKl7ryjo6N07txZlixZItu3b9eFSSIiIiKy49Do5OQkiYmJKbaXK1dOfvvtN9m3b5+MHz/eIsdGREREdjQQxpwnG2Y1zdP+/v5y5MgRqVSpktHLfvnlF+nevbuEhYVZ5PiIiIiI7JnVVBqbNGkiK1eulNjYWKOXYzT1vHnzZNu2bZl+bERERGQnOBDG+iuNvXr1UqenKVu2rKxYsUICAwMz7biIiIiIyIpC4+HDh9O8L0dRExERkVlw9LT1h0b0V9TCoLEBMfqwHyf3JiIiIrLD0Fi7dm05dOiQtGjRQgVIrCtNRERElKlsfISzXYTG+fPny9mzZ9VPhMbmzZtL79691chpIiIiokzB5mnrHz2tDXSZPHmyrF+/Xi0liLWn+/Xrp6biISIiIiLLsarQqMmXL5+MHDlSrQTj4+OjKo+jR4+29GERERFRFpcYn2jWky2zmubp5NC/EfMyYiWYNm3ayDvvvGPpQyIiIiKyW1YVGjFqeuPGjTJ37lwJCAiQjh07ypdffil58+a19KERERGRPeBAGOsPjVhfesGCBRIfHy89evSQ9u3bi7u7u6UPi4iIiIisKTR+9dVX4uLiIlWqVJFdu3ap09NglDURERFRhrLxfod2ERrRb5ErvRARERFZJ6sJjRMnTrT0IRAREZGdS2SfRtuacoeIiIiIrIvVVBqJiIiILI59Gk1iaCQiIiLSxCfwsTCBzdNERERElCpWGomIiIge40AY01hpJCIiIqJUsdJIREREpOFAGJNYaSQiIiKiVLHSSERERKTh5N4msdJIRERERKlipZGIiIjosUT2aTSJlUYiIiIiShUrjURERESaBK4IYwpDIxEREZGGzdMmsXmaiIiIiFLlkJiYmJj6bkRERERZX/Q37cx6+24frhBbZdfN0w7vv2zpQyAzS5x9QAr82JaPsx241e8vOR861dKHQWZWOudHEhT0wG4eZ2dnR/HxcZeQkEiJi7OvvnZ+fp6WPgRKxq5DIxEREZEB9mk0iX0aiYiIiChVrDQSERERaVhpNImVRiIiIiJKFSuNRERERI8lJnBSGVNYaSQiIiKiVLHSSERERKSJt6+pjdKDoZGIiIjoMTZPm8bmaSIiIiJKFSuNRERERBpOuWMSK41ERERElCpWGomIiIg0nHLHJFYaiYiIiMg2Q+P169dl5cqV8ujRI4PtsbGxsm3bNrl7967Fjo2IiIiyrsT4RLOebJlVhsaZM2fK33//LdmyZTPY7uLiosLkrFmzLHZsRERERPbIKkPjgQMHpHPnzkYva9++vezatSvTj4mIiIjspE+jOU82zCpDY0hIiPj4+Bi9DNvv3buX6cdEREREZM+sMjQWK1ZM9u3bZ/SygwcPSsGCBTP9mIiIiMhOlhE05+k57dy5U9q1aycVK1aUunXryvTp0yUuLu6p19mxY4f07dtX6tSpI5UrV5bmzZvLwoULJSEhwfan3OnZs6d8/vnn4uzsrO6Yn5+f3L9/XzZu3Kj6Ow4ePNjSh0hERERZkDUvI3jy5EkZMGCA9OnTR77++msJCAiQcePGqYHCI0aMMHm9NWvWSPHixaV3797i7e0tx44dk6lTp6oBx++++65th8Y333xTgoOD5fvvv5cpU6botjs5OUn37t2lV69eFj0+IiIiosw2b948VS0cMmSIOl+uXDmJj4+XUaNGSf/+/cXDw8Po9SZMmCCurq668+XLl5egoCBZtmyZ7YdGQBkVg2GQhkNDQ1UyrlSpksm+jkRERETPzYqnxTl48KAKh/rq1asn0dHRKi/h38boB0ZN3rx55c6dO+n6/VYbGgGJ2dQDQERERGRrGjVq9NTLt27danR7RESE6qpXqFChFFkpZ86cqqk6PRAy0WRtk6GxR48eMnnyZMmXL5+MHj061f1RaiUiIiKyhz6NkZGR6meOHDlSXObu7q5CZVqdP39eNmzYIGPHjrXN0JiY+ORJun37tkWPhYiIiMgctpqoJGaWBw8eqAHFtWvXlo4dO9pmaFy0aJHu37/88otFj4WIiIjsk7Uu9efu7q5+Pnz40GgV0tQgGH1RUVFq4AtW2MNUPY6OjrY/TyMRERERPYFQ6OvrKzdv3kzR1xEDhgsXLixPg2CJwIjg+Ouvv6YpZFptpVEf5hEyxcHBQaVtDDN/66231ByORERERFm5TyPUrFlTdu/eLV27dhXNnj17VOWwWrVq6jymLIyJiVFjRDRhYWHy3nvvqcoiJvX28vKSZ2GVlUbcOYwCwnBw/RNGB2GlGEz6vXnzZmnRooVcuHDB0odLRERElClFNYTGGTNmyNmzZ1UWwiTfmKJQqxyiv2L9+vUNrtetWzc1kTcGvmB+xkuXLulOCJk2XWnMnj27dOnSRU3ynZybm5v4+/vLtGnT1GSWmNH8p59+sshxEhERUdaSYKV9GgHzVWNlvG+//Vbmzp2rimmtW7dOdaU8jJaGtm3bprjsgw8+kIEDB4rNhsZz586p5mdjECTHjBmj2uWbNm0qH330UaYfHxEREWVN1tw8DQ0aNFCntAws1s9VGcEqm6fR5n79+nWTU/NoU/JgriKUW4mIiIjIvKyy0tikSROZNGmSFC1aVMqWLavbjnb37777TsqUKaPOBwYGSq5cuSx4pERERJSVJCYkWPoQrJZVhkb0VUQgRNt7kSJF1AhpTEZ5+fJltQb1nDlzdCHy9ddft/ThEhEREWV5VjsQBsHwwIEDsn//fhUOMTdRnz595I033tAtvN2rVy9LHyoRERFlIdY6ubc1sMrQqHn55ZeldOnSqrro5ORk6cMhIiIisltWORAmNjZWTaWDiSrr1KkjV65cUdsx43nLli1l9erVlj5EIiIiyqKjp815smVWGRrRNL1p0yb58ssvDbZjPiI0T69atcpix0ZERERkj6wyNKKSOGLECGnevLlaNlBfvXr15PTp0xY7NiIiIsrafRrNebJlVtmnESOnTS28jfUUHz58mOnHRERERFmfrTch212lMX/+/HLr1i2jl23dulWKFSuW6cdEREREZM+sMjR26NBBZs2apeZmBDRRo7qINaYXLlwob731lqUPkYiIiLKghIREs55smVU2T7/zzjuqibpu3boSHx8vXbt2lbCwMLWEYPv27aV79+6WPkQiIiIiu2KVoRHGjh0rPXv21E3u7enpKTVr1pSSJUta+tCIiIgoi7L1wSp2FxpHjx4tH374oRoMk3xAzNGjR2Xv3r0yaNAgix0fERERkb2xyj6NK1eu1PVnTA4rwyxevDjTj4mIiIiyPk7ubWOhEX0Xk8/PqDlz5oy6nIiIiIjssHl6y5YtajodQGD85ptvxMPDQ3d5QkKCGgyzb98+tZQgERERUUbjPI02EBojIiLk9u3b6t+oJAYFBalt+jAYZujQodKlSxcLHSURERGRfbKa0NimTRt10gbCDBs2TPz8/Cx9WERERGRHOHraBkKjvgkTJlj6EIiIiMgOJSYkWPoQrJZVhkZYvny5mloHczQag5Vhsrpy+YrJ6c+WSrGP28q14ECDy1ydXeTTZu9It5fekHxeueRqcKDM2vmnfLd9WYrbafZCbbVvpYIlJDLmkaw/uU+Gr5gpdx88eWydHZ3kq1b9pOtLb0gOVzfZdu6o9F86RYIehBjc1qGR8+X3w5vk221/mPGe27eX8pWT4TU6y4t5SktMQpwcDDwl4w/+JudDruv2cXV0lqHVO8qbpeqJXw4fufHgrvx6aqPMO7HW4LaKeuWTiXXfk6p5SklI9ANZcGqj/Hh8lcE+ZX2LyOo2E6Xu0gFy56Hh803mFREeLSt++08O7LoqdwOTuuN8+MWrUutVf90+sTHxsmTeMdmx8aKE3H8oefN7SrM3y0vLjhUMBgwG3giXWZP2yPlTd8XTO5vap123Sga/7+rFYBnRd7XMXtZecvm58+klItsPjXPnzpXvvvtOGjZsKEeOHJHGjRuLl5eXREVFyYYNG3TN2FmVTw4vKZO3iExpN9DkPnO6jpI3qzSQiX8vkjO3r8rL/hXkmzcHSXYXN5n09yLdfg3LVJfV70+Rlcd3yTdbFksuD28Z8Vo32TzoO6k+sZfExsep/d6r21YGN+wgn6yZI3cfhMiXLfrKrE7Dpf3PY3S31a5qA8nj6SOzd60w8yNgvxoVqSbz3xgl268fkxG7Zoubk4u8/UIzWdVmgrRYMUIuhSWtyT65fn9pXvxlmfnPCrkQckOq5S0jn9XqJdmdXGXmv0+en9mNh4mLo7OM3v2TlPQpJJ/W6iUXQ27KloAjun1Gv9RNfj21gYExk924FipjB6wXJ2cHadK2nBQs4i2hwVHi7ZPdYL+ZE3bLvu1X5K0elaVQMR85d/KuzPvugERHx0n7nlV0+00eu1XiYhPk/ZF15MaVUPnl+4NSqJi3vFSnqG6fhbMPS7O3yjMwEj0Fm6dtLDSuWLFCxowZI506dZKqVavK+++/L+XKlVOXOTo6Svny5SUrOzZmgRTLld/k5WXyFpXuLzWVXgvHyaKDG9S2Ff9sl5i4OPm4aS/5YeefEhH9UG3/qtV7svPCP/LWnNG6628/d1ROfbpYutR4QxYcWKe2tav6qvz5zw6Zuvl3dd7VyUVmdR6uKhkYmOTo4ChftXxPPl83V2LiYs38CNgnB3GQCXXflR3X/5FeG5900Vh9aa/s6fyDjHm5u7yzaZKUzFlQ3ipdX4Zs/17+d36H2mf9lQOqKjnoxbfkl1PrJTL2kRT0yC1V8pSSTms/l103jqv96hSsKE39a+pCY418ZaVG/nIyaNu3FrrX9ikuLkEmjt4iOX2zy/jZzSWHu6vR/a5fDZXtGy7IkE/rS8NmpdW2Vxr6i7OLoyz/9V9p/lZ5dd27tyPk4pl78uV3TaVqzUJqv/+O3pIDO67qQuPp47fVadhnr2biPSWirMQq52nEutOVK1fWjZgOCXnSZNahQwdZtixlE2xWgoBXZ+p78tnan41e3qLiK6pCuOxo0hRFmoUH14tnNndpUKaaOp/bI6fULFZBFyw15+5ck0NXT0urSnV12wp455ar9580gaM53MXJWfw8fNT5ni83S/odBwxvizJOKZ9CUsgzj/x5YafB9ojYKFl6dquqQqJZunHR6hKbEC9rLu012O9/57aLh2t2eaVARXU+bw5f9fP6g7u6fW48CJK87knbtSrj7H9XSlhMJJ/KTLRn62UJuBwi/UfVMRkY4fCeAHFydpQ6jYobbG/YrJREPYyVE0eT/maDg5KePzRda/zyecj9e0lfHmHhrMOqudrDy80M94go6+Dk3jYWGlFNjI1NqmZhGcGTJ0/qLnNzc5Pr15/07cqKjgaclb2XjqtwZ0yF/MXl8r1bEh0XY7D9/J0AFSZfKJD0AVM+v796LE8HXk1xG6cCr+j2g+DIcMmZw8OgiRxzY4Y8DFf9Jz9r/o6MXfOTJCSyg7C5eLnmUD/DY5580GvOBl9T1d9i3vmljE9hCQi/I9HxhhVfNF3j+S/jW0SdD41O6iPn5fqk75q3m4eEPEpabalB4ReleM4CMjdZP0gyv/3br0qxkr5SunzSDBHx8cb/rhAs8xX0Elc3w0YhNGU7OTnItctJ/ZI9vZOCYETEk/eEiAfR4uWdTf37yL7rcjMgTFp1fMFs94mIsj6rDI2FChWSs2fPqn/Xrl1b5s+fL9u3b5dLly7Jjz/+KMWKFRN7ltfLV+5Fhhq97H5EmOp3qPbzTKoo3YtIuS+2afvBrov/StvK9aVq4TJS2CevvF+vnRy8ekqFkP713lT9HNEE3q9eOzky+lc589lSmd5+iLg5m66SUPpcC7+jazJOLuhhmPrp7eYuuXPklOBH4UZvA4Ndcmf3Vv8OeHBHbkXck76VWkieHD5Su8ALUqtABTkYeFpdPrpmV/n26HJVvZzeYKDs7TxLDYhpXrwWnzozu3TunuTO6yFzZ+yXt1stlravzJNeLRbLz9P2q7CnQR9Hr8eBUB+6jWCwS1jwI3U+bwEvyZ3HXVYvPSHB9x7Kf0duycljgVK+cj7VvWTR7MPSsXdV1edx+pc75N03/5CP3lkle7de5nNNlExCQqJZT7bMKvs0Dhw4UK0xDT179pQ9e/aofo14o8yTJ4/MnDlT7Jmbs4vJfoUx8bFqMIy2n7YtxX5xT/aDKZt/k7olq6j+lHA9+I60+WmEeLjlkDFNekqX+Z9Jm8r1ZUrbD6TLL5/JzdC7sqjX56of3pDl0810T+1LUFSorLu8X/pVai33HobKloCj6rmr5FdC+lRMWgXpUVyMuDq6SMzjAUzJIeRnexzk4xLiZfjO2fJD46HSrlR9tW3jlYPyx7lt0rpEHVWB/O3MZpnz2nDxcnOXdzZNlBdyF5cfG38ozVaMkBP3GCjMBWEQzcuFi+WUvkNrqUrixTNBaiT1yX8CZdovbVSzdGxsvDi7JL0XJod+jRgMo/7t7CgDRteVqZ9uk52bLqltNesVlcYtS8vuzZdVEH2jTVmZNHqrREREy5hJr8nl8/dk8tht8k1BLylZNrfYEtxfe+Hk5Gjwk8iSrDI03rhxQxo1aqT+jaUElyxZIhcvXlRN1iVKlBBXV/uubkXHxYpntqSmzOTQhBkVG63bT9uWYj/nJ/tpzdN1pr6rBuDkcM2mmroROj5r3kdO3LokW84ekpX9JsuaE3tkzX+71XUwvc/ENv0ZGjPQsB0zZUq992VcnT7ytcO7atvFkBty+HZS5f1+VJjEJMSKh4vhCFsN+qEiWGowCrvqwt5S3LuAqkLejgwWJwdHGf5SZ5l6ZKm4u2ST14pVl67rxsnZ4AB16lmhibQv04Ch0YziYuNV/8IufZP6H0P12oVViJw4Zqsc2hsgteoXExcXJ4l6GGPiNhLETa/ZGtdfuK6raoZGs3SuPO4SH5cgv/10RLq+W00ePYyVQ3uuyeczmqimcZzW/++MbFt33uZCo4+P/U0X5OVl/G+eMh5HT9tYaJw2bZpUr15d9WfUlCxZ0qLHZE3QVOyfq4DRy3zdvSToQahuP21AzOV7Nw32w7YgI83W+oNhcrl7y7BGneX17wep8wiUmONRf9+cOTzVKfRhUj85ej4PYh5Kvy3fiO+eOVLEK5+EPnogV8NvywdV2klwVLjcirwv96LCpIhnXqPXz+nmIfeTNV2j7+OZ4Cf9YzuXbawqlX+e3ykVchVTI+Mxz6MG/y7skYdPpRnl8HCVsJCkpmV9NeoUEUy9eONqqEh9EW/fbHInMOXfFpqcMcejl09Sn0UNKpb+pXLpzv+9+py4uDrJq01KyZUL9yUxUSSP3mCZPPk9dPND2pKQEPsZuIUKIwJjeHiUyb6vWZU9fjmwdlYZGv39/VOsO01PnA68Ip2rv6aqhfrN1KXyFFbbTgUmNSuevn1F/Syfv5gcunrK4CEsn6+YnLr19ObHMU16ybZzR+TglaTrOjo4iJPjk6YyJ8ek5hI0UVPGCn70QJ00rUq+Iuuu7Ff/vhByXdqUrKv6ImKaHQ2qiagqnw8OMHm72ZxcZWj1DvLx7jmSKIm6yaExYErj6OCkgguZT9ESvnLtUsqFC2Ki41Wwy54jqXWgiL+P7Pr7kprgG+FPc+t6mJq2p0jxJ/2Sk4t+FCdL5x+TfsNfEUdHBzUiFBLin/SpQv8q/GdrcN/tDQKjPd5vS9D+Viglq+wk0a1bN/n996T5AimldSf3ipuLq3Ss1thge/eaTSUyOkoFPcBqLoevnlbb9SFc1vSvIGtPGk7Zoq+QTx55r24bNWJaExB8R0rneVL9LZu3mEQ8eqhGWJP5DKjSVkp4F5RZ/65U57dcO6om/W5Vso7Bfm+Wri8PYx/JnpsnTN5W74rN1OCYjVcPqfO3Iu6rnyW8n1SuMQ/kzYh7Zro3pM21eOrf22r1Fn07N11Ugb1yjYLqfPVXCqtm6N1bkvoparavvyhu2ZylcjXjLQ6wdvkp8cvjoZq5AQNv4Ob1pEFV2gTjfo+3E9GT5mlznmyZVVYa//33XzVaetCgQeLtnTQSNLlx48ZJVl4+EBXDor75dZVCTIeDfofXQ+6oSuPiw5vUii1FfPOp8y/7vyBDG3WSrzb8Ig8ePZmyBSu8rB8wTZb3Ha/mdUTz9YjXu8n5O9flt4MbTR7D5837yJ//bDeoRi45sll+6TFWRjfpKbfD7svw17rK4sN/m/nRsC8+bp7SqWwjuRIWKL7ZPKWJf02pV6iyfLB1hlwLv632wXKCf13YpSYCxwTe59WKMKWlb8WW8u2x5WpeR2M8XXNI/yrt5L2/p+i23X8UJrtvHJfRNbtLDpfs8kJufymXq6iM3DU70+6zPXqjdVnZvPqcfDFsk7zZvbL45XNXK72sW35a2nSppPo2QtHivlLv9RIye/JeCbodIYX9k1aEWbXkhBoNjWZuYyIjYuTPhcdl5ISkvuGAicQr1yig5mtE/8bL5+/LtUshMmDUk/laiYiexiERnWOsTPfu3VPdZ9GiJ0vlPSuH918Wa3Tlq7+Mrgjz6/518vbCpLCMqW4+b9FHutZ4Q02dExByR37c9ZdM27o4xfVaVqornzR9W83LiMEvG04dkOErvpfAsHsmV5zBKOoKX3Y26OOIpsxPmvWWd2q3FHfX7LLx9AHpv2SyhD+y3v5FibMPSIEf24qtyJvDR7Z1+FYNUAl6GCp7b52UH/5NWipQHyqNH1bvJO1K1ZNc2b3lZkSQLDq1SX76b7XJ2x5Ro4u8mBcrxHxhsD2fu69Mrve+WvMa/SEx2fdvZ2zvy8Ctfn/J+dCpYisehD2SRT8ekf07rqr+ifkLe0nLDi9I03ZJq19pYqLjZPHcY7Jz40UJDYlSlUHs06ZLRYO1p/Ut+vGwnD8VJOO+T5qUX3P/bqRalhArw2C5wrZdK6X4fdaudM6PJCjIfvpQY6Q4+vahH6e9NU/7+T3pf5uZLtSsYNbbL3XQsLuYLbHK0JhZrDU0kv2GRrKf0EjPhqHRfjA0Wh+r7NPYo0cPuX07qSkuuX379ql1qYmIiIgyGpcRtLHQeOjQIYmKMt4vK0eOHLJ58+ZMPyYiIiIie2aVA2HAVF+dAwcOqPWniYiIiDKarY9wtovQ+Ndff6mTFhhHjBgh2bI9mbg2ISFBwsLC1PrTb7/9tgWPlIiIiMj+WE1oxNQ6RYoU0TVP58+fXzw9DUdO4TzWpX799dctdJRERESUlWHSe7Ly0NiwYUN1gnz58qkJvnPmTJqrjIiIiIgsyyoHwrRr106OHz8u8fHxuqbpxYsXy/jx49XoaSIiIiJzSEgw78mWWWVonDp1qpq828kpaa3Vb7/9VgVGBMn3339f/v7b9iYeJiIiIuvH0GhjofHIkSPSoUMH3fnly5fL8OHD5Y8//lADZObMmWPR4yMiIiKyN1YZGjFKWhsUg9HSISEh8tprr6nz1apVk8uXn6yHTERERJRRWGm0sdCIgTBaMNy1a5fkzp1bChQooM5HRERwnkYiIiIiex09ra99+/byxRdfyNatW2XHjh3SqVMn3WXYVqpUKYseHxEREWVNnHHHxkJjnz59xNXVVY2UxtQ7AwYM0DVb//PPP9KzZ09LHyIRERGRXbHK0Ag9evRQp+QTgC9dulR3ftasWaoK6evra4EjJCIioqzG1qfFsbs+jWmF0BgcHGzpwyAiIiLK8qy20pgWiYlc6oeIiIgyDiuNWbTSSERERESZw6YrjUREREQZiZVG0xgaiYiIiB5jaDSNzdNERERElCpWGomIiIgeY6Uxi1YaHRwcLH0IRERERHbBpiuNnHKHiIiIMhIrjVk0NGJJQSw3SERERER2FBo3bNggmzdvFi8vL+nbt68ULFhQnZ8+fbrcvHlTihUrJkOHDpVXX31V7c/ASERERBmJlUYb6NO4cuVKGTZsmISHh8ulS5fUmtInTpyQ0aNHS6NGjdRPf39/GTBggBw/ftzSh0tERERkV6ym0rhgwQLp16+fDB48WJ3/6aef1L/79+8vvXv3VtsQJMeNGyffffedzJs3z8JHTERERFkNK402UGm8evWqNG7cWHe+Y8eOcuvWLalatarBfs2bN5fTp09b4AiJiIgoq8MgW3OebJnVhEb0T4yLi9Odz5kzp7z++uuSP39+g/3c3NwkJibGAkdIREREZL+spnm6ePHicvDgQalcubJuG5qhk0M/xwIFCmTy0REREZE9YPO0DVQaW7ZsKZs2bXpqFRFl3aVLl0qtWrUy9diIiIiI7J3VVBq7dOmiTk8THR0tY8aMkRIlSmTacREREZH9YKXRBkLj4cOH07x04OXLlyVXrlxmPyYiIiIisrLQ2L17d91a0qmNLsJ+Z86cyaQjIyIiInvBSqMNhMbatWvLoUOHpEWLFipA5s6d29KHRERERETWFhrnz58vZ8+eVT8RGjEfIyb1xiowRERERJmBlUYbGD0NZcuWlcmTJ8v69evFw8NDOnTooFaJOXLkiKUPjYiIiMiuWVVo1OTLl09Gjhwp27dvFx8fH1V5xNrTREREROauNJrzZMuspnk6OfRvxPrS+/btkzZt2sg777xj6UMiIiKiLM7Wg53dhEaMmt64caPMnTtXAgIC1PrTX375peTNm9fSh0ZERERk16wmNP7222+yYMECiY+Plx49ekj79u3F3d3d0odFREREdoSVRhsIjV999ZW4uLhIlSpVZNeuXer0NBhlTURERER2FhrRb1Gb3JuIiIjIEhKevr6IXbOa0Dhx4kRLHwIRERERWXtoJCIiIrI09mm0sXkaiYiIiMi6MDQSERER2cjk3jt37pR27dpJxYoVpW7dujJ9+nSJi4tL9XorV66UZs2ayQsvvCCNGjWSX375Jd2/m83TRERERDbg5MmTMmDAAOnTp498/fXXak7rcePGSWxsrIwYMcLk9bZu3Spjx46V4cOHS82aNeX06dPqeq6urtK1a9c0/36GRiIiIiIb6NM4b948qVOnjgwZMkSdL1eunJrfetSoUdK/f3/x8PAwer2ffvpJLZjSs2dPdb5s2bJy7949tT09oZHN00REREQ20Dx98OBBFRr11atXT6Kjo+XYsWNGr/Pw4UM5ceKE0evduXNHLl26lObfz0ojERERUSZp1KjRUy9HU7IxERERcv/+fSlUqJDBdlQXc+bMqZqqjbl+/bokJCSkuJ52HtcrUaJEmo7drkNj4uwDlj4EygS3+v3Fx9lOlM75kaUPgTKBn5+n3T3OPj5cVjezdEk8Z9bbn5dKaDQlMjJS/cyRI0eKy7DsMkKlMdr25NdD2MSiKqauZ4xdh0YiIiKizLTVRCUxsyUmJqpTerBPIxEREZGVc3d31/VRNFaFNDUIRtue/HraeVPXM4ahkYiIiMjKeXh4iK+vr9y8edNgO5qXQ0NDpXDhwkavh76Ljo6OKa6nnS9SpEiaj4GhkYiIiMgG1KxZU3bv3m2wbc+ePeLi4iLVqlVT54ODg+X27dsGFUpM6J38ejjv5+cnxYsXT/PvZ59GIiIiIhvQu3dv6dy5s8yYMUOaNGmiRkZjkm9s05qZBw8eLIcOHZJz554M6Hn33Xdl6NChqqqI4HnmzBn54YcfZNCgQWowTFo5JKa3FyQRERERWcT27dvl22+/lYsXL6qpdlq3bq2CIlZ3ge7du6cIjfDnn3/Kzz//LDdu3JA8efKooNm3b990/W6GRiIiIiJKFfs0EhEREVGqGBqJiIiIKFUMjURERESUKoZGIiIiIkoVQyMRERERpYqhkYiIiIhSxdCYQUaNGiVlypSRhQsXmpyQE5cfPHhQnY+NjZVp06ZJ3bp1pWLFitKuXbsUs7Wnxa1bt+T777+X8PBwMRcc96pVq4xehvmgPv7443TdXsOGDWXWrFm68yEhITJkyBB56aWXpHr16rJixYrnPmYioud9n168eLF06tRJTYZctWpVadOmjaxcuTLDH9itW7dm+PsejnPLli1iLnjvx4nsC0NjBsIyPgsWLJD4+HiD7WfPnlUTbeqbOnWq/PXXX/LJJ5/IsmXLVHh8//331Szt6Q2NM2fONGtoNLdvvvlGLl26pCYrnT9/vgqOWf3DSF+LFi1MhnKyvef2119/lY4dO6qggWW9EDqe5Qthag4fPqx+V1ocOXJEHSMm9X2a8uXLZ/kvbel5n/7f//4n9evXlx9//FE9/6+++qp6Paxfvz5Dj2nbtm3q88CWQuOkSZPUiewLQ2MGwjdRvBFt2rTJYPu8efOkWbNmBouL//777zJ27Fh5/fXXpVy5cmp5n5dfflnmzp0r9ubYsWPqg7VWrVpSqVKldC2ebqsfRlqFFRXXCxcuZOJRkrmfW6y60LhxY/npp5/kl19+US0J7733nnqdZ3RoNBVk6fnfp2HJkiXqyzyug+cRLSKvvPKK/P3333b/EBcoUECdyL4wNGYgJycn6dGjh0Hww6Lh+LanX8Y/evSoxMXFqTcfffXq1ZMDBw6k+fehatC1a1f170aNGqlKgn414fjx4+r3Vq5cWWrUqCEffvih3L17V3d9VBRQWdi/f7/aD4EN36SXL1/+zI8BmnOaNm0qVapUkRdffFEtb4Rv609rqkaV8csvv1THjvP28GGEqgK+JKC6SlnruUVoxNJc+BvA3xS6b+Dn0/4OyPrep8HNzS3F9WNiYsTLyytdvxOr9eL3vfHGG+q1gJYlFApu3rypuhfhtYEvH9p7uHYc+DlmzBj1ntyqVSt54YUX1BeRzZs3q/N4j8XrDO+5WB5OWxUY1VC8r+N9RrtNbNOOBa9bHAuCMAoXaK3C/dI8fPhQPvvsM9VlCNVyfM6gC1WvXr10++Df2m3qv/ZbtmypbhefZyNGjJCAgIB0PVZk3ZwtfQBZTYcOHVT1COEPoQDVCfxB+/n56fbBHxHWi9QWF9cUKlRI7t27J5GRkeLu7p7q78qbN69q5v7oo49UMxXWktS2nz9/Xr0xYkFzrEkZFRWljgvb8EaSPXt2tS8+CKdMmSL9+vVTf+D4Bo0m86JFi6o3jPTC7WJh9BIlSqjze/fuVRXVfPnySZ06dVLsj+PGGxKOE9VGVHSywoeRFiS0DyNUhPSboBHy16xZo/6NN9lnhS8IuC2ETzzWeP7QXxZN3ggrCPF//PGHOg58WE2YMEEKFiyou/4///yjFr7HFww8d/gQGjlypK7aiw8nfKjh9yQkJEj+/PnVh0efPn10i9zjg61w4cLqgwIV9OvXr0vp0qVl3LhxUrZsWckK0vPcauu/6sPr/86dO+n+vfhih5CA9wy8J+A5RLXr9OnTui8cCASA5xXNnIDmUzxvCCXFihWTChUqpLhtdIX5+uuv5b///pPcuXOr8KCFDg26vUyfPl29DtBCgtvC3zceg/v376um24kTJ6rXm75Bgwap1+Hs2bPFVt+njbUMoCvRlStXZPz48en6fYsWLVKVZwSx4sWLq+cTQRDv03j/Q2sDuhppzb3a+zPgtRUWFiajR49WrwFvb2+15nCXLl3U3xfeM/H3i79thFl0jRg2bJhcvXpVcuXKpf4Nnp6e6ieec1S9hw8frl4zOJbJkyeroIjPAMBrDMf2+eefq/cCvFbQRP+0sIzQitfkBx98ILVr11aPFyq16Bphq61HlBJDYwZDEMQfLb7J4Vsh3hjwoa0Pb745cuQwel3t8rSERrxZ4EMc8KGN0KnBGyI+uPX7nKDiiDd5hEa84WgfhkuXLtV90OGDHx9I+KDSD434Rok3reQQOvXfENq2bWtwOT7k0MkbgcZYaMR1cT98fHx0QdOWpfXDCG++6a1WPA0+jPBhjtcd+tbhQwABAiHwq6++Uq8p/MQHC6oKWmDElwU0v+GLR3R0tAp9b7/9tqxdu1Z9cDk6Oj71w0mzevVq9WUHXzjwmsKXGXzwILzgNrKCZwka2t8IghnCfXrg7+bTTz9V4R/VJISKdevWqZYKVJnwQb5x40Zdv0btCxeqoWhVQLUTvxPPS/J+igj2CPvodzlnzhz194/7pR8aUXnCawF/o3g+8ZzjNYP3Arw/4b0ELQOoLumHRoQFvPa015mtvk/rGzhwoPpChuZYvAbwfpse+/btU9VF7XFCCw++KCNY43lDoMPfm7H3wAYNGqR4LPGlXh++FODvHu+zuF8oIGTLlk3drv5tamF1165dKnwCukfhOPBaQ2jE62Dnzp3qNaN92cBjhNcdvigZ8+DBA/nhhx9UgQKvOw1eIwijlHUwNJoBKhJ4s8aHNEr7+KM19cemL/m3/OeBpo6ePXsabMObPkIE+kJpodFYZQQfJAiS+tCUgqbr5JIHSVRKETjxO1DlwAfWo0ePpGTJkmIP0vthlFHw5UB7fvB70dyFChSqiBpUHvQrPxiAhIqQ1sUBEE4wEAkDN1B5Sh50kn84aRAe9Jva8eGB5iu8BtL7AZvVnltUp/D33759+3QHDTzenTt31n244/nQgga+aOGnfijAewi+MGjVJv2/ca2yDQg+qH4ijGgVY7w36IcT7I/Aj0qjBmHn3LlzqoKEQID7hC8reJ61Cjauh8olmiezyvs03ufwekZoRpBGpRHNu2mFL/CoNmKgHx43VBvxuKelZUULd/rwJRBfWvB3iC8AOI/32dQGEaLJGvuh/7g+vG7QkoDqMfbBFwVj1WlT8LigNctYq4mxAgnZLoZGM0DzML5RoqKHNwpjHz7Gvn1p25I3Wz+L0NBQ8fX1TbEd2xDsngbhEm8eye8T3vie9oaANyN8wOFDDW+wCC14w/viiy/Enjzrl4bnkfw1g2Yp/SYuwAc5XheofOE5QhMVTmiu0ofLr127lq4PJ63pS6N1kA8KCsoyofFZnltUA9F8ixBt7O/nabA/vrx999138tprr6nzqOI+LWjgeUNXguTNxcnt2bNHdQfRAqOp0HrixAkVFPUhXCD0AFoP0NqBqhSqcYB/v/XWW1ZfYU7tfdrYoA885/gbQpBOT2gcMGCA+ptDaMQXPLwPI3DjS5uzc/o/hlHNu3z5sgqw+AKDLxBoPsaxPU1wcLDqGmXq/uL9Gu/9qVXPk0N1WXuPoayNodFM3nnnHfXTWL9AfIvDH3fyvov4to4P+7Q0TSeHN/LkwQ9vEMlhW2rNohgsYyxwpgbNGmj+QB8c/b5sycNLVpeeDyNzwQdR8sq19uGE7egjhXCIZm1j1Qntzf9ZP5wQboy9Lu3puUXfN7wPoP8fRk+nF0IFHmdUM9H0hy8G+N3oc2qqeqP9zeM4U/uQT20f3BYG6+H3Jae1TiB0IiCiso2+bKhCoi8cXiO2/j5tCiqqeK9ODwyoweOIE0I9+sKiyR/PgVbpTz4y3xT0f8SXPbwmMEpfg/f15H+XyW9T2wcB2FRxAu/96IaSHlo1FIEztdcV2Tbr/ipow0qVKqUqDMagGQgf4Pi2rw9NgmgaTg8tACZ/s8Bo6eRzdOFDAP1ScJkp+JBHPyl0ZE4vfJM21t8GzRb2Bh9G6N/5LIOJMgM+MPCBj+cbFazkJ3xwaB9OqESi7yOqSmiyysi+mFn1uUXQRvcQ9GNDVfJZoFKHsIn+gXhv0OYHxAAXU6EAXzoBXwqeBs9vanO7onqMcGns9YEBMZo333xTVVtRmUT/RtxnNH3b+vs03reMfelB9wz9+58W+u/P6HuOlhhUcPHFAvA3ldpzlvx9NvkxJH+fNXab2mvW2BcerVqIrkQ4ruQtUujzbAr6rqMCjs+O5PRHZZPtY2i0ALwZo2kIHyYYlYi53tD3DCESFZ30QEDDBwBWl0Glb/v27aoJEYMbcLv4ZovRa/jQQd8jNDvoD1bBmyL6uaFPCt4MUS1ApREhIb3QHw4VEISMU6dOqfuDUbYYBGBvnvZhZA1QzUblEKOrMf2TPgQRdGxP64eTvUntucXfXbdu3VSfUOynVV3TSz9oYGADKo8I7uibqoUCBD/9ijKaivH+knzqruThEl1Hku+T/HWAL7D4O8YXTVMBA1BZQj89VETRnxEDhrICvG/hvRL9N0+ePKkeB8wIgIFGGOSVHng/RbM0+nrj9YEBZ+i6gMdNe+/E1GPaezG6g5iCUIfHHH2ScYzov46BbBs2bDDYD7eJII+/cdwmPgfw2sXrCF0etOPBbaAvqzbNDwbooAkb9xG3jeuhTydu31R3BnwG4fr4HMIMA+jWgM8cdFnAoBvKOtg8bSEYpYYmHvT3w4cD3gjQ3IBvbOlt9sCbB4IaQiE+XPAmgW+xGFWJP2KsWIHfhQoA3hz0m7/xJoB+Z3iDQCUSI6zxLfRZ+qEhkCL8opM4Rnmi3xP6gCX/MKKkb9/oG6jBvxEA8G09s5rzMeUGqmYIOAj3qICgaRGvG3wIodla+3DClxAcIwZ14MPDFlftyQzaqGQMSkL/XlQc9aFZMK3PL0azIhiieRsfynhu8EGM500LBegHjb99jOJGVQkDktDciYEu+OBHZRiBB+8t+lDpwnOPvnnoL4npgDBlin64RAURQRDVTvTJxHsDutRgZD3+pvVnZkBQRDDC68XYgDlbhP6qaJX57bff1Mh1vIfifRWBD61F6YH3QYRP9PfE376/v78asIT3ZMAXDBQM8N6L0IXzyefx1eA48D6OmQpwu3ivRhDEe4f+ij8Y7IjWArwn430er0f83WJOXIRHdCnAfcMXfbxO8B6g3T66F6DrCj47UDVGFwS8xp72Xo7PNHwG4DWD34l/a8vkUhaSSHbrzz//TCxXrpylDyNLGDlyZGLPnj1NXh4YGJhYunTpxAMHDugee5xPfsLtpMf169fV9Q4fPmywHceS/LY2bNig9o2NjdVt++effxL79u2bWL169cRKlSoltmjRIvGbb75JvH//vrr8+PHjia1atUqsXLmyumzBggWJo0aNSuzWrZvuNvDvMWPGpOm4svpzi5Ox51U7ac9/WuzevTuxT58+ibVr11bPTfPmzRN///13g33mz5+fWLdu3cQqVarojjE6Ojrxiy++SKxWrZo6DR06NHHFihXq9+N50eC26tWrl/jCCy+o53Dfvn3q/QCvTU1YWFjiV199ldigQYPEChUqqP2HDRuW4nmNi4tTl82YMSPN949sS9u2bRNnzpxp6cMgC3PA/ywdXMkQvomiipCa/v37q+bkZ4VvvZh4G/MyEhGR9b1PWwKmTUN1G90d0B0FrQuYNxRVZg50sW9snrZCaGbAYvOp0Tq9U9aDOe5SmxqpTZs26V6ZgiyPz23WkJXfp9Ecj+CILkvoAoXmeDSdMzASK41EVgh94VLrC4ppLvgmbnv43BKRrWJoJCIiIqJUccodIiIiIkoVQyMRERERpYqhkYiIiIhSxdBIRERERKliaCQii8Pyc1iqzNhav5kBK51gaT0spUlERMZxnkYisjgsPYb57BwdTX+PxZxxmJsy+dJlLVq0kOXLl6vl9DCnHGC6IiyVtnTp0hQTMhtbzwDbAettR0dHp7gcy7BheTUiInvG0EhEmQaBTQtomsDAQDly5IhaB9dYYEOQxETKWKFi165dRm8Xq1aULVtWFxKxfvbq1atT7If1lg8dOmTy+HC5MQULFpRt27alev+IiLIyhkYiyjQ3b96URo0aGb2sa9euRrdj/1mzZsnQoUNl9+7dBpdhmTM0bd+4cUMFO2POnDmjlsz8+OOP1flPPvlEunXrluZj3rhxo0yePDnN+xMRZVUMjUSU6f7++28pWrRoqvuNGjVKwsPD1b+nT59udJ9Hjx7Jpk2bVBjUb07WKppXr16VEydOGFxn6tSp8vPPP6f6+/v27SvVqlUTHx+fVPclIsrqGBqJyCYgPHbo0MFg2xdffCE7duyQ6tWrS+PGjXXbq1atKgsXLpSGDRuqfopaszOardHcjVD50UcfGfSXrFWrlvzvf/+TihUrpvjdDRo0MOt9IyKyBQyNRGQTvLy8VFNxcuXKlRN3d3eDbZUqVZKtW7em2NfJyUlXncTlCJXZs2c341ETEWUdDI1EZBNCQ0OlefPmBtumTJkiR48elZkzZ5q8HqqMGGWtLygoSIYNG6YG1jA0EhGlDUMjEWW6119/Pc37agNncubMKTt37kxROXz55ZfVqOx///1X5syZo7sMcz7WqVNHKlSokOI2tVHa2hQ9mrfeeivFvh988IEMHDgwzcdLRJRVMTQSkU0MhAFn55RvWeif2LZtWxUYMVJa65OIUdUIk8ZGa9+9e1fdFpq89Znq00hERFwRhohsxL59+6R8+fLyyiuvqBMqiOvWrVOXFS5cWE3Zg8EtaMbG3I/jx49X57Nly5bits6dOyf58uV76mTiRERkiO+YRGQzMBfj3r171cnf39/gsg8//FBNjdO9e3fp0aOH6v/YsWNHk5VOzO1obAJwIiIyjqGRiDKdtlxfaqf4+Pg03yb6MGI09MWLF+X69etqnsZbt26l2A8rwpw8eVIGDx4sY8eOlQULFqhlB4mI6OnYp5GIMl3yUdBPo98nEdVBzMkIkZGRKlSuWrVK9u/fL9u3b5fcuXPLkiVL5MGDB2qyb6xJ/dJLL8mgQYPUJN33799X/ST79+8v77//vpquB/th/ka4fPmyqmZi0A2bromIDDE0EpHVDoT59NNPJSIiQne+UKFCsnnzZoN96tatK8WKFVPLBCKManMxor8jQiPWtPb09FQBE03XCKHvvfeebtLuLVu2qEEzWKIQg2lQfUQl1NXVVd0WKpgIkAcPHlTbiIjslUMihhcSEdkoNEM/LczhLQ4jrLUlBREwnwb7Y/JvBEcETZxHePT29s7wYycisiUMjURERESUKg6EISIiIqJUMTQSERERUaoYGomIiIgoVQyNRERERJQqhkYiIiIiShVDIxERERGliqGRiIiIiFLF0EhEREREqWJoJCIiIqJUMTQSERERkaTm/70BG82YxwMOAAAAAElFTkSuQmCC",
"text/plain": [
"<Figure size 700x600 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# 対戦カードごとの黒勝率ヒートマップ\n",
"df2['black_win_rate'] = df2['black_win'] / df2['games_per_matchup']\n",
"\n",
"pivot2 = df2.pivot(index='black_filter', columns='white_filter', values='black_win_rate')\n",
"\n",
"order2 = ['M0_topHalf', 'M1_mean', 'M2_stddev', 'M3_strategic']\n",
"pivot2 = pivot2.reindex(index=order2, columns=order2)\n",
"\n",
"fig, ax = plt.subplots(figsize=(7, 6))\n",
"sns.heatmap(pivot2, 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_move_filter.png\")\n",
"plt.show()\n",
"plt.close()"
]
},
{
"cell_type": "markdown",
"id": "e0a7db6f",
"metadata": {},
"source": [
"# M3 の内部フィルタを比較する\n",
"\n",
"前回の実験で M3_strategic（X/C 除外 → 上位半分 → 角強制）が圧倒的に強かった．\n",
"一方，X/C を除外しない M0_topHalf（上位半分）は最下位だったことから，\n",
"「X/C 除外 + 角強制」は有効だが，残った安全な手の絞り方として「上位半分」が最善かどうかは未検証である．\n",
"\n",
"今回は **X/C 除外と角強制は全設定共通**とし，残りの安全な手に対するフィルタ方法のみを 4 パターン比較する．\n",
"スコアの統計量（平均・標準偏差・中間値）は **X/C を除外した後の安全な手のスコアのみから計算**する．\n",
"\n",
"| 設定名 | X/C 除外後のフィルタ | 備考 |\n",
"|--------|---------------------|------|\n",
"| **M3a_topHalf** | 上位半分 ⌈n/2⌉ | 前回 M3_strategic と同じロジック（比較基準） |\n",
"| **M3b_mean** | 平均スコア以上 | 平均以下の手を除外 |\n",
"| **M3c_stddev** | 最大値 − 1σ 以上 | 局面の難しさに応じて絞り込む |\n",
"| **M3d_midpoint** | (最小値 + 最大値) / 2 以上 | スコア範囲の中間点以上 |\n",
"\n",
"全設定とも X/C 除外後に手が残らない場合は全合法手の上位半分にフォールバックし， \n",
"合法手に角が含まれていれば結果リストに強制追加する．"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "45450ad6",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"読み込み: ../csv\\compare_20260504_172503.csv\n"
]
},
{
"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_filter</th>\n",
" <th>white_filter</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>M3a_topHalf</td>\n",
" <td>M3b_mean</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>6</td>\n",
" <td>3</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>M3a_topHalf</td>\n",
" <td>M3c_stddev</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>5</td>\n",
" <td>5</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>M3a_topHalf</td>\n",
" <td>M3d_midpoint</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>6</td>\n",
" <td>4</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>M3b_mean</td>\n",
" <td>M3a_topHalf</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>7</td>\n",
" <td>3</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>4</th>\n",
" <td>M3b_mean</td>\n",
" <td>M3c_stddev</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>4</td>\n",
" <td>6</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>5</th>\n",
" <td>M3b_mean</td>\n",
" <td>M3d_midpoint</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>4</td>\n",
" <td>6</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>6</th>\n",
" <td>M3c_stddev</td>\n",
" <td>M3a_topHalf</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>2</td>\n",
" <td>8</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>7</th>\n",
" <td>M3c_stddev</td>\n",
" <td>M3b_mean</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>4</td>\n",
" <td>6</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>8</th>\n",
" <td>M3c_stddev</td>\n",
" <td>M3d_midpoint</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>4</td>\n",
" <td>5</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>9</th>\n",
" <td>M3d_midpoint</td>\n",
" <td>M3a_topHalf</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>6</td>\n",
" <td>4</td>\n",
" <td>0</td>\n",
" </tr>\n",
" <tr>\n",
" <th>10</th>\n",
" <td>M3d_midpoint</td>\n",
" <td>M3b_mean</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>2</td>\n",
" <td>7</td>\n",
" <td>1</td>\n",
" </tr>\n",
" <tr>\n",
" <th>11</th>\n",
" <td>M3d_midpoint</td>\n",
" <td>M3c_stddev</td>\n",
" <td>gemma4-osero-e2b</td>\n",
" <td>2026-05-04</td>\n",
" <td>10</td>\n",
" <td>6</td>\n",
" <td>3</td>\n",
" <td>1</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" black_filter white_filter model date \\\n",
"0 M3a_topHalf M3b_mean gemma4-osero-e2b 2026-05-04 \n",
"1 M3a_topHalf M3c_stddev gemma4-osero-e2b 2026-05-04 \n",
"2 M3a_topHalf M3d_midpoint gemma4-osero-e2b 2026-05-04 \n",
"3 M3b_mean M3a_topHalf gemma4-osero-e2b 2026-05-04 \n",
"4 M3b_mean M3c_stddev gemma4-osero-e2b 2026-05-04 \n",
"5 M3b_mean M3d_midpoint gemma4-osero-e2b 2026-05-04 \n",
"6 M3c_stddev M3a_topHalf gemma4-osero-e2b 2026-05-04 \n",
"7 M3c_stddev M3b_mean gemma4-osero-e2b 2026-05-04 \n",
"8 M3c_stddev M3d_midpoint gemma4-osero-e2b 2026-05-04 \n",
"9 M3d_midpoint M3a_topHalf gemma4-osero-e2b 2026-05-04 \n",
"10 M3d_midpoint M3b_mean gemma4-osero-e2b 2026-05-04 \n",
"11 M3d_midpoint M3c_stddev gemma4-osero-e2b 2026-05-04 \n",
"\n",
" games_per_matchup black_win black_lose black_draw \n",
"0 10 6 3 1 \n",
"1 10 5 5 0 \n",
"2 10 6 4 0 \n",
"3 10 7 3 0 \n",
"4 10 4 6 0 \n",
"5 10 4 6 0 \n",
"6 10 2 8 0 \n",
"7 10 4 6 0 \n",
"8 10 4 5 1 \n",
"9 10 6 4 0 \n",
"10 10 2 7 1 \n",
"11 10 6 3 1 "
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 最新の CSV を自動選択（Stage 3 用）\n",
"csv_path3 = sorted(glob.glob(\"../csv/compare_*.csv\"))[-1]\n",
"print(\"読み込み:\", csv_path3)\n",
"df3 = pd.read_csv(csv_path3)\n",
"df3"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "a7d9425b",
"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>filter</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>M3a_topHalf</td>\n",
" <td>32</td>\n",
" <td>27</td>\n",
" <td>1</td>\n",
" <td>60</td>\n",
" <td>0.533333</td>\n",
" </tr>\n",
" <tr>\n",
" <th>1</th>\n",
" <td>M3b_mean</td>\n",
" <td>31</td>\n",
" <td>27</td>\n",
" <td>2</td>\n",
" <td>60</td>\n",
" <td>0.516667</td>\n",
" </tr>\n",
" <tr>\n",
" <th>2</th>\n",
" <td>M3d_midpoint</td>\n",
" <td>29</td>\n",
" <td>28</td>\n",
" <td>3</td>\n",
" <td>60</td>\n",
" <td>0.483333</td>\n",
" </tr>\n",
" <tr>\n",
" <th>3</th>\n",
" <td>M3c_stddev</td>\n",
" <td>24</td>\n",
" <td>34</td>\n",
" <td>2</td>\n",
" <td>60</td>\n",
" <td>0.400000</td>\n",
" </tr>\n",
" </tbody>\n",
"</table>\n",
"</div>"
],
"text/plain": [
" filter wins losses draws total win_rate\n",
"0 M3a_topHalf 32 27 1 60 0.533333\n",
"1 M3b_mean 31 27 2 60 0.516667\n",
"2 M3d_midpoint 29 28 3 60 0.483333\n",
"3 M3c_stddev 24 34 2 60 0.400000"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 各設定の総合勝率を集計\n",
"filters3 = df3['black_filter'].unique()\n",
"records3 = []\n",
"for cfg in filters3:\n",
" b = df3[df3['black_filter'] == cfg]\n",
" w = df3[df3['white_filter'] == cfg]\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",
" records3.append({'filter': cfg, 'wins': wins, 'losses': losses,\n",
" 'draws': draws, 'total': total, 'win_rate': wins / total})\n",
"\n",
"summary3 = pd.DataFrame(records3).sort_values('win_rate', ascending=False).reset_index(drop=True)\n",
"summary3"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "7666a012",
"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",
"colors3 = ['#4CAF50' if r > 0.5 else '#EF5350' if r < 0.5 else '#9E9E9E'\n",
" for r in summary3['win_rate']]\n",
"bars3 = ax.bar(summary3['filter'], summary3['win_rate'], color=colors3, alpha=0.85, width=0.6)\n",
"\n",
"ax.axhline(0.5, color='gray', linestyle='--', linewidth=1, label='50%')\n",
"ax.set_ylim(0, min(1.0, summary3['win_rate'].max() + 0.12))\n",
"ax.set_ylabel('勝率')\n",
"ax.set_title('M3 内部フィルタ比較の総合勝率(黒白合算，60試合)')\n",
"\n",
"for bar, row in zip(bars3, summary3.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_m3_filter.png\")\n",
"plt.show()\n",
"plt.close()"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "75f0e140",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 700x600 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# 対戦カードごとの黒勝率ヒートマップ\n",
"df3['black_win_rate'] = df3['black_win'] / df3['games_per_matchup']\n",
"\n",
"pivot3 = df3.pivot(index='black_filter', columns='white_filter', values='black_win_rate')\n",
"\n",
"order3 = ['M3a_topHalf', 'M3b_mean', 'M3c_stddev', 'M3d_midpoint']\n",
"pivot3 = pivot3.reindex(index=order3, columns=order3)\n",
"\n",
"fig, ax = plt.subplots(figsize=(7, 6))\n",
"sns.heatmap(pivot3, 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_m3_filter.png\")\n",
"plt.show()\n",
"plt.close()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "42dc4995",
"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は，「ここに置いたら次のターンでどうなるか」しか考えていませんでした．しかし深さ優先探索で作ったオセロAIは，三手先や四手先まで読んだ状態で次の手を打っています．
LLMも同じように数手先まで読むことが出来たらかなり強くなるかもしれません．
次はそれを考えてみます．