From 08d8adbadedc6f822c5f0f35d378237ac06aed01 Mon Sep 17 00:00:00 2001
From: FireFather <firefather@telenet.be>
Date: Wed, 24 Jun 2020 22:41:00 +0200
Subject: [PATCH 1/3] added header guards

5 include files in \eval\nnue\architectures
---
 src/eval/nnue/architectures/halfkp-cr-ep_256x2-32-32.h | 4 ++++
 src/eval/nnue/architectures/halfkp_256x2-32-32.h       | 4 ++++
 src/eval/nnue/architectures/k-p-cr-ep_256x2-32-32.h    | 4 ++++
 src/eval/nnue/architectures/k-p-cr_256x2-32-32.h       | 4 ++++
 src/eval/nnue/architectures/k-p_256x2-32-32.h          | 3 +++
 5 files changed, 19 insertions(+)

diff --git a/src/eval/nnue/architectures/halfkp-cr-ep_256x2-32-32.h b/src/eval/nnue/architectures/halfkp-cr-ep_256x2-32-32.h
index 7063f334..9f1f97c0 100644
--- a/src/eval/nnue/architectures/halfkp-cr-ep_256x2-32-32.h
+++ b/src/eval/nnue/architectures/halfkp-cr-ep_256x2-32-32.h
@@ -1,5 +1,8 @@
 // NNUE•]‰¿ŠÖ�”‚Å—p‚¢‚é“ü—Í“Á’¥—ʂƃlƒbƒgƒ��[ƒN�\‘¢‚Ì’è‹`
 
+#ifndef HALFKP_CR_EP_256X2_32_32_H
+#define HALFKP_CR_EP_256X2_32_32_H
+
 #include "../features/feature_set.h"
 #include "../features/half_kp.h"
 #include "../features/castling_right.h"
@@ -36,3 +39,4 @@ namespace Eval {
   }  // namespace NNUE
 
 }  // namespace Eval
+#endif // HALFKP_CR_EP_256X2_32_32_H
\ No newline at end of file
diff --git a/src/eval/nnue/architectures/halfkp_256x2-32-32.h b/src/eval/nnue/architectures/halfkp_256x2-32-32.h
index 9b25ee54..c79747c3 100644
--- a/src/eval/nnue/architectures/halfkp_256x2-32-32.h
+++ b/src/eval/nnue/architectures/halfkp_256x2-32-32.h
@@ -1,5 +1,8 @@
 // NNUE評価関数�用�る入力特徴���ットワーク構造�定義
 
+#ifndef HALFKP_256X2_32_32_H
+#define HALFKP_256X2_32_32_H
+
 #include "../features/feature_set.h"
 #include "../features/half_kp.h"
 
@@ -33,3 +36,4 @@ using Network = Layers::OutputLayer;
 }  // namespace NNUE
 
 }  // namespace Eval
+#endif // HALFKP_256X2_32_32_H
diff --git a/src/eval/nnue/architectures/k-p-cr-ep_256x2-32-32.h b/src/eval/nnue/architectures/k-p-cr-ep_256x2-32-32.h
index 17871169..dc761866 100644
--- a/src/eval/nnue/architectures/k-p-cr-ep_256x2-32-32.h
+++ b/src/eval/nnue/architectures/k-p-cr-ep_256x2-32-32.h
@@ -1,5 +1,8 @@
 // NNUE•]‰¿ŠÖ�”‚Å—p‚¢‚é“ü—Í“Á’¥—ʂƃlƒbƒgƒ��[ƒN�\‘¢‚Ì’è‹`
 
+#ifndef K_P_CR_EP_256X2_32_32_H
+#define K_P_CR_EP_256X2_32_32_H
+
 #include "../features/feature_set.h"
 #include "../features/k.h"
 #include "../features/p.h"
@@ -36,3 +39,4 @@ namespace Eval {
   }  // namespace NNUE
 
 }  // namespace Eval
+#endif // K_P_CR_EP_256X2_32_32_H
\ No newline at end of file
diff --git a/src/eval/nnue/architectures/k-p-cr_256x2-32-32.h b/src/eval/nnue/architectures/k-p-cr_256x2-32-32.h
index 9ce7ecf1..331cb4f2 100644
--- a/src/eval/nnue/architectures/k-p-cr_256x2-32-32.h
+++ b/src/eval/nnue/architectures/k-p-cr_256x2-32-32.h
@@ -1,5 +1,8 @@
 // NNUE•]‰¿ŠÖ�”‚Å—p‚¢‚é“ü—Í“Á’¥—ʂƃlƒbƒgƒ��[ƒN�\‘¢‚Ì’è‹`
 
+#ifndef K_P_CR_256X2_32_32_H
+#define K_P_CR_256X2_32_32_H
+
 #include "../features/feature_set.h"
 #include "../features/k.h"
 #include "../features/p.h"
@@ -35,3 +38,4 @@ namespace Eval {
   }  // namespace NNUE
 
 }  // namespace Eval
+#endif // K_P_CR_256X2_32_32_H
\ No newline at end of file
diff --git a/src/eval/nnue/architectures/k-p_256x2-32-32.h b/src/eval/nnue/architectures/k-p_256x2-32-32.h
index b77aeaa6..2576ddfa 100644
--- a/src/eval/nnue/architectures/k-p_256x2-32-32.h
+++ b/src/eval/nnue/architectures/k-p_256x2-32-32.h
@@ -1,4 +1,6 @@
 // NNUE評価関数�用�る入力特徴���ットワーク構造�定義
+#ifndef K_P_256X2_32_32_H
+#define K_P_256X2_32_32_H
 
 #include "../features/feature_set.h"
 #include "../features/k.h"
@@ -33,3 +35,4 @@ using Network = Layers::OutputLayer;
 }  // namespace NNUE
 
 }  // namespace Eval
+#endif // K_P_256X2_32_32_H
\ No newline at end of file

From 86e3fedf7e19482d5c9056d0415ac8284e99125f Mon Sep 17 00:00:00 2001
From: FireFather <firefather@telenet.be>
Date: Thu, 25 Jun 2020 04:38:39 +0200
Subject: [PATCH 2/3] Update evaluate_nnue.cpp

---
 src/eval/nnue/evaluate_nnue.cpp | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/eval/nnue/evaluate_nnue.cpp b/src/eval/nnue/evaluate_nnue.cpp
index ce478783..46b3b5f9 100644
--- a/src/eval/nnue/evaluate_nnue.cpp
+++ b/src/eval/nnue/evaluate_nnue.cpp
@@ -250,10 +250,14 @@ void load_eval() {
 	if (!result)
 	{
 		// 読�込�エラー���終了���れ���困る。
-		std::cout << "Error! : failed to read " << NNUE::kFileName << std::endl;
-		my_exit();
+		std::cout << "Error! " << NNUE::kFileName << " not found or wrong format" << std::endl;
+		//my_exit();
 	}
+	else
+	  std::cout << "info string NNUE " << NNUE::kFileName << " found & loaded" << std::endl;
   }
+  else
+    std::cout << "info string NNUE " << NNUE::kFileName << " not loaded" << std::endl;
 }
 
 // �期化

From aea08de018a72c2ecb86b568853e3815b32551e6 Mon Sep 17 00:00:00 2001
From: FireFather <firefather@telenet.be>
Date: Sun, 28 Jun 2020 03:12:55 +0200
Subject: [PATCH 3/3] Translation

Files in /eval, /extra, & /learn - comments translated from Japanese to English
---
 src/eval/evaluate_common.h                    |   72 +-
 src/eval/evaluate_mir_inv_tools.cpp           |   72 +-
 src/eval/evaluate_mir_inv_tools.h             |   30 +-
 .../architectures/halfkp-cr-ep_256x2-32-32.h  |    8 +-
 .../nnue/architectures/halfkp_256x2-32-32.h   |    8 +-
 .../architectures/k-p-cr-ep_256x2-32-32.h     |    8 +-
 .../nnue/architectures/k-p-cr_256x2-32-32.h   |    8 +-
 src/eval/nnue/architectures/k-p_256x2-32-32.h |    8 +-
 src/eval/nnue/evaluate_nnue.cpp               |  114 +-
 src/eval/nnue/evaluate_nnue.h                 |   24 +-
 src/eval/nnue/evaluate_nnue_learner.cpp       |   44 +-
 src/eval/nnue/evaluate_nnue_learner.h         |   20 +-
 src/eval/nnue/features/castling_right.cpp     |   10 +-
 src/eval/nnue/features/castling_right.h       |   20 +-
 src/eval/nnue/features/enpassant.cpp          |    8 +-
 src/eval/nnue/features/enpassant.h            |   20 +-
 src/eval/nnue/features/feature_set.h          |   62 +-
 src/eval/nnue/features/features_common.h      |   26 +-
 src/eval/nnue/features/half_kp.cpp            |   10 +-
 src/eval/nnue/features/half_kp.h              |   24 +-
 src/eval/nnue/features/half_relative_kp.cpp   |   12 +-
 src/eval/nnue/features/half_relative_kp.h     |   30 +-
 src/eval/nnue/features/index_list.h           |    8 +-
 src/eval/nnue/features/k.cpp                  |    8 +-
 src/eval/nnue/features/k.h                    |   20 +-
 src/eval/nnue/features/p.cpp                  |    8 +-
 src/eval/nnue/features/p.h                    |   20 +-
 src/eval/nnue/layers/affine_transform.h       |   32 +-
 src/eval/nnue/layers/clipped_relu.h           |   26 +-
 src/eval/nnue/layers/input_slice.h            |   24 +-
 src/eval/nnue/layers/sum.h                    |   58 +-
 src/eval/nnue/nnue_accumulator.h              |    8 +-
 src/eval/nnue/nnue_architecture.h             |    8 +-
 src/eval/nnue/nnue_common.h                   |   18 +-
 src/eval/nnue/nnue_feature_transformer.h      |   40 +-
 src/eval/nnue/nnue_test_command.cpp           |   22 +-
 src/eval/nnue/nnue_test_command.h             |    4 +-
 src/eval/nnue/trainer/features/factorizer.h   |   28 +-
 .../trainer/features/factorizer_feature_set.h |   24 +-
 .../trainer/features/factorizer_half_kp.h     |   18 +-
 src/eval/nnue/trainer/trainer.h               |   22 +-
 .../nnue/trainer/trainer_affine_transform.h   |   54 +-
 src/eval/nnue/trainer/trainer_clipped_relu.h  |   38 +-
 .../trainer/trainer_feature_transformer.h     |   54 +-
 src/eval/nnue/trainer/trainer_input_slice.h   |   62 +-
 src/eval/nnue/trainer/trainer_sum.h           |   66 +-
 src/extra/sfen_packer.cpp                     |  193 ++-
 src/learn/half_float.h                        |    8 +-
 src/learn/learn.h                             |  176 +--
 src/learn/learner.cpp                         | 1367 ++++++++---------
 src/learn/learning_tools.cpp                  |   58 +-
 src/learn/learning_tools.h                    |  528 +++----
 src/learn/multi_think.cpp                     |   74 +-
 src/learn/multi_think.h                       |   96 +-
 54 files changed, 1903 insertions(+), 1905 deletions(-)

diff --git a/src/eval/evaluate_common.h b/src/eval/evaluate_common.h
index 5d5d05b1..84a96bee 100644
--- a/src/eval/evaluate_common.h
+++ b/src/eval/evaluate_common.h
@@ -1,75 +1,75 @@
 #ifndef _EVALUATE_COMMON_H_
 #define _EVALUATE_COMMON_H_
 
-// �����手番��評価関数(EVAL_KPPT�EVAL_KPP_KKPT)�共用header的�も�。
+// A common header-like function for modern evaluation functions (EVAL_KPPT and EVAL_KPP_KKPT).
 
 #if defined(EVAL_NNUE) || defined(EVAL_LEARN)
 #include <functional>
 
-// KKファイル�
+// KK file name
 #define KK_BIN "KK_synthesized.bin"
 
-// KKPファイル�
+// KKP file name
 #define KKP_BIN "KKP_synthesized.bin"
 
-// KPPファイル�
+// KPP file name
 #define KPP_BIN "KPP_synthesized.bin"
 
 namespace Eval
 {
 
 #if defined(USE_EVAL_HASH)
-	// prefetch�る関数
+	// prefetch function
 	void prefetch_evalhash(const Key key);
 #endif
 
-	// 評価関数��れ�れ�パラメーター�対��関数fを�用���れるoperator。
-	// パラメーター�分����用�る。
-	// type�調査対象を表�。
-	//   type = -1 : KK,KKP,KPP���
-	//   type = 0  : KK �� 
-	//   type = 1  : KKP�� 
-	//   type = 2  : KPP�� 
+	// An operator that applies the function f to each parameter of the evaluation function.
+	// Used for parameter analysis etc.
+	// type indicates the survey target.
+	// type = -1 :KK,KKP,KPP all
+	// type = 0: KK only
+	// type = 1: KKP only
+	// type = 2: KPP only
 	void foreach_eval_param(std::function<void(int32_t, int32_t)>f, int type = -1);
 
 	// --------------------------
-	//        学習用
+	// for learning
 	// --------------------------
 
 #if defined(EVAL_LEARN)
-	// 学習����勾��列��期化
-	// 学習率を引数�渡����。0.0�ら�default�値を採用�る。
-	// update_weights()�epoch��eta_epoch��eta�ら�々�eta2�変化�る。
-	// eta2_epoch以���eta2�ら�々�eta3�変化�る。
+	// Initialize the gradient array during learning
+	// Pass the learning rate as an argument. If 0.0, the default value is used.
+	// The epoch of update_weights() gradually changes from eta to eta2 until eta_epoch.
+	// After eta2_epoch, gradually change from eta2 to eta3.
 	void init_grad(double eta1, uint64_t eta_epoch, double eta2, uint64_t eta2_epoch, double eta3);
 
-	// �在�局��出����る特徴����対���勾��差分値を勾��列�加算�る。
-	// freeze[0]  : kk�学習����フラグ
-	// freeze[1]  : kkp�学習����フラグ
-	// freeze[2]  : kpp�学習����フラグ
-	// freeze[3]  : kppp�学習����フラグ
+	// Add the gradient difference value to the gradient array for all features that appear in the current phase.
+	// freeze[0]: Flag that kk does not learn
+	// freeze[1]: Flag that kkp does not learn
+	// freeze[2]: Flag that kpp does not learn
+	// freeze[3]: Flag that kppp does not learn
 	void add_grad(Position& pos, Color rootColor, double delt_grad, const std::array<bool, 4>& freeze);
 
-	// �在�勾�をも��SGD�AdaGrad�何��る。
-	// epoch      : 世代カウンター(0�ら始�る)
-	// freeze[0]  : kk�学習����フラグ
-	// freeze[1]  : kkp�学習����フラグ
-	// freeze[2]  : kpp�学習����フラグ
-	// freeze[3]  : kppp�学習����フラグ
-	void update_weights(uint64_t epoch, const std::array<bool,4>& freeze);
+	// Do SGD or AdaGrad or something based on the current gradient.
+	// epoch: Generation counter (starting from 0)
+	// freeze[0]: Flag that kk does not learn
+	// freeze[1]: Flag that kkp does not learn
+	// freeze[2]: Flag that kpp does not learn
+	// freeze[3]: Flag that kppp does not learn
+	void update_weights(uint64_t epoch, const std::array<bool, 4>& freeze);
 
-	// 評価関数パラメーターをファイル��存�る。
-	// ファイル�末尾���る拡張�を指定��る。
+	// Save the evaluation function parameters to a file.
+	// You can specify the extension added to the end of the file.
 	void save_eval(std::string suffix);
 
-	// �在�etaを�得�る。
+	// Get the current eta.
 	double get_eta();
 
-	// -- 学習�関連��コマンド
+	// --learning related commands
 
-	// KKを正�化�る関数。元�評価関数�完全�等価���ら����注�。
-	// kkp,kpp�値を�る��ゼロ�近��る����学習中�出������特徴因��値(ゼロ�����る)�
-	// 妥当��る��を�証�よ����考�。
+	// A function that normalizes KK. Note that it is not completely equivalent to the original evaluation function.
+	// By making the values ​​of kkp and kpp as close to zero as possible, the value of the feature factor (which is zero) that did not appear during learning
+	// The idea of ​​ensuring it is valid.
 	void regularize_kk();
 
 #endif
diff --git a/src/eval/evaluate_mir_inv_tools.cpp b/src/eval/evaluate_mir_inv_tools.cpp
index 56a0a63e..3b5d3a36 100644
--- a/src/eval/evaluate_mir_inv_tools.cpp
+++ b/src/eval/evaluate_mir_inv_tools.cpp
@@ -7,35 +7,35 @@ namespace Eval
 
 	// --- tables
 
-	// �るBonaPieceを相手��ら見����値
-	// BONA_PIECE_INIT�-1���符�型���必���る。
-	// KPPTを拡張��も当��BonaPiece�2^15を超�る�������int16_t�良���る。
+	// Value when a certain BonaPiece is seen from the other side
+	// BONA_PIECE_INIT is -1, so it must be a signed type.
+	// Even if KPPT is expanded, BonaPiece will not exceed 2^15 for the time being, so int16_t is good.
 	int16_t inv_piece_[Eval::fe_end];
 
-	// 盤�上��るBonaPieceをミラー���置��るも�を返�。
+	// Returns the one at the position where a BonaPiece on the board is mirrored.
 	int16_t mir_piece_[Eval::fe_end];
 
 
 	// --- methods
 
-	// �るBonaPieceを相手��ら見����値を返�
+// Returns the value when a certain BonaPiece is seen from the other side
 	Eval::BonaPiece inv_piece(Eval::BonaPiece p) { return (Eval::BonaPiece)inv_piece_[p]; }
 
-	// 盤�上��るBonaPieceをミラー���置��るも�を返�。
+	// Returns the one at the position where a BonaPiece on the board is mirrored.
 	Eval::BonaPiece mir_piece(Eval::BonaPiece p) { return (Eval::BonaPiece)mir_piece_[p]; }
 
 	std::function<void()> mir_piece_init_function;
 
 	void init_mir_inv_tables()
 	{
-		// mirror�inverse�テーブル��期化。
+		// Initialize the mirror and inverse tables.
 
-		// �期化�1回��る。
+		// Initialization is limited to once.
 		static bool first = true;
 		if (!first) return;
 		first = false;
 
-		// f�e��交�
+		// exchange f and e
 		int t[] = {
 			f_pawn             , e_pawn            ,
 			f_knight           , e_knight          ,
@@ -44,12 +44,12 @@ namespace Eval
 			f_queen            , e_queen           ,
 		};
 
-		// 未�期化�値を��込ん���。
+		// Insert uninitialized value.
 		for (BonaPiece p = BONA_PIECE_ZERO; p < fe_end; ++p)
 		{
 			inv_piece_[p] = BONA_PIECE_NOT_INIT;
 
-			// mirror�手駒�対���機能���。元�値を返���。
+			// mirror does not work for hand pieces. Just return the original value.
 			mir_piece_[p] = (p < f_pawn) ? p : BONA_PIECE_NOT_INIT;
 		}
 
@@ -61,26 +61,26 @@ namespace Eval
 				{
 					Square sq = (Square)(p - t[i]);
 
-					// 見����!!
+					// found!!
 					BonaPiece q = (p < fe_hand_end) ? BonaPiece(sq + t[i + 1]) : (BonaPiece)(Inv(sq) + t[i + 1]);
 					inv_piece_[p] = q;
 					inv_piece_[q] = p;
 
 					/*
-					�ょ��トリッキー���p�関��盤上�駒�
-					p >= fe_hand_end
-					���。
+					It's a bit tricky, but regarding p
+										p >= fe_hand_end
+										When.
 
-					��p�対���nを整数���(上�コード�i��数���ら��)�
-					a)  t[2n + 0] <= p < t[2n + 1] ����先手�駒
-					b)  t[2n + 1] <= p < t[2n + 2] ����後手�駒
-					　��る。
+					For this p, let n be an integer (i in the above code can only be an even number),
+					a) When t[2n + 0] <= p <t[2n + 1], the first piece
+					b) When t[2n + 1] <= p <t[2n + 2], the back piece
+					Is.
 
-					 ゆ���a)�範囲��るpをq = Inv(p-t[2n+0]) + t[2n+1] ��る�180度回転������る後手�駒��る。
-					 ���p�qをswap���inv_piece[ ]を�期化���る。
-					 */
+					Therefore, if p in the range of a) is set to q = Inv(p-t[2n+0]) + t[2n+1], it becomes the back piece in the box rotated 180 degrees.
+					So inv_piece[] is initialized by swapping p and q.
+					*/
 
-					 // 手駒�関���mirror��存在���。
+					// There is no mirror for hand pieces.
 					if (p < fe_hand_end)
 						continue;
 
@@ -103,28 +103,28 @@ namespace Eval
 
 		for (BonaPiece p = BONA_PIECE_ZERO; p < fe_end; ++p)
 		{
-			// 未�期化��������る。上�テーブル��期化コード�����。
+			// It remains uninitialized. The initialization code in the table above is incorrect.
 			assert(mir_piece_[p] != BONA_PIECE_NOT_INIT && mir_piece_[p] < fe_end);
 			assert(inv_piece_[p] != BONA_PIECE_NOT_INIT && inv_piece_[p] < fe_end);
 
-			// mir�inv��2回�用��ら元�座標�戻る。
+			// mir and inv return to their original coordinates after being applied twice.
 			assert(mir_piece_[mir_piece_[p]] == p);
 			assert(inv_piece_[inv_piece_[p]] == p);
 
-			// mir->inv->mir->inv�元�場所���れ��ら��。
+			// mir->inv->mir->inv must be the original location.
 			assert(p == inv_piece(mir_piece(inv_piece(mir_piece(p)))));
 
-			// inv->mir->inv->mir�元�場所���れ��ら��。
+			// inv->mir->inv->mir must be the original location.
 			assert(p == mir_piece(inv_piece(mir_piece(inv_piece(p)))));
 		}
 
 #if 0
-		// 評価関数�ミラーを��も大丈夫��る��事�検証
-		// 値を書�込ん����assertion��る���ミラー��ダメ��る場��
-		// ��assert�引���る��。
+		// Pre-verification that it is okay to mirror the evaluation function
+		// When writing a value, there is an assertion, so if you can't mirror it,
+		// Should get caught in the assert.
 
-		// Apery�WCSC26�評価関数�kpp�p1==0��p1==20(後手�0枚目�歩)���
-		// ����ゴミ�入������れを回�����assert�引���る。
+		// Apery's WCSC26 evaluation function, kpp p1==0 or p1==20 (0th step on the back)
+		// There is dust in it, and if you don't avoid it, it will get caught in the assert.
 
 		std::unordered_set<BonaPiece> s;
 		vector<int> a = {
@@ -139,24 +139,24 @@ namespace Eval
 		for (auto b : a)
 			s.insert((BonaPiece)b);
 
-		// �ら�出������盤上�歩�香�桂も除外(Apery����もゴミ�入���る)
+		// Excludes walks, incense, and katsura on the board that do not appear further (Apery also contains garbage here)
 		for (Rank r = RANK_1; r <= RANK_2; ++r)
 			for (File f = FILE_1; f <= FILE_9; ++f)
 			{
 				if (r == RANK_1)
 				{
-					// 1段目�歩
+					// first step
 					BonaPiece b1 = BonaPiece(f_pawn + (f | r));
 					s.insert(b1);
 					s.insert(inv_piece[b1]);
 
-					// 1段目�香
+					// 1st stage incense
 					BonaPiece b2 = BonaPiece(f_lance + (f | r));
 					s.insert(b2);
 					s.insert(inv_piece[b2]);
 				}
 
-				// 1,2段目�桂
+				// Katsura on the 1st and 2nd steps
 				BonaPiece b = BonaPiece(f_knight + (f | r));
 				s.insert(b);
 				s.insert(inv_piece[b]);
diff --git a/src/eval/evaluate_mir_inv_tools.h b/src/eval/evaluate_mir_inv_tools.h
index 8d6378ec..fa4e70ac 100644
--- a/src/eval/evaluate_mir_inv_tools.h
+++ b/src/eval/evaluate_mir_inv_tools.h
@@ -3,7 +3,7 @@
 
 #if defined(EVAL_NNUE) || defined(EVAL_LEARN)
 
-// BonaPiece�mirror(左��転)やinverse(盤上�180度回転)���駒を得る���ツール類。
+// BonaPiece's mirror (horizontal flip) and inverse (180° on the board) tools to get pieces.
 
 #include "../types.h"
 #include "../evaluate.h"
@@ -15,33 +15,33 @@ namespace Eval
 	//                  tables
 	// -------------------------------------------------
 
-	// 	--- BonaPiece�対��Mirror�Inverseを�供�る。
+	// --- Provide Mirror and Inverse to BonaPiece.
 
-	// �れら��列��init()�init_mir_inv_tables();を呼�出���期化�れる。
-	// ��テーブル��を評価関数����ら使�������評価関数��期化����
-	// init_mir_inv_tables()を呼�出��良�。
-	// �れら��列��以下�KK/KKP/KPPクラス�ら�照�れる。
+	// These arrays are initialized by calling init() or init_mir_inv_tables();.
+	// If you want to use only this table from the evaluation function,
+	// Call init_mir_inv_tables().
+	// These arrays are referenced from the KK/KKP/KPP classes below.
 
-	// �るBonaPieceを相手��ら見����値を返�
+	// Returns the value when a certain BonaPiece is seen from the other side
 	extern Eval::BonaPiece inv_piece(Eval::BonaPiece p);
 
-	// 盤�上��るBonaPieceをミラー���置��るも�を返�。
+	// Returns the one at the position where a BonaPiece on the board is mirrored.
 	extern Eval::BonaPiece mir_piece(Eval::BonaPiece p);
 
 
-	// mir_piece/inv_piece��期化����呼�出�れるcallback
-	// fe_endをユーザー��拡張�る���用�る。
-	// ���期化����必����inv_piece_�inv_piece_を公開���る。
-	// mir_piece_init_function�呼�出�れ�タイミング��fe_old_end���
-	// �れら�テーブル��期化�完了���る����証�れ��る。
+	// callback called when initializing mir_piece/inv_piece
+	// Used when extending fe_end on the user side.
+	// Inv_piece_ and inv_piece_ are exposed because they are necessary for this initialization.
+	// At the timing when mir_piece_init_function is called, until fe_old_end
+	// It is guaranteed that these tables have been initialized.
 	extern std::function<void()> mir_piece_init_function;
 	extern int16_t mir_piece_[Eval::fe_end];
 	extern int16_t inv_piece_[Eval::fe_end];
 
-	// ��関数を明示的�呼�出���init()を呼�出��������上�テーブル��期化�れる。
+	// The table above will be initialized when you call this function explicitly or call init().
 	extern void init_mir_inv_tables();
 }
 
 #endif  // defined(EVAL_NNUE) || defined(EVAL_LEARN)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/architectures/halfkp-cr-ep_256x2-32-32.h b/src/eval/nnue/architectures/halfkp-cr-ep_256x2-32-32.h
index 9f1f97c0..1bb9609e 100644
--- a/src/eval/nnue/architectures/halfkp-cr-ep_256x2-32-32.h
+++ b/src/eval/nnue/architectures/halfkp-cr-ep_256x2-32-32.h
@@ -1,4 +1,4 @@
-// NNUE•]‰¿ŠÖ�”‚Å—p‚¢‚é“ü—Í“Á’¥—ʂƃlƒbƒgƒ��[ƒN�\‘¢‚Ì’è‹`
+// Definition of input features and network structure used in NNUE evaluation function
 
 #ifndef HALFKP_CR_EP_256X2_32_32_H
 #define HALFKP_CR_EP_256X2_32_32_H
@@ -16,17 +16,17 @@ namespace Eval {
 
   namespace NNUE {
 
-    // •]‰¿ŠÖ�”‚Å—p‚¢‚é“ü—Í“Á’¥—Ê
+    // Input features used in evaluation function
     using RawFeatures = Features::FeatureSet<
       Features::HalfKP<Features::Side::kFriend>, Features::CastlingRight,
       Features::EnPassant>;
 
-    // •ÏŠ·Œã‚Ì“ü—Í“Á’¥—Ê‚ÌŽŸŒ³�”
+    // Number of input feature dimensions after conversion
     constexpr IndexType kTransformedFeatureDimensions = 256;
 
     namespace Layers {
 
-      // ƒlƒbƒgƒ��[ƒN�\‘¢‚Ì’è‹`
+      // define network structure
       using InputLayer = InputSlice<kTransformedFeatureDimensions * 2>;
       using HiddenLayer1 = ClippedReLU<AffineTransform<InputLayer, 32>>;
       using HiddenLayer2 = ClippedReLU<AffineTransform<HiddenLayer1, 32>>;
diff --git a/src/eval/nnue/architectures/halfkp_256x2-32-32.h b/src/eval/nnue/architectures/halfkp_256x2-32-32.h
index c79747c3..467d0222 100644
--- a/src/eval/nnue/architectures/halfkp_256x2-32-32.h
+++ b/src/eval/nnue/architectures/halfkp_256x2-32-32.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�用�る入力特徴���ットワーク構造�定義
+// Definition of input features and network structure used in NNUE evaluation function
 
 #ifndef HALFKP_256X2_32_32_H
 #define HALFKP_256X2_32_32_H
@@ -14,16 +14,16 @@ namespace Eval {
 
 namespace NNUE {
 
-// 評価関数�用�る入力特徴�
+// Input features used in evaluation function
 using RawFeatures = Features::FeatureSet<
     Features::HalfKP<Features::Side::kFriend>>;
 
-// 変�後�入力特徴��次元数
+// Number of input feature dimensions after conversion
 constexpr IndexType kTransformedFeatureDimensions = 256;
 
 namespace Layers {
 
-// �ットワーク構造�定義
+// define network structure
 using InputLayer = InputSlice<kTransformedFeatureDimensions * 2>;
 using HiddenLayer1 = ClippedReLU<AffineTransform<InputLayer, 32>>;
 using HiddenLayer2 = ClippedReLU<AffineTransform<HiddenLayer1, 32>>;
diff --git a/src/eval/nnue/architectures/k-p-cr-ep_256x2-32-32.h b/src/eval/nnue/architectures/k-p-cr-ep_256x2-32-32.h
index dc761866..72531fd4 100644
--- a/src/eval/nnue/architectures/k-p-cr-ep_256x2-32-32.h
+++ b/src/eval/nnue/architectures/k-p-cr-ep_256x2-32-32.h
@@ -1,4 +1,4 @@
-// NNUE•]‰¿ŠÖ�”‚Å—p‚¢‚é“ü—Í“Á’¥—ʂƃlƒbƒgƒ��[ƒN�\‘¢‚Ì’è‹`
+// Definition of input features and network structure used in NNUE evaluation function
 
 #ifndef K_P_CR_EP_256X2_32_32_H
 #define K_P_CR_EP_256X2_32_32_H
@@ -17,16 +17,16 @@ namespace Eval {
 
   namespace NNUE {
 
-    // •]‰¿ŠÖ�”‚Å—p‚¢‚é“ü—Í“Á’¥—Ê
+    // Input features used in evaluation function
     using RawFeatures = Features::FeatureSet<Features::K, Features::P,
       Features::CastlingRight, Features::EnPassant>;
 
-    // •ÏŠ·Œã‚Ì“ü—Í“Á’¥—Ê‚ÌŽŸŒ³�”
+    // Number of input feature dimensions after conversion
     constexpr IndexType kTransformedFeatureDimensions = 256;
 
     namespace Layers {
 
-      // ƒlƒbƒgƒ��[ƒN�\‘¢‚Ì’è‹`
+      // define network structure
       using InputLayer = InputSlice<kTransformedFeatureDimensions * 2>;
       using HiddenLayer1 = ClippedReLU<AffineTransform<InputLayer, 32>>;
       using HiddenLayer2 = ClippedReLU<AffineTransform<HiddenLayer1, 32>>;
diff --git a/src/eval/nnue/architectures/k-p-cr_256x2-32-32.h b/src/eval/nnue/architectures/k-p-cr_256x2-32-32.h
index 331cb4f2..b4161880 100644
--- a/src/eval/nnue/architectures/k-p-cr_256x2-32-32.h
+++ b/src/eval/nnue/architectures/k-p-cr_256x2-32-32.h
@@ -1,4 +1,4 @@
-// NNUE•]‰¿ŠÖ�”‚Å—p‚¢‚é“ü—Í“Á’¥—ʂƃlƒbƒgƒ��[ƒN�\‘¢‚Ì’è‹`
+// Definition of input features and network structure used in NNUE evaluation function
 
 #ifndef K_P_CR_256X2_32_32_H
 #define K_P_CR_256X2_32_32_H
@@ -16,16 +16,16 @@ namespace Eval {
 
   namespace NNUE {
 
-    // •]‰¿ŠÖ�”‚Å—p‚¢‚é“ü—Í“Á’¥—Ê
+    // Input features used in evaluation function
     using RawFeatures = Features::FeatureSet<Features::K, Features::P,
       Features::CastlingRight>;
 
-    // •ÏŠ·Œã‚Ì“ü—Í“Á’¥—Ê‚ÌŽŸŒ³�”
+    // Number of input feature dimensions after conversion
     constexpr IndexType kTransformedFeatureDimensions = 256;
 
     namespace Layers {
 
-      // ƒlƒbƒgƒ��[ƒN�\‘¢‚Ì’è‹`
+      // define network structure
       using InputLayer = InputSlice<kTransformedFeatureDimensions * 2>;
       using HiddenLayer1 = ClippedReLU<AffineTransform<InputLayer, 32>>;
       using HiddenLayer2 = ClippedReLU<AffineTransform<HiddenLayer1, 32>>;
diff --git a/src/eval/nnue/architectures/k-p_256x2-32-32.h b/src/eval/nnue/architectures/k-p_256x2-32-32.h
index 2576ddfa..9fc9b2a1 100644
--- a/src/eval/nnue/architectures/k-p_256x2-32-32.h
+++ b/src/eval/nnue/architectures/k-p_256x2-32-32.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�用�る入力特徴���ットワーク構造�定義
+// Definition of input features and network structure used in NNUE evaluation function
 #ifndef K_P_256X2_32_32_H
 #define K_P_256X2_32_32_H
 
@@ -14,15 +14,15 @@ namespace Eval {
 
 namespace NNUE {
 
-// 評価関数�用�る入力特徴�
+// Input features used in evaluation function
 using RawFeatures = Features::FeatureSet<Features::K, Features::P>;
 
-// 変�後�入力特徴��次元数
+// Number of input feature dimensions after conversion
 constexpr IndexType kTransformedFeatureDimensions = 256;
 
 namespace Layers {
 
-// �ットワーク構造�定義
+// define network structure
 using InputLayer = InputSlice<kTransformedFeatureDimensions * 2>;
 using HiddenLayer1 = ClippedReLU<AffineTransform<InputLayer, 32>>;
 using HiddenLayer2 = ClippedReLU<AffineTransform<HiddenLayer1, 32>>;
diff --git a/src/eval/nnue/evaluate_nnue.cpp b/src/eval/nnue/evaluate_nnue.cpp
index 46b3b5f9..6b3f0b2f 100644
--- a/src/eval/nnue/evaluate_nnue.cpp
+++ b/src/eval/nnue/evaluate_nnue.cpp
@@ -1,4 +1,4 @@
-// NNUE評価関数�計算�関�るコード
+// Code for calculating NNUE evaluation function
 
 #if defined(EVAL_NNUE)
 
@@ -16,16 +16,16 @@ namespace Eval {
 
 namespace NNUE {
 
-// 入力特徴�変�器
+// Input feature converter
 AlignedPtr<FeatureTransformer> feature_transformer;
 
-// 評価関数
+// Evaluation function
 AlignedPtr<Network> network;
 
-// 評価関数ファイル�
+// Evaluation function file name
 const char* const kFileName = "nn.bin";
 
-// 評価関数�構造を表�文字列を�得�る
+// Get a string that represents the structure of the evaluation function
 std::string GetArchitectureString() {
   return "Features=" + FeatureTransformer::GetStructureString() +
       ",Network=" + Network::GetStructureString();
@@ -35,14 +35,14 @@ namespace {
 
 namespace Detail {
 
-// 評価関数パラメータを�期化�る
+// Initialize the evaluation function parameters
 template <typename T>
 void Initialize(AlignedPtr<T>& pointer) {
   pointer.reset(reinterpret_cast<T*>(aligned_malloc(sizeof(T), alignof(T))));
   std::memset(pointer.get(), 0, sizeof(T));
 }
 
-// 評価関数パラメータを読�込む
+// read evaluation function parameters
 template <typename T>
 bool ReadParameters(std::istream& stream, const AlignedPtr<T>& pointer) {
   std::uint32_t header;
@@ -51,7 +51,7 @@ bool ReadParameters(std::istream& stream, const AlignedPtr<T>& pointer) {
   return pointer->ReadParameters(stream);
 }
 
-// 評価関数パラメータを書�込む
+// write evaluation function parameters
 template <typename T>
 bool WriteParameters(std::ostream& stream, const AlignedPtr<T>& pointer) {
   constexpr std::uint32_t header = T::GetHashValue();
@@ -61,7 +61,7 @@ bool WriteParameters(std::ostream& stream, const AlignedPtr<T>& pointer) {
 
 }  // namespace Detail
 
-// 評価関数パラメータを�期化�る
+// Initialize the evaluation function parameters
 void Initialize() {
   Detail::Initialize(feature_transformer);
   Detail::Initialize(network);
@@ -69,7 +69,7 @@ void Initialize() {
 
 }  // namespace
 
-// ヘッダを読�込む
+// read the header
 bool ReadHeader(std::istream& stream,
   std::uint32_t* hash_value, std::string* architecture) {
   std::uint32_t version, size;
@@ -82,7 +82,7 @@ bool ReadHeader(std::istream& stream,
   return !stream.fail();
 }
 
-// ヘッダを書�込む
+// write the header
 bool WriteHeader(std::ostream& stream,
   std::uint32_t hash_value, const std::string& architecture) {
   stream.write(reinterpret_cast<const char*>(&kVersion), sizeof(kVersion));
@@ -93,7 +93,7 @@ bool WriteHeader(std::ostream& stream,
   return !stream.fail();
 }
 
-// 評価関数パラメータを読�込む
+// read evaluation function parameters
 bool ReadParameters(std::istream& stream) {
   std::uint32_t hash_value;
   std::string architecture;
@@ -104,7 +104,7 @@ bool ReadParameters(std::istream& stream) {
   return stream && stream.peek() == std::ios::traits_type::eof();
 }
 
-// 評価関数パラメータを書�込む
+// write evaluation function parameters
 bool WriteParameters(std::ostream& stream) {
   if (!WriteHeader(stream, kHashValue, GetArchitectureString())) return false;
   if (!Detail::WriteParameters(stream, feature_transformer)) return false;
@@ -112,12 +112,12 @@ bool WriteParameters(std::ostream& stream) {
   return !stream.fail();
 }
 
-// 差分計算���る�ら進�る
+// proceed if you can calculate the difference
 static void UpdateAccumulatorIfPossible(const Position& pos) {
   feature_transformer->UpdateAccumulatorIfPossible(pos);
 }
 
-// 評価値を計算�る
+// Calculate the evaluation value
 static Value ComputeScore(const Position& pos, bool refresh = false) {
   auto& accumulator = pos.state()->accumulator;
   if (!refresh && accumulator.computed_score) {
@@ -130,22 +130,22 @@ static Value ComputeScore(const Position& pos, bool refresh = false) {
   alignas(kCacheLineSize) char buffer[Network::kBufferSize];
   const auto output = network->Propagate(transformed_features, buffer);
 
-  // VALUE_MAX_EVALより大��値�返���る�aspiration search�fail high��
-  // 探索�終�ら���る��VALUE_MAX_EVAL以下��る��を�証���。
+  // When a value larger than VALUE_MAX_EVAL is returned, aspiration search fails high
+  // It should be guaranteed that it is less than VALUE_MAX_EVAL because the search will not end.
 
-  // ���象�起��も�対局時�秒固定�������探索�打�切られる���
-  // 1���iteration����最善手�bestmove���指�れる��見��上�
-  // �題��。��VALUE_MAX_EVAL�返���るよ��状�����詰��局���り�
-  // ��よ��詰��局��出��る��終盤�形勢�大差�����る���多���
-  // �敗����り影響���。
+  // Even if this phenomenon occurs, if the seconds are fixed when playing, the search will be aborted there, so
+  // The best move in the previous iteration is pointed to as bestmove, so apparently
+  // no problem. The situation in which this VALUE_MAX_EVAL is returned is almost at a dead end,
+  // Since such a jamming phase often appears at the end, there is a big difference in the situation
+  // Doesn't really affect the outcome.
 
-  // ����教師生�時��depth固定�探索�る���探索�ら戻������る��
-  // ��スレッド�計算時間を無駄��る。��depth固定対局�time-out�るよ���る。
+  // However, when searching with a fixed depth such as when creating a teacher, it will not return from the search
+  // Waste the computation time for that thread. Also, it will be timed out with fixed depth game.
 
   auto score = static_cast<Value>(output[0] / FV_SCALE);
 
-  // 1) ���下手�clip�る�学習時��影響��るよ��気も�る�…。
-  // 2) accumulator.score��差分計算�時�用�����書�����題��。
+  // 1) I feel that if I clip too poorly, it will have an effect on my learning...
+  // 2) Since accumulator.score is not used at the time of difference calculation, it can be rewritten without any problem.
   score = Math::clamp(score , -VALUE_MAX_EVAL , VALUE_MAX_EVAL);
 
   accumulator.score = score;
@@ -153,10 +153,10 @@ static Value ComputeScore(const Position& pos, bool refresh = false) {
   return accumulator.score;
 }
 
-}  // namespace NNUE
+} // namespace NNUE
 
 #if defined(USE_EVAL_HASH)
-// HashTable�評価値を�存�る���利用�るクラス
+// Class used to store evaluation values ​​in HashTable
 struct alignas(16) ScoreKeyValue {
 #if defined(USE_SSE2)
   ScoreKeyValue() = default;
@@ -171,15 +171,15 @@ struct alignas(16) ScoreKeyValue {
   }
 #endif
 
-  // evaluate hash�atomic��作��る必���る��������作�
+  // It is necessary to be able to operate atomically with evaluate hash, so the manipulator for that
   void encode() {
 #if defined(USE_SSE2)
-    // ScoreKeyValue � atomic �コピー�れる�� key �����れ�データも����る。
+    // ScoreKeyValue is copied to atomic, so if the key matches, the data matches.
 #else
     key ^= score;
 #endif
   }
-  // decode()�encode()�逆変����xor���逆変�も��変�。
+  // decode() is the reverse conversion of encode(), but since it is xor, the reverse conversion is the same.
   void decode() { encode(); }
 
   union {
@@ -193,45 +193,45 @@ struct alignas(16) ScoreKeyValue {
   };
 };
 
-// シンプル�HashTable�実装。
-// Size�2���乗。
+// Simple HashTable implementation.
+// Size is a power of 2.
 template <typename T, size_t Size>
 struct HashTable {
   HashTable() { clear(); }
   T* operator [] (const Key k) { return entries_ + (static_cast<size_t>(k) & (Size - 1)); }
   void clear() { memset(entries_, 0, sizeof(T)*Size); }
 
-  // Size � 2���乗��る����ェック
+  // Check that Size is a power of 2
   static_assert((Size & (Size - 1)) == 0, "");
 
  private:
   T entries_[Size];
 };
 
-// evaluate��も�を�存����HashTable(俗���ehash)
+//HashTable to save the evaluated ones (following ehash)
 
 #if !defined(USE_LARGE_EVAL_HASH)
-// 134MB(魔女�AVX2以外�時�設定)
+// 134MB (setting other than witch's AVX2)
 struct EvaluateHashTable : HashTable<ScoreKeyValue, 0x800000> {};
 #else
-// prefetch有り�ら大�����良����…。
-// →　��り変�ら����メモリも�������デフォルト��↑�設定�良��…。
-// 1GB(魔女�AVX2�時�設定)
+// If you have prefetch, it's better to have a big one...
+// → It doesn't change much and the memory is wasteful, so is it okay to set ↑ by default?
+// 1GB (setting for witch's AVX2)
 struct EvaluateHashTable : HashTable<ScoreKeyValue, 0x4000000> {};
 #endif
 
 EvaluateHashTable g_evalTable;
 
-// prefetch�る関数も用�����。
+// Prepare a function to prefetch.
 void prefetch_evalhash(const Key key) {
   constexpr auto mask = ~((uint64_t)0x1f);
   prefetch((void*)((uint64_t)g_evalTable[key] & mask));
 }
 #endif
 
-// 評価関数ファイルを読�込む
-// benchコマンド���Optionsを�存��復元�る������EvalDir�変更�れ��������
-// 評価関数��読込�必���る���フラグを立�る�����関数�2度呼�出�れる����る。
+// read the evaluation function file
+// Save and restore Options with bench command etc., so EvalDir is changed at this time,
+// This function may be called twice to flag that the evaluation function needs to be reloaded.
 void load_eval() {
   NNUE::Initialize();
 
@@ -249,7 +249,7 @@ void load_eval() {
 //    ASSERT(result);
 	if (!result)
 	{
-		// 読�込�エラー���終了���れ���困る。
+		// It's a problem if it doesn't finish when there is a read error.
 		std::cout << "Error! " << NNUE::kFileName << " not found or wrong format" << std::endl;
 		//my_exit();
 	}
@@ -260,19 +260,19 @@ void load_eval() {
     std::cout << "info string NNUE " << NNUE::kFileName << " not loaded" << std::endl;
 }
 
-// �期化
+// Initialization
 void init() {
 }
 
-// 評価関数。差分計算����全計算�る。
-// Position::set()�一度��呼�出�れる。(以��差分計算)
-// 手番��ら見�評価値を返���注�。(他�評価関数��設計���点����異�る)
-// ������関数�最�化�頑張ら��。
+// Evaluation function. Perform full calculation instead of difference calculation.
+// Called only once with Position::set(). (The difference calculation after that)
+// Note that the evaluation value seen from the turn side is returned. (Design differs from other evaluation functions in this respect)
+// Since, we will not try to optimize this function.
 Value compute_eval(const Position& pos) {
   return NNUE::ComputeScore(pos, true);
 }
 
-// 評価関数
+// Evaluation function
 Value evaluate(const Position& pos) {
   const auto& accumulator = pos.state()->accumulator;
   if (accumulator.computed_score) {
@@ -280,8 +280,8 @@ Value evaluate(const Position& pos) {
   }
 
 #if defined(USE_GLOBAL_OPTIONS)
-  // GlobalOptions�eval hashを用���設定�����る�ら
-  // eval hash��照会をskip�る。
+  // If Global Options is set not to use eval hash
+  // Skip the query to the eval hash.
   if (!GlobalOptions.use_eval_hash) {
     ASSERT_LV5(pos.state()->materialValue == Eval::material(pos));
     return NNUE::ComputeScore(pos);
@@ -289,19 +289,19 @@ Value evaluate(const Position& pos) {
 #endif
 
 #if defined(USE_EVAL_HASH)
-  // evaluate hash table���る�も。
+  // May be in the evaluate hash table.
   const Key key = pos.key();
   ScoreKeyValue entry = *g_evalTable[key];
   entry.decode();
   if (entry.key == key) {
-    // ����
+    // there were!
     return Value(entry.score);
   }
 #endif
 
   Value score = NNUE::ComputeScore(pos);
 #if defined(USE_EVAL_HASH)
-  // ����計算����evaluate hash table��存����。
+  // Since it was calculated carefully, save it in the evaluate hash table.
   entry.key = key;
   entry.score = score;
   entry.encode();
@@ -311,12 +311,12 @@ Value evaluate(const Position& pos) {
   return score;
 }
 
-// 差分計算���る�ら進�る
+// proceed if you can calculate the difference
 void evaluate_with_no_return(const Position& pos) {
   NNUE::UpdateAccumulatorIfPossible(pos);
 }
 
-// �在�局��評価値�内訳を表示�る
+// display the breakdown of the evaluation value of the current phase
 void print_eval_stat(Position& /*pos*/) {
   std::cout << "--- EVAL STAT: not implemented" << std::endl;
 }
diff --git a/src/eval/nnue/evaluate_nnue.h b/src/eval/nnue/evaluate_nnue.h
index a95f2bd9..7f8f700a 100644
--- a/src/eval/nnue/evaluate_nnue.h
+++ b/src/eval/nnue/evaluate_nnue.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�用�るheader
+// header used in NNUE evaluation function
 
 #ifndef _EVALUATE_NNUE_H_
 #define _EVALUATE_NNUE_H_
@@ -14,11 +14,11 @@ namespace Eval {
 
 namespace NNUE {
 
-// 評価関数�構造��ッシュ値
+// hash value of evaluation function structure
 constexpr std::uint32_t kHashValue =
     FeatureTransformer::GetHashValue() ^ Network::GetHashValue();
 
-// メモリ領域�解放を自動化�る���デリータ
+// Deleter for automating release of memory area
 template <typename T>
 struct AlignedDeleter {
   void operator()(T* ptr) const {
@@ -29,30 +29,30 @@ struct AlignedDeleter {
 template <typename T>
 using AlignedPtr = std::unique_ptr<T, AlignedDeleter<T>>;
 
-// 入力特徴�変�器
+// Input feature converter
 extern AlignedPtr<FeatureTransformer> feature_transformer;
 
-// 評価関数
+// Evaluation function
 extern AlignedPtr<Network> network;
 
-// 評価関数ファイル�
+// Evaluation function file name
 extern const char* const kFileName;
 
-// 評価関数�構造を表�文字列を�得�る
+// Get a string that represents the structure of the evaluation function
 std::string GetArchitectureString();
 
-// ヘッダを読�込む
+// read the header
 bool ReadHeader(std::istream& stream,
     std::uint32_t* hash_value, std::string* architecture);
 
-// ヘッダを書�込む
+// write the header
 bool WriteHeader(std::ostream& stream,
     std::uint32_t hash_value, const std::string& architecture);
 
-// 評価関数パラメータを読�込む
+// read evaluation function parameters
 bool ReadParameters(std::istream& stream);
 
-// 評価関数パラメータを書�込む
+// write evaluation function parameters
 bool WriteParameters(std::ostream& stream);
 
 }  // namespace NNUE
@@ -61,4 +61,4 @@ bool WriteParameters(std::ostream& stream);
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/evaluate_nnue_learner.cpp b/src/eval/nnue/evaluate_nnue_learner.cpp
index 636f90e1..0a2077a7 100644
--- a/src/eval/nnue/evaluate_nnue_learner.cpp
+++ b/src/eval/nnue/evaluate_nnue_learner.cpp
@@ -1,4 +1,4 @@
-// NNUE評価関数�学習時用�コード
+// Code for learning NNUE evaluation function
 
 #if defined(EVAL_LEARN) && defined(EVAL_NNUE)
 
@@ -31,30 +31,30 @@ namespace NNUE {
 
 namespace {
 
-// 学習データ
+// learning data
 std::vector<Example> examples;
 
-// examples�排他制御を�るMutex
+// Mutex for exclusive control of examples
 std::mutex examples_mutex;
 
-// ミニ�ッ��サンプル数
+// number of samples in mini-batch
 uint64_t batch_size;
 
-// 乱数生�器
+// random number generator
 std::mt19937 rng;
 
-// 学習器
+// learner
 std::shared_ptr<Trainer<Network>> trainer;
 
-// 学習率�スケール
+// Learning rate scale
 double global_learning_rate_scale;
 
-// 学習率�スケールを�得�る
+// Get the learning rate scale
 double GetGlobalLearningRateScale() {
   return global_learning_rate_scale;
 }
 
-// �イパーパラメータ���オプションを学習器���る
+// Tell the learner options such as hyperparameters
 void SendMessages(std::vector<Message> messages) {
   for (auto& message : messages) {
     trainer->SendMessage(&message);
@@ -64,7 +64,7 @@ void SendMessages(std::vector<Message> messages) {
 
 }  // namespace
 
-// 学習��期化を行�
+// Initialize learning
 void InitializeTraining(double eta1, uint64_t eta1_epoch,
                         double eta2, uint64_t eta2_epoch, double eta3) {
   std::cout << "Initializing NN training for "
@@ -82,18 +82,18 @@ void InitializeTraining(double eta1, uint64_t eta1_epoch,
   EvalLearningTools::Weight::init_eta(eta1, eta2, eta3, eta1_epoch, eta2_epoch);
 }
 
-// ミニ�ッ��サンプル数を設定�る
+// set the number of samples in the mini-batch
 void SetBatchSize(uint64_t size) {
   assert(size > 0);
   batch_size = size;
 }
 
-// 学習率�スケールを設定�る
+// set the learning rate scale
 void SetGlobalLearningRateScale(double scale) {
   global_learning_rate_scale = scale;
 }
 
-// �イパーパラメータ���オプションを設定�る
+// Set options such as hyperparameters
 void SetOptions(const std::string& options) {
   std::vector<Message> messages;
   for (const auto& option : Split(options, ',')) {
@@ -108,7 +108,7 @@ void SetOptions(const std::string& options) {
   SendMessages(std::move(messages));
 }
 
-// 学習用評価関数パラメータをファイル�ら読�直�
+// Reread the evaluation function parameters for learning from the file
 void RestoreParameters(const std::string& dir_name) {
   const std::string file_name = Path::Combine(dir_name, NNUE::kFileName);
   std::ifstream stream(file_name, std::ios::binary);
@@ -118,7 +118,7 @@ void RestoreParameters(const std::string& dir_name) {
   SendMessages({{"reset"}});
 }
 
-// 学習データを1サンプル追加�る
+// Add 1 sample of learning data
 void AddExample(Position& pos, Color rootColor,
                 const Learner::PackedSfenValue& psv, double weight) {
   Example example;
@@ -162,7 +162,7 @@ void AddExample(Position& pos, Color rootColor,
   examples.push_back(std::move(example));
 }
 
-// 評価関数パラメーターを更新�る
+// update the evaluation function parameters
 void UpdateParameters(uint64_t epoch) {
   assert(batch_size > 0);
 
@@ -192,21 +192,21 @@ void UpdateParameters(uint64_t epoch) {
   SendMessages({{"quantize_parameters"}});
 }
 
-// 学習��題�生�������ェック�る
+// Check if there are any problems with learning
 void CheckHealth() {
   SendMessages({{"check_health"}});
 }
 
 }  // namespace NNUE
 
-// 評価関数パラメーターをファイル��存�る
+// save merit function parameters to a file
 void save_eval(std::string dir_name) {
   auto eval_dir = Path::Combine(Options["EvalSaveDir"], dir_name);
   std::cout << "save_eval() start. folder = " << eval_dir << std::endl;
 
-  // �����フォルダ��る�らmkdir()�失敗�る��
-  // 別��れ�構���。��れ�作��欲����。
-  // ���EvalSaveDir���フォルダ�掘���るも���る。
+  // mkdir() will fail if this folder already exists, but
+  // Apart from that. If not, I just want you to make it.
+  // Also, assume that the folders up to EvalSaveDir have been dug.
   Dependency::mkdir(eval_dir);
 
   if (Options["SkipLoadingEval"] && NNUE::trainer) {
@@ -221,7 +221,7 @@ void save_eval(std::string dir_name) {
   std::cout << "save_eval() finished. folder = " << eval_dir << std::endl;
 }
 
-// �在�etaを�得�る
+// get the current eta
 double get_eta() {
   return NNUE::GetGlobalLearningRateScale() * EvalLearningTools::Weight::eta;
 }
diff --git a/src/eval/nnue/evaluate_nnue_learner.h b/src/eval/nnue/evaluate_nnue_learner.h
index e2e68738..932a5f8c 100644
--- a/src/eval/nnue/evaluate_nnue_learner.h
+++ b/src/eval/nnue/evaluate_nnue_learner.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�学習�用�るインターフェイス
+// Interface used for learning NNUE evaluation function
 
 #ifndef _EVALUATE_NNUE_LEARNER_H_
 #define _EVALUATE_NNUE_LEARNER_H_
@@ -11,30 +11,30 @@ namespace Eval {
 
 namespace NNUE {
 
-// 学習��期化を行�
+// Initialize learning
 void InitializeTraining(double eta1, uint64_t eta1_epoch,
                         double eta2, uint64_t eta2_epoch, double eta3);
 
-// ミニ�ッ��サンプル数を設定�る
+// set the number of samples in the mini-batch
 void SetBatchSize(uint64_t size);
 
-// 学習率�スケールを設定�る
+// set the learning rate scale
 void SetGlobalLearningRateScale(double scale);
 
-// �イパーパラメータ���オプションを設定�る
+// Set options such as hyperparameters
 void SetOptions(const std::string& options);
 
-// 学習用評価関数パラメータをファイル�ら読�直�
+// Reread the evaluation function parameters for learning from the file
 void RestoreParameters(const std::string& dir_name);
 
-// 学習データを1サンプル追加�る
+// Add 1 sample of learning data
 void AddExample(Position& pos, Color rootColor,
                 const Learner::PackedSfenValue& psv, double weight);
 
-// 評価関数パラメータを更新�る
+// update the evaluation function parameters
 void UpdateParameters(uint64_t epoch);
 
-// 学習��題�生�������ェック�る
+// Check if there are any problems with learning
 void CheckHealth();
 
 }  // namespace NNUE
@@ -43,4 +43,4 @@ void CheckHealth();
 
 #endif  // defined(EVAL_LEARN) && defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/features/castling_right.cpp b/src/eval/nnue/features/castling_right.cpp
index 30e46e23..ee7b6576 100644
--- a/src/eval/nnue/features/castling_right.cpp
+++ b/src/eval/nnue/features/castling_right.cpp
@@ -1,4 +1,4 @@
-// NNUE評価関数�入力特徴�K�定義
+//Definition of input feature quantity K of NNUE evaluation function
 
 #if defined(EVAL_NNUE)
 
@@ -11,10 +11,10 @@ namespace Eval {
 
     namespace Features {
 
-      // 特徴�����値�1��るインデックス�リストを�得�る
+      // Get a list of indices with a value of 1 among the features
       void CastlingRight::AppendActiveIndices(
         const Position& pos, Color perspective, IndexList* active) {
-        // コンパイラ�警告を回��る����列サイズ����場��何も���
+        // do nothing if array size is small to avoid compiler warning
         if (RawFeatures::kMaxActiveDimensions < kMaxActiveDimensions) return;
 
         int castling_rights = pos.state()->castlingRights;
@@ -28,14 +28,14 @@ namespace Eval {
             & ((castling_rights >> 2) & 3);
         }
 
-        for (int i = 0; i < kDimensions; ++i) {
+        for (int i = 0; i <kDimensions; ++i) {
           if (relative_castling_rights & (i << 1)) {
             active->push_back(i);
           }
         }
       }
 
-      // 特徴�����一手��ら値�変化��インデックス�リストを�得�る
+      // Get a list of indices whose values ​​have changed from the previous one in the feature quantity
       void CastlingRight::AppendChangedIndices(
         const Position& pos, Color perspective,
         IndexList* removed, IndexList* added) {
diff --git a/src/eval/nnue/features/castling_right.h b/src/eval/nnue/features/castling_right.h
index 1384865f..f585b1d7 100644
--- a/src/eval/nnue/features/castling_right.h
+++ b/src/eval/nnue/features/castling_right.h
@@ -1,4 +1,4 @@
-// NNUE•]‰¿ŠÖ�”‚Ì“ü—Í“Á’¥—ÊK‚Ì’è‹`
+//Definition of input feature quantity K of NNUE evaluation function
 
 #ifndef _NNUE_FEATURES_CASTLING_RIGHT_H_
 #define _NNUE_FEATURES_CASTLING_RIGHT_H_
@@ -14,25 +14,25 @@ namespace Eval {
 
     namespace Features {
 
-      // “Á’¥—ÊK�F‹Ê‚̈ʒu
+      // Feature K: Ball position
       class CastlingRight {
       public:
-        // “Á’¥—Ê–¼
+        // feature quantity name
         static constexpr const char* kName = "CastlingRight";
-        // •]‰¿ŠÖ�”ƒtƒ@ƒCƒ‹‚É–„‚ß�ž‚ÞƒnƒbƒVƒ…’l
+        // Hash value embedded in the evaluation function file
         static constexpr std::uint32_t kHashValue = 0x913968AAu;
-        // “Á’¥—Ê‚ÌŽŸŒ³�”
+        // number of feature dimensions
         static constexpr IndexType kDimensions = 4;
-        // “Á’¥—Ê‚Ì‚¤‚¿�A“¯Žž‚É’l‚ª1‚Æ‚È‚éƒCƒ“ƒfƒbƒNƒX‚Ì�”‚Ì�Å‘å’l
+        // The maximum value of the number of indexes whose value is 1 at the same time among the feature values
         static constexpr IndexType kMaxActiveDimensions = 4;
-        // �·•ªŒvŽZ‚Ì‘ã‚í‚è‚É‘SŒvŽZ‚ð�s‚¤ƒ^ƒCƒ~ƒ“ƒO
+        // Timing of full calculation instead of difference calculation
         static constexpr TriggerEvent kRefreshTrigger = TriggerEvent::kNone;
 
-        // “Á’¥—Ê‚Ì‚¤‚¿�A’l‚ª1‚Å‚ ‚éƒCƒ“ƒfƒbƒNƒX‚̃ŠƒXƒg‚ðŽæ“¾‚·‚é
+        // Get a list of indices with a value of 1 among the features
         static void AppendActiveIndices(const Position& pos, Color perspective,
           IndexList* active);
 
-        // “Á’¥—Ê‚Ì‚¤‚¿�AˆêŽè‘O‚©‚ç’l‚ª•Ï‰»‚µ‚½ƒCƒ“ƒfƒbƒNƒX‚̃ŠƒXƒg‚ðŽæ“¾‚·‚é
+        // Get a list of indices whose values ??have changed from the previous one in the feature quantity
         static void AppendChangedIndices(const Position& pos, Color perspective,
           IndexList* removed, IndexList* added);
       };
@@ -45,4 +45,4 @@ namespace Eval {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/features/enpassant.cpp b/src/eval/nnue/features/enpassant.cpp
index 523fd966..82a4158e 100644
--- a/src/eval/nnue/features/enpassant.cpp
+++ b/src/eval/nnue/features/enpassant.cpp
@@ -1,4 +1,4 @@
-// NNUE•]‰¿ŠÖ�”‚Ì“ü—Í“Á’¥—ÊK‚Ì’è‹`
+//Definition of input feature quantity K of NNUE evaluation function
 
 #if defined(EVAL_NNUE)
 
@@ -11,10 +11,10 @@ namespace Eval {
 
     namespace Features {
 
-      // “Á’¥—Ê‚Ì‚¤‚¿�A’l‚ª1‚Å‚ ‚éƒCƒ“ƒfƒbƒNƒX‚̃ŠƒXƒg‚ðŽæ“¾‚·‚é
+      // Get a list of indices with a value of 1 among the features
       void EnPassant::AppendActiveIndices(
         const Position& pos, Color perspective, IndexList* active) {
-        // ƒRƒ“ƒpƒCƒ‰‚ÌŒx��‚ð‰ñ”ð‚·‚é‚½‚ß�A”z—ñƒTƒCƒY‚ª�¬‚³‚¢�ê�‡‚͉½‚à‚µ‚È‚¢
+        // do nothing if array size is small to avoid compiler warning
         if (RawFeatures::kMaxActiveDimensions < kMaxActiveDimensions) return;
 
         auto epSquare = pos.state()->epSquare;
@@ -30,7 +30,7 @@ namespace Eval {
         active->push_back(file);
       }
 
-      // “Á’¥—Ê‚Ì‚¤‚¿�AˆêŽè‘O‚©‚ç’l‚ª•Ï‰»‚µ‚½ƒCƒ“ƒfƒbƒNƒX‚̃ŠƒXƒg‚ðŽæ“¾‚·‚é
+      // Get a list of indices whose values ??have changed from the previous one in the feature quantity
       void EnPassant::AppendChangedIndices(
         const Position& pos, Color perspective,
         IndexList* removed, IndexList* added) {
diff --git a/src/eval/nnue/features/enpassant.h b/src/eval/nnue/features/enpassant.h
index fe827584..c0ac8234 100644
--- a/src/eval/nnue/features/enpassant.h
+++ b/src/eval/nnue/features/enpassant.h
@@ -1,4 +1,4 @@
-// NNUE•]‰¿ŠÖ�”‚Ì“ü—Í“Á’¥—ÊK‚Ì’è‹`
+//Definition of input feature quantity K of NNUE evaluation function
 
 #ifndef _NNUE_FEATURES_ENPASSANT_H_
 #define _NNUE_FEATURES_ENPASSANT_H_
@@ -14,25 +14,25 @@ namespace Eval {
 
     namespace Features {
 
-      // “Á’¥—ÊK�F‹Ê‚̈ʒu
+      // Feature K: Ball position
       class EnPassant {
       public:
-        // “Á’¥—Ê–¼
+        // feature quantity name
         static constexpr const char* kName = "EnPassant";
-        // •]‰¿ŠÖ�”ƒtƒ@ƒCƒ‹‚É–„‚ß�ž‚ÞƒnƒbƒVƒ…’l
+        // Hash value embedded in the evaluation function file
         static constexpr std::uint32_t kHashValue = 0x02924F91u;
-        // “Á’¥—Ê‚ÌŽŸŒ³�”
+        // number of feature dimensions
         static constexpr IndexType kDimensions = 8;
-        // “Á’¥—Ê‚Ì‚¤‚¿�A“¯Žž‚É’l‚ª1‚Æ‚È‚éƒCƒ“ƒfƒbƒNƒX‚Ì�”‚Ì�Å‘å’l
+        // The maximum value of the number of indexes whose value is 1 at the same time among the feature values
         static constexpr IndexType kMaxActiveDimensions = 1;
-        // �·•ªŒvŽZ‚Ì‘ã‚í‚è‚É‘SŒvŽZ‚ð�s‚¤ƒ^ƒCƒ~ƒ“ƒO
+        // Timing of full calculation instead of difference calculation
         static constexpr TriggerEvent kRefreshTrigger = TriggerEvent::kAnyPieceMoved;
 
-        // “Á’¥—Ê‚Ì‚¤‚¿�A’l‚ª1‚Å‚ ‚éƒCƒ“ƒfƒbƒNƒX‚̃ŠƒXƒg‚ðŽæ“¾‚·‚é
+        // Get a list of indices with a value of 1 among the features
         static void AppendActiveIndices(const Position& pos, Color perspective,
           IndexList* active);
 
-        // “Á’¥—Ê‚Ì‚¤‚¿�AˆêŽè‘O‚©‚ç’l‚ª•Ï‰»‚µ‚½ƒCƒ“ƒfƒbƒNƒX‚̃ŠƒXƒg‚ðŽæ“¾‚·‚é
+        // Get a list of indices whose values ??have changed from the previous one in the feature quantity
         static void AppendChangedIndices(const Position& pos, Color perspective,
           IndexList* removed, IndexList* added);
       };
@@ -45,4 +45,4 @@ namespace Eval {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/features/feature_set.h b/src/eval/nnue/features/feature_set.h
index 919be65d..6190db04 100644
--- a/src/eval/nnue/features/feature_set.h
+++ b/src/eval/nnue/features/feature_set.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�入力特徴�セットを表�クラステンプレート
+// A class template that represents the input feature set of the NNUE evaluation function
 
 #ifndef _NNUE_FEATURE_SET_H_
 #define _NNUE_FEATURE_SET_H_
@@ -14,7 +14,7 @@ namespace NNUE {
 
 namespace Features {
 
-// 値�リストを表�クラステンプレート
+// A class template that represents a list of values
 template <typename T, T... Values>
 struct CompileTimeList;
 template <typename T, T First, T... Remaining>
@@ -36,7 +36,7 @@ struct CompileTimeList<T> {
   static constexpr std::array<T, 0> kValues = {{}};
 };
 
-// リスト�先頭��追加を行�クラステンプレート
+// Class template that adds to the beginning of the list
 template <typename T, typename ListType, T Value>
 struct AppendToList;
 template <typename T, T... Values, T AnotherValue>
@@ -44,7 +44,7 @@ struct AppendToList<T, CompileTimeList<T, Values...>, AnotherValue> {
   using Result = CompileTimeList<T, AnotherValue, Values...>;
 };
 
-// ソート�れ��複���リスト��追加を行�クラステンプレート
+// Class template for adding to a sorted, unique list
 template <typename T, typename ListType, T Value>
 struct InsertToSet;
 template <typename T, T First, T... Remaining, T AnotherValue>
@@ -52,7 +52,7 @@ struct InsertToSet<T, CompileTimeList<T, First, Remaining...>, AnotherValue> {
   using Result = std::conditional_t<
       CompileTimeList<T, First, Remaining...>::Contains(AnotherValue),
       CompileTimeList<T, First, Remaining...>,
-      std::conditional_t<(AnotherValue < First),
+      std::conditional_t<(AnotherValue <First),
           CompileTimeList<T, AnotherValue, First, Remaining...>,
           typename AppendToList<T, typename InsertToSet<
               T, CompileTimeList<T, Remaining...>, AnotherValue>::Result,
@@ -63,21 +63,21 @@ struct InsertToSet<T, CompileTimeList<T>, Value> {
   using Result = CompileTimeList<T, Value>;
 };
 
-// 特徴�セット�基底クラス
+// Base class of feature set
 template <typename Derived>
 class FeatureSetBase {
  public:
-  // 特徴�����値�1��るインデックス�リストを�得�る
+  // Get a list of indices with a value of 1 among the features
   template <typename IndexListType>
   static void AppendActiveIndices(
       const Position& pos, TriggerEvent trigger, IndexListType active[2]) {
-    for (const auto perspective : Colors) {
+    for (const auto perspective :Colors) {
       Derived::CollectActiveIndices(
           pos, trigger, perspective, &active[perspective]);
     }
   }
 
-  // 特徴�����一手��ら値�変化��インデックス�リストを�得�る
+  // Get a list of indices whose values ​​have changed from the previous one in the feature quantity
   template <typename PositionType, typename IndexListType>
   static void AppendChangedIndices(
       const PositionType& pos, TriggerEvent trigger,
@@ -85,7 +85,7 @@ class FeatureSetBase {
     const auto& dp = pos.state()->dirtyPiece;
     if (dp.dirty_num == 0) return;
 
-    for (const auto perspective : Colors) {
+    for (const auto perspective :Colors) {
       reset[perspective] = false;
       switch (trigger) {
         case TriggerEvent::kNone:
@@ -120,8 +120,8 @@ class FeatureSetBase {
   }
 };
 
-// 特徴�セットを表�クラステンプレート
-// 実行時�計算�を線形��る����内部�処��テンプレート引数�逆順�行�
+// Class template that represents the feature set
+// do internal processing in reverse order of template arguments in order to linearize the amount of calculation at runtime
 template <typename FirstFeatureType, typename... RemainingFeatureTypes>
 class FeatureSet<FirstFeatureType, RemainingFeatureTypes...> :
     public FeatureSetBase<
@@ -131,27 +131,27 @@ class FeatureSet<FirstFeatureType, RemainingFeatureTypes...> :
   using Tail = FeatureSet<RemainingFeatureTypes...>;
 
  public:
-  // 評価関数ファイル�埋�込む�ッシュ値
+  // Hash value embedded in the evaluation function file
   static constexpr std::uint32_t kHashValue =
       Head::kHashValue ^ (Tail::kHashValue << 1) ^ (Tail::kHashValue >> 31);
-  // 特徴��次元数
+  // number of feature dimensions
   static constexpr IndexType kDimensions =
       Head::kDimensions + Tail::kDimensions;
-  // 特徴������時�値�1��るインデックス�数�最大値
+  // The maximum value of the number of indexes whose value is 1 at the same time among the feature values
   static constexpr IndexType kMaxActiveDimensions =
       Head::kMaxActiveDimensions + Tail::kMaxActiveDimensions;
-  // 差分計算�代�り�全計算を行�タイミング�リスト
+  // List of timings to perform all calculations instead of difference calculation
   using SortedTriggerSet = typename InsertToSet<TriggerEvent,
       typename Tail::SortedTriggerSet, Head::kRefreshTrigger>::Result;
   static constexpr auto kRefreshTriggers = SortedTriggerSet::kValues;
 
-  // 特徴��を�得�る
+  // Get the feature quantity name
   static std::string GetName() {
     return std::string(Head::kName) + "+" + Tail::GetName();
   }
 
  private:
-  // 特徴�����値�1��るインデックス�リストを�得�る
+  // Get a list of indices with a value of 1 among the features
   template <typename IndexListType>
   static void CollectActiveIndices(
       const Position& pos, const TriggerEvent trigger, const Color perspective,
@@ -166,7 +166,7 @@ class FeatureSet<FirstFeatureType, RemainingFeatureTypes...> :
     }
   }
 
-  // 特徴�����一手��ら値�変化��インデックス�リストを�得�る
+  // Get a list of indices whose values ​​have changed from the previous one in the feature quantity
   template <typename IndexListType>
   static void CollectChangedIndices(
       const Position& pos, const TriggerEvent trigger, const Color perspective,
@@ -185,36 +185,36 @@ class FeatureSet<FirstFeatureType, RemainingFeatureTypes...> :
     }
   }
 
-  // 基底クラス��自身を�帰的�利用�るクラステンプレートをfriend��る
+  // Make the base class and the class template that recursively uses itself a friend
   friend class FeatureSetBase<FeatureSet>;
   template <typename... FeatureTypes>
   friend class FeatureSet;
 };
 
-// 特徴�セットを表�クラステンプレート
-// テンプレート引数�1��場��特殊化
+// Class template that represents the feature set
+// Specialization with one template argument
 template <typename FeatureType>
 class FeatureSet<FeatureType> : public FeatureSetBase<FeatureSet<FeatureType>> {
  public:
-  // 評価関数ファイル�埋�込む�ッシュ値
+  // Hash value embedded in the evaluation function file
   static constexpr std::uint32_t kHashValue = FeatureType::kHashValue;
-  // 特徴��次元数
+  // number of feature dimensions
   static constexpr IndexType kDimensions = FeatureType::kDimensions;
-  // 特徴������時�値�1��るインデックス�数�最大値
+  // The maximum value of the number of indexes whose value is 1 at the same time among the feature values
   static constexpr IndexType kMaxActiveDimensions =
       FeatureType::kMaxActiveDimensions;
-  // 差分計算�代�り�全計算を行�タイミング�リスト
+  // List of timings to perform all calculations instead of difference calculation
   using SortedTriggerSet =
       CompileTimeList<TriggerEvent, FeatureType::kRefreshTrigger>;
   static constexpr auto kRefreshTriggers = SortedTriggerSet::kValues;
 
-  // 特徴��を�得�る
+  // Get the feature quantity name
   static std::string GetName() {
     return FeatureType::kName;
   }
 
  private:
-  // 特徴�����値�1��るインデックス�リストを�得�る
+  // Get a list of indices with a value of 1 among the features
   static void CollectActiveIndices(
       const Position& pos, const TriggerEvent trigger, const Color perspective,
       IndexList* const active) {
@@ -223,7 +223,7 @@ class FeatureSet<FeatureType> : public FeatureSetBase<FeatureSet<FeatureType>> {
     }
   }
 
-  // 特徴�����一手��ら値�変化��インデックス�リストを�得�る
+  // Get a list of indices whose values ​​have changed from the previous one in the feature quantity
   static void CollectChangedIndices(
       const Position& pos, const TriggerEvent trigger, const Color perspective,
       IndexList* const removed, IndexList* const added) {
@@ -232,7 +232,7 @@ class FeatureSet<FeatureType> : public FeatureSetBase<FeatureSet<FeatureType>> {
     }
   }
 
-  // 基底クラス��自身を�帰的�利用�るクラステンプレートをfriend��る
+  // Make the base class and the class template that recursively uses itself a friend
   friend class FeatureSetBase<FeatureSet>;
   template <typename... FeatureTypes>
   friend class FeatureSet;
@@ -246,4 +246,4 @@ class FeatureSet<FeatureType> : public FeatureSetBase<FeatureSet<FeatureType>> {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/features/features_common.h b/src/eval/nnue/features/features_common.h
index 15ccb8a7..0031d37b 100644
--- a/src/eval/nnue/features/features_common.h
+++ b/src/eval/nnue/features/features_common.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�入力特徴��共通ヘッダ
+//Common header of input features of NNUE evaluation function
 
 #ifndef _NNUE_FEATURES_COMMON_H_
 #define _NNUE_FEATURES_COMMON_H_
@@ -14,26 +14,26 @@ namespace NNUE {
 
 namespace Features {
 
-// インデックスリスト�型
+// Index list type
 class IndexList;
 
-// 特徴�セットを表�クラステンプレート
+// Class template that represents the feature set
 template <typename... FeatureTypes>
 class FeatureSet;
 
-// 差分計算�代�り�全計算を行�タイミング�種類
+// Type of timing to perform all calculations instead of difference calculation
 enum class TriggerEvent {
-  kNone,             // �能�場��常�差分計算�る
-  kFriendKingMoved,  // 自玉�移動��場��全計算�る
-  kEnemyKingMoved,   // 敵玉�移動��場��全計算�る
-  kAnyKingMoved,     // ��ら��玉�移動��場��全計算�る
-  kAnyPieceMoved,    // 常�全計算�る
+  kNone, // Calculate the difference whenever possible
+  kFriendKingMoved, // calculate all when own ball moves
+  kEnemyKingMoved, // do all calculations when enemy balls move
+  kAnyKingMoved, // do all calculations if either ball moves
+  kAnyPieceMoved, // always do all calculations
 };
 
-// 手番�or相手�
+// turn side or other side
 enum class Side {
-  kFriend,  // 手番�
-  kEnemy,   // 相手�
+  kFriend, // turn side
+  kEnemy, // opponent
 };
 
 }  // namespace Features
@@ -44,4 +44,4 @@ enum class Side {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/features/half_kp.cpp b/src/eval/nnue/features/half_kp.cpp
index 5cd95637..72156c82 100644
--- a/src/eval/nnue/features/half_kp.cpp
+++ b/src/eval/nnue/features/half_kp.cpp
@@ -1,4 +1,4 @@
-// NNUE評価関数�入力特徴�HalfKP�定義
+//Definition of input features HalfKP of NNUE evaluation function
 
 #if defined(EVAL_NNUE)
 
@@ -11,13 +11,13 @@ namespace NNUE {
 
 namespace Features {
 
-// 玉��置�BonaPiece�ら特徴��インデックスを求�る
+// Find the index of the feature quantity from the ball position and BonaPiece
 template <Side AssociatedKing>
 inline IndexType HalfKP<AssociatedKing>::MakeIndex(Square sq_k, BonaPiece p) {
   return static_cast<IndexType>(fe_end) * static_cast<IndexType>(sq_k) + p;
 }
 
-// 駒�情報を�得�る
+// Get the piece information
 template <Side AssociatedKing>
 inline void HalfKP<AssociatedKing>::GetPieces(
     const Position& pos, Color perspective,
@@ -31,7 +31,7 @@ inline void HalfKP<AssociatedKing>::GetPieces(
   *sq_target_k = static_cast<Square>(((*pieces)[target] - f_king) % SQUARE_NB);
 }
 
-// 特徴�����値�1��るインデックス�リストを�得�る
+// Get a list of indices with a value of 1 among the features
 template <Side AssociatedKing>
 void HalfKP<AssociatedKing>::AppendActiveIndices(
     const Position& pos, Color perspective, IndexList* active) {
@@ -48,7 +48,7 @@ void HalfKP<AssociatedKing>::AppendActiveIndices(
   }
 }
 
-// 特徴�����一手��ら値�変化��インデックス�リストを�得�る
+// Get a list of indices whose values ​​have changed from the previous one in the feature quantity
 template <Side AssociatedKing>
 void HalfKP<AssociatedKing>::AppendChangedIndices(
     const Position& pos, Color perspective,
diff --git a/src/eval/nnue/features/half_kp.h b/src/eval/nnue/features/half_kp.h
index 556127d3..65ea46f1 100644
--- a/src/eval/nnue/features/half_kp.h
+++ b/src/eval/nnue/features/half_kp.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�入力特徴�HalfKP�定義
+//Definition of input features HalfKP of NNUE evaluation function
 
 #ifndef _NNUE_FEATURES_HALF_KP_H_
 #define _NNUE_FEATURES_HALF_KP_H_
@@ -14,39 +14,39 @@ namespace NNUE {
 
 namespace Features {
 
-// 特徴�HalfKP：自玉���敵玉��置��玉以外�駒��置�組����
+// Feature HalfKP: Combination of the position of own ball or enemy ball and the position of pieces other than balls
 template <Side AssociatedKing>
 class HalfKP {
  public:
-  // 特徴��
+  // feature quantity name
   static constexpr const char* kName =
       (AssociatedKing == Side::kFriend) ? "HalfKP(Friend)" : "HalfKP(Enemy)";
-  // 評価関数ファイル�埋�込む�ッシュ値
+  // Hash value embedded in the evaluation function file
   static constexpr std::uint32_t kHashValue =
       0x5D69D5B9u ^ (AssociatedKing == Side::kFriend);
-  // 特徴��次元数
+  // number of feature dimensions
   static constexpr IndexType kDimensions =
       static_cast<IndexType>(SQUARE_NB) * static_cast<IndexType>(fe_end);
-  // 特徴������時�値�1��るインデックス�数�最大値
+  // The maximum value of the number of indexes whose value is 1 at the same time among the feature values
   static constexpr IndexType kMaxActiveDimensions = PIECE_NUMBER_KING;
-  // 差分計算�代�り�全計算を行�タイミング
+  // Timing of full calculation instead of difference calculation
   static constexpr TriggerEvent kRefreshTrigger =
       (AssociatedKing == Side::kFriend) ?
       TriggerEvent::kFriendKingMoved : TriggerEvent::kEnemyKingMoved;
 
-  // 特徴�����値�1��るインデックス�リストを�得�る
+  // Get a list of indices with a value of 1 among the features
   static void AppendActiveIndices(const Position& pos, Color perspective,
                                   IndexList* active);
 
-  // 特徴�����一手��ら値�変化��インデックス�リストを�得�る
+  // Get a list of indices whose values ​​have changed from the previous one in the feature quantity
   static void AppendChangedIndices(const Position& pos, Color perspective,
                                    IndexList* removed, IndexList* added);
 
-  // 玉��置�BonaPiece�ら特徴��インデックスを求�る
+  // Find the index of the feature quantity from the ball position and BonaPiece
   static IndexType MakeIndex(Square sq_k, BonaPiece p);
 
  private:
-  // 駒�情報を�得�る
+  // Get the piece information
   static void GetPieces(const Position& pos, Color perspective,
                         BonaPiece** pieces, Square* sq_target_k);
 };
@@ -59,4 +59,4 @@ class HalfKP {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/features/half_relative_kp.cpp b/src/eval/nnue/features/half_relative_kp.cpp
index d62beea0..623b839c 100644
--- a/src/eval/nnue/features/half_relative_kp.cpp
+++ b/src/eval/nnue/features/half_relative_kp.cpp
@@ -1,4 +1,4 @@
-// NNUE評価関数�入力特徴�HalfRelativeKP�定義
+//Definition of input features HalfRelativeKP of NNUE evaluation function
 
 #if defined(EVAL_NNUE)
 
@@ -11,7 +11,7 @@ namespace NNUE {
 
 namespace Features {
 
-// 玉��置�BonaPiece�ら特徴��インデックスを求�る
+// Find the index of the feature quantity from the ball position and BonaPiece
 template <Side AssociatedKing>
 inline IndexType HalfRelativeKP<AssociatedKing>::MakeIndex(
     Square sq_k, BonaPiece p) {
@@ -24,7 +24,7 @@ inline IndexType HalfRelativeKP<AssociatedKing>::MakeIndex(
   return H * W * piece_index + H * relative_file + relative_rank;
 }
 
-// 駒�情報を�得�る
+// Get the piece information
 template <Side AssociatedKing>
 inline void HalfRelativeKP<AssociatedKing>::GetPieces(
     const Position& pos, Color perspective,
@@ -38,11 +38,11 @@ inline void HalfRelativeKP<AssociatedKing>::GetPieces(
   *sq_target_k = static_cast<Square>(((*pieces)[target] - f_king) % SQUARE_NB);
 }
 
-// 特徴�����値�1��るインデックス�リストを�得�る
+// Get a list of indices with a value of 1 among the features
 template <Side AssociatedKing>
 void HalfRelativeKP<AssociatedKing>::AppendActiveIndices(
     const Position& pos, Color perspective, IndexList* active) {
-  // コンパイラ�警告を回��る����列サイズ����場��何も���
+  // do nothing if array size is small to avoid compiler warning
   if (RawFeatures::kMaxActiveDimensions < kMaxActiveDimensions) return;
 
   BonaPiece* pieces;
@@ -57,7 +57,7 @@ void HalfRelativeKP<AssociatedKing>::AppendActiveIndices(
   }
 }
 
-// 特徴�����一手��ら値�変化��インデックス�リストを�得�る
+// Get a list of indices whose values ​​have changed from the previous one in the feature quantity
 template <Side AssociatedKing>
 void HalfRelativeKP<AssociatedKing>::AppendChangedIndices(
     const Position& pos, Color perspective,
diff --git a/src/eval/nnue/features/half_relative_kp.h b/src/eval/nnue/features/half_relative_kp.h
index 99e10c57..f6ca5cc0 100644
--- a/src/eval/nnue/features/half_relative_kp.h
+++ b/src/eval/nnue/features/half_relative_kp.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�入力特徴�HalfRelativeKP�定義
+//Definition of input features HalfRelativeKP of NNUE evaluation function
 
 #ifndef _NNUE_FEATURES_HALF_RELATIVE_KP_H_
 #define _NNUE_FEATURES_HALF_RELATIVE_KP_H_
@@ -14,45 +14,45 @@ namespace NNUE {
 
 namespace Features {
 
-// 特徴�HalfRelativeKP：自玉���敵玉を基準����玉以外��駒�相対�置
+// Feature HalfRelativeKP: Relative position of each piece other than the ball based on own ball or enemy ball
 template <Side AssociatedKing>
 class HalfRelativeKP {
  public:
-  // 特徴��
+  // feature quantity name
   static constexpr const char* kName = (AssociatedKing == Side::kFriend) ?
       "HalfRelativeKP(Friend)" : "HalfRelativeKP(Enemy)";
-  // 評価関数ファイル�埋�込む�ッシュ値
+  // Hash value embedded in the evaluation function file
   static constexpr std::uint32_t kHashValue =
       0xF9180919u ^ (AssociatedKing == Side::kFriend);
-  // 玉を除��駒種
+  // Piece type excluding balls
   static constexpr IndexType kNumPieceKinds = (fe_end - fe_hand_end) / SQUARE_NB;
-  // 玉を中央�置��仮想的�盤�幅
+  // width of the virtual board with the ball in the center
   static constexpr IndexType kBoardWidth = FILE_NB * 2 - 1;
-  // 玉を中央�置��仮想的�盤�高�
+  // height of a virtual board with balls in the center
   static constexpr IndexType kBoardHeight = RANK_NB * 2 - 1;
-  // 特徴��次元数
+  // number of feature dimensions
   static constexpr IndexType kDimensions =
       kNumPieceKinds * kBoardHeight * kBoardWidth;
-  // 特徴������時�値�1��るインデックス�数�最大値
+  // The maximum value of the number of indexes whose value is 1 at the same time among the feature values
   static constexpr IndexType kMaxActiveDimensions = PIECE_NUMBER_KING;
-  // 差分計算�代�り�全計算を行�タイミング
+  // Timing of full calculation instead of difference calculation
   static constexpr TriggerEvent kRefreshTrigger =
       (AssociatedKing == Side::kFriend) ?
       TriggerEvent::kFriendKingMoved : TriggerEvent::kEnemyKingMoved;
 
-  // 特徴�����値�1��るインデックス�リストを�得�る
+  // Get a list of indices with a value of 1 among the features
   static void AppendActiveIndices(const Position& pos, Color perspective,
                                   IndexList* active);
 
-  // 特徴�����一手��ら値�変化��インデックス�リストを�得�る
+  // Get a list of indices whose values ​​have changed from the previous one in the feature quantity
   static void AppendChangedIndices(const Position& pos, Color perspective,
                                    IndexList* removed, IndexList* added);
 
-  // 玉��置�BonaPiece�ら特徴��インデックスを求�る
+  // Find the index of the feature quantity from the ball position and BonaPiece
   static IndexType MakeIndex(Square sq_k, BonaPiece p);
 
  private:
-  // 駒�情報を�得�る
+  // Get the piece information
   static void GetPieces(const Position& pos, Color perspective,
                         BonaPiece** pieces, Square* sq_target_k);
 };
@@ -65,4 +65,4 @@ class HalfRelativeKP {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/features/index_list.h b/src/eval/nnue/features/index_list.h
index a5a71011..90317b4c 100644
--- a/src/eval/nnue/features/index_list.h
+++ b/src/eval/nnue/features/index_list.h
@@ -1,4 +1,4 @@
-// 入力特徴��インデックスリスト�定義
+// Definition of index list of input features
 
 #ifndef _NNUE_FEATURES_INDEX_LIST_H_
 #define _NNUE_FEATURES_INDEX_LIST_H_
@@ -14,7 +14,7 @@ namespace NNUE {
 
 namespace Features {
 
-// 特徴��インデックスリスト�使�クラステンプレート
+// Class template used for feature index list
 template <typename T, std::size_t MaxSize>
 class ValueList {
  public:
@@ -39,7 +39,7 @@ class ValueList {
   std::size_t size_ = 0;
 };
 
-// 特徴��インデックスリスト�型
+//Type of feature index list
 class IndexList
     : public ValueList<IndexType, RawFeatures::kMaxActiveDimensions> {
 };
@@ -52,4 +52,4 @@ class IndexList
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/features/k.cpp b/src/eval/nnue/features/k.cpp
index 03f66ff5..dc01eb92 100644
--- a/src/eval/nnue/features/k.cpp
+++ b/src/eval/nnue/features/k.cpp
@@ -1,4 +1,4 @@
-// NNUE評価関数�入力特徴�K�定義
+//Definition of input feature quantity K of NNUE evaluation function
 
 #if defined(EVAL_NNUE)
 
@@ -11,10 +11,10 @@ namespace NNUE {
 
 namespace Features {
 
-// 特徴�����値�1��るインデックス�リストを�得�る
+// Get a list of indices with a value of 1 among the features
 void K::AppendActiveIndices(
     const Position& pos, Color perspective, IndexList* active) {
-  // コンパイラ�警告を回��る����列サイズ����場��何も���
+  // do nothing if array size is small to avoid compiler warning
   if (RawFeatures::kMaxActiveDimensions < kMaxActiveDimensions) return;
 
   const BonaPiece* pieces = (perspective == BLACK) ?
@@ -27,7 +27,7 @@ void K::AppendActiveIndices(
   }
 }
 
-// 特徴�����一手��ら値�変化��インデックス�リストを�得�る
+// Get a list of indices whose values ​​have changed from the previous one in the feature quantity
 void K::AppendChangedIndices(
     const Position& pos, Color perspective,
     IndexList* removed, IndexList* added) {
diff --git a/src/eval/nnue/features/k.h b/src/eval/nnue/features/k.h
index 1a01c471..0930c160 100644
--- a/src/eval/nnue/features/k.h
+++ b/src/eval/nnue/features/k.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�入力特徴�K�定義
+//Definition of input feature quantity K of NNUE evaluation function
 
 #ifndef _NNUE_FEATURES_K_H_
 #define _NNUE_FEATURES_K_H_
@@ -14,25 +14,25 @@ namespace NNUE {
 
 namespace Features {
 
-// 特徴�K：玉��置
+// Feature K: Ball position
 class K {
  public:
-  // 特徴��
+  // feature quantity name
   static constexpr const char* kName = "K";
-  // 評価関数ファイル�埋�込む�ッシュ値
+  // Hash value embedded in the evaluation function file
   static constexpr std::uint32_t kHashValue = 0xD3CEE169u;
-  // 特徴��次元数
+  // number of feature dimensions
   static constexpr IndexType kDimensions = SQUARE_NB * 2;
-  // 特徴������時�値�1��るインデックス�数�最大値
+  // The maximum value of the number of indexes whose value is 1 at the same time among the feature values
   static constexpr IndexType kMaxActiveDimensions = 2;
-  // 差分計算�代�り�全計算を行�タイミング
+  // Timing of full calculation instead of difference calculation
   static constexpr TriggerEvent kRefreshTrigger = TriggerEvent::kNone;
 
-  // 特徴�����値�1��るインデックス�リストを�得�る
+  // Get a list of indices with a value of 1 among the features
   static void AppendActiveIndices(const Position& pos, Color perspective,
                                   IndexList* active);
 
-  // 特徴�����一手��ら値�変化��インデックス�リストを�得�る
+  // Get a list of indices whose values ​​have changed from the previous one in the feature quantity
   static void AppendChangedIndices(const Position& pos, Color perspective,
                                    IndexList* removed, IndexList* added);
 };
@@ -45,4 +45,4 @@ class K {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/features/p.cpp b/src/eval/nnue/features/p.cpp
index 56bca0a4..68527119 100644
--- a/src/eval/nnue/features/p.cpp
+++ b/src/eval/nnue/features/p.cpp
@@ -1,4 +1,4 @@
-// NNUE評価関数�入力特徴�P�定義
+//Definition of input feature P of NNUE evaluation function
 
 #if defined(EVAL_NNUE)
 
@@ -11,10 +11,10 @@ namespace NNUE {
 
 namespace Features {
 
-// 特徴�����値�1��るインデックス�リストを�得�る
+// Get a list of indices with a value of 1 among the features
 void P::AppendActiveIndices(
     const Position& pos, Color perspective, IndexList* active) {
-  // コンパイラ�警告を回��る����列サイズ����場��何も���
+  // do nothing if array size is small to avoid compiler warning
   if (RawFeatures::kMaxActiveDimensions < kMaxActiveDimensions) return;
 
   const BonaPiece* pieces = (perspective == BLACK) ?
@@ -27,7 +27,7 @@ void P::AppendActiveIndices(
   }
 }
 
-// 特徴�����一手��ら値�変化��インデックス�リストを�得�る
+// Get a list of indices whose values ​​have changed from the previous one in the feature quantity
 void P::AppendChangedIndices(
     const Position& pos, Color perspective,
     IndexList* removed, IndexList* added) {
diff --git a/src/eval/nnue/features/p.h b/src/eval/nnue/features/p.h
index 77ea882d..ded678a5 100644
--- a/src/eval/nnue/features/p.h
+++ b/src/eval/nnue/features/p.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�入力特徴�P�定義
+//Definition of input feature P of NNUE evaluation function
 
 #ifndef _NNUE_FEATURES_P_H_
 #define _NNUE_FEATURES_P_H_
@@ -14,25 +14,25 @@ namespace NNUE {
 
 namespace Features {
 
-// 特徴�P：玉以外�駒�BonaPiece
+// Feature P: BonaPiece of pieces other than balls
 class P {
  public:
-  // 特徴��
+  // feature quantity name
   static constexpr const char* kName = "P";
-  // 評価関数ファイル�埋�込む�ッシュ値
+  // Hash value embedded in the evaluation function file
   static constexpr std::uint32_t kHashValue = 0x764CFB4Bu;
-  // 特徴��次元数
+  // number of feature dimensions
   static constexpr IndexType kDimensions = fe_end;
-  // 特徴������時�値�1��るインデックス�数�最大値
+  // The maximum value of the number of indexes whose value is 1 at the same time among the feature values
   static constexpr IndexType kMaxActiveDimensions = PIECE_NUMBER_KING;
-  // 差分計算�代�り�全計算を行�タイミング
+  // Timing of full calculation instead of difference calculation
   static constexpr TriggerEvent kRefreshTrigger = TriggerEvent::kNone;
 
-  // 特徴�����値�1��るインデックス�リストを�得�る
+  // Get a list of indices with a value of 1 among the features
   static void AppendActiveIndices(const Position& pos, Color perspective,
                                   IndexList* active);
 
-  // 特徴�����一手��ら値�変化��インデックス�リストを�得�る
+  // Get a list of indices whose values ​​have changed from the previous one in the feature quantity
   static void AppendChangedIndices(const Position& pos, Color perspective,
                                    IndexList* removed, IndexList* added);
 };
@@ -45,4 +45,4 @@ class P {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/layers/affine_transform.h b/src/eval/nnue/layers/affine_transform.h
index d8101ba4..99dae0fe 100644
--- a/src/eval/nnue/layers/affine_transform.h
+++ b/src/eval/nnue/layers/affine_transform.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�層AffineTransform�定義
+// Definition of layer AffineTransform of NNUE evaluation function
 
 #ifndef _NNUE_LAYERS_AFFINE_TRANSFORM_H_
 #define _NNUE_LAYERS_AFFINE_TRANSFORM_H_
@@ -13,31 +13,31 @@ namespace NNUE {
 
 namespace Layers {
 
-// アフィン変�層
+// affine transformation layer
 template <typename PreviousLayer, IndexType OutputDimensions>
 class AffineTransform {
  public:
-  // 入出力�型
+  // Input/output type
   using InputType = typename PreviousLayer::OutputType;
   using OutputType = std::int32_t;
   static_assert(std::is_same<InputType, std::uint8_t>::value, "");
 
-  // 入出力�次元数
+  // number of input/output dimensions
   static constexpr IndexType kInputDimensions =
       PreviousLayer::kOutputDimensions;
   static constexpr IndexType kOutputDimensions = OutputDimensions;
   static constexpr IndexType kPaddedInputDimensions =
       CeilToMultiple<IndexType>(kInputDimensions, kMaxSimdWidth);
 
-  // ��層�使用�る順�播用�ッファ�サイズ
+  // Size of forward propagation buffer used in this layer
   static constexpr std::size_t kSelfBufferSize =
       CeilToMultiple(kOutputDimensions * sizeof(OutputType), kCacheLineSize);
 
-  // 入力層�ら��層���使用�る順�播用�ッファ�サイズ
+  // Size of the forward propagation buffer used from the input layer to this layer
   static constexpr std::size_t kBufferSize =
       PreviousLayer::kBufferSize + kSelfBufferSize;
 
-  // 評価関数ファイル�埋�込む�ッシュ値
+  // Hash value embedded in the evaluation function file
   static constexpr std::uint32_t GetHashValue() {
     std::uint32_t hash_value = 0xCC03DAE4u;
     hash_value += kOutputDimensions;
@@ -46,7 +46,7 @@ class AffineTransform {
     return hash_value;
   }
 
-  // 入力層�ら��層���構造を表�文字列
+  // A string that represents the structure from the input layer to this layer
   static std::string GetStructureString() {
     return "AffineTransform[" +
         std::to_string(kOutputDimensions) + "<-" +
@@ -54,7 +54,7 @@ class AffineTransform {
         PreviousLayer::GetStructureString() + ")";
   }
 
-  // パラメータを読�込む
+  // read parameters
   bool ReadParameters(std::istream& stream) {
     if (!previous_layer_.ReadParameters(stream)) return false;
     stream.read(reinterpret_cast<char*>(biases_),
@@ -65,7 +65,7 @@ class AffineTransform {
     return !stream.fail();
   }
 
-  // パラメータを書�込む
+  // write parameters
   bool WriteParameters(std::ostream& stream) const {
     if (!previous_layer_.WriteParameters(stream)) return false;
     stream.write(reinterpret_cast<const char*>(biases_),
@@ -76,7 +76,7 @@ class AffineTransform {
     return !stream.fail();
   }
 
-  // 順�播
+  // forward propagation
   const OutputType* Propagate(
       const TransformedFeatureType* transformed_features, char* buffer) const {
     const auto input = previous_layer_.Propagate(
@@ -151,17 +151,17 @@ class AffineTransform {
   }
 
  private:
-  // パラメータ�型
+  // parameter type
   using BiasType = OutputType;
   using WeightType = std::int8_t;
 
-  // 学習用クラスをfriend��る
+  // Make the learning class a friend
   friend class Trainer<AffineTransform>;
 
-  // ��層�直��層
+  // the layer immediately before this layer
   PreviousLayer previous_layer_;
 
-  // パラメータ
+  // parameter
   alignas(kCacheLineSize) BiasType biases_[kOutputDimensions];
   alignas(kCacheLineSize)
       WeightType weights_[kOutputDimensions * kPaddedInputDimensions];
@@ -175,4 +175,4 @@ class AffineTransform {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/layers/clipped_relu.h b/src/eval/nnue/layers/clipped_relu.h
index 5877fc32..1b7e8fc1 100644
--- a/src/eval/nnue/layers/clipped_relu.h
+++ b/src/eval/nnue/layers/clipped_relu.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�層ClippedReLU�定義
+// Definition of layer ClippedReLU of NNUE evaluation function
 
 #ifndef _NNUE_LAYERS_CLIPPED_RELU_H_
 #define _NNUE_LAYERS_CLIPPED_RELU_H_
@@ -17,49 +17,49 @@ namespace Layers {
 template <typename PreviousLayer>
 class ClippedReLU {
  public:
-  // 入出力�型
+  // Input/output type
   using InputType = typename PreviousLayer::OutputType;
   using OutputType = std::uint8_t;
   static_assert(std::is_same<InputType, std::int32_t>::value, "");
 
-  // 入出力�次元数
+  // number of input/output dimensions
   static constexpr IndexType kInputDimensions =
       PreviousLayer::kOutputDimensions;
   static constexpr IndexType kOutputDimensions = kInputDimensions;
 
-  // ��層�使用�る順�播用�ッファ�サイズ
+  // Size of forward propagation buffer used in this layer
   static constexpr std::size_t kSelfBufferSize =
       CeilToMultiple(kOutputDimensions * sizeof(OutputType), kCacheLineSize);
 
-  // 入力層�ら��層���使用�る順�播用�ッファ�サイズ
+  // Size of the forward propagation buffer used from the input layer to this layer
   static constexpr std::size_t kBufferSize =
       PreviousLayer::kBufferSize + kSelfBufferSize;
 
-  // 評価関数ファイル�埋�込む�ッシュ値
+  // Hash value embedded in the evaluation function file
   static constexpr std::uint32_t GetHashValue() {
     std::uint32_t hash_value = 0x538D24C7u;
     hash_value += PreviousLayer::GetHashValue();
     return hash_value;
   }
 
-  // 入力層�ら��層���構造を表�文字列
+  // A string that represents the structure from the input layer to this layer
   static std::string GetStructureString() {
     return "ClippedReLU[" +
         std::to_string(kOutputDimensions) + "](" +
         PreviousLayer::GetStructureString() + ")";
   }
 
-  // パラメータを読�込む
+  // read parameters
   bool ReadParameters(std::istream& stream) {
     return previous_layer_.ReadParameters(stream);
   }
 
-  // パラメータを書�込む
+  // write parameters
   bool WriteParameters(std::ostream& stream) const {
     return previous_layer_.WriteParameters(stream);
   }
 
-  // 順�播
+  // forward propagation
   const OutputType* Propagate(
       const TransformedFeatureType* transformed_features, char* buffer) const {
     const auto input = previous_layer_.Propagate(
@@ -150,10 +150,10 @@ class ClippedReLU {
   }
 
  private:
-  // 学習用クラスをfriend��る
+  // Make the learning class a friend
   friend class Trainer<ClippedReLU>;
 
-  // ��層�直��層
+  // the layer immediately before this layer
   PreviousLayer previous_layer_;
 };
 
@@ -165,4 +165,4 @@ class ClippedReLU {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/layers/input_slice.h b/src/eval/nnue/layers/input_slice.h
index c9c6a7c9..0497e769 100644
--- a/src/eval/nnue/layers/input_slice.h
+++ b/src/eval/nnue/layers/input_slice.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�層InputSlice�定義
+// NNUE evaluation function layer InputSlice definition
 
 #ifndef _NNUE_LAYERS_INPUT_SLICE_H_
 #define _NNUE_LAYERS_INPUT_SLICE_H_
@@ -13,47 +13,47 @@ namespace NNUE {
 
 namespace Layers {
 
-// 入力層
+// input layer
 template <IndexType OutputDimensions, IndexType Offset = 0>
 class InputSlice {
  public:
-  // アライメントを維��る必���る
+  // need to maintain alignment
   static_assert(Offset % kMaxSimdWidth == 0, "");
 
-  // 出力�型
+  // output type
   using OutputType = TransformedFeatureType;
 
-  // 出力�次元数
+  // output dimensionality
   static constexpr IndexType kOutputDimensions = OutputDimensions;
 
-  // 入力層�ら��層���使用�る順�播用�ッファ�サイズ
+  // Size of the forward propagation buffer used from the input layer to this layer
   static constexpr std::size_t kBufferSize = 0;
 
-  // 評価関数ファイル�埋�込む�ッシュ値
+  // Hash value embedded in the evaluation function file
   static constexpr std::uint32_t GetHashValue() {
     std::uint32_t hash_value = 0xEC42E90Du;
     hash_value ^= kOutputDimensions ^ (Offset << 10);
     return hash_value;
   }
 
-  // 入力層�ら��層���構造を表�文字列
+  // A string that represents the structure from the input layer to this layer
   static std::string GetStructureString() {
     return "InputSlice[" + std::to_string(kOutputDimensions) + "(" +
         std::to_string(Offset) + ":" +
         std::to_string(Offset + kOutputDimensions) + ")]";
   }
 
-  // パラメータを読�込む
+  // read parameters
   bool ReadParameters(std::istream& /*stream*/) {
     return true;
   }
 
-  // パラメータを書�込む
+  // write parameters
   bool WriteParameters(std::ostream& /*stream*/) const {
     return true;
   }
 
-  // 順�播
+  // forward propagation
   const OutputType* Propagate(
       const TransformedFeatureType* transformed_features,
       char* /*buffer*/) const {
@@ -71,4 +71,4 @@ class InputSlice {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/layers/sum.h b/src/eval/nnue/layers/sum.h
index 3fe000cf..c64852a1 100644
--- a/src/eval/nnue/layers/sum.h
+++ b/src/eval/nnue/layers/sum.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�層Sum�定義
+// Definition of layer Sum of NNUE evaluation function
 
 #ifndef _NNUE_LAYERS_SUM_H_
 #define _NNUE_LAYERS_SUM_H_
@@ -13,7 +13,7 @@ namespace NNUE {
 
 namespace Layers {
 
-// 複数�層�出力�和を�る層
+// Layer that sums the output of multiple layers
 template <typename FirstPreviousLayer, typename... RemainingPreviousLayers>
 class Sum : public Sum<RemainingPreviousLayers...> {
  private:
@@ -21,25 +21,25 @@ class Sum : public Sum<RemainingPreviousLayers...> {
   using Tail = Sum<RemainingPreviousLayers...>;
 
  public:
-  // 入出力�型
+  // Input/output type
   using InputType = typename Head::OutputType;
   using OutputType = InputType;
   static_assert(std::is_same<InputType, typename Tail::InputType>::value, "");
 
-  // 入出力�次元数
+  // number of input/output dimensions
   static constexpr IndexType kInputDimensions = Head::kOutputDimensions;
   static constexpr IndexType kOutputDimensions = kInputDimensions;
-  static_assert(kInputDimensions == Tail::kInputDimensions , "");
+  static_assert(kInputDimensions == Tail::kInputDimensions ,"");
 
-  // ��層�使用�る順�播用�ッファ�サイズ
+  // Size of forward propagation buffer used in this layer
   static constexpr std::size_t kSelfBufferSize =
       CeilToMultiple(kOutputDimensions * sizeof(OutputType), kCacheLineSize);
 
-  // 入力層�ら��層���使用�る順�播用�ッファ�サイズ
+  // Size of the forward propagation buffer used from the input layer to this layer
   static constexpr std::size_t kBufferSize =
       std::max(Head::kBufferSize + kSelfBufferSize, Tail::kBufferSize);
 
-  // 評価関数ファイル�埋�込む�ッシュ値
+  // Hash value embedded in the evaluation function file
   static constexpr std::uint32_t GetHashValue() {
     std::uint32_t hash_value = 0xBCE400B4u;
     hash_value ^= Head::GetHashValue() >> 1;
@@ -49,67 +49,67 @@ class Sum : public Sum<RemainingPreviousLayers...> {
     return hash_value;
   }
 
-  // 入力層�ら��層���構造を表�文字列
+  // A string that represents the structure from the input layer to this layer
   static std::string GetStructureString() {
     return "Sum[" +
         std::to_string(kOutputDimensions) + "](" + GetSummandsString() + ")";
   }
 
-  // パラメータを読�込む
+  // read parameters
   bool ReadParameters(std::istream& stream) {
     if (!Tail::ReadParameters(stream)) return false;
     return previous_layer_.ReadParameters(stream);
   }
 
-  // パラメータを書�込む
+  // write parameters
   bool WriteParameters(std::ostream& stream) const {
     if (!Tail::WriteParameters(stream)) return false;
     return previous_layer_.WriteParameters(stream);
   }
 
-  // 順�播
+  // forward propagation
   const OutputType* Propagate(
       const TransformedFeatureType* transformed_features, char* buffer) const {
     Tail::Propagate(transformed_features, buffer);
     const auto head_output = previous_layer_.Propagate(
         transformed_features, buffer + kSelfBufferSize);
     const auto output = reinterpret_cast<OutputType*>(buffer);
-    for (IndexType i = 0; i < kOutputDimensions; ++i) {
+    for (IndexType i = 0; i <kOutputDimensions; ++i) {
       output[i] += head_output[i];
     }
     return output;
   }
 
  protected:
-  // 和を�る対象��る層�リストを表�文字列
+  // A string that represents the list of layers to be summed
   static std::string GetSummandsString() {
     return Head::GetStructureString() + "," + Tail::GetSummandsString();
   }
 
-  // 学習用クラスをfriend��る
+  // Make the learning class a friend
   friend class Trainer<Sum>;
 
-  // ��層�直��層
+  // the layer immediately before this layer
   FirstPreviousLayer previous_layer_;
 };
 
-// 複数�層�出力�和を�る層（テンプレート引数�1��場�）
+// Layer that sums the output of multiple layers (when there is one template argument)
 template <typename PreviousLayer>
 class Sum<PreviousLayer> {
  public:
-  // 入出力�型
+  // Input/output type
   using InputType = typename PreviousLayer::OutputType;
   using OutputType = InputType;
 
-  // 入出力�次元数
+  // number of input/output dimensions
   static constexpr IndexType kInputDimensions =
       PreviousLayer::kOutputDimensions;
   static constexpr IndexType kOutputDimensions = kInputDimensions;
 
-  // 入力層�ら��層���使用�る順�播用�ッファ�サイズ
+  // Size of the forward propagation buffer used from the input layer to this layer
   static constexpr std::size_t kBufferSize = PreviousLayer::kBufferSize;
 
-  // 評価関数ファイル�埋�込む�ッシュ値
+  // Hash value embedded in the evaluation function file
   static constexpr std::uint32_t GetHashValue() {
     std::uint32_t hash_value = 0xBCE400B4u;
     hash_value ^= PreviousLayer::GetHashValue() >> 1;
@@ -117,38 +117,38 @@ class Sum<PreviousLayer> {
     return hash_value;
   }
 
-  // 入力層�ら��層���構造を表�文字列
+  // A string that represents the structure from the input layer to this layer
   static std::string GetStructureString() {
     return "Sum[" +
         std::to_string(kOutputDimensions) + "](" + GetSummandsString() + ")";
   }
 
-  // パラメータを読�込む
+  // read parameters
   bool ReadParameters(std::istream& stream) {
     return previous_layer_.ReadParameters(stream);
   }
 
-  // パラメータを書�込む
+  // write parameters
   bool WriteParameters(std::ostream& stream) const {
     return previous_layer_.WriteParameters(stream);
   }
 
-  // 順�播
+  // forward propagation
   const OutputType* Propagate(
       const TransformedFeatureType* transformed_features, char* buffer) const {
     return previous_layer_.Propagate(transformed_features, buffer);
   }
 
  protected:
-  // 和を�る対象��る層�リストを表�文字列
+  // A string that represents the list of layers to be summed
   static std::string GetSummandsString() {
     return PreviousLayer::GetStructureString();
   }
 
-  // 学習用クラスをfriend��る
+  // Make the learning class a friend
   friend class Trainer<Sum>;
 
-  // ��層�直��層
+  // the layer immediately before this layer
   PreviousLayer previous_layer_;
 };
 
@@ -160,4 +160,4 @@ class Sum<PreviousLayer> {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/nnue_accumulator.h b/src/eval/nnue/nnue_accumulator.h
index 4241edb3..e480526b 100644
--- a/src/eval/nnue/nnue_accumulator.h
+++ b/src/eval/nnue/nnue_accumulator.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�差分計算用�クラス
+// Class for difference calculation of NNUE evaluation function
 
 #ifndef _NNUE_ACCUMULATOR_H_
 #define _NNUE_ACCUMULATOR_H_
@@ -11,8 +11,8 @@ namespace Eval {
 
 namespace NNUE {
 
-// 入力特徴�をアフィン変����果を���るクラス
-// 最終的�出力��る評価値も一緒�������
+// Class that holds the result of affine transformation of input features
+// Keep the evaluation value that is the final output together
 struct alignas(32) Accumulator {
   std::int16_t
       accumulation[2][kRefreshTriggers.size()][kTransformedFeatureDimensions];
@@ -27,4 +27,4 @@ struct alignas(32) Accumulator {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/nnue_architecture.h b/src/eval/nnue/nnue_architecture.h
index 7479ac0a..aa4e8c7f 100644
--- a/src/eval/nnue/nnue_architecture.h
+++ b/src/eval/nnue/nnue_architecture.h
@@ -1,11 +1,11 @@
-// NNUE評価関数�用�る入力特徴���ットワーク構造
+// Input features and network structure used in NNUE evaluation function
 
 #ifndef _NNUE_ARCHITECTURE_H_
 #define _NNUE_ARCHITECTURE_H_
 
 #if defined(EVAL_NNUE)
 
-// 入力特徴���ットワーク構造�定義�れ�ヘッダをinclude�る
+// include a header that defines the input features and network structure
 //#include "architectures/k-p_256x2-32-32.h"
 //#include "architectures/k-p-cr_256x2-32-32.h"
 //#include "architectures/k-p-cr-ep_256x2-32-32.h"
@@ -20,7 +20,7 @@ static_assert(kTransformedFeatureDimensions % kMaxSimdWidth == 0, "");
 static_assert(Network::kOutputDimensions == 1, "");
 static_assert(std::is_same<Network::OutputType, std::int32_t>::value, "");
 
-// 差分計算�代�り�全計算を行�タイミング�リスト
+// List of timings to perform all calculations instead of difference calculation
 constexpr auto kRefreshTriggers = RawFeatures::kRefreshTriggers;
 
 }  // namespace NNUE
@@ -29,4 +29,4 @@ constexpr auto kRefreshTriggers = RawFeatures::kRefreshTriggers;
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/nnue_common.h b/src/eval/nnue/nnue_common.h
index 8ef8fee4..502fbc05 100644
--- a/src/eval/nnue/nnue_common.h
+++ b/src/eval/nnue/nnue_common.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�用�る定数��
+// Constants used in NNUE evaluation function
 
 #ifndef _NNUE_COMMON_H_
 #define _NNUE_COMMON_H_
@@ -15,17 +15,17 @@ namespace Eval {
 
 namespace NNUE {
 
-// 評価関数ファイル��ージョンを表�定数
+// A constant that represents the version of the evaluation function file
 constexpr std::uint32_t kVersion = 0x7AF32F16u;
 
-// 評価値�計算�利用�る定数
+// Constant used in evaluation value calculation
 constexpr int FV_SCALE = 16;
 constexpr int kWeightScaleBits = 6;
 
-// キャッシュライン�サイズ（�イト��）
+// Size of cache line (in bytes)
 constexpr std::size_t kCacheLineSize = 64;
 
-// SIMD幅（�イト��）
+// SIMD width (in bytes)
 #if defined(USE_AVX2)
 constexpr std::size_t kSimdWidth = 32;
 #elif defined(USE_SSE2)
@@ -35,17 +35,17 @@ constexpr std::size_t kSimdWidth = 16;
 #endif
 constexpr std::size_t kMaxSimdWidth = 32;
 
-// 変�後�入力特徴��型
+// Type of input feature after conversion
 using TransformedFeatureType = std::uint8_t;
 
-// インデックス�型
+// index type
 using IndexType = std::uint32_t;
 
-// 学習用クラステンプレート��方宣言
+// Forward declaration of learning class template
 template <typename Layer>
 class Trainer;
 
-// n以上�最��base��数を求�る
+// find the smallest multiple of n and above
 template <typename IntType>
 constexpr IntType CeilToMultiple(IntType n, IntType base) {
   return (n + base - 1) / base * base;
diff --git a/src/eval/nnue/nnue_feature_transformer.h b/src/eval/nnue/nnue_feature_transformer.h
index 57d25310..039a0b98 100644
--- a/src/eval/nnue/nnue_feature_transformer.h
+++ b/src/eval/nnue/nnue_feature_transformer.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�入力特徴��変�を行�クラス
+// A class that converts the input features of the NNUE evaluation function
 
 #ifndef _NNUE_FEATURE_TRANSFORMER_H_
 #define _NNUE_FEATURE_TRANSFORMER_H_
@@ -15,37 +15,37 @@ namespace Eval {
 
 namespace NNUE {
 
-// 入力特徴�変�器
+// Input feature converter
 class FeatureTransformer {
  private:
-  // 片�分�出力�次元数
+  // number of output dimensions for one side
   static constexpr IndexType kHalfDimensions = kTransformedFeatureDimensions;
 
  public:
-  // 出力�型
+  // output type
   using OutputType = TransformedFeatureType;
 
-  // 入出力�次元数
+  // number of input/output dimensions
   static constexpr IndexType kInputDimensions = RawFeatures::kDimensions;
   static constexpr IndexType kOutputDimensions = kHalfDimensions * 2;
 
-  // 順�播用�ッファ�サイズ
+  // size of forward propagation buffer
   static constexpr std::size_t kBufferSize =
       kOutputDimensions * sizeof(OutputType);
 
-  // 評価関数ファイル�埋�込む�ッシュ値
+  // Hash value embedded in the evaluation function file
   static constexpr std::uint32_t GetHashValue() {
     return RawFeatures::kHashValue ^ kOutputDimensions;
   }
 
-  // 構造を表�文字列
+  // a string representing the structure
   static std::string GetStructureString() {
     return RawFeatures::GetName() + "[" +
         std::to_string(kInputDimensions) + "->" +
         std::to_string(kHalfDimensions) + "x2]";
   }
 
-  // パラメータを読�込む
+  // read parameters
   bool ReadParameters(std::istream& stream) {
     stream.read(reinterpret_cast<char*>(biases_),
                 kHalfDimensions * sizeof(BiasType));
@@ -54,7 +54,7 @@ class FeatureTransformer {
     return !stream.fail();
   }
 
-  // パラメータを書�込む
+  // write parameters
   bool WriteParameters(std::ostream& stream) const {
     stream.write(reinterpret_cast<const char*>(biases_),
                  kHalfDimensions * sizeof(BiasType));
@@ -63,7 +63,7 @@ class FeatureTransformer {
     return !stream.fail();
   }
 
-  // �能�ら差分計算を進�る
+  // proceed with the difference calculation if possible
   bool UpdateAccumulatorIfPossible(const Position& pos) const {
     const auto now = pos.state();
     if (now->accumulator.computed_accumulation) {
@@ -77,7 +77,7 @@ class FeatureTransformer {
     return false;
   }
 
-  // 入力特徴�を変��る
+  // convert input features
   void Transform(const Position& pos, OutputType* output, bool refresh) const {
     if (refresh || !UpdateAccumulatorIfPossible(pos)) {
       RefreshAccumulator(pos);
@@ -174,7 +174,7 @@ class FeatureTransformer {
   }
 
  private:
-  // 差分計算を用���累�値を計算�る
+  // Calculate cumulative value without using difference calculation
   void RefreshAccumulator(const Position& pos) const {
     auto& accumulator = pos.state()->accumulator;
     for (IndexType i = 0; i < kRefreshTriggers.size(); ++i) {
@@ -232,7 +232,7 @@ class FeatureTransformer {
     accumulator.computed_score = false;
   }
 
-  // 差分計算を用��累�値を計算�る
+  // Calculate cumulative value using difference calculation
   void UpdateAccumulator(const Position& pos) const {
     const auto prev_accumulator = pos.state()->previous->accumulator;
     auto& accumulator = pos.state()->accumulator;
@@ -263,7 +263,7 @@ class FeatureTransformer {
             std::memset(accumulator.accumulation[perspective][i], 0,
                         kHalfDimensions * sizeof(BiasType));
           }
-        } else {  // 1�ら0�変化��特徴��関�る差分計算
+        } else {// Difference calculation for the feature amount changed from 1 to 0
           std::memcpy(accumulator.accumulation[perspective][i],
                       prev_accumulator.accumulation[perspective][i],
                       kHalfDimensions * sizeof(BiasType));
@@ -292,7 +292,7 @@ class FeatureTransformer {
 #endif
           }
         }
-        {  // 0�ら1�変化��特徴��関�る差分計算
+        {// Difference calculation for features that changed from 0 to 1
           for (const auto index : added_indices[perspective]) {
             const IndexType offset = kHalfDimensions * index;
 #if defined(USE_AVX2)
@@ -325,14 +325,14 @@ class FeatureTransformer {
     accumulator.computed_score = false;
   }
 
-  // パラメータ�型
+  // parameter type
   using BiasType = std::int16_t;
   using WeightType = std::int16_t;
 
-  // 学習用クラスをfriend��る
+  // Make the learning class a friend
   friend class Trainer<FeatureTransformer>;
 
-  // パラメータ
+  // parameter
   alignas(kCacheLineSize) BiasType biases_[kHalfDimensions];
   alignas(kCacheLineSize)
       WeightType weights_[kHalfDimensions * kInputDimensions];
@@ -344,4 +344,4 @@ class FeatureTransformer {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/nnue_test_command.cpp b/src/eval/nnue/nnue_test_command.cpp
index 28e44273..46bc97de 100644
--- a/src/eval/nnue/nnue_test_command.cpp
+++ b/src/eval/nnue/nnue_test_command.cpp
@@ -1,4 +1,4 @@
-// NNUE評価関数�関�るUSI拡張コマンド
+// USI extended command for NNUE evaluation function
 
 #if defined(ENABLE_TEST_CMD) && defined(EVAL_NNUE)
 
@@ -19,15 +19,15 @@ namespace NNUE {
 
 namespace {
 
-// 主�差分計算�関�るRawFeatures�テスト
+// Testing RawFeatures mainly for difference calculation
 void TestFeatures(Position& pos) {
   const std::uint64_t num_games = 1000;
   StateInfo si;
   pos.set(StartFEN, false, &si, Threads.main());
-  const int MAX_PLY = 256; // 256手��テスト
+  const int MAX_PLY = 256; // test up to 256 hands
 
-  StateInfo state[MAX_PLY]; // StateInfoを最大手数分��
-  int ply; // �期局��ら�手数
+  StateInfo state[MAX_PLY]; // StateInfo only for the maximum number of steps
+  int ply; // Trouble from the initial phase
 
   PRNG prng(20171128);
 
@@ -96,13 +96,13 @@ void TestFeatures(Position& pos) {
   for (std::uint64_t i = 0; i < num_games; ++i) {
     auto index_sets = make_index_sets(pos);
     for (ply = 0; ply < MAX_PLY; ++ply) {
-      MoveList<LEGAL> mg(pos); // 全�法手�生�
+      MoveList<LEGAL> mg(pos); // Generate all legal hands
 
-      // �法�指�手����� == 詰�
+      // There was no legal move == Clog
       if (mg.size() == 0)
         break;
 
-      // 生��れ�指�手����らランダム������指�手�局�を進�る。
+      // Randomly choose from the generated moves and advance the phase with the moves.
       Move m = mg.begin()[prng.rand(mg.size())];
       pos.do_move(m, state[ply]);
 
@@ -113,7 +113,7 @@ void TestFeatures(Position& pos) {
 
     pos.set(StartFEN, false, &si, Threads.main());
 
-    // 100回�1回���'.'を出力(進ん��る�����るよ��)
+    // Output'.' every 100 times (so you can see that it's progressing)
     if ((i % 100) == 0)
       std::cout << "." << std::flush;
   }
@@ -141,7 +141,7 @@ void TestFeatures(Position& pos) {
             << ") features" << std::endl;
 }
 
-// 評価関数�構造を表�文字列を出力�る
+// Output a string that represents the structure of the evaluation function
 void PrintInfo(std::istream& stream) {
   std::cout << "network architecture: " << GetArchitectureString() << std::endl;
 
@@ -178,7 +178,7 @@ void PrintInfo(std::istream& stream) {
 
 }  // namespace
 
-// NNUE評価関数�関�るUSI拡張コマンド
+// USI extended command for NNUE evaluation function
 void TestCommand(Position& pos, std::istream& stream) {
   std::string sub_command;
   stream >> sub_command;
diff --git a/src/eval/nnue/nnue_test_command.h b/src/eval/nnue/nnue_test_command.h
index 10f57f6c..570ef01b 100644
--- a/src/eval/nnue/nnue_test_command.h
+++ b/src/eval/nnue/nnue_test_command.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�関�るUSI拡張コマンド�インターフェイス
+// USI extended command interface for NNUE evaluation function
 
 #ifndef _NNUE_TEST_COMMAND_H_
 #define _NNUE_TEST_COMMAND_H_
@@ -9,7 +9,7 @@ namespace Eval {
 
 namespace NNUE {
 
-// NNUE評価関数�関�るUSI拡張コマンド
+// USI extended command for NNUE evaluation function
 void TestCommand(Position& pos, std::istream& stream);
 
 }  // namespace NNUE
diff --git a/src/eval/nnue/trainer/features/factorizer.h b/src/eval/nnue/trainer/features/factorizer.h
index 3bc59260..dea95370 100644
--- a/src/eval/nnue/trainer/features/factorizer.h
+++ b/src/eval/nnue/trainer/features/factorizer.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�特徴�変�クラステンプレート
+// NNUE evaluation function feature conversion class template
 
 #ifndef _NNUE_TRAINER_FEATURES_FACTORIZER_H_
 #define _NNUE_TRAINER_FEATURES_FACTORIZER_H_
@@ -14,31 +14,31 @@ namespace NNUE {
 
 namespace Features {
 
-// 入力特徴�を学習用特徴��変��るクラステンプレート
-// デフォルト��学習用特徴��元�入力特徴�������必��応��特殊化�る
+// Class template that converts input features into learning features
+// By default, the learning feature is the same as the original input feature, and specialized as necessary
 template <typename FeatureType>
 class Factorizer {
  public:
-  // 学習用特徴��次元数を�得�る
+  // Get the dimensionality of the learning feature
   static constexpr IndexType GetDimensions() {
     return FeatureType::kDimensions;
   }
 
-  // 学習用特徴��インデックス�学習率�スケールを�得�る
+  // Get index of learning feature and scale of learning rate
   static void AppendTrainingFeatures(
       IndexType base_index, std::vector<TrainingFeature>* training_features) {
-    assert(base_index < FeatureType::kDimensions);
+    assert(base_index <FeatureType::kDimensions);
     training_features->emplace_back(base_index);
   }
 };
 
-// 学習用特徴��情報
+// Learning feature information
 struct FeatureProperties {
   bool active;
   IndexType dimensions;
 };
 
-// 元�入力特徴�を学習用特徴��追加�る
+// Add the original input features to the learning features
 template <typename FeatureType>
 IndexType AppendBaseFeature(
     FeatureProperties properties, IndexType base_index,
@@ -49,7 +49,7 @@ IndexType AppendBaseFeature(
   return properties.dimensions;
 }
 
-// 学習率�スケール�0���れ�他�種類�学習用特徴�を引�継�
+// If the learning rate scale is not 0, inherit other types of learning features
 template <typename FeatureType>
 IndexType InheritFeaturesIfRequired(
     IndexType index_offset, FeatureProperties properties, IndexType base_index,
@@ -70,8 +70,8 @@ IndexType InheritFeaturesIfRequired(
   return properties.dimensions;
 }
 
-// 学習用特徴�を追加���必��応��インデックス�差分を返�
-// 対応�る特徴����場��InheritFeaturesIfRequired()�代�り�呼�
+// Return the index difference as needed, without adding learning features
+// Call instead of InheritFeaturesIfRequired() if there are no corresponding features
 IndexType SkipFeatures(FeatureProperties properties) {
   if (!properties.active) {
     return 0;
@@ -79,7 +79,7 @@ IndexType SkipFeatures(FeatureProperties properties) {
   return properties.dimensions;
 }
 
-// 学習用特徴��次元数を�得�る
+// Get the dimensionality of the learning feature
 template <std::size_t N>
 constexpr IndexType GetActiveDimensions(
     const FeatureProperties (&properties)[N]) {
@@ -93,7 +93,7 @@ constexpr IndexType GetActiveDimensions(
   return dimensions;
 }
 
-// �列��素数を�得�る
+// get the number of elements in the array
 template <typename T, std::size_t N>
 constexpr std::size_t GetArrayLength(const T (&/*array*/)[N]) {
   return N;
@@ -107,4 +107,4 @@ constexpr std::size_t GetArrayLength(const T (&/*array*/)[N]) {
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/trainer/features/factorizer_feature_set.h b/src/eval/nnue/trainer/features/factorizer_feature_set.h
index 111678e4..0afe7a48 100644
--- a/src/eval/nnue/trainer/features/factorizer_feature_set.h
+++ b/src/eval/nnue/trainer/features/factorizer_feature_set.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�特徴�変�クラステンプレート�FeatureSet用特殊化
+// Specialization for feature set of feature conversion class template of NNUE evaluation function
 
 #ifndef _NNUE_TRAINER_FEATURES_FACTORIZER_FEATURE_SET_H_
 #define _NNUE_TRAINER_FEATURES_FACTORIZER_FEATURE_SET_H_
@@ -14,8 +14,8 @@ namespace NNUE {
 
 namespace Features {
 
-// 入力特徴�を学習用特徴��変��るクラステンプレート
-// FeatureSet用特殊化
+// Class template that converts input features into learning features
+// Specialization for FeatureSet
 template <typename FirstFeatureType, typename... RemainingFeatureTypes>
 class Factorizer<FeatureSet<FirstFeatureType, RemainingFeatureTypes...>> {
  private:
@@ -23,16 +23,16 @@ class Factorizer<FeatureSet<FirstFeatureType, RemainingFeatureTypes...>> {
   using Tail = Factorizer<FeatureSet<RemainingFeatureTypes...>>;
 
  public:
-  // 元�入力特徴��次元数
+  // number of dimensions of original input features
   static constexpr IndexType kBaseDimensions =
       FeatureSet<FirstFeatureType, RemainingFeatureTypes...>::kDimensions;
 
-  // 学習用特徴��次元数を�得�る
+  // Get the dimensionality of the learning feature
   static constexpr IndexType GetDimensions() {
     return Head::GetDimensions() + Tail::GetDimensions();
   }
 
-  // 学習用特徴��インデックス�学習率�スケールを�得�る
+  // Get index of learning feature and scale of learning rate
   static void AppendTrainingFeatures(
       IndexType base_index, std::vector<TrainingFeature>* training_features,
       IndexType base_dimensions = kBaseDimensions) {
@@ -62,20 +62,20 @@ class Factorizer<FeatureSet<FirstFeatureType, RemainingFeatureTypes...>> {
   }
 };
 
-// 入力特徴�を学習用特徴��変��るクラステンプレート
-// FeatureSet�テンプレート引数�1��場��特殊化
+// Class template that converts input features into learning features
+// Specialization when FeatureSet has one template argument
 template <typename FeatureType>
 class Factorizer<FeatureSet<FeatureType>> {
 public:
-  // 元�入力特徴��次元数
+  // number of dimensions of original input features
   static constexpr IndexType kBaseDimensions = FeatureType::kDimensions;
 
-  // 学習用特徴��次元数を�得�る
+  // Get the dimensionality of the learning feature
   static constexpr IndexType GetDimensions() {
     return Factorizer<FeatureType>::GetDimensions();
   }
 
-  // 学習用特徴��インデックス�学習率�スケールを�得�る
+  // Get index of learning feature and scale of learning rate
   static void AppendTrainingFeatures(
       IndexType base_index, std::vector<TrainingFeature>* training_features,
       IndexType base_dimensions = kBaseDimensions) {
@@ -101,4 +101,4 @@ public:
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/trainer/features/factorizer_half_kp.h b/src/eval/nnue/trainer/features/factorizer_half_kp.h
index 28c11074..6ce5854a 100644
--- a/src/eval/nnue/trainer/features/factorizer_half_kp.h
+++ b/src/eval/nnue/trainer/features/factorizer_half_kp.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�特徴�変�クラステンプレート�HalfKP用特殊化
+// Specialization of NNUE evaluation function feature conversion class template for HalfKP
 
 #ifndef _NNUE_TRAINER_FEATURES_FACTORIZER_HALF_KP_H_
 #define _NNUE_TRAINER_FEATURES_FACTORIZER_HALF_KP_H_
@@ -16,18 +16,18 @@ namespace NNUE {
 
 namespace Features {
 
-// 入力特徴�を学習用特徴��変��るクラステンプレート
-// HalfKP用特殊化
+// Class template that converts input features into learning features
+// Specialization for HalfKP
 template <Side AssociatedKing>
 class Factorizer<HalfKP<AssociatedKing>> {
  private:
   using FeatureType = HalfKP<AssociatedKing>;
 
-  // 特徴������時�値�1��るインデックス�数�最大値
+  // The maximum value of the number of indexes whose value is 1 at the same time among the feature values
   static constexpr IndexType kMaxActiveDimensions =
       FeatureType::kMaxActiveDimensions;
 
-  // 学習用特徴��種類
+  // Type of learning feature
   enum TrainingFeatureType {
     kFeaturesHalfKP,
     kFeaturesHalfK,
@@ -36,7 +36,7 @@ class Factorizer<HalfKP<AssociatedKing>> {
     kNumTrainingFeatureTypes,
   };
 
-  // 学習用特徴��情報
+  // Learning feature information
   static constexpr FeatureProperties kProperties[] = {
     // kFeaturesHalfKP
     {true, FeatureType::kDimensions},
@@ -50,12 +50,12 @@ class Factorizer<HalfKP<AssociatedKing>> {
   static_assert(GetArrayLength(kProperties) == kNumTrainingFeatureTypes, "");
 
  public:
-  // 学習用特徴��次元数を�得�る
+  // Get the dimensionality of the learning feature
   static constexpr IndexType GetDimensions() {
     return GetActiveDimensions(kProperties);
   }
 
-  // 学習用特徴��インデックス�学習率�スケールを�得�る
+  // Get index of learning feature and scale of learning rate
   static void AppendTrainingFeatures(
       IndexType base_index, std::vector<TrainingFeature>* training_features) {
     // kFeaturesHalfKP
@@ -100,4 +100,4 @@ constexpr FeatureProperties Factorizer<HalfKP<AssociatedKing>>::kProperties[];
 
 #endif  // defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/trainer/trainer.h b/src/eval/nnue/trainer/trainer.h
index 630f1a3d..f50ce092 100644
--- a/src/eval/nnue/trainer/trainer.h
+++ b/src/eval/nnue/trainer/trainer.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�学習用クラステンプレート�共通ヘッダ
+// Common header of class template for learning NNUE evaluation function
 
 #ifndef _NNUE_TRAINER_H_
 #define _NNUE_TRAINER_H_
@@ -18,10 +18,10 @@ namespace Eval {
 
 namespace NNUE {
 
-// 評価値��率�関係��用�るPonanza定数
+// Ponanza constant used in the relation between evaluation value and winning percentage
 constexpr double kPonanzaConstant = 600.0;
 
-// 学習用特徴��インデックス1�を表�クラス
+// Class that represents one index of learning feature
 class TrainingFeature {
   using StorageType = std::uint32_t;
   static_assert(std::is_unsigned<StorageType>::value, "");
@@ -60,7 +60,7 @@ class TrainingFeature {
   StorageType index_and_count_;
 };
 
-// 学習データ1サンプルを表�構造体
+// Structure that represents one sample of training data
 struct Example {
   std::vector<TrainingFeature> training_features[2];
   Learner::PackedSfenValue psv;
@@ -68,9 +68,9 @@ struct Example {
   double weight;
 };
 
-// �イパーパラメータ�設定���使用�るメッセージ
+// Message used for setting hyperparameters
 struct Message {
-  Message(const std::string& name, const std::string& value = "") :
+  Message(const std::string& name, const std::string& value = ""):
       name(name), value(value), num_peekers(0), num_receivers(0) {}
   const std::string name;
   const std::string value;
@@ -78,7 +78,7 @@ struct Message {
   std::uint32_t num_receivers;
 };
 
-// メッセージを���る����を判定�る
+// determine whether to accept the message
 bool ReceiveMessage(const std::string& name, Message* message) {
   const auto subscript = "[" + std::to_string(message->num_peekers) + "]";
   if (message->name.substr(0, name.size() + 1) == name + "[") {
@@ -91,7 +91,7 @@ bool ReceiveMessage(const std::string& name, Message* message) {
   return false;
 }
 
-// 文字列を分割�る
+// split the string
 std::vector<std::string> Split(const std::string& input, char delimiter) {
   std::istringstream stream(input);
   std::string field;
@@ -102,13 +102,13 @@ std::vector<std::string> Split(const std::string& input, char delimiter) {
   return fields;
 }
 
-// 浮動�数点数を整数�丸�る
+// round a floating point number to an integer
 template <typename IntType>
 IntType Round(double value) {
   return static_cast<IntType>(std::floor(value + 0.5));
 }
 
-// アライメント付�make_shared
+// make_shared with alignment
 template <typename T, typename... ArgumentTypes>
 std::shared_ptr<T> MakeAlignedSharedPtr(ArgumentTypes&&... arguments) {
   const auto ptr = new(aligned_malloc(sizeof(T), alignof(T)))
@@ -122,4 +122,4 @@ std::shared_ptr<T> MakeAlignedSharedPtr(ArgumentTypes&&... arguments) {
 
 #endif  // defined(EVAL_LEARN) && defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/trainer/trainer_affine_transform.h b/src/eval/nnue/trainer/trainer_affine_transform.h
index 34c4816b..f5b208a3 100644
--- a/src/eval/nnue/trainer/trainer_affine_transform.h
+++ b/src/eval/nnue/trainer/trainer_affine_transform.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�学習クラステンプレート�AffineTransform用特殊化
+// Specialization of NNUE evaluation function learning class template for AffineTransform
 
 #ifndef _NNUE_TRAINER_AFFINE_TRANSFORM_H_
 #define _NNUE_TRAINER_AFFINE_TRANSFORM_H_
@@ -15,22 +15,22 @@ namespace Eval {
 
 namespace NNUE {
 
-// 学習：アフィン変�層
+// Learning: Affine transformation layer
 template <typename PreviousLayer, IndexType OutputDimensions>
 class Trainer<Layers::AffineTransform<PreviousLayer, OutputDimensions>> {
  private:
-  // 学習対象�層�型
+  // Type of layer to learn
   using LayerType = Layers::AffineTransform<PreviousLayer, OutputDimensions>;
 
  public:
-  // ファクトリ関数
+  // factory function
   static std::shared_ptr<Trainer> Create(
       LayerType* target_layer, FeatureTransformer* feature_transformer) {
     return std::shared_ptr<Trainer>(
         new Trainer(target_layer, feature_transformer));
   }
 
-  // �イパーパラメータ���オプションを設定�る
+  // Set options such as hyperparameters
   void SendMessage(Message* message) {
     previous_layer_trainer_->SendMessage(message);
     if (ReceiveMessage("momentum", message)) {
@@ -48,19 +48,19 @@ class Trainer<Layers::AffineTransform<PreviousLayer, OutputDimensions>> {
     }
   }
 
-  // パラメータを乱数��期化�る
+  // Initialize the parameters with random numbers
   template <typename RNG>
   void Initialize(RNG& rng) {
     previous_layer_trainer_->Initialize(rng);
     if (kIsOutputLayer) {
-      // 出力層�0��期化�る
+      // Initialize output layer with 0
       std::fill(std::begin(biases_), std::end(biases_),
                 static_cast<LearnFloatType>(0.0));
       std::fill(std::begin(weights_), std::end(weights_),
                 static_cast<LearnFloatType>(0.0));
     } else {
-      // 入力�分布��ユニット平�0.5�等分散��る��を仮定��
-      // 出力�分布��ユニット平�0.5�入力���等分散��るよ���期化�る
+      // Assuming that the input distribution is unit-mean 0.5, equal variance,
+      // Initialize the output distribution so that each unit has a mean of 0.5 and the same variance as the input
       const double kSigma = 1.0 / std::sqrt(kInputDimensions);
       auto distribution = std::normal_distribution<double>(0.0, kSigma);
       for (IndexType i = 0; i < kOutputDimensions; ++i) {
@@ -76,7 +76,7 @@ class Trainer<Layers::AffineTransform<PreviousLayer, OutputDimensions>> {
     QuantizeParameters();
   }
 
-  // 順�播
+  // forward propagation
   const LearnFloatType* Propagate(const std::vector<Example>& batch) {
     if (output_.size() < kOutputDimensions * batch.size()) {
       output_.resize(kOutputDimensions * batch.size());
@@ -111,7 +111,7 @@ class Trainer<Layers::AffineTransform<PreviousLayer, OutputDimensions>> {
     return output_.data();
   }
 
-  // 逆�播
+  // backpropagation
   void Backpropagate(const LearnFloatType* gradients,
                      LearnFloatType learning_rate) {
     const LearnFloatType local_learning_rate =
@@ -185,7 +185,7 @@ class Trainer<Layers::AffineTransform<PreviousLayer, OutputDimensions>> {
   }
 
  private:
-  // コンストラクタ
+  // constructor
   Trainer(LayerType* target_layer, FeatureTransformer* feature_transformer) :
       batch_size_(0),
       batch_input_(nullptr),
@@ -201,7 +201,7 @@ class Trainer<Layers::AffineTransform<PreviousLayer, OutputDimensions>> {
     DequantizeParameters();
   }
 
-  // ���飽和�パラメータ�整数化
+  // Weight saturation and parameterization
   void QuantizeParameters() {
     for (IndexType i = 0; i < kOutputDimensions * kInputDimensions; ++i) {
       weights_[i] = std::max(-kMaxWeightMagnitude,
@@ -222,7 +222,7 @@ class Trainer<Layers::AffineTransform<PreviousLayer, OutputDimensions>> {
     }
   }
 
-  // 整数化�れ�パラメータ�読�込�
+  // read parameterized integer
   void DequantizeParameters() {
     for (IndexType i = 0; i < kOutputDimensions; ++i) {
       biases_[i] = static_cast<LearnFloatType>(
@@ -242,14 +242,14 @@ class Trainer<Layers::AffineTransform<PreviousLayer, OutputDimensions>> {
               static_cast<LearnFloatType>(0.0));
   }
 
-  // 入出力�次元数
+  // number of input/output dimensions
   static constexpr IndexType kInputDimensions = LayerType::kInputDimensions;
   static constexpr IndexType kOutputDimensions = LayerType::kOutputDimensions;
 
-  // 出力�次元数�1�ら出力層
+  // If the output dimensionality is 1, the output layer
   static constexpr bool kIsOutputLayer = kOutputDimensions == 1;
 
-  // パラメータ�整数化�用�る係数
+  // Coefficient used for parameterization
   static constexpr LearnFloatType kActivationScale =
       std::numeric_limits<std::int8_t>::max();
   static constexpr LearnFloatType kBiasScale = kIsOutputLayer ?
@@ -257,37 +257,37 @@ class Trainer<Layers::AffineTransform<PreviousLayer, OutputDimensions>> {
       ((1 << kWeightScaleBits) * kActivationScale);
   static constexpr LearnFloatType kWeightScale = kBiasScale / kActivationScale;
 
-  // パラメータ�整数化�オー�ーフロー�������用�る���絶対値�上�
+  // Upper limit of absolute value of weight used to prevent overflow when parameterizing integers
   static constexpr LearnFloatType kMaxWeightMagnitude =
       std::numeric_limits<typename LayerType::WeightType>::max() / kWeightScale;
 
-  // ミニ�ッ��サンプル数
+  // number of samples in mini-batch
   IndexType batch_size_;
 
-  // ミニ�ッ��入力
+  // Input mini batch
   const LearnFloatType* batch_input_;
 
-  // 直��層�Trainer
+  // Trainer of the previous layer
   const std::shared_ptr<Trainer<PreviousLayer>> previous_layer_trainer_;
 
-  // 学習対象�層
+  // layer to learn
   LayerType* const target_layer_;
 
-  // パラメータ
+  // parameter
   LearnFloatType biases_[kOutputDimensions];
   LearnFloatType weights_[kOutputDimensions * kInputDimensions];
 
-  // パラメータ�更新�用�る�ッファ
+  // Buffer used for updating parameters
   LearnFloatType biases_diff_[kOutputDimensions];
   LearnFloatType weights_diff_[kOutputDimensions * kInputDimensions];
 
-  // 順�播用�ッファ
+  // Forward propagation buffer
   std::vector<LearnFloatType> output_;
 
-  // 逆�播用�ッファ
+  // buffer for back propagation
   std::vector<LearnFloatType> gradients_;
 
-  // �イパーパラメータ
+  // hyper parameter
   LearnFloatType momentum_;
   LearnFloatType learning_rate_scale_;
 };
diff --git a/src/eval/nnue/trainer/trainer_clipped_relu.h b/src/eval/nnue/trainer/trainer_clipped_relu.h
index bd894769..7fe1913d 100644
--- a/src/eval/nnue/trainer/trainer_clipped_relu.h
+++ b/src/eval/nnue/trainer/trainer_clipped_relu.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�学習クラステンプレート�ClippedReLU用特殊化
+// Specialization of NNUE evaluation function learning class template for ClippedReLU
 
 #ifndef _NNUE_TRAINER_CLIPPED_RELU_H_
 #define _NNUE_TRAINER_CLIPPED_RELU_H_
@@ -13,22 +13,22 @@ namespace Eval {
 
 namespace NNUE {
 
-// 学習：アフィン変�層
+// Learning: Affine transformation layer
 template <typename PreviousLayer>
 class Trainer<Layers::ClippedReLU<PreviousLayer>> {
  private:
-  // 学習対象�層�型
+  // Type of layer to learn
   using LayerType = Layers::ClippedReLU<PreviousLayer>;
 
  public:
-  // ファクトリ関数
+  // factory function
   static std::shared_ptr<Trainer> Create(
       LayerType* target_layer, FeatureTransformer* feature_transformer) {
     return std::shared_ptr<Trainer>(
         new Trainer(target_layer, feature_transformer));
   }
 
-  // �イパーパラメータ���オプションを設定�る
+  // Set options such as hyperparameters
   void SendMessage(Message* message) {
     previous_layer_trainer_->SendMessage(message);
     if (ReceiveMessage("check_health", message)) {
@@ -36,13 +36,13 @@ class Trainer<Layers::ClippedReLU<PreviousLayer>> {
     }
   }
 
-  // パラメータを乱数��期化�る
+  // Initialize the parameters with random numbers
   template <typename RNG>
   void Initialize(RNG& rng) {
     previous_layer_trainer_->Initialize(rng);
   }
 
-  // 順�播
+  // forward propagation
   const LearnFloatType* Propagate(const std::vector<Example>& batch) {
     if (output_.size() < kOutputDimensions * batch.size()) {
       output_.resize(kOutputDimensions * batch.size());
@@ -62,7 +62,7 @@ class Trainer<Layers::ClippedReLU<PreviousLayer>> {
     return output_.data();
   }
 
-  // 逆�播
+  // backpropagation
   void Backpropagate(const LearnFloatType* gradients,
                      LearnFloatType learning_rate) {
     for (IndexType b = 0; b < batch_size_; ++b) {
@@ -77,7 +77,7 @@ class Trainer<Layers::ClippedReLU<PreviousLayer>> {
   }
 
  private:
-  // コンストラクタ
+  // constructor
   Trainer(LayerType* target_layer, FeatureTransformer* feature_transformer) :
       batch_size_(0),
       previous_layer_trainer_(Trainer<PreviousLayer>::Create(
@@ -89,7 +89,7 @@ class Trainer<Layers::ClippedReLU<PreviousLayer>> {
               std::numeric_limits<LearnFloatType>::lowest());
   }
 
-  // 学習��題�生�������ェック�る
+  // Check if there are any problems with learning
   void CheckHealth() {
     const auto largest_min_activation = *std::max_element(
         std::begin(min_activations_), std::end(min_activations_));
@@ -105,30 +105,30 @@ class Trainer<Layers::ClippedReLU<PreviousLayer>> {
               std::numeric_limits<LearnFloatType>::lowest());
   }
 
-  // 入出力�次元数
+  // number of input/output dimensions
   static constexpr IndexType kInputDimensions = LayerType::kOutputDimensions;
   static constexpr IndexType kOutputDimensions = LayerType::kOutputDimensions;
 
-  // LearnFloatType�定数
+  // LearnFloatType constant
   static constexpr LearnFloatType kZero = static_cast<LearnFloatType>(0.0);
   static constexpr LearnFloatType kOne = static_cast<LearnFloatType>(1.0);
 
-  // ミニ�ッ��サンプル数
+  // number of samples in mini-batch
   IndexType batch_size_;
 
-  // 直��層�Trainer
+  // Trainer of the previous layer
   const std::shared_ptr<Trainer<PreviousLayer>> previous_layer_trainer_;
 
-  // 学習対象�層
+  // layer to learn
   LayerType* const target_layer_;
 
-  // 順�播用�ッファ
+  // Forward propagation buffer
   std::vector<LearnFloatType> output_;
 
-  // 逆�播用�ッファ
+  // buffer for back propagation
   std::vector<LearnFloatType> gradients_;
 
-  // ヘルス�ェック用統計値
+  // Health check statistics
   LearnFloatType min_activations_[kOutputDimensions];
   LearnFloatType max_activations_[kOutputDimensions];
 };
@@ -139,4 +139,4 @@ class Trainer<Layers::ClippedReLU<PreviousLayer>> {
 
 #endif  // defined(EVAL_LEARN) && defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/trainer/trainer_feature_transformer.h b/src/eval/nnue/trainer/trainer_feature_transformer.h
index 742da440..eb14d98b 100644
--- a/src/eval/nnue/trainer/trainer_feature_transformer.h
+++ b/src/eval/nnue/trainer/trainer_feature_transformer.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�学習クラステンプレート�FeatureTransformer用特殊化
+// Specialization for feature transformer of learning class template of NNUE evaluation function
 
 #ifndef _NNUE_TRAINER_FEATURE_TRANSFORMER_H_
 #define _NNUE_TRAINER_FEATURE_TRANSFORMER_H_
@@ -24,11 +24,11 @@ namespace Eval {
 
 namespace NNUE {
 
-// 学習：入力特徴�変�器
+// Learning: Input feature converter
 template <>
 class Trainer<FeatureTransformer> {
  private:
-  // 学習対象�層�型
+  // Type of layer to learn
   using LayerType = FeatureTransformer;
 
  public:
@@ -37,12 +37,12 @@ class Trainer<FeatureTransformer> {
   template <typename T, typename... ArgumentTypes>
   friend std::shared_ptr<T> MakeAlignedSharedPtr(ArgumentTypes&&... arguments);
 
-  // ファクトリ関数
+  // factory function
   static std::shared_ptr<Trainer> Create(LayerType* target_layer) {
     return MakeAlignedSharedPtr<Trainer>(target_layer);
   }
 
-  // �イパーパラメータ���オプションを設定�る
+  // Set options such as hyperparameters
   void SendMessage(Message* message) {
     if (ReceiveMessage("momentum", message)) {
       momentum_ = static_cast<LearnFloatType>(std::stod(message->value));
@@ -65,7 +65,7 @@ class Trainer<FeatureTransformer> {
     }
   }
 
-  // パラメータを乱数��期化�る
+  // Initialize the parameters with random numbers
   template <typename RNG>
   void Initialize(RNG& rng) {
     std::fill(std::begin(weights_), std::end(weights_), +kZero);
@@ -81,7 +81,7 @@ class Trainer<FeatureTransformer> {
     QuantizeParameters();
   }
 
-  // 順�播
+  // forward propagation
   const LearnFloatType* Propagate(const std::vector<Example>& batch) {
     if (output_.size() < kOutputDimensions * batch.size()) {
       output_.resize(kOutputDimensions * batch.size());
@@ -131,7 +131,7 @@ class Trainer<FeatureTransformer> {
     return output_.data();
   }
 
-  // 逆�播
+  // backpropagation
   void Backpropagate(const LearnFloatType* gradients,
                      LearnFloatType learning_rate) {
     const LearnFloatType local_learning_rate =
@@ -144,8 +144,8 @@ class Trainer<FeatureTransformer> {
             ((output_[index] > kZero) * (output_[index] < kOne));
       }
     }
-    // ��行列�入力�出���特徴��対応�る列��を更新�る���
-    // momentumを使用���学習率を補正��スケールを���る
+    // Since the weight matrix updates only the columns corresponding to the features that appeared in the input,
+    // Correct the learning rate and adjust the scale without using momentum
     const LearnFloatType effective_learning_rate =
         static_cast<LearnFloatType>(local_learning_rate / (1.0 - momentum_));
 #if defined(USE_BLAS)
@@ -227,7 +227,7 @@ class Trainer<FeatureTransformer> {
   }
 
  private:
-  // コンストラクタ
+  // constructor
   Trainer(LayerType* target_layer) :
       batch_(nullptr),
       target_layer_(target_layer),
@@ -245,7 +245,7 @@ class Trainer<FeatureTransformer> {
     DequantizeParameters();
   }
 
-  // ���飽和�パラメータ�整数化
+  // Weight saturation and parameterization
   void QuantizeParameters() {
     for (IndexType i = 0; i < kHalfDimensions; ++i) {
       target_layer_->biases_[i] =
@@ -268,7 +268,7 @@ class Trainer<FeatureTransformer> {
     }
   }
 
-  // 整数化�れ�パラメータ�読�込�
+  // read parameterized integer
   void DequantizeParameters() {
     for (IndexType i = 0; i < kHalfDimensions; ++i) {
       biases_[i] = static_cast<LearnFloatType>(
@@ -282,7 +282,7 @@ class Trainer<FeatureTransformer> {
     std::fill(std::begin(biases_diff_), std::end(biases_diff_), +kZero);
   }
 
-  // 学習データ�出������特徴��対応�る��を0��る
+  // Set the weight corresponding to the feature that does not appear in the learning data to 0
   void ClearUnobservedFeatureWeights() {
     for (IndexType i = 0; i < kInputDimensions; ++i) {
       if (!observed_features.test(i)) {
@@ -293,7 +293,7 @@ class Trainer<FeatureTransformer> {
     QuantizeParameters();
   }
 
-  // 学習��題�生�������ェック�る
+  // Check if there are any problems with learning
   void CheckHealth() {
     std::cout << "INFO: observed " << observed_features.count()
               << " (out of " << kInputDimensions << ") features" << std::endl;
@@ -320,48 +320,48 @@ class Trainer<FeatureTransformer> {
               std::numeric_limits<LearnFloatType>::lowest());
   }
 
-  // 入出力�次元数
+  // number of input/output dimensions
   static constexpr IndexType kInputDimensions =
       Features::Factorizer<RawFeatures>::GetDimensions();
   static constexpr IndexType kOutputDimensions = LayerType::kOutputDimensions;
   static constexpr IndexType kHalfDimensions = LayerType::kHalfDimensions;
 
-  // パラメータ�整数化�用�る係数
+  // Coefficient used for parameterization
   static constexpr LearnFloatType kActivationScale =
       std::numeric_limits<std::int8_t>::max();
   static constexpr LearnFloatType kBiasScale = kActivationScale;
   static constexpr LearnFloatType kWeightScale = kActivationScale;
 
-  // LearnFloatType�定数
+  // LearnFloatType constant
   static constexpr LearnFloatType kZero = static_cast<LearnFloatType>(0.0);
   static constexpr LearnFloatType kOne = static_cast<LearnFloatType>(1.0);
 
-  // ミニ�ッ�
+  // mini batch
   const std::vector<Example>* batch_;
 
-  // 学習対象�層
+  // layer to learn
   LayerType* const target_layer_;
 
-  // パラメータ
+  // parameter
   alignas(kCacheLineSize) LearnFloatType biases_[kHalfDimensions];
   alignas(kCacheLineSize)
       LearnFloatType weights_[kHalfDimensions * kInputDimensions];
 
-  // パラメータ�更新�用�る�ッファ
+  // Buffer used for updating parameters
   LearnFloatType biases_diff_[kHalfDimensions];
   std::vector<LearnFloatType> gradients_;
 
-  // 順�播用�ッファ
+  // Forward propagation buffer
   std::vector<LearnFloatType> output_;
 
-  // 学習データ�出���特徴�
+  // Features that appeared in the training data
   std::bitset<kInputDimensions> observed_features;
 
-  // �イパーパラメータ
+  // hyper parameter
   LearnFloatType momentum_;
   LearnFloatType learning_rate_scale_;
 
-  // ヘルス�ェック用統計値
+  // Health check statistics
   LearnFloatType min_pre_activation_;
   LearnFloatType max_pre_activation_;
   LearnFloatType min_activations_[kHalfDimensions];
@@ -374,4 +374,4 @@ class Trainer<FeatureTransformer> {
 
 #endif  // defined(EVAL_LEARN) && defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/eval/nnue/trainer/trainer_input_slice.h b/src/eval/nnue/trainer/trainer_input_slice.h
index 0660e987..f5b263d3 100644
--- a/src/eval/nnue/trainer/trainer_input_slice.h
+++ b/src/eval/nnue/trainer/trainer_input_slice.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�学習クラステンプレート�InputSlice用特殊化
+// Specialization of NNUE evaluation function learning class template for InputSlice
 
 #ifndef _NNUE_TRAINER_INPUT_SLICE_H_
 #define _NNUE_TRAINER_INPUT_SLICE_H_
@@ -13,10 +13,10 @@ namespace Eval {
 
 namespace NNUE {
 
-// 学習：入力層
+// Learning: Input layer
 class SharedInputTrainer {
  public:
-  // ファクトリ関数
+  // factory function
   static std::shared_ptr<SharedInputTrainer> Create(
       FeatureTransformer* feature_transformer) {
     static std::shared_ptr<SharedInputTrainer> instance;
@@ -27,7 +27,7 @@ class SharedInputTrainer {
     return instance;
   }
 
-  // �イパーパラメータ���オプションを設定�る
+  // Set options such as hyperparameters
   void SendMessage(Message* message) {
     if (num_calls_ == 0) {
       current_operation_ = Operation::kSendMessage;
@@ -40,7 +40,7 @@ class SharedInputTrainer {
     }
   }
 
-  // パラメータを乱数��期化�る
+  // Initialize the parameters with random numbers
   template <typename RNG>
   void Initialize(RNG& rng) {
     if (num_calls_ == 0) {
@@ -54,7 +54,7 @@ class SharedInputTrainer {
     }
   }
 
-  // 順�播
+  // forward propagation
   const LearnFloatType* Propagate(const std::vector<Example>& batch) {
     if (gradients_.size() < kInputDimensions * batch.size()) {
       gradients_.resize(kInputDimensions * batch.size());
@@ -72,7 +72,7 @@ class SharedInputTrainer {
     return output_;
   }
 
-  // 逆�播
+  // backpropagation
   void Backpropagate(const LearnFloatType* gradients,
                      LearnFloatType learning_rate) {
     if (num_referrers_ == 1) {
@@ -104,7 +104,7 @@ class SharedInputTrainer {
   }
 
  private:
-  // コンストラクタ
+  // constructor
   SharedInputTrainer(FeatureTransformer* feature_transformer) :
       batch_size_(0),
       num_referrers_(0),
@@ -115,11 +115,11 @@ class SharedInputTrainer {
       output_(nullptr) {
   }
 
-  // 入出力�次元数
+  // number of input/output dimensions
   static constexpr IndexType kInputDimensions =
       FeatureTransformer::kOutputDimensions;
 
-  // 処��種類
+  // type of processing
   enum class Operation {
     kNone,
     kSendMessage,
@@ -128,55 +128,55 @@ class SharedInputTrainer {
     kBackPropagate,
   };
 
-  // ミニ�ッ��サンプル数
+  // number of samples in mini-batch
   IndexType batch_size_;
 
-  // ��層を入力���共有�る層�数
+  // number of layers sharing this layer as input
   std::uint32_t num_referrers_;
 
-  // �在�処��呼�出�れ�回数
+  // Number of times the current process has been called
   std::uint32_t num_calls_;
 
-  // �在�処��種類
+  // current processing type
   Operation current_operation_;
 
-  // 入力特徴�変�器�Trainer
+  // Trainer of input feature converter
   const std::shared_ptr<Trainer<FeatureTransformer>>
       feature_transformer_trainer_;
 
-  // 順�播用�共有�る出力��インタ
+  // pointer to output shared for forward propagation
   const LearnFloatType* output_;
 
-  // 逆�播用�ッファ
+  // buffer for back propagation
   std::vector<LearnFloatType> gradients_;
 };
 
-// 学習：入力層
+// Learning: Input layer
 template <IndexType OutputDimensions, IndexType Offset>
 class Trainer<Layers::InputSlice<OutputDimensions, Offset>> {
  private:
-  // 学習対象�層�型
+  // Type of layer to learn
   using LayerType = Layers::InputSlice<OutputDimensions, Offset>;
 
  public:
-  // ファクトリ関数
+  // factory function
   static std::shared_ptr<Trainer> Create(
       LayerType* /*target_layer*/, FeatureTransformer* feature_transformer) {
     return std::shared_ptr<Trainer>(new Trainer(feature_transformer));
   }
 
-  // �イパーパラメータ���オプションを設定�る
+  // Set options such as hyperparameters
   void SendMessage(Message* message) {
     shared_input_trainer_->SendMessage(message);
   }
 
-  // パラメータを乱数��期化�る
+  // Initialize the parameters with random numbers
   template <typename RNG>
   void Initialize(RNG& rng) {
     shared_input_trainer_->Initialize(rng);
   }
 
-  // 順�播
+  // forward propagation
   const LearnFloatType* Propagate(const std::vector<Example>& batch) {
     if (output_.size() < kOutputDimensions * batch.size()) {
       output_.resize(kOutputDimensions * batch.size());
@@ -199,7 +199,7 @@ class Trainer<Layers::InputSlice<OutputDimensions, Offset>> {
     return output_.data();
   }
 
-  // 逆�播
+  // backpropagation
   void Backpropagate(const LearnFloatType* gradients,
                      LearnFloatType learning_rate) {
     for (IndexType b = 0; b < batch_size_; ++b) {
@@ -217,28 +217,28 @@ class Trainer<Layers::InputSlice<OutputDimensions, Offset>> {
   }
 
  private:
-  // コンストラクタ
-  Trainer(FeatureTransformer* feature_transformer) :
+  // constructor
+  Trainer(FeatureTransformer* feature_transformer):
       batch_size_(0),
       shared_input_trainer_(SharedInputTrainer::Create(feature_transformer)) {
   }
 
-  // 入出力�次元数
+  // number of input/output dimensions
   static constexpr IndexType kInputDimensions =
       FeatureTransformer::kOutputDimensions;
   static constexpr IndexType kOutputDimensions = OutputDimensions;
   static_assert(Offset + kOutputDimensions <= kInputDimensions, "");
 
-  // ミニ�ッ��サンプル数
+  // number of samples in mini-batch
   IndexType batch_size_;
 
-  // 共有入力層�Trainer
+  // Trainer of shared input layer
   const std::shared_ptr<SharedInputTrainer> shared_input_trainer_;
 
-  // 順�播用�ッファ
+  // Forward propagation buffer
   std::vector<LearnFloatType> output_;
 
-  // 逆�播用�ッファ
+  // buffer for back propagation
   std::vector<LearnFloatType> gradients_;
 };
 
diff --git a/src/eval/nnue/trainer/trainer_sum.h b/src/eval/nnue/trainer/trainer_sum.h
index 76f6073f..bae3edd5 100644
--- a/src/eval/nnue/trainer/trainer_sum.h
+++ b/src/eval/nnue/trainer/trainer_sum.h
@@ -1,4 +1,4 @@
-// NNUE評価関数�学習クラステンプレート�Sum用特殊化
+// Specialization of NNUE evaluation function learning class template for Sum
 
 #ifndef _NNUE_TRAINER_SUM_H_
 #define _NNUE_TRAINER_SUM_H_
@@ -13,40 +13,40 @@ namespace Eval {
 
 namespace NNUE {
 
-// 学習：複数�層�出力�和を�る層
+// Learning: A layer that sums the outputs of multiple layers
 template <typename FirstPreviousLayer, typename... RemainingPreviousLayers>
 class Trainer<Layers::Sum<FirstPreviousLayer, RemainingPreviousLayers...>> :
       Trainer<Layers::Sum<RemainingPreviousLayers...>> {
  private:
-  // 学習対象�層�型
+  // Type of layer to learn
   using LayerType = Layers::Sum<FirstPreviousLayer, RemainingPreviousLayers...>;
   using Tail = Trainer<Layers::Sum<RemainingPreviousLayers...>>;
 
  public:
-  // ファクトリ関数
+  // factory function
   static std::shared_ptr<Trainer> Create(
       LayerType* target_layer, FeatureTransformer* feature_transformer) {
     return std::shared_ptr<Trainer>(
         new Trainer(target_layer, feature_transformer));
   }
 
-  // �イパーパラメータ���オプションを設定�る
+  // Set options such as hyperparameters
   void SendMessage(Message* message) {
-    // 他�メン�関数��果�処��順番��存������
-    // 実装をシンプル��る��を目的���Tailを先�処��る��
-    // SendMessage�添字�対応を分�りや���る���Headを先�処��る
+    // The results of other member functions do not depend on the processing order, so
+    // Tail is processed first for the purpose of simplifying the implementation, but
+    // SendMessage processes Head first to make it easier to understand subscript correspondence
     previous_layer_trainer_->SendMessage(message);
     Tail::SendMessage(message);
   }
 
-  // パラメータを乱数��期化�る
+  // Initialize the parameters with random numbers
   template <typename RNG>
   void Initialize(RNG& rng) {
     Tail::Initialize(rng);
     previous_layer_trainer_->Initialize(rng);
   }
 
-  // 順�播
+  // forward propagation
   /*const*/ LearnFloatType* Propagate(const std::vector<Example>& batch) {
     batch_size_ = static_cast<IndexType>(batch.size());
     auto output = Tail::Propagate(batch);
@@ -65,7 +65,7 @@ class Trainer<Layers::Sum<FirstPreviousLayer, RemainingPreviousLayers...>> :
     return output;
   }
 
-  // 逆�播
+  // backpropagation
   void Backpropagate(const LearnFloatType* gradients,
                      LearnFloatType learning_rate) {
     Tail::Backpropagate(gradients, learning_rate);
@@ -73,8 +73,8 @@ class Trainer<Layers::Sum<FirstPreviousLayer, RemainingPreviousLayers...>> :
   }
 
  private:
-  // コンストラクタ
-  Trainer(LayerType* target_layer, FeatureTransformer* feature_transformer) :
+  // constructor
+  Trainer(LayerType* target_layer, FeatureTransformer* feature_transformer):
       Tail(target_layer, feature_transformer),
       batch_size_(0),
       previous_layer_trainer_(Trainer<FirstPreviousLayer>::Create(
@@ -82,51 +82,51 @@ class Trainer<Layers::Sum<FirstPreviousLayer, RemainingPreviousLayers...>> :
       target_layer_(target_layer) {
   }
 
-  // 入出力�次元数
+  // number of input/output dimensions
   static constexpr IndexType kOutputDimensions = LayerType::kOutputDimensions;
 
-  // サブクラスをfriend��る
+  // make subclass friend
   template <typename SumLayer>
   friend class Trainer;
 
-  // ミニ�ッ��サンプル数
+  // number of samples in mini-batch
   IndexType batch_size_;
 
-  // 直��層�Trainer
+  // Trainer of the previous layer
   const std::shared_ptr<Trainer<FirstPreviousLayer>> previous_layer_trainer_;
 
-  // 学習対象�層
+  // layer to learn
   LayerType* const target_layer_;
 };
 
 
-// 学習：複数�層�出力�和を�る層（テンプレート引数�1��場�）
+// Learning: Layer that takes the sum of the outputs of multiple layers (when there is one template argument)
 template <typename PreviousLayer>
 class Trainer<Layers::Sum<PreviousLayer>> {
  private:
-  // 学習対象�層�型
+  // Type of layer to learn
   using LayerType = Layers::Sum<PreviousLayer>;
 
  public:
-  // ファクトリ関数
+  // factory function
   static std::shared_ptr<Trainer> Create(
       LayerType* target_layer, FeatureTransformer* feature_transformer) {
     return std::shared_ptr<Trainer>(
         new Trainer(target_layer, feature_transformer));
   }
 
-  // �イパーパラメータ���オプションを設定�る
+  // Set options such as hyperparameters
   void SendMessage(Message* message) {
     previous_layer_trainer_->SendMessage(message);
   }
 
-  // パラメータを乱数��期化�る
+  // Initialize the parameters with random numbers
   template <typename RNG>
   void Initialize(RNG& rng) {
     previous_layer_trainer_->Initialize(rng);
   }
 
-  // 順�播
+  // forward propagation
   /*const*/ LearnFloatType* Propagate(const std::vector<Example>& batch) {
     if (output_.size() < kOutputDimensions * batch.size()) {
       output_.resize(kOutputDimensions * batch.size());
@@ -146,14 +146,14 @@ class Trainer<Layers::Sum<PreviousLayer>> {
     return output_.data();
   }
 
-  // 逆�播
+  // backpropagation
   void Backpropagate(const LearnFloatType* gradients,
                      LearnFloatType learning_rate) {
     previous_layer_trainer_->Backpropagate(gradients, learning_rate);
   }
 
  private:
-  // コンストラクタ
+  // constructor
   Trainer(LayerType* target_layer, FeatureTransformer* feature_transformer) :
       batch_size_(0),
       previous_layer_trainer_(Trainer<PreviousLayer>::Create(
@@ -161,23 +161,23 @@ class Trainer<Layers::Sum<PreviousLayer>> {
       target_layer_(target_layer) {
   }
 
-  // 入出力�次元数
+  // number of input/output dimensions
   static constexpr IndexType kOutputDimensions = LayerType::kOutputDimensions;
 
-  // サブクラスをfriend��る
+  // make subclass friend
   template <typename SumLayer>
   friend class Trainer;
 
-  // ミニ�ッ��サンプル数
+  // number of samples in mini-batch
   IndexType batch_size_;
 
-  // 直��層�Trainer
+  // Trainer of the previous layer
   const std::shared_ptr<Trainer<PreviousLayer>> previous_layer_trainer_;
 
-  // 学習対象�層
+  // layer to learn
   LayerType* const target_layer_;
 
-  // 順�播用�ッファ
+  // Forward propagation buffer
   std::vector<LearnFloatType> output_;
 };
 
@@ -187,4 +187,4 @@ class Trainer<Layers::Sum<PreviousLayer>> {
 
 #endif  // defined(EVAL_LEARN) && defined(EVAL_NNUE)
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/extra/sfen_packer.cpp b/src/extra/sfen_packer.cpp
index d56e808b..b3404542 100644
--- a/src/extra/sfen_packer.cpp
+++ b/src/extra/sfen_packer.cpp
@@ -5,33 +5,33 @@
 
 #include <sstream>
 #include <fstream>
-#include <cstring>	// std::memset()
+#include <cstring> // std::memset()
 
 using namespace std;
 
 // -----------------------------------
-//        局��圧縮・解�
+// stage compression/decompression
 // -----------------------------------
 
-// ビットストリームを扱�クラス
-// 局��符�化を行�������れ��る�便利
+// Class that handles bitstream
+// useful when doing aspect encoding
 struct BitStream
 {
-  // データを格��るメモリを事��セット�る。
-  // ��メモリ�0クリア�れ��るも���る。
+  // Set the memory to store the data in advance.
+  // Assume that memory is cleared to 0.
   void  set_data(uint8_t* data_) { data = data_; reset(); }
 
-  // set_data()�渡�れ��インタ��得。
+  // Get the pointer passed in set_data().
   uint8_t* get_data() const { return data; }
 
-  // カーソル��得。
+  // Get the cursor.
   int get_cursor() const { return bit_cursor; }
 
-  // カーソル�リセット
+  // reset the cursor
   void reset() { bit_cursor = 0; }
 
-  // ストリーム�1bit書�出�。
-  // b��0�ら1を書�出�。0�ら0を書�出�。
+  // Write 1bit to the stream.
+  // If b is non-zero, write out 1. If 0, write 0.
   void write_one_bit(int b)
   {
     if (b)
@@ -40,7 +40,7 @@ struct BitStream
     ++bit_cursor;
   }
 
-  // ストリーム�ら1ビット�り出�。
+  // Get 1 bit from the stream.
   int read_one_bit()
   {
     int b = (data[bit_cursor / 8] >> (bit_cursor & 7)) & 1;
@@ -49,16 +49,16 @@ struct BitStream
     return b;
   }
 
-  // nビット�データを書�出�
-  // データ�d�下��ら順�書�出�れるも���る。
+  // write n bits of data
+  // Data shall be written out from the lower order of d.
   void write_n_bit(int d, int n)
   {
-    for (int i = 0; i < n; ++i)
+    for (int i = 0; i <n; ++i)
       write_one_bit(d & (1 << i));
   }
 
-  // nビット�データを読�込む
-  // write_n_bit()�逆変�。
+  // read n bits of data
+  // Reverse conversion of write_n_bit().
   int read_n_bit(int n)
   {
     int result = 0;
@@ -69,46 +69,46 @@ struct BitStream
   }
 
 private:
-  // 次�読�書����bit�置。
+  // Next bit position to read/write.
   int bit_cursor;
 
-  // データ�実体
+  // data entity
   uint8_t* data;
 };
 
 
-//  �フマン符�化
-//   ※　 ���mini�符�化�ら�変��楽��るよ���純化。
+// Huffman coding
+// * is simplified from mini encoding to make conversion easier.
 //
-//   盤上�1�(NO_PIECE以外) = 2～6bit ( + �りフラグ1bit+ 先後1bit )
-//   手駒�1枚               = 1～5bit ( + �りフラグ1bit+ 先後1bit )
+// 1 box on the board (other than NO_PIECE) = 2 to 6 bits (+ 1-bit flag + 1-bit forward and backward)
+// 1 piece of hand piece = 1-5bit (+ 1-bit flag + 1bit ahead and behind)
 //
-//    空     xxxxx0 + 0    (none)
-//    æ­©     xxxx01 + 2    xxxx0 + 2
-//    香     xx0011 + 2    xx001 + 2
-//    æ¡‚     xx1011 + 2    xx101 + 2
-//    銀     xx0111 + 2    xx011 + 2
-//    金     x01111 + 1    x0111 + 1 // 金��りフラグ���。
-//    角     011111 + 2    01111 + 2
-//    飛     111111 + 2    11111 + 2
+// empty xxxxx0 + 0 (none)
+// step xxxx01 + 2 xxxx0 + 2
+// incense xx0011 + 2 xx001 + 2
+// Katsura xx1011 + 2 xx101 + 2
+// silver xx0111 + 2 xx011 + 2
+// Gold x01111 + 1 x0111 + 1 // Gold is valid and has no flags.
+// corner 011111 + 2 01111 + 2
+// Fly 111111 + 2 11111 + 2
 //
-// ����駒�盤上��る����
-//     空 81 - 40駒 = 41� = 41bit
-//     歩      4bit*18駒   = 72bit
-//     香      6bit* 4駒   = 24bit
-//     桂      6bit* 4駒   = 24bit
-//     銀      6bit* 4駒   = 24bit            
-//     金      6bit* 4駒   = 24bit
-//     角      8bit* 2駒   = 16bit
-//     飛      8bit* 2駒   = 16bit
-//                          -------
-//                          241bit + 1bit(手番) + 7bit×2(王��置先後) = 256bit
+// Assuming all pieces are on the board,
+// Sky 81-40 pieces = 41 boxes = 41bit
+// Walk 4bit*18 pieces = 72bit
+// Incense 6bit*4 pieces = 24bit
+// Katsura 6bit*4 pieces = 24bit
+// Silver 6bit*4 pieces = 24bit
+// Gold 6bit* 4 pieces = 24bit
+// corner 8bit* 2 pieces = 16bit
+// Fly 8bit* 2 pieces = 16bit
+// -------
+// 241bit + 1bit (turn) + 7bit × 2 (King's position after) = 256bit
 //
-// 盤上�駒�手駒�移動�る�盤上�駒�空��る��盤上�����1bit�表����
-// 手駒��盤上�駒より1bit少��表���る���局�全体�bit数�変化���。
-// ゆ�����表�������ん�局��も��bit数�表���る。
-// 手駒��りフラグ�������れも������盤上�駒�bit数-1��る��
-// 全体�bit数�固定化��る���れも���������る。
+// When the piece on the board moves to the hand piece, the piece on the board becomes empty, so the box on the board can be expressed with 1 bit,
+// Since the hand piece can be expressed by 1 bit less than the piece on the board, the total number of bits does not change in the end.
+// Therefore, in this expression, any aspect can be expressed by this bit number.
+// It is a hand piece and no flag is required, but if you include this, the bit number of the piece on the board will be -1
+// Since the total number of bits can be fixed, we will include this as well.
 
 // Huffman Encoding
 //
@@ -120,8 +120,8 @@ private:
 
 struct HuffmanedPiece
 {
-  int code; // ��コード化�れる�
-  int bits; // 何bit専有�る��
+  int code; // how it will be coded
+  int bits; // How many bits do you have
 };
 
 HuffmanedPiece huffman_table[] =
@@ -134,11 +134,11 @@ HuffmanedPiece huffman_table[] =
   {0b1001,4}, // QUEEN
 };
 
-// sfenを圧縮/解��る���クラス
-// sfen��フマン符�化を�る���256bit(32bytes)�pack��る。
-// ��������mini�より証明�れ�。上��フマン符�化��る。
+// Class for compressing/decompressing sfen
+// sfen can be packed to 256bit (32bytes) by Huffman coding.
+// This is proven by mini. The above is Huffman coding.
 //
-// 内部フォーマット = 手番1bit+王��置7bit*2 + 盤上�駒(�フマン符�化) + 手駒(�フマン符�化)
+// Internal format = 1-bit turn + 7-bit king position *2 + piece on board (Huffman coding) + hand piece (Huffman coding)
 // Side to move (White = 0, Black = 1) (1bit)
 // White King Position (6 bits)
 // Black King Position (6 bits)
@@ -152,21 +152,21 @@ HuffmanedPiece huffman_table[] =
 //
 struct SfenPacker
 {
-  // sfenをpack��data[32]�格��る。
+  // Pack sfen and store in data[32].
   void pack(const Position& pos)
   {
-//    cout << pos;
+// cout << pos;
 
     memset(data, 0, 32 /* 256bit */);
     stream.set_data(data);
 
-    // 手番
+    // turn
     // Side to move.
     stream.write_one_bit((int)(pos.side_to_move()));
 
-    // 先手玉�後手玉��置��れ�れ7bit
+    // 7-bit positions for leading and trailing balls
     // White king and black king, 6 bits for each.
-    for(auto c : Colors)
+    for(auto c: Colors)
       stream.write_n_bit(pos.king_square(c), 6);
 
     // Write the pieces on the board other than the kings.
@@ -197,24 +197,24 @@ struct SfenPacker
 
     stream.write_n_bit(pos.state()->rule50, 6);
 
-    stream.write_n_bit(1 + (pos.game_ply() - (pos.side_to_move() == BLACK)) / 2, 8);
+    stream.write_n_bit(1 + (pos.game_ply()-(pos.side_to_move() == BLACK)) / 2, 8);
 
     assert(stream.get_cursor() <= 256);
   }
 
-  // pack()�pack�れ�sfen(256bit = 32bytes)
-  // も���unpack()�decode�るsfen
+  // sfen packed by pack() (256bit = 32bytes)
+  // Or sfen to decode with unpack()
   uint8_t *data; // uint8_t[32];
 
 //private:
-  // Position::set_from_packed_sfen(uint8_t data[32])��れら�関数を使�����筋�悪��public�����。
+  // Position::set_from_packed_sfen(uint8_t data[32]) I want to use these functions, so the line is bad, but I want to keep it public.
 
   BitStream stream;
 
-  // 盤��駒をstream�出力�る。
+  // Output the board pieces to stream.
   void write_board_piece_to_stream(Piece pc)
   {
-    // 駒種
+    // piece type
     PieceType pr = type_of(pc);
     auto c = huffman_table[pr];
     stream.write_n_bit(c.code, c.bits);
@@ -222,11 +222,11 @@ struct SfenPacker
     if (pc == NO_PIECE)
       return;
 
-    // 先後フラグ
+    // first and second flag
     stream.write_one_bit(color_of(pc));
   }
 
-  // 盤��駒を1枚stream�ら読�込む
+  // Read one board piece from stream
   Piece read_board_piece_from_stream()
   {
     PieceType pr = NO_PIECE_TYPE;
@@ -238,7 +238,7 @@ struct SfenPacker
 
       assert(bits <= 6);
 
-      for (pr = NO_PIECE_TYPE; pr < KING; ++pr)
+      for (pr = NO_PIECE_TYPE; pr <KING; ++pr)
         if (huffman_table[pr].code == code
           && huffman_table[pr].bits == bits)
           goto Found;
@@ -247,7 +247,7 @@ struct SfenPacker
     if (pr == NO_PIECE_TYPE)
       return NO_PIECE;
 
-    // 先後フラグ
+    // first and second flag
     Color c = (Color)stream.read_one_bit();
     
     return make_piece(c, pr);
@@ -256,12 +256,12 @@ struct SfenPacker
 
 
 // -----------------------------------
-//        Positionクラス�追加
+// Add to Position class
 // -----------------------------------
 
-// 高速化����直接unpack�る関数を追加。��り�ん��。
-// packer::unpack()�Position::set()�を�体���書�。
-// 渡�れ�局���題�����エラー�����0を返�。
+// Add a function that directly unpacks for speed. It's pretty tough.
+// Write it by combining packer::unpack() and Position::set().
+// If there is a problem with the passed phase and there is an error, non-zero is returned.
 int Position::set_from_packed_sfen(const PackedSfen& sfen , StateInfo * si, Thread* th, bool mirror)
 {
 	SfenPacker packer;
@@ -276,17 +276,17 @@ int Position::set_from_packed_sfen(const PackedSfen& sfen , StateInfo * si, Thre
 	// Active color
 	sideToMove = (Color)stream.read_one_bit();
 
-	// evalList�clear。上�memset�ゼロクリア�����クリア�れ��る�…。
+	// clear evalList. It is cleared when memset is cleared to zero above...
 	evalList.clear();
 
-	// PieceListを更新�る上����駒�����る�を設定���れ��ら����
-	// �れ�れ�駒を����使����カウンター
+	// In updating the PieceList, we have to set which piece is where,
+	// A counter of how much each piece has been used
   PieceNumber next_piece_number = PIECE_NUMBER_ZERO;
 
   pieceList[W_KING][0] = SQUARE_NB;
   pieceList[B_KING][0] = SQUARE_NB;
 
-	// ��玉��置
+	// First the position of the ball
 	if (mirror)
 	{
 		for (auto c : Colors)
@@ -308,7 +308,7 @@ int Position::set_from_packed_sfen(const PackedSfen& sfen , StateInfo * si, Thre
         sq = Mir(sq);
       }
 
-      // ���玉��るよ��
+      // it seems there are already balls
       Piece pc;
       if (type_of(board[sq]) != KING)
       {
@@ -318,26 +318,26 @@ int Position::set_from_packed_sfen(const PackedSfen& sfen , StateInfo * si, Thre
       else
       {
         pc = board[sq];
-        board[sq] = NO_PIECE; // �����り除�������put_piece()�ASSERT�引���る。
+        board[sq] = NO_PIECE; // put_piece() will catch ASSERT unless you remove it all.
       }
 
-      // 駒���場�も�る����場��スキップ�る。
+      // There may be no pieces, so skip in that case.
       if (pc == NO_PIECE)
         continue;
 
       put_piece(Piece(pc), sq);
 
-      // evalList�更新
+      // update evalList
       PieceNumber piece_no =
-        (pc == B_KING) ? PIECE_NUMBER_BKING : // 先手玉
-        (pc == W_KING) ? PIECE_NUMBER_WKING : // 後手玉
-        next_piece_number++; // �れ以外
+        (pc == B_KING) ?PIECE_NUMBER_BKING :// Move ball
+        (pc == W_KING) ?PIECE_NUMBER_WKING :// Backing ball
+        next_piece_number++; // otherwise
 
-      evalList.put_piece(piece_no, sq, pc); // sq���pc�駒を�置�る
+      evalList.put_piece(piece_no, sq, pc); // Place the pc piece in the sq box
 
       //cout << sq << ' ' << board[sq] << ' ' << stream.get_cursor() << endl;
 
-      if (stream.get_cursor() > 256)
+      if (stream.get_cursor()> 256)
         return 1;
       //assert(stream.get_cursor() <= 256);
 
@@ -397,7 +397,7 @@ int Position::set_from_packed_sfen(const PackedSfen& sfen , StateInfo * si, Thre
 
   chess960 = false;
   thisThread = th;
-	set_state(st);
+set_state(st);
 
   //std::cout << *this << std::endl;
 
@@ -409,11 +409,11 @@ int Position::set_from_packed_sfen(const PackedSfen& sfen , StateInfo * si, Thre
 	return 0;
 }
 
-// 盤��手駒�手番を与�����sfenを返�。
+// Give the board, hand piece, and turn, and return the sfen.
 //std::string Position::sfen_from_rawdata(Piece board[81], Hand hands[2], Color turn, int gamePly_)
 //{
-//  // 内部的�構造体�コピー���sfen()を呼���変��程�������存������ら�
-//  // �れ�正常�変��れる���…。
+// // Copy it to an internal structure and call sfen() if the conversion process depends only on it
+// // Maybe it will be converted normally...
 //  Position pos;
 //
 //  memcpy(pos.board, board, sizeof(Piece) * 81);
@@ -423,11 +423,11 @@ int Position::set_from_packed_sfen(const PackedSfen& sfen , StateInfo * si, Thre
 //
 //  return pos.sfen();
 //
-//  // ↑�実装�美������ん�ん��。
-//  // 棋譜を大��読�込���学習��る������ボトル�ック��る��直接unpack�る関数を書�。
+// // Implementation of ↑ is beautiful, but slow.
+// // This is a bottleneck when learning a large amount of game records, so write a function to unpack directly.
 //}
 
-// pack�れ�sfenを得る。引数�指定���ッファ�返�。
+// Get the packed sfen. Returns to the buffer specified in the argument.
 void Position::sfen_pack(PackedSfen& sfen)
 {
   SfenPacker sp;
@@ -435,14 +435,13 @@ void Position::sfen_pack(PackedSfen& sfen)
   sp.pack(*this);
 }
 
-//// pack�れ�sfenを解��る。sfen文字列�返る。
+//// Unpack the packed sfen. Returns an sfen string.
 //std::string Position::sfen_unpack(const PackedSfen& sfen)
 //{
-//  SfenPacker sp;
-//  sp.data = (uint8_t*)&sfen;
-//  return sp.unpack();
+// SfenPacker sp;
+// sp.data = (uint8_t*)&sfen;
+// return sp.unpack();
 //}
 
 
 #endif // USE_SFEN_PACKER
-
diff --git a/src/learn/half_float.h b/src/learn/half_float.h
index 31dc5a29..d5c2f83c 100644
--- a/src/learn/half_float.h
+++ b/src/learn/half_float.h
@@ -4,8 +4,8 @@
 // Half Float Library by yaneurao
 // (16-bit float)
 
-// 16bit型�よる浮動�数点演算
-// コンパイラ�生��るfloat型�コード�IEEE 754�形���る�仮定����れを利用�る。
+// Floating point operation by 16bit type
+// Assume that the float type code generated by the compiler is in IEEE 754 format and use it.
 
 #include "../types.h"
 
@@ -99,7 +99,7 @@ namespace HalfFloat
 			return c.f;
 		}
 
-		// unit test��������一応計算�出�る���確���。コード�������(�も)。
+		// It is not a unit test, but I confirmed that it can be calculated. I'll fix the code later (maybe).
 		static void unit_test()
 		{
 			float16 a, b, c, d;
@@ -130,4 +130,4 @@ namespace HalfFloat
 
 }
 
-#endif // __HALF_FLOAT_H__
+#endif // __HALF_FLOAT_H__
\ No newline at end of file
diff --git a/src/learn/learn.h b/src/learn/learn.h
index 246e5cc9..ab53e046 100644
--- a/src/learn/learn.h
+++ b/src/learn/learn.h
@@ -6,173 +6,173 @@
 #include <vector>
 
 // =====================
-//  学習時�設定
+// Settings for learning
 // =====================
 
-// 以下���れ�を�択�れ�������細々��も��自動的��択�れる。
-// ��れも�択���場��������細々��も�を������設定�る必���る。
+// If you select one of the following, the details after that will be automatically selected.
+// If you don't select any of them, you need to set the subsequent details one by one.
 
-// elmo方���学習設定。�れをデフォルト設定��る。
-// 標準�雑巾絞り��る����learnコマンド� "lambda 1"を指定��やれ�良�。
+// Learning setting by elmo method. This is the default setting.
+// To make a standard squeeze diaphragm, specify "lambda 1" with the learn command.
 #define LEARN_ELMO_METHOD
 
 
 // ----------------------
-//        更新�
+// update formula
 // ----------------------
 
-// AdaGrad。�れ�安定���る���勧�。
+// Ada Grad. Recommended because it is stable.
 // #define ADA_GRAD_UPDATE
 
-// 勾��符���見るSGD。�メモリ�済む�精度�…。
+// SGD looking only at the sign of the gradient. It requires less memory, but the accuracy is...
 // #define SGD_UPDATE
 
 // ----------------------
-//    学習時�設定
+// Settings for learning
 // ----------------------
 
-// mini-batchサイズ。
-// ��数���局�を����勾�を計算�る。
-// ����る�update_weights()�回数�増�る�����速��る。勾���正確��る。
-// 大���る�update_weights()�回数�減る��������る。勾��正確�出るよ���る。
-// 多��場��������値を変更�る必�������。
+// mini-batch size.
+// Calculate the gradient by combining this number of phases.
+// If you make it smaller, the number of update_weights() will increase and the convergence will be faster. The gradient is incorrect.
+// If you increase it, the number of update_weights() decreases, so the convergence will be slow. The slope will come out accurately.
+// I don't think you need to change this value in most cases.
 
 #define LEARN_MINI_BATCH_SIZE (1000 * 1000 * 1)
 
-// ファイル�ら1回�読�込む局�数。�れ��読�込ん���shuffle�る。
-// �る程度大�����良�����数×40byte×3��ら��メモリを消費�る。10M局��ら400MB*3程度消費�る。
-// THREAD_BUFFER_SIZE(=10000)��数��る��。
+// The number of phases to read from the file at one time. After reading this much, shuffle.
+// It is better to have a certain size, but this number x 40 bytes x 3 times as much memory is consumed. 400MB*3 is consumed in the 10M phase.
+// Must be a multiple of THREAD_BUFFER_SIZE(=10000).
 
 #define LEARN_SFEN_READ_SIZE (1000 * 1000 * 10)
 
-// 学習時�評価関数��存間隔。��局�数��学習��る����存。
-// 当然��ら��存間隔を長������学習時間�短��る。
-// フォルダ�� 0/ , 1/ , 2/ ...�よ���存���インクリメント�れ���。
-// デフォルト��10億局��1回。
+// Saving interval of evaluation function at learning. Save each time you learn this number of phases.
+// Needless to say, the longer the saving interval, the shorter the learning time.
+// Folder name is incremented for each save like 0/, 1/, 2/...
+// By default, once every 1 billion phases.
 #define LEARN_EVAL_SAVE_INTERVAL (1000000000ULL)
 
 
 // ----------------------
-//    目的関数��択
+// Select the objective function
 // ----------------------
 
-// 目的関数��率�差�二乗和
-// 詳��説明��learner.cppを見る��。
+// The objective function is the sum of squares of the difference in winning percentage
+// See learner.cpp for more information.
 
 //#define LOSS_FUNCTION_IS_WINNING_PERCENTAGE
 
-// 目的関数�交差エントロピー
-// 詳��説明��learner.cppを見る��。
-// ��ゆる�普通�「雑巾絞り�
+// Objective function is cross entropy
+// See learner.cpp for more information.
+// So-called ordinary "rag cloth squeezer"
 //#define LOSS_FUNCTION_IS_CROSS_ENTOROPY
 
-// 目的関数�交差エントロピー����率�関数を通���版
+// A version in which the objective function is cross entropy, but the win rate function is not passed
 // #define LOSS_FUNCTION_IS_CROSS_ENTOROPY_FOR_VALUE
 
-// elmo(WCSC27)�方�
+// elmo (WCSC27) method
 // #define LOSS_FUNCTION_IS_ELMO_METHOD
 
-// ※　他�色々追加�る�も。
+// ※ Other things may be added.
 
 
 // ----------------------
-// 学習�関�るデ�ッグ設定
+// debug settings for learning
 // ----------------------
 
-// 学習時�rmse�出力を��回数�1回�減ら�。
-// rmse�計算�1スレッド�行��������時間を�られる��出力を減ら��効果��る。
+// Reduce the output of rmse during learning to 1 for this number of times.
+// rmse calculation is done in one thread, so it takes some time, so reducing the output is effective.
 #define LEARN_RMSE_OUTPUT_INTERVAL 1
 
 
 // ----------------------
-// ゼロベクトル�ら�学習
+// learning from zero vector
 // ----------------------
 
-// 評価関数パラメーターをゼロベクトル�ら学習を開始�る。
-// ゼロ�期化��棋譜生���ゼロベクトル�ら学習����
-// 棋譜生�→学習を繰り返��プロ�棋譜��ら��パラメーター�得られる。(�も)
-// (���時間��る)
+// Start learning the evaluation function parameters from the zero vector.
+// Initialize to zero, generate a game, learn from zero vector,
+// Game generation → If you repeat learning, you will get parameters that do not depend on the professional game. (maybe)
+// (very time consuming)
 
 //#define RESET_TO_ZERO_VECTOR
 
 
 // ----------------------
-//  学習����浮動�数
+// Floating point for learning
 // ----------------------
 
-// �れをdouble������計算精度�上�る�����列絡��メモリ��必���る。
-// �状���をfloat���場��評価関数ファイル�対������列���4.5��サイズ。(KPPT�4.5GB程度)
-// double型���も���仕方���ん�差異�������float�固定�る。
+// If this is set to double, the calculation accuracy will be higher, but the weight array entangled memory will be doubled.
+// Currently, if this is float, the weight array is 4.5 times the size of the evaluation function file. (About 4.5GB with KPPT)
+// Even if it is a double type, there is almost no difference in the way of convergence, so fix it to float.
 
-// floatを使�場�
+// when using float
 typedef float LearnFloatType;
 
-// doubleを使�場�
+// when using double
 //typedef double LearnFloatType;
 
-// float16を使�場�
+// when using float16
 //#include "half_float.h"
 //typedef HalfFloat::float16 LearnFloatType;
 
 // ----------------------
-//  �メモリ化
+// save memory
 // ----------------------
 
-// Weight�列(����KPP)�三角�列を用���メモリ化�る。
-// �れを用�る��学習用����列�評価関数ファイル�3�程度�済むよ���る。
+// Use a triangular array for the Weight array (of which is KPP) to save memory.
+// If this is used, the weight array for learning will be about 3 times as large as the evaluation function file.
 
 #define USE_TRIANGLE_WEIGHT_ARRAY
 
 // ----------------------
-//  次元下�
+// dimension down
 // ----------------------
 
-// ミラー(左�対称性)�イン�ース(先後対称性)�関��次元下�を行��。
-// デフォルト�����オン。
+// Dimension reduction for mirrors (left/right symmetry) and inverse (forward/backward symmetry).
+// All on by default.
 
-// KK�対��ミラー�イン�ースを利用��次元下�を行��。(効果�����明)
-// USE_KK_INVERSE_WRITEをオン��る���USE_KK_MIRROR_WRITEもオン���れ��ら��。
+// Dimension reduction using mirror and inverse for KK. (Unclear effect)
+// USE_KK_MIRROR_WRITE must be on when USE_KK_INVERSE_WRITE is on.
 #define USE_KK_MIRROR_WRITE
 #define USE_KK_INVERSE_WRITE
 
-// KKP�対��ミラー�イン�ースを利用��次元下�を行��。(イン�ース����効果�����明)
-// USE_KKP_INVERSE_WRITEをオン��る����USE_KKP_MIRROR_WRITEもオン�������れ��ら��。
+// Dimension reduction using Mirror and Inverse for KKP. (Inverse is not so effective)
+// When USE_KKP_INVERSE_WRITE is turned on, USE_KKP_MIRROR_WRITE must also be turned on.
 #define USE_KKP_MIRROR_WRITE
 #define USE_KKP_INVERSE_WRITE
 
-// KPP�対��ミラーを利用��次元下�を行��。(�れをオフ��る�教師局����ら�必���る)
-// KPP��イン�ース���。(先手��K������)
+// Perform dimension reduction using a mirror for KPP. (Turning this off requires double the teacher position)
+// KPP has no inverse. (Because there is only K on the front side)
 #define USE_KPP_MIRROR_WRITE
 
-// KPPP�対��ミラーを利用��次元下�を行��。(�れをオフ��る�教師局����ら�必���る)
-// KPPP�もイン�ース���。(先手��K������)
+// Perform a dimension reduction using a mirror for KPPP. (Turning this off requires double the teacher position)
+// KPPP has no inverse. (Because there is only K on the front side)
 #define USE_KPPP_MIRROR_WRITE
 
-// KKPP�分�対��学習時�KPP�よる次元下�を行��。
-// 学習����ゃ���る。
-// 未デ�ッグ���使�����。
+// Reduce the dimension by KPP for learning the KKPP component.
+// Learning is very slow.
+// Do not use as it is not debugged.
 //#define USE_KKPP_LOWER_DIM
 
 
 // ======================
-//  教師局�生�時�設定
+// Settings for creating teacher phases
 // ======================
 
 // ----------------------
-//  引�分�を書�出�
+// write out the draw
 // ----------------------
 
-// 引�分��至������れを教師局����書�出�
-// �れを�る���良������微妙。
+// When you reach a draw, write it out as a teacher position
+// It's subtle whether it's better to do this.
 // #define LEARN_GENSFEN_USE_DRAW_RESULT
 
 
 // ======================
-//       configure
+// configure
 // ======================
 
 // ----------------------
-//  elmo(WCSC27)�方法��学習
+// Learning with the method of elmo (WCSC27)
 // ----------------------
 
 #if defined( LEARN_ELMO_METHOD )
@@ -182,49 +182,49 @@ typedef float LearnFloatType;
 
 
 // ----------------------
-// Learner�用�るstruct�定義
+// Definition of struct used in Learner
 // ----------------------
 #include "../position.h"
 
 namespace Learner
 {
-	// PackedSfen�評価値�一体化��構造体
-	// オプション���書�出�内容�異�る�教師棋譜を�利用�る���困る��
-	// �り����以下�メン�ー�オプション�よら����書�出����。
+	//Structure in which PackedSfen and evaluation value are integrated
+	// If you write different contents for each option, it will be a problem when reusing the teacher game
+	// For the time being, write all the following members regardless of the options.
 	struct PackedSfenValue
 	{
-		// 局�
+		// phase
 		PackedSfen sfen;
 
-		// Learner::search()�ら返����評価値
+		// Evaluation value returned from Learner::search()
 		int16_t score;
 
-		// PV��手
-		// 教師��指�手一致率を求�る�����用�る
+		// PV first move
+		// Used when finding the match rate with the teacher
 		uint16_t move;
 
-		// �期局��ら�局��手数。
+		// Trouble of the phase from the initial phase.
 		uint16_t gamePly;
 
-		// ��局��手番���ゲームを最終的�����る�ら1。負���る�ら-1。
-		// 引�分��至��場���0。
-		// 引�分���教師局�生�コマンドgensfen�����
-		// LEARN_GENSFEN_DRAW_RESULT�有効������書�出�。
+		// 1 if the player on this side ultimately wins the game. -1 if you are losing.
+		// 0 if a draw is reached.
+		// The draw is in the teacher position generation command gensfen,
+		// Only write if LEARN_GENSFEN_DRAW_RESULT is enabled.
 		int8_t game_result;
 
-		// 教師局�を書�出��ファイルを他�人�やり�り�る���
-		// ��構造体サイズ��定��困る���padding����環境�も必�40bytes��るよ������。
+		// When exchanging the file that wrote the teacher aspect with other people
+		//Because this structure size is not fixed, pad it so that it is 40 bytes in any environment.
 		uint8_t padding;
 
 		// 32 + 2 + 2 + 2 + 1 + 1 = 40bytes
 	};
 
-	// 読�筋������評価値を返�型
-	// Learner::search() , Learner::qsearch()�用�る。
+	// Type that returns the reading line and the evaluation value at that time
+	// Used in Learner::search(), Learner::qsearch().
 	typedef std::pair<Value, std::vector<Move> > ValueAndPV;
 
-	// �������や��ら王2018 Otafuku�����スタブを�������
-	// EVAL_LEARNをdefine�る�ら���スタブ�必須。
+	// So far, only Yaneura King 2018 Otafuku has this stub
+	// This stub is required if EVAL_LEARN is defined.
 	extern Learner::ValueAndPV  search(Position& pos, int depth , size_t multiPV = 1 , uint64_t NodesLimit = 0);
 	extern Learner::ValueAndPV qsearch(Position& pos);
 
@@ -234,4 +234,4 @@ namespace Learner
 
 #endif
 
-#endif // ifndef _LEARN_H_
+#endif // ifndef _LEARN_H_
\ No newline at end of file
diff --git a/src/learn/learner.cpp b/src/learn/learner.cpp
index f105296f..fb0d9959 100644
--- a/src/learn/learner.cpp
+++ b/src/learn/learner.cpp
@@ -1,16 +1,16 @@
-// 学習関係�ルー�ン
+// learning routines
 //
-// 1) 棋譜�自動生�
-//   → "gensfen"コマンド
-// 2) 生���棋譜�ら�評価関数パラメーター�学習
-//   → "learn"コマンド
-//   → 教師局��shuffleも��コマンド�拡張���行��。
-//   例) "learn shuffle"
-// 3) 定跡�自動生�
-//   → "makebook think"コマンド
-//   → extra/book/book.cpp�実装
-// 4) 局後自動検討モード
-//   →　GUI�補�����題���エンジン��関与�������る。
+// 1) Automatic generation of game records
+// → "gensfen" command
+// 2) Learning evaluation function parameters from the generated game record
+// → "learn" command
+// → Shuffle in the teacher phase is also an extension of this command.
+// Example) "learn shuffle"
+// 3) Automatic generation of fixed traces
+// → "makebook think" command
+// → implemented in extra/book/book.cpp
+// 4) Post-station automatic review mode
+// → I will not be involved in the engine because it is a problem that the GUI should assist.
 // etc..
 
 #if defined(EVAL_LEARN)
@@ -23,15 +23,15 @@
 #include "multi_think.h"
 #include "../uci.h"
 
-// 学習用�evaluate絡��header
+// evaluate header for learning
 #include "../eval/evaluate_common.h"
 
 // ----------------------
-// 設定内容�基��定数文字列
+// constant string based on the settings
 // ----------------------
 
-// 更新��応��文字列。(デ�ッグ用�出力�る。)
-// 色々更新�を実装���AdaGrad�速度��メモリ�����ベスト����論����。
+// Character string according to update formula. (Output for debugging.)
+// Implemented various update expressions, but concluded that AdaGrad is the best in terms of speed and memory.
 #if defined(ADA_GRAD_UPDATE)
 #define LEARN_UPDATE "AdaGrad"
 #elif defined(SGD_UPDATE)
@@ -49,7 +49,7 @@
 #endif
 
 // -----------------------------------
-//    以下�実装部。
+// Below, the implementation section.
 // -----------------------------------
 
 #include <sstream>
@@ -65,9 +65,9 @@
 #endif
 
 #if defined(_MSC_VER)
-// C++�filesystem��C++17以���MSVC����使���よ��。
-// windows.hを使�よ������msys2�g++�����フォルダ内�ファイル��得����。
-// 仕方����dirent.hを用�る。
+// The C++ filesystem cannot be used unless it is C++17 or later or MSVC.
+// I tried to use windows.h, but with g++ of msys2 I can not get the files in the folder well.
+// Use dirent.h because there is no help for it.
 #include <filesystem>
 #elif defined(__GNUC__)
 #include <dirent.h>
@@ -87,17 +87,17 @@
 
 using namespace std;
 
-//// �れ�探索部�定義�れ��るも���る。
+//// This is defined in the search section.
 //extern Book::BookMoveSelector book;
 
-// atomic<T>�対�る足�算�引�算�定義
-// Apery/learner.hpp��るatomicAdd()������る。
+// Addition and subtraction definition for atomic<T>
+// Aligned with atomicAdd() in Apery/learner.hpp.
 template <typename T>
 T operator += (std::atomic<T>& x, const T rhs)
 {
 	T old = x.load(std::memory_order_consume);
-	// ��タイミング�他スレッド�ら値�書���られる���許容�る。
-	// 値�破壊�れ��れ�良����考�。
+	// It is allowed that the value is rewritten from other thread at this timing.
+	// The idea that the value is not destroyed is good.
 	T desired = old + rhs;
 	while (!x.compare_exchange_weak(old, desired, std::memory_order_release, std::memory_order_consume))
 		desired = old + rhs;
@@ -109,7 +109,7 @@ T operator -= (std::atomic<T>& x, const T rhs) { return x += -rhs; }
 namespace Learner
 {
 
-// 局���列 : PSVector � packed sfen vector �略。
+// Phase array: PSVector stands for packed sfen vector.
 typedef std::vector<PackedSfenValue> PSVector;
 
 bool use_draw_in_training_data_generation = false;
@@ -118,20 +118,20 @@ bool use_draw_in_validation = false;
 bool use_hash_in_training = true;
 
 // -----------------------------------
-//    局��ファイル��書�出�
+// write phase file
 // -----------------------------------
 
-// Sfenを書�出��行����ヘルパクラス
+// Helper class for exporting Sfen
 struct SfenWriter
 {
-	// 書�出�ファイル��生��るスレッド�数
+		// File name to write and number of threads to create
 	SfenWriter(string filename, int thread_num)
 	{
 		sfen_buffers_pool.reserve((size_t)thread_num * 10);
 		sfen_buffers.resize(thread_num);
 
-		// 追加学習�る���評価関数�学習後も生��れる教師�質���り変�ら��教師局�数を稼�����
-		// ��教師も使���好���������仕様����る。
+		// When performing additional learning, the quality of the teacher generated after learning the evaluation function does not change much and I want to earn more teacher positions.
+		// Since it is preferable that old teachers also use it, it has such a specification.
 		fs.open(filename, ios::out | ios::binary | ios::app);
 		filename_ = filename;
 
@@ -144,76 +144,76 @@ struct SfenWriter
 		file_worker_thread.join();
 		fs.close();
 
-		// file_worker_thread����書�出�������buffer����空�������..
+		// all buffers should be empty since file_worker_thread has written all..
 		for (auto p : sfen_buffers) { assert(p == nullptr); }
 		assert(sfen_buffers_pool.empty());
 	}
 
-	// �スレッド�������局�数���ファイル�flush�る。
+	// For each thread, flush the file by this number of phases.
 	const size_t SFEN_WRITE_SIZE = 5000;
 
-	// 局��評価値をペア���1�書�出�(pack�れ�sfen形��)
+	// write one by pairing the phase and evaluation value (in packed sfen format)
 	void write(size_t thread_id, const PackedSfenValue& psv)
 	{
-		// スレッド���bufferを���������追加�る。
-		// buffer�溢れ�ら�ファイル�書�出�。
+		// We have a buffer for each thread and add it there.
+		// If the buffer overflows, write it to a file.
 
-		// ���ッファ�スレッド���用��れ��る。
+		// This buffer is prepared for each thread.
 		auto& buf = sfen_buffers[thread_id];
 
-		// �回�スレッド�ッファを書�出��直後�buf�����確��る。
+		// Secure since there is no buf at the first time and immediately after writing the thread buffer.
 		if (!buf)
 		{
 			buf = new PSVector();
 			buf->reserve(SFEN_WRITE_SIZE);
 		}
 
-		// スレッド���用��れ��り�一��スレッド��時���write()関数を呼�出�����
-		// ��時点��排他�る必����。
+		// It is prepared for each thread, so one thread does not call this write() function at the same time.
+		// There is no need to exclude at this point.
 		buf->push_back(psv);
 
 		if (buf->size() >= SFEN_WRITE_SIZE)
 		{
-			// sfen_buffers_pool��ん�������worker�よ��計ら���れる。
+			// If you load it in sfen_buffers_pool, the worker will do the rest.
 
-			// sfen_buffers_pool�内容を変更�る���mutex�lock�必�。
+			// Mutex lock is required when changing the contents of sfen_buffers_pool.
 			std::unique_lock<std::mutex> lk(mutex);
 			sfen_buffers_pool.push_back(buf);
 
 			buf = nullptr;
-			// buf == nullptr������次回���関数�呼�出�れ�����ッファ�確��れる。
+			// If you set buf == nullptr, the buffer will be allocated the next time this function is called.
 		}
 	}
 
-	// 自分�スレッド用��ッファ�残���る分をファイル�書�出�����ッファ�移動��る。
+	// Move what remains in the buffer for your thread to a buffer for writing to a file.
 	void finalize(size_t thread_id)
 	{
 		std::unique_lock<std::mutex> lk(mutex);
 
 		auto& buf = sfen_buffers[thread_id];
 
-		// buf==nullptr��るケースも�る�����ェック�必�。
+		// There is a case that buf==nullptr, so that check is necessary.
 		if (buf && buf->size() != 0)
 			sfen_buffers_pool.push_back(buf);
 
 		buf = nullptr;
 	}
 
-	// write_workerスレッドを開始�る。
+	// Start the write_worker thread.
 	void start_file_write_worker()
 	{
 		file_worker_thread = std::thread([&] { this->file_write_worker(); });
 	}
 
-	// ファイル�書�出��専用スレッド
+	// Dedicated thread to write to file
 	void file_write_worker()
 	{
 		auto output_status = [&]()
 		{
-			// �在時刻も出力
+			// also output the current time
 			sync_cout << endl << sfen_write_count << " sfens , at " << now_string() << sync_endl;
 
-			// flush()���タイミング��分。
+			// This is enough for flush().
 			fs.flush();
 		};
 
@@ -223,12 +223,12 @@ struct SfenWriter
 			{
 				std::unique_lock<std::mutex> lk(mutex);
 
-				// �る��コピー
+				// copy the whole
 				buffers = sfen_buffers_pool;
 				sfen_buffers_pool.clear();
 			}
 
-			// 何も�得������らsleep()
+			// sleep() if you didn't get anything
 			if (!buffers.size())
 				sleep(100);
 			else
@@ -240,83 +240,83 @@ struct SfenWriter
 					sfen_write_count += ptr->size();
 
 #if 1
-					// 処���件数を���加算�����save_everyを超��ら�ファイル�を変更����カウンターをリセット�る。
+					// Add the processed number here, and if it exceeds save_every, change the file name and reset this counter.
 					save_every_counter += ptr->size();
 					if (save_every_counter >= save_every)
 					{
 						save_every_counter = 0;
-						// ファイル�を変更。
+						// Change the file name.
 
 						fs.close();
 
-						// ファイル���る連番
+						// Sequential number attached to the file
 						int n = (int)(sfen_write_count / save_every);
-						// ファイル�を変更���度open�る。上書�考慮��ios::appを�����。(�用�よ������������も..)
+						// Rename the file and open it again. Add ios::app in consideration of overwriting. (Depending on the operation, it may not be necessary.)
 						string filename = filename_ + "_" + std::to_string(n);
 						fs.open(filename, ios::out | ios::binary | ios::app);
 						cout << endl << "output sfen file = " << filename << endl;
 					}
 #endif
 
-					// 棋譜を書�出����'.'を出力。
+					// Output'.' every time when writing a game record.
 					std::cout << ".";
 
-					// 40回���処���局�数を出力
-					// 最後��スレッド�教師局��余りを書�出���中途�端�数�表示�れる�������…。
-					// スレッドを論�コア�最大数��酷使�る�コンソール�詰�る��も�少�間隔甘��も�����。
+					// Output the number of phases processed every 40 times
+					// Finally, the remainder of the teacher phase of each thread is written out, so halfway numbers are displayed, but is it okay?
+					// If you overuse the threads to the maximum number of logical cores, the console will be clogged, so it may be a little more loose.
 					if ((++time_stamp_count % 40) == 0)
 						output_status();
 
-					// ��メモリ��������タイミング�開放����。
+					// Since this memory is unnecessary, release it at this timing.
 					delete ptr;
 				}
 			}
 		}
 
-		// 終了��も�一度�タイムスタンプを出力。
+		// Output the time stamp again before the end.
 		output_status();
 	}
 
-	// �����ファイル�を変更�る。
+	// Change the file name in this unit.
 	uint64_t save_every = UINT64_MAX;
 
 private:
 
 	fstream fs;
 
-	// コンストラクタ�渡�れ�ファイル�
+	// File name passed in the constructor
 	std::string filename_;
 
-	// 処���件数を���加算�����save_everyを超��ら�ファイル�を変更����カウンターをリセット�る。
+	// Add the processed number here, and if it exceeds save_every, change the file name and reset this counter.
 	uint64_t save_every_counter = 0;
 
-	// ファイル�書�込む用�thread
+	// thread to write to the file
 	std::thread file_worker_thread;
-	// ����スレッド�終了����フラグ
+	// Flag that all threads have finished
 	atomic<bool> finished;
 
-	// タイムスタンプ�出力用�カウンター
+	// Counter for time stamp output
 	uint64_t time_stamp_count = 0;
 
-	// ファイル�書�出����ッファ
-	// sfen_buffers��スレッド�対�る�ッファ
-	// sfen_buffers_pool�書�出������ッファ。
-	// �者��ッファ�局�をSFEN_WRITE_SIZE���ん�ら�後者���替�る。
+	// buffer before writing to file
+	// sfen_buffers is the buffer for each thread
+	// sfen_buffers_pool is a buffer for writing.
+	// After loading the phase in the former buffer by SFEN_WRITE_SIZE, transfer it to the latter.
 	std::vector<PSVector*> sfen_buffers;
 	std::vector<PSVector*> sfen_buffers_pool;
 
-	// sfen_buffers_pool�アクセス�る���必��mutex
+	// Mutex required to access sfen_buffers_pool
 	std::mutex mutex;
 
-	// 書����局��数
+	// number of written phases
 	uint64_t sfen_write_count = 0;
 };
 
 // -----------------------------------
-//  棋譜を生��るworker(スレッド��)
+// worker that creates the game record (for each thread)
 // -----------------------------------
 
-// 複数スレッド�sfenを生��る���クラス
+// Class to generate sfen with multiple threads
 struct MultiThinkGenSfen : public MultiThink
 {
 	MultiThinkGenSfen(int search_depth_, int search_depth2_, SfenWriter& sw_)
@@ -324,49 +324,49 @@ struct MultiThinkGenSfen : public MultiThink
 	{
 		hash.resize(GENSFEN_HASH_SIZE);
 
-		// PCを並列化��gensfen�る�����乱数seedを引������確�用�出力。
+		// Output for confirmation if the same random seed is not drawn when parallelizing and gensfening the PC.
 		std::cout << prng << std::endl;
 	}
 
 	virtual void thread_worker(size_t thread_id);
 	void start_file_write_worker() { sw.start_file_write_worker(); }
 
-	//  search_depth = 通常探索�探索深�
+	// search_depth = search depth for normal search
 	int search_depth;
 	int search_depth2;
 
-	// 生��る局��評価値�上�
+	// Upper limit of evaluation value of generated situation
 	int eval_limit;
 
-	// ランダムムーブを行��最�ply
+	// minimum ply with random move
 	int random_move_minply;
-	// ランダムムーブを行��最大ply
+	// maximum ply with random move
 	int random_move_maxply;
-	// 1局����ランダムムーブを行��回数
+	// Number of random moves in one station
 	int random_move_count;
-	// Apery�よ��ランダムムーブ����1/N�確率�玉を動��。
-	// ��玉を動������1/N�確率�相手番�1回ランダムムーブ�る。
-	// Apery�N=2。��0を指定�る���機能を無効化�る。
+	// Move balls with a probability of 1/N when randomly moving like Apery.
+	// When you move the ball again, there is a 1/N chance that it will randomly move once in the opponent's number.
+	// Apery has N=2. Specifying 0 here disables this function.
 	int random_move_like_apery;
 
-	// ランダムムーブ�代�り�multi pvを使���用。
-	// random_multi_pv��MultiPV����候補手�数。
-	// 候補手�指�手を採択�る���1��指�手�評価値�N��指�手�評価値��差�
-	// random_multi_pv_diff�範囲���れ��ら��。
-	// random_multi_pv_depth�MultiPV����探索深�。
+	// For when using multi pv instead of random move.
+	// random_multi_pv is the number of candidates for MultiPV.
+	// When adopting the move of the candidate move, the difference between the evaluation value of the move of the 1st place and the evaluation value of the move of the Nth place is
+	// Must be in the range random_multi_pv_diff.
+	// random_multi_pv_depth is the search depth for MultiPV.
 	int random_multi_pv;
 	int random_multi_pv_diff;
 	int random_multi_pv_depth;
 
-	// 書�出�局��ply(�期局��ら�手数)�最��最大。
+	// The minimum and maximum ply (number of steps from the initial phase) of the phase to write out.
 	int write_minply;
 	int write_maxply;
 
-	// sfen�書�出�器
+	// sfen exporter
 	SfenWriter& sw;
 
-	// �一局��書�出�を制��る���hash
-	// hash_indexを求�る���mask�使����2**N���れ��ら��。
+	// hash to limit the export of the same phase
+	// It must be 2**N because it will be used as the mask to calculate hash_index.
 	static const uint64_t GENSFEN_HASH_SIZE = 64 * 1024 * 1024;
 
 	vector<Key> hash; // 64MB*sizeof(HASH_KEY) = 512MB
@@ -375,25 +375,25 @@ struct MultiThinkGenSfen : public MultiThink
 //  thread_id    = 0..Threads.size()-1
 void MultiThinkGenSfen::thread_worker(size_t thread_id)
 {
-	// �り����書�出�手数�最大�����引�分�扱���るも���る。
+	// For the time being, it will be treated as a draw at the maximum number of steps to write.
 	const int MAX_PLY2 = write_maxply;
 
-	// StateInfoを最大手数分 + Search�PV�leaf���進�るbuffer
+	//Maximum StateInfo + Search PV to advance to leaf buffer
 	std::vector<StateInfo,AlignedAllocator<StateInfo>> states(MAX_PLY2 + MAX_PLY /* == search_depth + α */);
 	StateInfo si;
 
-	// 今回�指�手。��指�手�局�を進�る。
+	// This move. Use this move to advance the stage.
 	Move m = MOVE_NONE;
 
-	// 終了フラグ
+	// end flag
 	bool quit = false;
 
-	// �定回数回��る��繰り返�
+	// repeat until the specified number of times
 	while (!quit)
 	{
-		// Position�対��従属スレッド�設定�必�。
-		// 並列化�る����Threads (�れ�実体� vector<Thread*>����
-		// Threads[0]...Threads[thread_num-1]���対����よ���れ�良�。
+		// It is necessary to set a dependent thread for Position.
+		// When parallelizing, Threads (since this is a vector<Thread*>,
+		// Do the same for up to Threads[0]...Threads[thread_num-1].
 		auto th = Threads[thread_id];
 
 		auto& pos = th->rootPos;
@@ -409,42 +409,42 @@ void MultiThinkGenSfen::thread_worker(size_t thread_id)
     //  assert(actual == StartFEN);
     //}
 
-		// 探索部�定義�れ��るBookMoveSelector�メン�を�照�る。
+		// Refer to the members of BookMoveSelector defined in the search section.
 		//auto& book = ::book;
 
-		// 1局分�局�を�存�����終局�����敗を���書�出�。
-		// 書�出�関数����下��るflush_psv()��る。
+		// Save the situation for one station, and write it out including the winning and losing at the end.
+		// The function to write is flush_psv() below this.
 		PSVector a_psv;
 		a_psv.reserve(MAX_PLY2 + MAX_PLY);
 
-		// a_psv���れ��る局�をファイル�書�出�。
-		// lastTurnIsWin : a_psv���れ��る最終局��次�局����敗
-		// ������1。負�����-1。引�分�����0を渡�。
-		// 返�値 : も��定局�数������終了�る場��true。
+		// Write out the phases loaded in a_psv to a file.
+		// lastTurnIsWin: win/loss in the next phase after the final phase in a_psv
+		// 1 when winning. -1 when losing. Pass 0 for a draw.
+		// Return value: true if the specified number of phases has already been reached and the process ends.
 		auto flush_psv = [&](int8_t lastTurnIsWin)
 		{
 			int8_t isWin = lastTurnIsWin;
 
-			// 終局�局�(�一��)�ら�手������局��関���対局��敗�情報を付与����。
-			// a_psv��存�れ��る局��(手番的�)連続���るも���る。
+			// From the final stage (one step before) to the first stage, give information on the outcome of the game for each stage.
+			// The phases stored in a_psv are assumed to be continuous (in order).
 			for (auto it = a_psv.rbegin(); it != a_psv.rend(); ++it)
 			{
-				// isWin == 0(引�分�)�ら -1を掛��も 0(引�分�)���
+				// If isWin == 0 (draw), multiply by -1 and it will remain 0 (draw)
 				isWin = - isWin;
 				it->game_result = isWin;
 
-				// 局�を書�出������ら�定回数������。
-				// get_next_loop_count()内�カウンターを加算�る��
-				// 局�を出力������れを呼�出����カウンター�狂�。
+				// When I tried to write out the phase, it reached the specified number of times.
+				// Because the counter is added in get_next_loop_count()
+				// If you don't call this when the phase is output, the counter goes crazy.
 				auto loop_count = get_next_loop_count();
 				if (loop_count == UINT64_MAX)
 				{
-					// 終了フラグを立����。
+					// Set the end flag.
 					quit = true;
 					return;
 				}
 
-				// 局�を一�書�出�。
+				// Write out one aspect.
 				sw.write(thread_id, *it);
 
 #if 0
@@ -454,30 +454,30 @@ void MultiThinkGenSfen::thread_worker(size_t thread_id)
 			}
 		};
 
-		// ply手目�ランダムムーブを�る�����フラグ
+		// ply flag for whether or not to randomly move by eyes
 		vector<bool> random_move_flag;
 		{
-			// ランダムムーブを入れる�らrandom_move_maxply手目���絶対�random_move_count回入れる。
-			// �����ら��欲��。
-			// �れ�ら��ベスト����よ���ら��。色々�件を変��実験中。
-			
-			// a[0] = 0 , a[1] = 1, ... �����列を作����れを
-			// Fisher-Yates shuffle��先頭�N個を�り出��良�。
-			// 実際���N個欲�������先頭N個分��Fisher-Yates�shuffle�れ�良�。
+			// If you want to add a random move, random_move_maxply be sure to enter random_move_count times before the first move.
+			// I want you to disperse so much.
+			// I'm not sure how best it is. Experimenting under various conditions.
+
+			// Make an array like a[0] = 0 ,a[1] = 1, ...
+			// Fisher-Yates shuffle and take out the first N items.
+			// Actually, I only want N pieces, so I only need to shuffle the first N pieces with Fisher-Yates.
 
 			vector<int> a;
 			a.reserve((size_t)random_move_maxply);
 
-			// random_move_minply , random_move_maxply�1 origin�指定�れる��
-			// ����0 origin�扱���る��注�。
+			// random_move_minply ,random_move_maxply is specified by 1 origin,
+			// Note that we are handling 0 origin here.
 			for (int i = std::max(random_move_minply - 1 , 0) ; i < random_move_maxply; ++i)
 				a.push_back(i);
 
-			// Apery方��ランダムムーブ�場��insert()�random_move_count回呼�出�れる�能性��る��
-			// �れを考慮��サイズ��確�����。
+			// In case of Apery random move, insert() may be called random_move_count times.
+			// Reserve only the size considering it.
 			random_move_flag.resize((size_t)random_move_maxply + random_move_count);
 
-			// a[]�size()を超�る回数�ランダムムーブ��用������制��る。
+			// A random move that exceeds the size() of a[] cannot be applied, so limit it.
 			for (int i = 0 ; i < std::min(random_move_count, (int)a.size()) ; ++i)
 			{
 				swap(a[i], a[prng.rand((uint64_t)a.size() - i) + i]);
@@ -485,26 +485,26 @@ void MultiThinkGenSfen::thread_worker(size_t thread_id)
 			}
 		}
 
-		// random moveを行���回数をカウント����カウンター
-		// random_move_minply == -1�����連続��ランダムムーブを行����������用�る。
+		// A counter that keeps track of the number of random moves
+		// When random_move_minply == -1, random moves are performed continuously, so use it at this time.
 		int random_move_c = 0;
 
-		// ply : �期局��ら�手数
+		// ply: steps from the initial stage
 		for (int ply = 0; ; ++ply)
 		{
 			//cout << pos << endl;
 
-			// 今回�探索depth
-			// goto�飛���先�宣言����。
+			// Current search depth
+			// Goto will fly, so declare it first.
 			int depth = search_depth + (int)prng.rand(search_depth2 - search_depth + 1);
 
-			// 長手数������
+			// has it reached the length
 			if (ply >= MAX_PLY2)
 			{
 				if (use_draw_in_training_data_generation) {
-					// �敗 = 引�分����書�出�。
-					// �������自分�入玉������相手�入玉を許����(�も)
-					flush_psv(0);
+				// Write out as win/loss = draw.
+				// This way it is harder to allow the opponent to enter the ball when I enter (may)
+				flush_psv(0);
 				}
 				break;
 			}
@@ -514,13 +514,13 @@ void MultiThinkGenSfen::thread_worker(size_t thread_id)
 			  // Write if draw.
 			  flush_psv(0);
 		  }
-          break;
+        break;
       }
 
-			// 全駒�れ�詰ん���り����？
-			if (MoveList<LEGAL>(pos).size() == 0) // Can be mate or stalemate
+			// Isn't all pieces stuck and stuck?
+			if (MoveList<LEGAL>(pos).size() == 0)
 			{
-        // (��局��一���局����書�出�)
+        // (write up to the previous phase of this phase)
         // Write the positions other than this position if checkmated.
                 if (pos.checkers()) // Mate
                     flush_psv(-1);
@@ -530,63 +530,63 @@ void MultiThinkGenSfen::thread_worker(size_t thread_id)
 				break;
 			}
 
-			//// 定跡
+			//// constant track
 			//if ((m = book.probe(pos)) != MOVE_NONE)
 			//{
-			//	// 定跡�hit��。
-			//	// ��指�手�m�格��れ�。
+			//  // Hit the constant track.
+			//  // The move was stored in m.
 
-			//	// 定跡�局��学習��用���。
-			//	a_psv.clear();
+			//  // Do not use the fixed phase for learning.
+			//  a_psv.clear();
 
-			//	if (random_move_minply != -1)
-			//		// 定跡�局�����も�一定確率�ランダムムーブ�行��。
-			//		goto RANDOM_MOVE;
-			//	else
-			//		// random_move_minply���-1�指定�れ��る���定跡を抜�る������定跡�従��指�。
-			//		// 巨大定跡を用���ConsiderBookMoveCount true���定跡を抜��局�を無数�用������
-			//		// ���ら5回ランダムムーブを行������用途�用�る。
-			//		goto DO_MOVE;
+			//  if (random_move_minply != -1)
+			// 		// Random move is performed with a certain probability even in the constant phase.
+			// 		goto RANDOM_MOVE;
+			//  else
+			// 		// When -1 is specified as random_move_minply, it points according to the standard until it goes out of the standard.
+			// 		// Prepare an innumerable number of situations that have left the constant as ConsiderationBookMoveCount true using a huge constant
+			// 		// Used for purposes such as performing a random move 5 times from there.
+			// 		goto DO_MOVE;
 			//}
 
 			{
-				// search_depth～search_depth2 手読��評価値�PV(最善応手列)
-				// 探索窓を狭�����も�題����。
+				// search_depth～search_depth2 Evaluation value of hand reading and PV (best responder row)
+				// There should be no problem if you narrow the search window.
 
 				auto pv_value1 = search(pos, depth);
 
 				auto value1 = pv_value1.first;
 				auto& pv1 = pv_value1.second;
 
-				// 評価値�絶対値���値以上�局������
-				// ��局�を学習�使�����り�味�������試�を終了�る。
-				// �れをも���敗�������扱�を�る。
+				// For situations where the absolute evaluation value is greater than or equal to this value
+				// It doesn't make much sense to use that aspect for learning, so this game ends.
+				// Treat this as having won or lost.
 
-				// 1手詰��宣言���ら�����mate_in(2)�返る��eval_limit�上�値���値��り�
-				// ��if��必�真��る。resign����も�様。
+				// If you win one move, declarative win, mate_in(2) will be returned here, so it will be the same value as the upper limit of eval_limit,
+				// This if expression is always true. The same applies to resign.
 
 				if (abs(value1) >= eval_limit)
 				{
-//					sync_cout << pos << "eval limit = " << eval_limit << " over , move = " << pv1[0] << sync_endl;
+					// sync_cout << pos << "eval limit = "<< eval_limit << "over ,move = "<< pv1[0] << sync_endl;
 
-					// ��局��value1 >= eval_limit�ら��(��局��手番��)����る。
+					// If value1 >= eval_limit in this aspect, you win (the turn side of this aspect).
 					flush_psv((value1 >= eval_limit) ? 1 : -1);
 					break;
 				}
 
-				// ����指�手�検証
+				// Verification of a strange move
 				if (pv1.size() > 0
 					&& (pv1[0] == MOVE_NONE || pv1[0] == MOVE_NULL)
 					)
 				{
-					// MOVE_WIN����手��宣言���局���る��ェック���る��
-					// ���宣言���指�手�返���る�������。
-					// ���MOVE_RESIGN���value1�1手詰��スコア��り�eval_limit�最�値(-31998)�������…。
+					// MOVE_WIN is checking if it is the declaration victory stage before this
+					// The declarative winning move should never come back here.
+					// Also, when MOVE_RESIGN, value1 is a one-stop score, which should be the minimum value of eval_limit (-31998)...
 					cout << "Error! : " << pos.fen() << m << value1 << endl;
 					break;
 				}
 
-				// ��日手�応��処�。
+				// Processing according to each thousand-day hand.
 
         if (pos.is_draw(0)) {
 			if (use_draw_in_training_data_generation) {
@@ -596,7 +596,7 @@ void MultiThinkGenSfen::thread_worker(size_t thread_id)
           break;
         }
 
-				// PV�指�手�leaf node��進�����leaf node�evaluate()を呼�出��値を用�る。
+				// Use PV's move to the leaf node and use the value that evaluated() is called on that leaf node.
 				auto evaluate_leaf = [&](Position& pos , vector<Move>& pv)
 				{
 					auto rootColor = pos.side_to_move();
@@ -604,14 +604,14 @@ void MultiThinkGenSfen::thread_worker(size_t thread_id)
 					int ply2 = ply;
 					for (auto m : pv)
 					{
-						// デ�ッグ用�検証����途中���法手�存在�����を確��る。
-						// NULL_MOVE����も���る。
+						// As a verification for debugging, make sure there are no illegal players in the middle.
+						// NULL_MOVE does not come.
 
-						// �分�テスト����コメントアウト�良�。
+						// I tested it out enough so I can comment it out.
 #if 1
-						// ��法手�や�����������。
-						// 宣言���mated()������上�テスト���る��
-						// 読�筋���MOVE_WIN�MOVE_RESIGN��������証�れ��る。(����…)
+						// I shouldn't be an illegal player.
+						// declarative win and not mated() are tested above so
+						// It is guaranteed that MOVE_WIN and MOVE_RESIGN do not come as a reader. (Should...)
 						if (!pos.pseudo_legal(m) || !pos.legal(m))
 						{
 							cout << "Error! : " << pos.fen() << m << endl;
@@ -619,25 +619,25 @@ void MultiThinkGenSfen::thread_worker(size_t thread_id)
 #endif
 						pos.do_move(m, states[ply2++]);
 						
-						// 毎ノードevaluate()を呼�出�����evaluate()�差分計算�出�����注��
-						// depth�8以上����差分計算�������速����れる。
+						//Because the difference calculation of evaluate() cannot be performed unless each node evaluate() is called!
+						// If the depth is 8 or more, it seems faster not to calculate this difference.
 #if defined(EVAL_NNUE)
             if (depth < 8)
               Eval::evaluate_with_no_return(pos);
 #endif  // defined(EVAL_NNUE)
 					}
 
-					// leaf�到�
-					//      cout << pos;
+					// reach leaf
+					// cout << pos;
 
 					auto v = Eval::evaluate(pos);
-					// evaluate()�手番��評価値を返����
-					// root_color���手番�ら�vを�転���返��������。
+					// evaluate() returns the evaluation value on the turn side, so
+					// If it's a turn different from root_color, you must invert v and return it.
 					if (rootColor != pos.side_to_move())
 						v = -v;
 
-					// 巻�戻�。
-					// C++x14�も�������reverse�回�foreach�ら����…。
+					// Rewind.
+					// Is it C++x14, and isn't there even foreach to turn in reverse?
 					//  for (auto it : boost::adaptors::reverse(pv))
 
 					for (auto it = pv.rbegin(); it != pv.rend(); ++it)
@@ -655,52 +655,52 @@ void MultiThinkGenSfen::thread_worker(size_t thread_id)
 				// gensfen depth 6 eval_limit 3000
 				// Total 53879 Hits 43713 hit rate (%) 81.132
 
-				// 置�表�指�手��刈り�れる����題。
-				// �れ�教師����少�気��悪��…。
+				// Problems such as pruning with moves in the substitution table.
+				// This is a little uncomfortable as a teacher...
 #endif
 
-				// depth 0�場��pv�得られ������depth 2�探索����。
+				//If depth 0, pv is not obtained, so search again at depth 2.
 				if (search_depth <= 0)
 				{
 					pv_value1 = search(pos, 2);
 					pv1 = pv_value1.second;
 				}
 
-				// �期局�周辺��類似局���り���
-				// 学習�用�る��学習��り�����ら書�出���。
-				// →　比較実験���
+				// The surroundings of the initial stage are all similar
+				// Do not write it out because it can lead to overlearning when used for learning.
+				// → comparative experiment should be done
 				if (ply < write_minply - 1)
 				{
 					a_psv.clear();
 					goto SKIP_SAVE;
 				}
 
-				// �一局�を書�出������？
-				// �れ�複数�PC�並列��生����る���局����れる����る��
-				// 読�込�����も�様�処�を�����良�。
+				// Did you just write the same phase?
+				// This may include the same aspect as it is generated in parallel on multiple PCs, so
+				// It is better to do the same process when reading.
 				{
 					auto key = pos.key();
 					auto hash_index = (size_t)(key & (GENSFEN_HASH_SIZE - 1));
 					auto key2 = hash[hash_index];
 					if (key == key2)
 					{
-						// スキップ�る����れ以��関�る
-						// �敗�情報������る���存���る局�をクリア�る。
-						// �����hash��致��時点���以��局�も�致���る�能性�高��ら
-						// 書�出�価値���。
+						// when skipping regarding earlier
+						// Clear the saved situation because the win/loss information will be incorrect.
+						// anyway, when the hash matches, it's likely that the previous phases also match
+						// Not worth writing out.
 						a_psv.clear();
 						goto SKIP_SAVE;
 					}
-					hash[hash_index] = key; // 今回�key�入れ替����。
+					hash[hash_index] = key; // Replace with the current key.
 				}
 
-				// 局��一時�存。
+				// Temporary saving of the situation.
 				{
 					a_psv.emplace_back(PackedSfenValue());
 					auto &psv = a_psv.back();
-					
-					// packを�求�れ��る�らpack�れ�sfen������評価値を書�出�。
-					// 最終的�書�出����敗�����ら。
+
+					// If pack is requested, write the packed sfen and the evaluation value at that time.
+					// The final writing is after winning or losing.
 					pos.sfen_pack(psv.sfen);
 
           //{
@@ -710,12 +710,12 @@ void MultiThinkGenSfen::thread_worker(size_t thread_id)
           //  assert(before_fen == after_fen);
           //}
 
-					// PV line�leaf node��root color�ら見�evaluate()�値を�得。
-					// search()�返�値を����使������る���善悪�良���ら��。
+					// Get the value of evaluate() as seen from the root color on the leaf node of the PV line.
+					//I don't know the goodness and badness of using the return value of search() as it is.
 					psv.score = evaluate_leaf(pos, pv1);
 					psv.gamePly = ply;
 
-					// PV��手を�り出�。�れ�depth 0����り�存在�る��。
+					// Take out the first PV hand. This should be present unless depth 0.
 					assert(pv_value1.second.size() >= 1);
 					Move pv_move1 = pv_value1.second[0];
 					psv.move = pv_move1;
@@ -723,44 +723,44 @@ void MultiThinkGenSfen::thread_worker(size_t thread_id)
 
 			SKIP_SAVE:;
 
-				// 何故�PV�得られ����(置�表���hit��詰ん���？)��次�対局�行�。
-				// ��り�レアケース���無視��良����。
+				// For some reason, I could not get PV (hit the substitution table etc. and got stuck?) so go to the next game.
+				// It's a rare case, so you can ignore it.
 				if (pv1.size() == 0)
 					break;
-				
-				// search_depth手読��指�手�局�を進�る。
+
+				// search_depth Advance the phase by hand reading.
 				m = pv1[0];
 			}
 
 		RANDOM_MOVE:;
 
-			// �法手����らランダム�1手��フェーズ
+			// Phase to randomly choose one from legal hands
 			if (
-				// 1. random_move_minply�らrandom_move_maxply�間�random_move_count回�ランダムムーブを行��モード
-				(random_move_minply != -1 && ply < (int)random_move_flag.size() && random_move_flag[ply]) ||
-				// 2. 定跡を抜���������random_move_count回�ランダムムーブを行��モード
-				(random_move_minply == -1 && random_move_c < random_move_count))
+				// 1. Random move of random_move_count times from random_move_minply to random_move_maxply
+				(random_move_minply != -1 && ply <(int)random_move_flag.size() && random_move_flag[ply]) ||
+				// 2. A mode to perform random move of random_move_count times after leaving the track
+				(random_move_minply == -1 && random_move_c <random_move_count))
 			{
 				++random_move_c;
 
-				// mate�������法手�1手��る��…。
+				// It's not a mate, so there should be one legal hand...
 				if (random_multi_pv == 0)
 				{
-					// 普通�ランダムムーブ
+					// normal random move
 
 					MoveList<LEGAL> list(pos);
 
-					// ��をApery方���る���善悪�よ���ら��。
+					// I don't really know the goodness and badness of making this the Apery method.
 					if (random_move_like_apery == 0
 						|| prng.rand(random_move_like_apery) != 0
 					)
 					{
-						// 普通��法手�ら1手�択
+						// Normally one move from legal move
 						m = list.at((size_t)prng.rand((uint64_t)list.size()));
 					}
 					else {
-						// 玉�動��る�ら玉を動��
-						Move moves[8]; // 8近�
+						// if you can move the ball, move the ball
+						Move moves[8]; // Near 8
 						Move* p = &moves[0];
 						for (auto& m : list)
 							if (type_of(pos.moved_piece(m)) == KING)
@@ -768,36 +768,36 @@ void MultiThinkGenSfen::thread_worker(size_t thread_id)
 						size_t n = p - &moves[0];
 						if (n != 0)
 						{
-							// 玉を動��指�手
+							// move to move the ball
 							m = moves[prng.rand(n)];
 
-							// Apery方�������1/2�確率�相手もランダムムーブ
+							// In Apery method, at this time there is a 1/2 chance that the opponent will also move randomly
 							if (prng.rand(2) == 0)
 							{
-								// random_move_flag[ply]�次�����"1"を追加�る��シンプル�hack�。
+								// Is it a simple hack to add a "1" next to random_move_flag[ply]?
 								random_move_flag.insert(random_move_flag.begin() + ply + 1, 1, true);
 							}
 						}
 						else
-							// 普通��法手�ら1手�択
+							// Normally one move from legal move
 							m = list.at((size_t)prng.rand((uint64_t)list.size()));
 					}
 
-					// 玉�2手指��コードを入れ������法手�ら1手����れ�相当�る���
-					// コード�複雑化�る����ら����判断��。
+					// I put in the code of two handed balls, but if you choose one from legal hands, it should be equivalent to that
+					// I decided it's unnecessary because it just makes the code more complicated.
 				}
 				else {
-					// ロジック�複雑��る�����ん�����度MultiPV�探索�る。
+					// Since the logic becomes complicated, I'm sorry, I will search again with MultiPV here.
 					Learner::search(pos, random_multi_pv_depth, random_multi_pv);
-					// rootMoves�上�N手����ら一��択
+					// Select one from the top N hands of root Moves
 
 					auto& rm = pos.this_thread()->rootMoves;
 
 					uint64_t s = min((uint64_t)rm.size(), (uint64_t)random_multi_pv);
 					for (uint64_t i = 1; i < s; ++i)
 					{
-						// rm[0]�評価値��差�random_multi_pv_diff�範囲���れ��ら��。
-						// rm[x].score���順�並ん��る�仮定��る。 
+						// The difference from the evaluation value of rm[0] must be within the range of random_multi_pv_diff.
+						// It can be assumed that rm[x].score is arranged in descending order.
 						if (rm[0].score > rm[i].score + random_multi_pv_diff)
 						{
 							s = i;
@@ -807,81 +807,81 @@ void MultiThinkGenSfen::thread_worker(size_t thread_id)
 
 					m = rm[prng.rand(s)].pv[0];
 
-					// ��1局�も書�出�������終局�����書�出�処��端折��次�対局�。
+					// I haven't written one phase yet, but it ended, so the writing process ends and the next game starts.
 					if (!is_ok(m))
 						break;
 				}
 
-				// ゲーム��敗�ら指�手を評価�よ���る���
-				// 今回�random move��る�����以�������よ���る。
-				a_psv.clear(); // �存����局��クリア
+				// When trying to evaluate the move from the outcome of the game,
+				// There is a random move this time, so try not to fall below this.
+				a_psv.clear(); // clear saved aspect
 			}
 
 		DO_MOVE:;
 			pos.do_move(m, states[ply]);
 
-			// 差分計算を行�����毎node evaluate()を呼�出����。
+			// Call node evaluate() for each difference calculation.
 			Eval::evaluate_with_no_return(pos);
 
 		} // for (int ply = 0; ; ++ply)
-	
+
 	} // while(!quit)
-	
+
 	sw.finalize(thread_id);
 }
 
 // -----------------------------------
-//    棋譜を生��るコマンド(master thread)
+// Command to generate a game record (master thread)
 // -----------------------------------
 
-// 棋譜を生��るコマンド
+// Command to generate a game record
 void gen_sfen(Position&, istringstream& is)
 {
-	// スレッド数(�れ��USI�setoption�与�られる)
+	// number of threads (given by USI setoption)
 	uint32_t thread_num = (uint32_t)Options["Threads"];
 
-	// 生�棋譜�個数 default = 80億局�(Ponanza仕様)
+	// Number of generated game records default = 8 billion phases (Ponanza specification)
 	uint64_t loop_max = 8000000000UL;
 
-	// 評価値���値����ら生�を打�切る。
+	// Stop the generation when the evaluation value reaches this value.
 	int eval_limit = 3000;
 
-	// 探索深�
+	// search depth
 	int search_depth = 3;
 	int search_depth2 = INT_MIN;
 
-	// ランダムムーブを行��最�ply�最大ply�回数
+	// minimum ply, maximum ply and number of random moves
 	int random_move_minply = 1;
 	int random_move_maxply = 24;
 	int random_move_count = 5;
-	// ランダムムーブをApery�よ��玉を主�動��機能
-	// �れを例��3��る�1/3�確率�玉を動��。
+	// A function to move the random move mainly like Apery
+	// If this is set to 3, the ball will move with a probability of 1/3.
 	int random_move_like_apery = 0;
-	// ランダムムーブ�代�り�multipv�探索�������らランダム������random_multi_pv = 1以上�数��る。
+	// If you search with multipv instead of random move and choose from among them randomly, set random_multi_pv = 1 or more.
 	int random_multi_pv = 0;
 	int random_multi_pv_diff = 32000;
 	int random_multi_pv_depth = INT_MIN;
 
-	// 書�出�局��ply(�期局��ら�手数)�最��最大。
+	// The minimum and maximum ply (number of steps from the initial phase) of the phase to write out.
 	int write_minply = 16;
 	int write_maxply = 400;
 
-	// 書�出�ファイル�
+	// File name to write
 	string output_file_name = "generated_kifu.bin";
 
 	string token;
 
-	// eval hash�hit�る��期局�付近�評価値����hash����大��値を書�込�れ�����
-	// eval_limit����設定�れ��る����期局��毎回eval_limitを超�����局��生��進����る。
-	// �����eval hash�無効化�る必���る。
-	// ��eval hash�hash��������変�値�評価値�使�れ��れを教師�使���気分�悪�����も�る。
+	// When hit to eval hash, as a evaluation value near the initial stage, if a hash collision occurs and a large value is written
+	// When eval_limit is set small, eval_limit will be exceeded every time in the initial phase, and phase generation will not proceed.
+	// Therefore, eval hash needs to be disabled.
+	// After that, when the hash of the eval hash collides, the evaluation value of a strange value is used, and it may be unpleasant to use it for the teacher.
 	bool use_eval_hash = false;
 
-	// �����ファイル��存�る。
-	// ファイル�� file_1.bin , file_2.bin�よ��連番���。
+	// Save to file in this unit.
+	// File names are serialized like file_1.bin, file_2.bin.
 	uint64_t save_every = UINT64_MAX;
 
-	// ファイル��末尾�ランダム�数値を付与�る。
+	// Add a random number to the end of the file name.
 	bool random_file_name = false;
 
 	while (true)
@@ -902,7 +902,7 @@ void gen_sfen(Position&, istringstream& is)
 		else if (token == "eval_limit")
 		{
 			is >> eval_limit;
-			// 最大値を1手詰��スコア�制��る。(������ループを終了����能性��る��)
+			// Limit the maximum to a one-stop score. (Otherwise you might not end the loop)
 			eval_limit = std::min(eval_limit, (int)mate_in(2));
 		}
 		else if (token == "random_move_minply")
@@ -934,12 +934,12 @@ void gen_sfen(Position&, istringstream& is)
 	}
 
 #if defined(USE_GLOBAL_OPTIONS)
-	// ���復元�る����存����。
+	// Save it for later restore.
 	auto oldGlobalOptions = GlobalOptions;
 	GlobalOptions.use_eval_hash = use_eval_hash;
 #endif
 
-	// search depth2�設定�れ�����ら�search depth��������。
+	// If search depth2 is not set, leave it the same as search depth.
 	if (search_depth2 == INT_MIN)
 		search_depth2 = search_depth;
 	if (random_multi_pv_depth == INT_MIN)
@@ -947,10 +947,10 @@ void gen_sfen(Position&, istringstream& is)
 
 	if (random_file_name)
 	{
-		// output_file_name���時点�ランダム�数値を付与�����。
+		// Give a random number to output_file_name at this point.
     std::random_device seed_gen;
     PRNG r(seed_gen());
-		// 念���乱数振り直����。
+		// Just in case, reassign the random numbers.
 		for(int i=0;i<10;++i)
 			r.rand(1);
 		auto to_hex = [](uint64_t u){
@@ -958,7 +958,7 @@ void gen_sfen(Position&, istringstream& is)
 			ss << std::hex << u;
 			return ss.str();
 		};
-		// 64bit�数値��然��る�嫌���念���64bit�数値２��������。
+		// I don't want to wear 64bit numbers by accident, so I'm going to make a 64bit number 2 just in case.
 		output_file_name = output_file_name + "_" + to_hex(r.rand<uint64_t>()) + to_hex(r.rand<uint64_t>());
 	}
 
@@ -982,7 +982,7 @@ void gen_sfen(Position&, istringstream& is)
 		<< "  save_every             = " << save_every << endl
 		<< "  random_file_name       = " << random_file_name << endl;
 
-	// Options["Threads"]�数��スレッドを作��実行。
+	// Create and execute threads as many as Options["Threads"].
 	{
 		SfenWriter sw(output_file_name, thread_num);
 		sw.save_every = save_every;
@@ -1002,30 +1002,30 @@ void gen_sfen(Position&, istringstream& is)
 		multi_think.start_file_write_worker();
 		multi_think.go_think();
 
-		// SfenWriter�デストラクタ�join�る���join�終����ら終了�����メッセージを
-		// 表示��る�������をブロック�囲む。
+		// Since we are joining with the destructor of SfenWriter, please give a message that it has finished after the join
+		// Enclose this in a block because it should be displayed.
 	}
 
 	std::cout << "gensfen finished." << endl;
 
 #if defined(USE_GLOBAL_OPTIONS)
-	// GlobalOptions�復元。
+	// Restore Global Options.
 	GlobalOptions = oldGlobalOptions;
 #endif
 
 }
 
 // -----------------------------------
-// 生���棋譜�ら学習��るコマンド(learn)
+// command to learn from the generated game (learn)
 // -----------------------------------
 
-// 普通�シグモイド関数
+// ordinary sigmoid function
 double sigmoid(double x)
 {
 	return 1.0 / (1.0 + std::exp(-x));
 }
 
-// 評価値を�率[0,1]�変��る関数
+// A function that converts the evaluation value to the winning rate [0,1]
 double winning_percentage(double value)
 {
 	// In Maxima,
@@ -1047,43 +1047,41 @@ double delta_winning_percentage(double value)
 		0.5756462732485115 * pow(PawnValue, -1) * pow(10.0, -0.25 * pow(PawnValue, -1) * value) *
 		pow(pow(10.0, -0.25 * pow(PawnValue, -1) * value) + 1.0, -2);
 }
-
-// 普通�シグモイド関数�導関数。
 double dsigmoid(double x)
 {
-	// シグモイド関数
-	//    f(x) = 1/(1+exp(-x))
-	// �対��1階微分��
-	//    f'(x) = df/dx = f(x)・{ 1 - f(x) }
-	// ��る。
+	// Sigmoid function
+	// f(x) = 1/(1+exp(-x))
+	// the first derivative is
+	// f'(x) = df/dx = f(x)・{ 1-f(x)}
+	// becomes
 
 	return sigmoid(x) * (1.0 - sigmoid(x));
 }
 
-// 目的関数��率�差�二乗和���
+// When the objective function is the sum of squares of the difference in winning percentage
 #if defined (LOSS_FUNCTION_IS_WINNING_PERCENTAGE)
-// 勾�を計算�る関数
+// function to calculate the gradient
 double calc_grad(Value deep, Value shallow, PackedSfenValue& psv)
 {
-	// �率�差�2乗�目的関数�れを最�化�る。
-	// 目的関数 J = 1/2m Σ ( win_rate(shallow) - win_rate(deep) ) ^2
-	// ����σ�シグモイド関数��評価値を�率�差�変��るも�。
-	// m�サンプル�件数。shallow�浅�探索(qsearch())����評価値。deep�深�探索����評価値。
-	// ���Wを特徴ベクトル(評価関数�パラメーター)�Xi,Yiを教師��る�
-	// shallow = W*Xi   // *�アダマール���W�転置・X ��味
+	// The square of the win rate difference minimizes it in the objective function.
+	// Objective function J = 1/2m Σ (win_rate(shallow)-win_rate(deep) )^2
+	// However, σ is a sigmoid function that converts the evaluation value into the difference in the winning percentage.
+	// m is the number of samples. shallow is the evaluation value for a shallow search (qsearch()). deep is the evaluation value for deep search.
+	// If W is the feature vector (parameter of the evaluation function) and Xi and Yi are teachers
+	// shallow = W*Xi // * is the Hadamard product, transposing W and meaning X
 	// f(Xi) = win_rate(W*Xi)
-	// σ(i番目�deep) = Yi �����
-	// J = m/2 Σ ( f(Xi) - Yi )^2
-	// �よ��る���る。
-	// W�ベクトル��j番目��素をWj�書���る��連鎖律�ら
-	// ∂J/∂Wj =            ∂J/∂f     ・  ∂f/∂W   ・ ∂W/∂Wj
-	//          =  1/m Σ ( f(Xi) - y )  ・  f'(Xi)    ・    1
+	// If σ(i th deep) = Yi,
+	// J = m/2 Σ (f(Xi)-Yi )^2
+	// becomes a common expression.
+	// W is a vector, and if we write the jth element as Wj, from the chain rule
+	// ∂J/∂Wj = ∂J/∂f ・∂f/∂W ・∂W/∂Wj
+	// = 1/m Σ (f(Xi)-y) ・f'(Xi) ・ 1
 
-	// 1/m����掛�る����勾��値����Σ�中身を�列��������良�。
+	// 1/m will be multiplied later, but the contents of Σ can be retained in the array as the value of the gradient.
 	// f'(Xi) = win_rate'(shallow) = sigmoid'(shallow/600) = dsigmoid(shallow / 600) / 600
-	// ��末尾� /600 �学習率�調整�る�ら書�������..
-	// ��1/m���係数も�Adam , AdaGrad�よ��勾��自動調整機能を��更新�を用�る�ら��。
-	// ゆ��メモリ上��存����必����。
+	// This /600 at the end is adjusted by the learning rate, so do not write it..
+	// Also, the coefficient of 1/m is unnecessary if you use the update formula that has the automatic gradient adjustment function like Adam and AdaGrad.
+	// Therefore, it is not necessary to save it in memory.
 
 	double p = winning_percentage(deep);
 	double q = winning_percentage(shallow);
@@ -1094,22 +1092,22 @@ double calc_grad(Value deep, Value shallow, PackedSfenValue& psv)
 #if defined (LOSS_FUNCTION_IS_CROSS_ENTOROPY)
 double calc_grad(Value deep, Value shallow, const PackedSfenValue& psv)
 {
-	// 交差エントロピーを用��目的関数
+	// Objective function with cross entropy
 
-	// 交差エントロピー�概念�性質������
+	// For the concept and nature of cross entropy,
 	// http://nnadl-ja.github.io/nnadl_site_ja/chap3.html#the_cross-entropy_cost_function
 	// http://postd.cc/visual-information-theory-3/
-	// ��を�考�。
+	// Refer to etc.
 
-	// 目的関数�設計)
-	// p�分布をq�分布�近���� → p�q�確率分布間�交差エントロピー�最�化�題�考�る。
-	// J = H(p,q) = - Σ p(x) log(q(x)) = -p log q - (1-p) log(1-q)
-	//                 x
+	// Objective function design)
+	// We want to make the distribution of p closer to the distribution of q → Think of it as the problem of minimizing the cross entropy between the probability distributions of p and q.
+	// J = H(p,q) =-Σ p(x) log(q(x)) = -p log q-(1-p) log(1-q)
+	// x
 
-	// p�定数�q�Wi�関数(q = σ(W・Xi) )���Wi�対�る�微分を求�る。
-	// ∂J/∂Wi = -p・q'/q - (1-p)(1-q)'/(1-q)
-	//          = ...
-	//          = q - p.
+	// p is a constant and q is a Wi function (q = σ(W・Xi) ).
+	// ∂J/∂Wi = -p・q'/q-(1-p)(1-q)'/(1-q)
+	// = ...
+	// = q-p.
 
 	double p = winning_percentage(deep);
 	double q = winning_percentage(shallow);
@@ -1121,41 +1119,41 @@ double calc_grad(Value deep, Value shallow, const PackedSfenValue& psv)
 #if defined ( LOSS_FUNCTION_IS_CROSS_ENTOROPY_FOR_VALUE )
 double calc_grad(Value deep, Value shallow, const PackedSfenValue& psv)
 {
-	// �率�関数を通���版
-	// �れ�EVAL_LIMITを低���������終盤�形�対��評価値を一致��よ����
-	// eval�eval�範囲を超�����。
+	// Version that does not pass the winning percentage function
+	// This, unless EVAL_LIMIT is set low, trying to match the evaluation value with the shape of the end stage
+	// eval may exceed the range of eval.
 	return shallow - deep;
 }
 #endif
 
 #if defined ( LOSS_FUNCTION_IS_ELMO_METHOD )
 
-// elmo(WCSC27)�使�れ��る定数。�調整。
-// elmo�����を内分�������値���。
-// learnコマンド���値を設定��る。
-// 0.33��elmo(WCSC27)�使�れ���定数(0.5)相当
+// A constant used in elmo (WCSC27). Adjustment required.
+// Since elmo does not internally divide the expression, the value is different.
+// You can set this value with the learn command.
+// 0.33 is equivalent to the constant (0.5) used in elmo (WCSC27)
 double ELMO_LAMBDA = 0.33;
 double ELMO_LAMBDA2 = 0.33;
 double ELMO_LAMBDA_LIMIT = 32000;
 
 double calc_grad(Value deep, Value shallow , const PackedSfenValue& psv)
 {
-	// elmo(WCSC27)方�
-	// 実際�ゲーム��敗�補正�る。
+	// elmo (WCSC27) method
+	// Correct with the actual game wins and losses.
 
 	const double q = winning_percentage(shallow);
 	const double p = winning_percentage(deep);
 	const double dq = delta_winning_percentage(shallow);
 
-	// 期待�率を����れ�1�負���れ� 0�引�分��ら0.5���補正項���用�る。
-	// game_result = 1,0,-1���1足��2�割る。
+	// Use 1 as the correction term if the expected win rate is 1, 0 if you lose, and 0.5 if you draw.
+	// game_result = 1,0,-1 so add 1 and divide by 2.
 	const double t = double(psv.game_result + 1) / 2;
 
-	// 深�探索��評価値�ELMO_LAMBDA_LIMITを超���る�らELMO_LAMBDA����ELMO_LAMBDA2を�用�る。
+	// If the evaluation value in deep search exceeds ELMO_LAMBDA_LIMIT, apply ELMO_LAMBDA2 instead of ELMO_LAMBDA.
 	const double lambda = (abs(deep) >= ELMO_LAMBDA_LIMIT) ? ELMO_LAMBDA2 : ELMO_LAMBDA;
 
-	// 実際��率を補正項���使���る。
-	// �れ�elmo(WCSC27)�アイデア���代�オーパーツ。
+	// Use the actual win rate as a correction term.
+	// This is the idea of ​​elmo (WCSC27), modern O-parts.
 	const double pp = (q - p) * dq / q / (1.0 - q);
 	const double tt = (q - t) * dq / q / (1.0 - q);
 	const double grad = lambda * pp + (1.0 - lambda) * tt;
@@ -1163,8 +1161,8 @@ double calc_grad(Value deep, Value shallow , const PackedSfenValue& psv)
 	return grad;
 }
 
-// 学習時�交差エントロピー�計算
-// elmo���敗項��率項��個別�交差エントロピー�引数��るcross_entropy_eval�cross_entropy_win�返る。
+// Calculate cross entropy during learning
+// The individual cross entropy of the win/loss term and win rate term of the elmo expression is returned to the arguments cross_entropy_eval and cross_entropy_win.
 void calc_cross_entropy(Value deep, Value shallow, const PackedSfenValue& psv,
 	double& cross_entropy_eval, double& cross_entropy_win, double& cross_entropy,
 	double& entropy_eval, double& entropy_win, double& entropy)
@@ -1175,7 +1173,7 @@ void calc_cross_entropy(Value deep, Value shallow, const PackedSfenValue& psv,
 
 	constexpr double epsilon = 0.000001;
 
-	// 深�探索��評価値�ELMO_LAMBDA_LIMITを超���る�らELMO_LAMBDA����ELMO_LAMBDA2を�用�る。
+	// If the evaluation value in deep search exceeds ELMO_LAMBDA_LIMIT, apply ELMO_LAMBDA2 instead of ELMO_LAMBDA.
 	const double lambda = (abs(deep) >= ELMO_LAMBDA_LIMIT) ? ELMO_LAMBDA2 : ELMO_LAMBDA;
 
 	const double m = (1.0 - lambda) * t + lambda * p;
@@ -1198,13 +1196,14 @@ void calc_cross_entropy(Value deep, Value shallow, const PackedSfenValue& psv,
 #endif
 
 
-// 目的関数���他��リエーションも色々用��る�も..
+// Other variations may be prepared as the objective function..
+
 
 double calc_grad(Value shallow, const PackedSfenValue& psv) {
 	return calc_grad((Value)psv.score, shallow, psv);
 }
 
-// Sfen�読�込�機
+// Sfen reader
 struct SfenReader
 {
 	SfenReader(int thread_num) : prng((std::random_device())())
@@ -1233,12 +1232,12 @@ struct SfenReader
 			delete p;
 	}
 
-	// mse���計算用�用�る局�数
-	// mini-batch size = 1M�標準的������0.2%程度�ら時間的��無視��る��。
-	// 指�手一致率�計算�depth = 1�search()を�る����純比較������…。
+	// number of phases used for calculation such as mse
+	// mini-batch size = 1M is standard, so 0.2% of that should be negligible in terms of time.
+	//Since search() is performed with depth = 1 in calculation of move match rate, simple comparison is not possible...
 	const uint64_t sfen_for_mse_size = 2000;
 
-	// mse���計算用�局�を読�込ん���。
+	// Load the phase for calculation such as mse.
 	void read_for_mse()
 	{
 		auto th = Threads.main();
@@ -1253,7 +1252,7 @@ struct SfenReader
 			}
 			sfen_for_mse.push_back(ps);
 
-			// hash keyを求�る。
+			// Get the hash key.
 			StateInfo si;
 			pos.set_from_packed_sfen(ps.sfen,&si,th);
 			sfen_for_mse_hash.insert(pos.key());
@@ -1280,35 +1279,36 @@ struct SfenReader
 		}
 	}
 
-	// �スレッド��ッファリング���る局�数 0.1M局�。40HT�4M局�
+	// Number of phases buffered by each thread 0.1M phases. 4M phase at 40HT
 	const size_t THREAD_BUFFER_SIZE = 10 * 1000;
 
-	// ファイル読�込�用��ッファ(�れ大�������局��shuffle�大���る��局���ラ��������
-	// ��り大���メモリ消費�も上�る。
-	// SFEN_READ_SIZE�THREAD_BUFFER_SIZE��数��るも���る。
+	// Buffer for reading files (If this is made larger, the shuffle becomes larger and the phases may vary.
+	// If it is too large, the memory consumption will increase.
+	// SFEN_READ_SIZE is a multiple of THREAD_BUFFER_SIZE.
 	const size_t SFEN_READ_SIZE = LEARN_SFEN_READ_SIZE;
 
-	// [ASYNC] スレッド�局�を一�返�。��れ�false�返る。
+	// [ASYNC] Thread returns one aspect. Otherwise returns false.
 	bool read_to_thread_buffer(size_t thread_id, PackedSfenValue& ps)
 	{
-		// スレッド�ッファ�局��残���る�ら��れを1��り出��返�。
+		// If there are any positions left in the thread buffer, retrieve one and return it.
 		auto& thread_ps = packed_sfens[thread_id];
 
-		// �ッファ�残り�����らread buffer�ら充填�る���れ�ら����らも�終了。
-		if ((thread_ps == nullptr || thread_ps->size() == 0) // �ッファ�空�ら充填�る。
+		// Fill the read buffer if there is no remaining buffer, but if it doesn't even exist, finish.
+		if ((thread_ps == nullptr || thread_ps->size() == 0) // If the buffer is empty, fill it.
 			&& !read_to_thread_buffer_impl(thread_id))
 			return false;
 
-		// read_to_thread_buffer_impl()�trueを返��������
-		// スレッド�ッファ��局��充填�無事完了����������
-		// thread_ps->rbegin()��在。
+		// read_to_thread_buffer_impl() returned true,
+		// Since the filling of the thread buffer with the phase has been completed successfully
+		// thread_ps->rbegin() is alive.
 
 		ps = *(thread_ps->rbegin());
 		thread_ps->pop_back();
-		
-		// �ッファを使�������れ�自らdeleteを呼�出�����ッファを開放�る。
+
+		// If you've run out of buffers, call delete yourself to free this buffer.
 		if (thread_ps->size() == 0)
 		{
+
 			delete thread_ps;
 			thread_ps = nullptr;
 		}
@@ -1316,17 +1316,17 @@ struct SfenReader
 		return true;
 	}
 
-	// [ASYNC] スレッド�ッファ�局�を�る程度読�込む。
+	// [ASYNC] Read some aspects into thread buffer.
 	bool read_to_thread_buffer_impl(size_t thread_id)
 	{
 		while (true)
 		{
 			{
 				std::unique_lock<std::mutex> lk(mutex);
-				// ファイル�ッファ�ら充填����ら��れ�良�。
+				// If you can fill from the file buffer, that's fine.
 				if (packed_sfens_pool.size() != 0)
 				{
-					// 充填�能�よ����充填��終了。
+					// It seems that filling is possible, so fill and finish.
 
 					packed_sfens[thread_id] = packed_sfens_pool.front();
 					packed_sfens_pool.pop_front();
@@ -1337,24 +1337,24 @@ struct SfenReader
 				}
 			}
 
-			// も����読�込むファイル�無�����る。も�ダメ�。
+			// The file to read is already gone. No more use.
 			if (end_of_files)
 				return false;
 
-			// file worker�packed_sfens_pool�充填���れる�を待���る。
-			// mutex�lock���������れ充填���れる���。
+			// Waiting for file worker to fill packed_sfens_pool.
+			// The mutex isn't locked, so it should fill up soon.
 			sleep(1);
 		}
 
 	}
-	
-	// 局�ファイルを�ックグラウンド�読�込むスレッドを起動�る。
+
+	// Start a thread that loads the phase file in the background.
 	void start_file_read_worker()
 	{
 		file_worker_thread = std::thread([&] { this->file_read_worker(); });
 	}
 
-	// ファイル�読�込�専用スレッド用
+	// for file read-only threads
 	void file_read_worker()
 	{
 		auto open_next_file = [&]()
@@ -1362,11 +1362,11 @@ struct SfenReader
 			if (fs.is_open())
 				fs.close();
 
-			// も�無�
+			// no more
 			if (filenames.size() == 0)
 				return false;
 
-			// 次�ファイル�����得。
+			// Get the next file name.
 			string filename = *filenames.rbegin();
 			filenames.pop_back();
 
@@ -1379,8 +1379,8 @@ struct SfenReader
 
 		while (true)
 		{
-			// �ッファ�減���る�を待�。
-			// ��size()�読��り�read only���lock���������。
+			// Wait for the buffer to run out.
+			// This size() is read only, so you don't need to lock it.
 			while (!stop_flag && packed_sfens_pool.size() >= SFEN_READ_SIZE / THREAD_BUFFER_SIZE)
 				sleep(100);
 			if (stop_flag)
@@ -1389,7 +1389,7 @@ struct SfenReader
 			PSVector sfens;
 			sfens.reserve(SFEN_READ_SIZE);
 
-			// ファイル�ッファ�ファイル�ら読�込む。
+			// Read from the file into the file buffer.
 			while (sfens.size() < SFEN_READ_SIZE)
 			{
 				PackedSfenValue p;
@@ -1398,10 +1398,10 @@ struct SfenReader
 					sfens.push_back(p);
 				} else
 				{
-					// 読�込�失敗
+					// read failure
 					if (!open_next_file())
 					{
-						// 次�ファイルも����。��ーん。
+						// There was no next file. Abon.
 						cout << "..end of files." << endl;
 						end_of_files = true;
 						return;
@@ -1409,7 +1409,7 @@ struct SfenReader
 				}
 			}
 
-			// ��読�込ん�局�データをshuffle�る。
+			// Shuffle the read phase data.
 			// random shuffle by Fisher-Yates algorithm
 
 			if (!no_shuffle)
@@ -1419,8 +1419,8 @@ struct SfenReader
 					swap(sfens[i], sfens[(size_t)(prng.rand((uint64_t)size - i) + i)]);
 			}
 
-			// �れをTHREAD_BUFFER_SIZE���細切れ��る。�れ�size個�る��。
-			// SFEN_READ_SIZE�THREAD_BUFFER_SIZE��数��るも���る。
+			// Divide this by THREAD_BUFFER_SIZE. There should be size pieces.
+			// SFEN_READ_SIZE shall be a multiple of THREAD_BUFFER_SIZE.
 			assert((SFEN_READ_SIZE % THREAD_BUFFER_SIZE)==0);
 
 			auto size = size_t(SFEN_READ_SIZE / THREAD_BUFFER_SIZE);
@@ -1429,7 +1429,7 @@ struct SfenReader
 
 			for (size_t i = 0; i < size; ++i)
 			{
-				// ���インター�delete������行��。
+				// Delete this pointer on the receiving side.
 				PSVector* ptr = new PSVector();
 				ptr->resize(THREAD_BUFFER_SIZE);
 				memcpy(&((*ptr)[0]), &sfens[i * THREAD_BUFFER_SIZE], sizeof(PackedSfenValue) * THREAD_BUFFER_SIZE);
@@ -1437,12 +1437,12 @@ struct SfenReader
 				ptrs.push_back(ptr);
 			}
 
-			// sfens�用��出�����折を見�コピー
+			// Since sfens is ready, look at the occasion and copy
 			{
 				std::unique_lock<std::mutex> lk(mutex);
 
-				// �インタをコピー�る�������時間�無視��る��…。
-				// packed_sfens_pool�内容を変更�る��mutex�lock�必�。
+				// You can ignore this time because you just copy the pointer...
+				// The mutex lock is required because the contents of packed_sfens_pool are changed.
 
 				for (size_t i = 0; i < size; ++i)
 					packed_sfens_pool.push_back(ptrs[i]);
@@ -1450,76 +1450,76 @@ struct SfenReader
 		}
 	}
 
-	// sfenファイル群
+	// sfen files
 	vector<string> filenames;
 
-	// 読�込ん�局�数(ファイル�らメモリ上��ッファ�)
+	// number of phases read (file to memory buffer)
 	atomic<uint64_t> total_read;
 
-	// 処���局�数
+	// number of processed phases
 	atomic<uint64_t> total_done;
 
-	// �回���処���件数
+	// number of cases processed so far
 	uint64_t last_done;
 
-	// total_read���値を超��らupdate_weights()��mse�計算を�る。
+	// If total_read exceeds this value, update_weights() and calculate mse.
 	uint64_t next_update_weights;
 
 	uint64_t save_count;
 
-	// 局�読�込�時�シャッフルを行���。
+	// Do not shuffle when reading the phase.
 	bool no_shuffle;
 
 	bool stop_flag;
 
-	// rmse�計算用�局���る����を判定�る。
-	// (rmse�計算用�局��学習����使�������。)
+	// Determine if it is a phase for calculating rmse.
+	// (The computational aspects of rmse should not be used for learning.)
 	bool is_for_rmse(Key key) const
 	{
-		return sfen_for_mse_hash.count(key) != 0;
+			return sfen_for_mse_hash.count(key) != 0;
 	}
 
-	// �一局��読�出�を制��る���hash
-	// 6400万局���多��る�？���も���..
-	// hash_indexを求�る���mask�使����2**N���れ��ら��。
+	// hash to limit the reading of the same situation
+	// Is there too many 64 million phases? Or Not really..
+	// It must be 2**N because it will be used as the mask to calculate hash_index.
 	static const uint64_t READ_SFEN_HASH_SIZE = 64 * 1024 * 1024;
 	vector<Key> hash; // 64MB*8 = 512MB
 
-	// mse計算用�test局�
+	// test phase for mse calculation
 	PSVector sfen_for_mse;
 
 protected:
 
-	// fileを�ックグラウンド�読�込����るworker thread
+	// worker thread reading file in background
 	std::thread file_worker_thread;
 
-	// 局��読�込�時�shuffle�る���乱数
+	// Random number to shuffle when reading the phase
 	PRNG prng;
 
-	// ファイル群を読�込ん����最後��到����。
+	// Did you read the files and reached the end?
 	atomic<bool> end_of_files;
 
 
-	// sfenファイル��ンドル
+	// handle of sfen file
 	std::fstream fs;
 
-	// �スレッド用�sfen
-	// (使�������スレッド�自らdeleteを呼�出��開放���。)
+	// sfen for each thread
+	// (When the thread is used up, the thread should call delete to release it.)
 	std::vector<PSVector*> packed_sfens;
 
-	// packed_sfens_pool�アクセス�る���mutex
+	// Mutex when accessing packed_sfens_pool
 	std::mutex mutex;
 
-	// sfen�pool。file�ら読�込むworker thread����補充�る。
-	// �worker thread����ら自分�packed_sfens[thread_id]�充填�る。
-	// ※　mutexをlock��アクセス�る��。
+	// pool of sfen. The worker thread read from the file is added here.
+	// Each worker thread fills its own packed_sfens[thread_id] from here.
+	// * Lock and access the mutex.
 	std::list<PSVector*> packed_sfens_pool;
 
-	// mse計算用�局�を学習�用������hash keyを������。
+	// Hold the hash key so that the mse calculation phase is not used for learning.
 	std::unordered_set<Key> sfen_for_mse_hash;
 };
 
-// 複数スレッド�sfenを生��る���クラス
+// Class to generate sfen with multiple threads
 struct LearnerThink: public MultiThink
 {
 	LearnerThink(SfenReader& sr_):sr(sr_),stop_flag(false), save_only_once(false)
@@ -1544,43 +1544,43 @@ struct LearnerThink: public MultiThink
 
 	virtual void thread_worker(size_t thread_id);
 
-	// 局�ファイルを�ックグラウンド�読�込むスレッドを起動�る。
+	// Start a thread that loads the phase file in the background.
 	void start_file_read_worker() { sr.start_file_read_worker(); }
 
-	// 評価関数パラメーターをファイル��存
+	// save merit function parameters to a file
 	bool save(bool is_final=false);
 
-	// sfen�読�出�器
+	// sfen reader
 	SfenReader& sr;
 
-	// 学習��復回数�カウンター
+	// Learning iteration counter
 	uint64_t epoch = 0;
 
-	// ミニ�ッ�サイズ�サイズ。必���classを使���設定�る��。
+	// Mini batch size size. Be sure to set it on the side that uses this class.
 	uint64_t mini_batch_size = 1000*1000;
 
 	bool stop_flag;
 
-	// 割引率
+	// Discount rate
 	double discount_rate;
 
-	// �盤を学習対象�ら外�オプション
+	// Option to exclude early stage from learning
 	int reduction_gameply;
 
-	// kk/kkp/kpp/kpppを学習����オプション
+	// Option not to learn kk/kkp/kpp/kppp
 	std::array<bool,4> freeze;
 
-	// 教師局��深�探索�評価値�絶対値���値を超����ら��教師局�を��る。
+	// If the absolute value of the evaluation value of the deep search of the teacher phase exceeds this value, discard the teacher phase.
 	int eval_limit;
 
-	// 評価関数��存�る���都度フォルダを掘る��フラグ。
-	// true��フォルダを掘ら��。
+	// Flag whether to dig a folder each time the evaluation function is saved.
+	// If true, do not dig the folder.
 	bool save_only_once;
 
-	// --- loss�計算
+	// --- loss calculation
 
-#if defined ( LOSS_FUNCTION_IS_ELMO_METHOD )
-	// 学習用データ�ロス�計算用
+#if defined (LOSS_FUNCTION_IS_ELMO_METHOD)
+	// For calculation of learning data loss
 	atomic<double> learn_sum_cross_entropy_eval;
 	atomic<double> learn_sum_cross_entropy_win;
 	atomic<double> learn_sum_cross_entropy;
@@ -1604,20 +1604,21 @@ struct LearnerThink: public MultiThink
 	uint64_t loss_output_interval;
 	uint64_t mirror_percentage;
 
-	// ロス�計算。
-	// done : 今回対象���局�数
+	// Loss calculation.
+	// done: Number of phases targeted this time
 	void calc_loss(size_t thread_id , uint64_t done);
 
-	// ↑�loss�計算をタスク���定義��やり��れを実行�る
+	// Define the loss calculation in ↑ as a task and execute it
 	TaskDispatcher task_dispatcher;
 };
 
 void LearnerThink::calc_loss(size_t thread_id, uint64_t done)
 {
-	// 置�表�hit�れ�も���ん�����タイミング�置�表�世代を新���る。
-	// 置�表を無効����る�ら関係�����。
+	// There is no point in hitting the replacement table, so at this timing the generation of the replacement table is updated.
+	// It doesn't matter if you have disabled the substitution table.
 	TT.new_search();
 
+
 #if defined(EVAL_NNUE)
 	std::cout << "PROGRESS: " << now_string() << ", ";
 	std::cout << sr.total_done << " sfens";
@@ -1631,8 +1632,8 @@ void LearnerThink::calc_loss(size_t thread_id, uint64_t done)
 	double sum_error3 = 0;
 #endif
 
-#if defined ( LOSS_FUNCTION_IS_ELMO_METHOD )
-	// 検証用データ�ロス�計算用
+#if defined (LOSS_FUNCTION_IS_ELMO_METHOD)
+	// For calculation of verification data loss
 	atomic<double> test_sum_cross_entropy_eval,test_sum_cross_entropy_win,test_sum_cross_entropy;
 	atomic<double> test_sum_entropy_eval,test_sum_entropy_win,test_sum_entropy;
 	test_sum_cross_entropy_eval = 0;
@@ -1642,16 +1643,16 @@ void LearnerThink::calc_loss(size_t thread_id, uint64_t done)
 	test_sum_entropy_win = 0;
 	test_sum_entropy = 0;
 
-	// 学習時�norm
+	// norm for learning
 	atomic<double> sum_norm;
 	sum_norm = 0;
 #endif
 
-	// 深�探索�pv��手��search(1)�pv��手�指�手�一致��回数。
+	// The number of times the pv first move of deep search matches the pv first move of search(1).
 	atomic<int> move_accord_count;
 	move_accord_count = 0;
 
-	// 平手��期局��eval()�値を表示�����れを見る。
+	// Display the value of eval() in the initial stage of Hirate and see the shaking.
 	auto th = Threads[thread_id];
 	auto& pos = th->rootPos;
 	StateInfo si;
@@ -1660,36 +1661,36 @@ void LearnerThink::calc_loss(size_t thread_id, uint64_t done)
 
 	//Eval::print_eval_stat(pos);
 
-	// ���並列化�����良����slave���探索�終�������り���ょ���倒。
-	// taskを呼�出����仕組�を作�����れを用�る。
+	// It's better to parallelize here, but it's a bit troublesome because the search before slave has not finished.
+	// I created a mechanism to call task, so I will use it.
 
-	// �����task�数。
+	// The number of tasks to do.
 	atomic<int> task_count;
 	task_count = (int)sr.sfen_for_mse.size();
 	task_dispatcher.task_reserve(task_count);
 
-	// 局��探索を�るtaskを生����スレッド�振��やる。
+	// Create a task to search for the situation and give it to each thread.
 	for (const auto& ps : sr.sfen_for_mse)
 	{
-		// TaskDispatcherを用���スレッド�作業を振る。
-		// �����タスク�定義。
-		// ↑�使���るposをcapture�れる���らん��capture���変数�一���指定����。
+		// Assign work to each thread using TaskDispatcher.
+		// A task definition for that.
+		// It is not possible to capture pos used in ↑, so specify the variables you want to capture one by one.
 		auto task = [&ps,&test_sum_cross_entropy_eval,&test_sum_cross_entropy_win,&test_sum_cross_entropy,&test_sum_entropy_eval,&test_sum_entropy_win,&test_sum_entropy, &sum_norm,&task_count ,&move_accord_count](size_t thread_id)
 		{
-			// �れ�C++��ループ���新��ps�インスタンスを�ゃん�capture�る�����.. →　�るよ��。
+			// Does C++ properly capture a new ps instance for each loop?.
 			auto th = Threads[thread_id];
 			auto& pos = th->rootPos;
 			StateInfo si;
 			if (pos.set_from_packed_sfen(ps.sfen ,&si, th) != 0)
 			{
-				// �悪�rmse計算用�sfen�����正�sfenを引��������。
+				// Unfortunately, as an sfen for rmse calculation, an invalid sfen was drawn.
 				cout << "Error! : illegal packed sfen " << pos.fen() << endl;
 			}
 
-			// 浅�探索�評価値
-			// evaluate()�値を用��も良�����ロスを計算�る���learn_cross_entropy�
-			// 値�比較�����困る��qsearch()を用�る。
-			// EvalHash�事��無効化���る。(������毎回��値�返�����)
+			// Evaluation value for shallow search
+			// The value of evaluate() may be used, but when calculating loss, learn_cross_entropy and
+			// Use qsearch() because it is difficult to compare the values.
+			// EvalHash has been disabled in advance. (If not, the same value will be returned every time)
 			auto r = qsearch(pos);
 
 			auto shallow_value = r.first;
@@ -1707,34 +1708,34 @@ void LearnerThink::calc_loss(size_t thread_id, uint64_t done)
 					pos.undo_move(*it);
 			}
 
-			// 深�探索�評価値
+			// Evaluation value of deep search
 			auto deep_value = (Value)ps.score;
 
-			// 注) ��コード��learnコマンド�eval_limitを指定���る�����を考慮����。
+			// Note) This code does not consider when eval_limit is specified in the learn command.
 
-			// --- 誤差�計算
+			// --- error calculation
 
 #if !defined(LOSS_FUNCTION_IS_ELMO_METHOD)
 			auto grad = calc_grad(deep_value, shallow_value, ps);
 
-			// rmse的�も�
+			// something like rmse
 			sum_error += grad*grad;
-			// 勾��絶対値を足��も�
+			// Add the absolute value of the gradient
 			sum_error2 += abs(grad);
-			// 評価値�差�絶対値を足��も�
+			// Add the absolute value of the difference between the evaluation values
 			sum_error3 += abs(shallow_value - deep_value);
 #endif
 
-			// --- 交差エントロピー�計算
+			// --- calculation of cross entropy
 
-			// �り���elmo method�時���率項��敗項�関��
-			// 交差エントロピーを計算��表示��る。
+			// For the time being, regarding the win rate and loss terms only in the elmo method
+			// Calculate and display the cross entropy.
 
-#if defined ( LOSS_FUNCTION_IS_ELMO_METHOD )
+#if defined (LOSS_FUNCTION_IS_ELMO_METHOD)
 			double test_cross_entropy_eval, test_cross_entropy_win, test_cross_entropy;
 			double test_entropy_eval, test_entropy_win, test_entropy;
 			calc_cross_entropy(deep_value, shallow_value, ps, test_cross_entropy_eval, test_cross_entropy_win, test_cross_entropy, test_entropy_eval, test_entropy_win, test_entropy);
-			// 交差エントロピー��計�定義的�abs()を�る必����。
+			// The total cross entropy need not be abs() by definition.
 			test_sum_cross_entropy_eval += test_cross_entropy_eval;
 			test_sum_cross_entropy_win += test_cross_entropy_win;
 			test_sum_cross_entropy += test_cross_entropy;
@@ -1744,31 +1745,31 @@ void LearnerThink::calc_loss(size_t thread_id, uint64_t done)
 			sum_norm += (double)abs(shallow_value);
 #endif
 
-			// 教師�指�手�浅�探索�スコア�一致�る��判定
+			// Determine if the teacher's move and the score of the shallow search match
 			{
 				auto r = search(pos,1);
 				if ((uint16_t)r.second[0] == ps.move)
 					move_accord_count.fetch_add(1, std::memory_order_relaxed);
 			}
 
-			// ������タスク一�減る
+			// Reduced one task because I did it
 			--task_count;
 		};
 
-		// 定義��タスクをslave�投�る。
+		// Throw the defined task to slave.
 		task_dispatcher.push_task_async(task);
 	}
 
-	// 自分自身もslave����加�る
+	// join yourself as a slave
 	task_dispatcher.on_idle(thread_id);
 
-	// ����task�完了を待�
+	// wait for all tasks to complete
 	while (task_count)
 		sleep(1);
 
 #if !defined(LOSS_FUNCTION_IS_ELMO_METHOD)
-	// rmse = root mean square error : 平�二乗誤差
-	// mae  = mean absolute error    : 平�絶対誤差
+	// rmse = root mean square error: mean square error
+	// mae = mean absolute error: mean absolute error
 	auto dsig_rmse = std::sqrt(sum_error / (sfen_for_mse.size() + epsilon));
 	auto dsig_mae = sum_error2 / (sfen_for_mse.size() + epsilon);
 	auto eval_mae = sum_error3 / (sfen_for_mse.size() + epsilon);
@@ -1782,8 +1783,8 @@ void LearnerThink::calc_loss(size_t thread_id, uint64_t done)
 	latest_loss_count += sr.sfen_for_mse.size();
 #endif
 
-	// learn_cross_entropy��機械学習�世界��train cross entropy�呼����も知れ����
-	// 頭文字を略�る����lce�書���test cross entropy(tce)�区別出�����嬉���������る。
+// learn_cross_entropy may be called train cross entropy in the world of machine learning,
+// When omitting the acronym, it is nice to be able to distinguish it from test cross entropy(tce) by writing it as lce.
 
 	if (sr.sfen_for_mse.size() && done)
 	{
@@ -1812,7 +1813,7 @@ void LearnerThink::calc_loss(size_t thread_id, uint64_t done)
 		cout << "Error! : sr.sfen_for_mse.size() = " << sr.sfen_for_mse.size() << " ,  done = " << done << endl;
 	}
 
-	// 次回����0クリア����。
+	// Clear 0 for next time.
 	learn_sum_cross_entropy_eval = 0.0;
 	learn_sum_cross_entropy_win = 0.0;
 	learn_sum_cross_entropy = 0.0;
@@ -1836,11 +1837,11 @@ void LearnerThink::thread_worker(size_t thread_id)
 
 	while (true)
 	{
-		// mse�表示(�れ�thread 0������行�)
-		// ファイル�ら読�込ん�直後�����よ��…。
+	// display mse (this is sometimes done only for thread 0)
+	// Immediately after being read from the file...
 
 #if defined(EVAL_NNUE)
-		// 更新中�評価関数を使���よ��ロック�る。
+		// Lock the evaluation function so that it is not used during updating.
 		shared_lock<shared_timed_mutex> read_lock(nn_mutex, defer_lock);
 		if (sr.next_update_weights <= sr.total_done ||
 		    (thread_id != 0 && !read_lock.try_lock()))
@@ -1850,20 +1851,20 @@ void LearnerThink::thread_worker(size_t thread_id)
 		{
 			if (thread_id != 0)
 			{
-				// thread_id == 0以外��待機。
+				// Wait except thread_id == 0.
 
 				if (stop_flag)
 					break;
 
-				// rmse�計算��を並列化�����task()���れ��れ��れを処��る。
+				// I want to parallelize rmse calculation etc., so if task() is loaded, process it.
 				task_dispatcher.on_idle(thread_id);
 				continue;
 			}
 			else
 			{
-				// thread_id == 0���以下�更新処�を行��。
+				// Only thread_id == 0 performs the following update process.
 
-				// �回�weight�列�更新�行���。
+				// The weight array is not updated for the first time.
 				if (sr.next_update_weights == 0)
 				{
 					sr.next_update_weights += mini_batch_size;
@@ -1871,33 +1872,33 @@ void LearnerThink::thread_worker(size_t thread_id)
 				}
 
 #if !defined(EVAL_NNUE)
-				// �在時刻を出力。毎回出力�る。
+				// Output the current time. Output every time.
 				std::cout << sr.total_done << " sfens , at " << now_string() << std::endl;
 
-				// ��タイミング�勾�をweight�列��映。勾��計算も1M局����mini-batch的���ょ�������。
+				// Reflect the gradient in the weight array at this timing. The calculation of the gradient is just right for each 1M phase in terms of mini-batch.
 				Eval::update_weights(epoch , freeze);
 
-				// デ�ッグ用�epoch��在�etaを表示��やる。
+				// Display epoch and current eta for debugging.
 				std::cout << "epoch = " << epoch << " , eta = " << Eval::get_eta() << std::endl;
 #else
 				{
-					// パラメータ�更新
+					// update parameters
 
-					// 更新中�評価関数を使���よ��ロック�る。
+					// Lock the evaluation function so that it is not used during updating.
 					lock_guard<shared_timed_mutex> write_lock(nn_mutex);
 					Eval::NNUE::UpdateParameters(epoch);
 				}
 #endif
 				++epoch;
 
-				// 10億局����1回�存��ら��感��。
+				// Save once every 1 billion phases.
 
-				// ����update_weights(),calc_rmse()���る間�時間経��無視�るも���る。
+				// However, the elapsed time during update_weights() and calc_rmse() is ignored.
 				if (++sr.save_count * mini_batch_size >= eval_save_interval)
 				{
 					sr.save_count = 0;
 
-					// ��間�gradient�計算�進む�値�大���り���困る気��る��他�スレッドを�止��る。
+					// During this time, as the gradient calculation proceeds, the value becomes too large and I feel annoyed, so stop other threads.
 					const bool converged = save();
 					if (converged)
 					{
@@ -1907,33 +1908,33 @@ void LearnerThink::thread_worker(size_t thread_id)
 					}
 				}
 
-				// rmseを計算�る。1万局��サンプル�対��行�。
-				// 40コア�やる�100万局����update_weights�る����特定�スレッド�
-				// ����り����������りよ���よ��気も…。
+				// Calculate rmse. This is done for samples of 10,000 phases.
+				// If you do with 40 cores, update_weights every 1 million phases
+				// I don't think it's so good to be tiring.
 				static uint64_t loss_output_count = 0;
 				if (++loss_output_count * mini_batch_size >= loss_output_interval)
 				{
 					loss_output_count = 0;
 
-					// 今回処���件数
+					// Number of cases processed this time
 					uint64_t done = sr.total_done - sr.last_done;
 
-					// loss�計算
+					// loss calculation
 					calc_loss(thread_id , done);
 
 #if defined(EVAL_NNUE)
 					Eval::NNUE::CheckHealth();
 #endif
 
-					// ����集計���を記録����。
+					// Make a note of how far you have totaled.
 					sr.last_done = sr.total_done;
 				}
 
-				// 次回���一連�処���次回�mini_batch_size��処�������度や��欲��。
+				// Next time, I want you to do this series of processing again when you process only mini_batch_size.
 				sr.next_update_weights += mini_batch_size;
 
-				// main thread以外����sr.next_update_weights�更新を待������
-				// ��値�更新�れる��度動�始�る。				
+				// Since I was waiting for the update of this sr.next_update_weights except the main thread,
+				// Once this value is updated, it will start moving again.
 			}
 		}
 
@@ -1941,17 +1942,17 @@ void LearnerThink::thread_worker(size_t thread_id)
 	RetryRead:;
 		if (!sr.read_to_thread_buffer(thread_id, ps))
 		{
-			// 自分�スレッド用�局�poolを使�尽���。
-			// 局��も���ん�残������������ら�
-			// 他�スレッドも���終了��る。
+			// ran out of thread pool for my thread.
+			// Because there are almost no phases left,
+			// Terminate all other threads.
 
 			stop_flag = true;
 			break;
 		}
 
-		// 評価値�学習対象�値を超���る。
-		// ��局�情報を無視�る。
-		if (eval_limit < abs(ps.score))
+		// The evaluation value exceeds the learning target value.
+		// Ignore this aspect information.
+		if (eval_limit <abs(ps.score))
 			goto RetryRead;
 
 
@@ -1959,7 +1960,7 @@ void LearnerThink::thread_worker(size_t thread_id)
 			goto RetryRead;
 
 
-		// �盤局��関�る読�飛��
+		// Skip over the opening phase
 		if (ps.gamePly < prng.rand(reduction_gameply))
 			goto RetryRead;
 
@@ -1967,70 +1968,70 @@ void LearnerThink::thread_worker(size_t thread_id)
 		auto sfen = pos.sfen_unpack(ps.data);
 		pos.set(sfen);
 #endif
-		// ↑sfenを経由�る�����専用�関数を作��。
+		// ↑ Since it is slow when passing through sfen, I made a dedicated function.
 		StateInfo si;
 		const bool mirror = prng.rand(100) < mirror_percentage;
 		if (pos.set_from_packed_sfen(ps.sfen,&si,th,mirror) != 0)
 		{
-			// 変�sfenを掴���れ�。デ�ッグ����
-			// �正�sfen���pos.sfen()�表示��る���ら�������よりマシ。
+			// I got a strange sfen. Should be debugged!
+			// Since it is an illegal sfen, it may not be displayed with pos.sfen(), but it is better than not.
 			cout << "Error! : illigal packed sfen = " << pos.fen() << endl;
 			goto RetryRead;
 		}
 #if !defined(EVAL_NNUE)
 		{
 			auto key = pos.key();
-			// rmse�計算用�使���る局��ら除外�る。
+			// Exclude the phase used for rmse calculation.
 			if (sr.is_for_rmse(key) && use_hash_in_training)
 				goto RetryRead;
 
-			// 直近�用��局�も除外�る。
+			// Exclude the most recently used aspect.
 			auto hash_index = size_t(key & (sr.READ_SFEN_HASH_SIZE - 1));
 			auto key2 = sr.hash[hash_index];
 			if (key == key2 && use_hash_in_training)
 				goto RetryRead;
-			sr.hash[hash_index] = key; // 今回�key�入れ替����。
+			sr.hash[hash_index] = key; // Replace with the current key.
 		}
 #endif
 
-		// 全駒�れ�詰ん��る�能性��る。
-		// ��宣言���局��PV�指�手�leaf�行�����学習�ら除外����。
-		// (��よ��教師局�自体を書�出������������生�ルー�ン�書�出���る�も知れ����)
-    // Skip the position if there are no legal moves (=checkmated or stalemate).
+		// There is a possibility that all the pieces are blocked and stuck.
+		// Also, the declaration win phase is excluded from learning because you cannot go to leaf with PV moves.
+		// (shouldn't write out such teacher aspect itself, but may have written it out with an old generation routine)
+	// Skip the position if there are no legal moves (=checkmated or stalemate).
 		if (MoveList<LEGAL>(pos).size() == 0)
 			goto RetryRead;
 
-		// 読�込����試��表示���る。
+		// I can read it, so try displaying it.
 		//		cout << pos << value << endl;
 
-		// 浅�探索(qsearch)�評価値
+		// Evaluation value of shallow search (qsearch)
 		auto r = qsearch(pos);
 		auto pv = r.second;
 
-		// 深�探索�評価値
+		// Evaluation value of deep search
 		auto deep_value = (Value)ps.score;
 
-		// mini batch����勾��出���よ��気��る。
-		// ����leaf node�行���勾��列���足��������rmse�集計����AdaGrad���る。
+		// I feel that the mini batch has a better gradient.
+		// Go to the leaf node as it is, add only to the gradient array, and later try AdaGrad at the time of rmse aggregation.
 
 		auto rootColor = pos.side_to_move();
 
-		// PV��手�異�る場��学習�用������良����…。
-		// 全然�����を探索���果���れ�ノイズ��り����。
-		// 評価値�差�大���る���も学習対象����������も…。
+		// If the initial PV is different, it is better not to use it for learning.
+		// If it is the result of searching a completely different place, it may become noise.
+		// It may be better not to study where the difference in evaluation values ​​is too large.
 
 #if 0
-		// �れやる�13%程度�局��学習対象�ら外れ����。善悪�微妙。
+		// If you do this, about 13% of the phases will be excluded from the learning target. Good and bad are subtle.
 		if (pv.size() >= 1 && (uint16_t)pv[0] != ps.move)
 		{
-//			dbg_hit_on(false);
+			// dbg_hit_on(false);
 			continue;
 		}
 #endif
 
 #if 0
-		// 評価値�差�大���る���も学習対象����������も…。
-		// →　�率�関数を通��������…。30%�ら��局��学習対象�ら外れ������…。
+		// It may be better not to study where the difference in evaluation values ​​is too large.
+		// → It's okay because it passes the win rate function... About 30% of the phases are out of the scope of learning...
 		if (abs((int16_t)r.first - ps.score) >= Eval::PawnValue * 4)
 		{
 //			dbg_hit_on(false);
@@ -2041,18 +2042,18 @@ void LearnerThink::thread_worker(size_t thread_id)
 
 		int ply = 0;
 
-		// �在�局��対��勾�を加算�るヘルパー関数。
+		// A helper function that adds the gradient to the current phase.
 		auto pos_add_grad = [&]() {
-			// shallow_value����leaf��evaluate�値を用�る。
-			// qsearch()�戻り値をshallow_value���用�る��
-			// PV�途中�途切れ��る場��勾�を計算�る��evaluate()を呼�出��局���
-			// ��勾�を与�る局���異�る����る����れ���り好���性質�������。
-			// 置�表をオフ�����る����1手詰����pv�列を更新�������…。
+			// Use the value of evaluate in leaf as shallow_value.
+			// Using the return value of qsearch() as shallow_value,
+			// If PV is interrupted in the middle, the phase where evaluate() is called to calculate the gradient, and
+			// I don't think this is a very desirable property, as the aspect that gives that gradient will be different.
+			// I have turned off the substitution table, but since the pv array has not been updated due to one stumbling block etc...
 
 			Value shallow_value = (rootColor == pos.side_to_move()) ? Eval::evaluate(pos) : -Eval::evaluate(pos);
 
-#if defined ( LOSS_FUNCTION_IS_ELMO_METHOD )
-			// 学習データ�対�るロス�計算
+#if defined (LOSS_FUNCTION_IS_ELMO_METHOD)
+			// Calculate loss for training data
 			double learn_cross_entropy_eval, learn_cross_entropy_win, learn_cross_entropy;
 			double learn_entropy_eval, learn_entropy_win, learn_entropy;
 			calc_cross_entropy(deep_value, shallow_value, ps, learn_cross_entropy_eval, learn_cross_entropy_win, learn_cross_entropy, learn_entropy_eval, learn_entropy_win, learn_entropy);
@@ -2065,17 +2066,17 @@ void LearnerThink::thread_worker(size_t thread_id)
 #endif
 
 #if !defined(EVAL_NNUE)
-			// 勾�
+			// Slope
 			double dj_dw = calc_grad(deep_value, shallow_value, ps);
 
-			// �在�leaf node�出����る特徴ベクトル�対�る勾�(∂J/∂Wj)����jd_dwを加算�る。
+			// Add jd_dw as the gradient (∂J/∂Wj) for the feature vector currently appearing in the leaf node.
 
-			// PV終端���れ�割引率����も�を�用。
+			// If it is not PV termination, apply a discount rate.
 			if (discount_rate != 0 && ply != (int)pv.size())
 				dj_dw *= discount_rate;
 
-			// leaf�到�������局��出����る特徴�勾�を加算����。
-			// 勾��基��update�����行��。
+			// Since we have reached leaf, add the gradient to the features that appear in this phase.
+			// Update based on gradient later.
 			Eval::add_grad(pos, rootColor, dj_dw, freeze);
 #else
 			const double example_weight =
@@ -2083,15 +2084,15 @@ void LearnerThink::thread_worker(size_t thread_id)
 			Eval::NNUE::AddExample(pos, rootColor, ps, example_weight);
 #endif
 
-			// 処��終了����処���件数�カウンターをインクリメント
+			// Since the processing is completed, the counter of the processed number is incremented
 			sr.total_done++;
 		};
 
-		StateInfo state[MAX_PLY]; // qsearch�PV��ん��長��る����り���。
+		StateInfo state[MAX_PLY]; // PV of qsearch cannot be so long.
 		bool illegal_move = false;
 		for (auto m : pv)
 		{
-			// ��法手�や�����������。
+			// I shouldn't be an illegal player.
 			// An illegal move sometimes comes here...
 			if (!pos.pseudo_legal(m) || !pos.legal(m))
 			{
@@ -2101,14 +2102,14 @@ void LearnerThink::thread_worker(size_t thread_id)
 				break;
 			}
 
-			// �PV上�node�も勾�を加算�る場��処�。
-			// discount_rate�0������処��行���。
+			// Processing when adding the gradient to the node on each PV.
+			//If discount_rate is 0, this process is not performed.
 			if (discount_rate != 0)
 				pos_add_grad();
 
 			pos.do_move(m, state[ply++]);
-			
-			// leaf��evaluate�値を用�る��差分更新����。
+
+			// Since the value of evaluate in leaf is used, the difference is updated.
 			Eval::evaluate_with_no_return(pos);
 		}
 
@@ -2117,15 +2118,15 @@ void LearnerThink::thread_worker(size_t thread_id)
 			continue;
 		}
 
-		// PV�終端局�����������勾�を加算�る。
+		// Since we have reached the end phase of PV, add the slope here.
 		pos_add_grad();
 
-		// 局�を巻�戻�
+		// rewind the phase
 		for (auto it = pv.rbegin(); it != pv.rend(); ++it)
 			pos.undo_move(*it);
 
 #if 0
-		// root�局��も勾�を加算�る場�
+		// When adding the gradient to the root phase
 		shallow_value = (rootColor == pos.side_to_move()) ? Eval::evaluate(pos) : -Eval::evaluate(pos);
 		dj_dw = calc_grad(deep_value, shallow_value, ps);
 		Eval::add_grad(pos, rootColor, dj_dw , without_kpp);
@@ -2135,19 +2136,19 @@ void LearnerThink::thread_worker(size_t thread_id)
 
 }
 
-// 評価関数ファイル�書�出�。
+// Write evaluation function file.
 bool LearnerThink::save(bool is_final)
 {
-	// �存��check sumを計算��出力����。(次�読�込ん�����致�る�調�る��)
-	std::cout << "Check Sum = " << std::hex << Eval::calc_check_sum() << std::dec << std::endl;
+	// Calculate and output check sum before saving. (To check if it matches the next time)
+	std::cout << "Check Sum = "<< std::hex << Eval::calc_check_sum() << std::dec << std::endl;
 
-	// �存���ファイル��拡張�部分を"0","1","2",..�よ��変����。
-	// (����れ�れ�評価関数パラメーター�����率を比較�����)
+	// Each time you save, change the extension part of the file name like "0","1","2",..
+	// (Because I want to compare the winning rate for each evaluation function parameter later)
 
 	if (save_only_once)
 	{
-		// EVAL_SAVE_ONLY_ONCE�定義�れ��る����
-		// 1度����存������サブフォルダを掘ら��。
+		// When EVAL_SAVE_ONLY_ONCE is defined,
+		// Do not dig a subfolder because I want to save it only once.
 		Eval::save_eval("");
 	}
 	else if (is_final) {
@@ -2196,26 +2197,26 @@ bool LearnerThink::save(bool is_final)
 	return false;
 }
 
-// shuffle_files() , shuffle_files_quick()�下請���書�出�部分。
-// output_file_name : 書�出�ファイル�
-// prng : 乱数
-// afs  : �れ�れ�教師局�ファイル�fstream
-// a_count : �れ�れ�ファイル�内在�る教師局��数。
+// Shuffle_files(), shuffle_files_quick() subcontracting, writing part.
+// output_file_name: Name of the file to write
+// prng: random number
+// afs: fstream of each teacher phase file
+// a_count: The number of teacher positions inherent in each file.
 void shuffle_write(const string& output_file_name , PRNG& prng , vector<fstream>& afs , vector<uint64_t>& a_count)
 {
 	uint64_t total_sfen_count = 0;
 	for (auto c : a_count)
 		total_sfen_count += c;
 
-	// 書�出��局�数
+	// number of exported phases
 	uint64_t write_sfen_count = 0;
 
-	// 進�を��局�数���画��出力�る。
+	// Output the progress on the screen for each phase.
 	const uint64_t buffer_size = 10000000;
 
 	auto print_status = [&]()
 	{
-		// 10M局����も��������書�出��終������進�を出力�る
+		// Output progress every 10M phase or when all writing is completed
 		if (((write_sfen_count % buffer_size) == 0) ||
 			(write_sfen_count == total_sfen_count))
 			cout << write_sfen_count << " / " << total_sfen_count << endl;
@@ -2226,7 +2227,7 @@ void shuffle_write(const string& output_file_name , PRNG& prng , vector<fstream>
 
 	fstream fs(output_file_name, ios::out | ios::binary);
 
-	// 教師局���計
+	// total teacher positions
 	uint64_t sum = 0;
 	for (auto c : a_count)
 		sum += c;
@@ -2235,22 +2236,22 @@ void shuffle_write(const string& output_file_name , PRNG& prng , vector<fstream>
 	{
 		auto r = prng.rand(sum);
 
-		// fs[0]�ファイル�格��れ��る局� ... fs[1]�ファイル�格��れ��る局� ...
-		// �よ����続������るも��考���r���ファイル�格��れ��る局�を指���る�を確定��る。
-		// ファイル�中身�シャッフル�れ��る�����ファイル�ら次��素を1�����れ�良�。
-		// �れ�れ�ファイル��a_count[x]��局��残���る�����処��以下�よ��書�る。
+		// Aspects stored in fs[0] file ... Aspects stored in fs[1] file ...
+		//Think of it as a series like, and determine in which file r is pointing.
+		// The contents of the file are shuffled, so you can take the next element from that file.
+		// Each file has a_count[x] phases, so this process can be written as follows.
 
 		uint64_t n = 0;
 		while (a_count[n] <= r)
 			r -= a_count[n++];
 
-		// �れ�n�確定��。忘れ�����残り件数を減ら����。
+		// This confirms n. Before you forget it, reduce the remaining number.
 
 		--a_count[n];
 		--sum;
 
 		PackedSfenValue psv;
-		// �れ�パフォーマンス�ん�りよ���������読�書������良����…。
+		// It's better to read and write all at once until the performance is not so good...
 		if (afs[n].read((char*)&psv, sizeof(PackedSfenValue)))
 		{
 			fs.write((char*)&psv, sizeof(PackedSfenValue));
@@ -2263,47 +2264,47 @@ void shuffle_write(const string& output_file_name , PRNG& prng , vector<fstream>
 	cout << "done!" << endl;
 }
 
-// 教師局��シャッフル "learn shuffle"コマンド�下請�。
-// output_file_name : シャッフル�れ�教師局��書�出�れる出力ファイル�
+// Subcontracting the teacher shuffle "learn shuffle" command.
+// output_file_name: name of the output file where the shuffled teacher positions will be written
 void shuffle_files(const vector<string>& filenames , const string& output_file_name , uint64_t buffer_size )
 {
-	// 出力先�フォルダ�
-	// tmp/               一時書�出�用
+	// The destination folder is
+	// tmp/ for temporary writing
 
-	// テン�ラリファイル�buffer_size局���tmp/フォルダ����ん書�出�。
-	// 例���buffer_size = 20M�ら� 20M*40bytes = 800MB��ッファ�必�。
-	// メモリ�少��PC�����を減ら��良����。
-	// ������りファイル数�増�る�OS�制����ら�時�open出����る。
-	// Windows��1プロセス512���制約�������������open出�る��500����
-	// �在�設定�500ファイル×20M = 10G = 100億局���度。
+	// Temporary file is written to tmp/ folder for each buffer_size phase.
+	// For example, if buffer_size = 20M, you need a buffer of 20M*40bytes = 800MB.
+	// In a PC with a small memory, it would be better to reduce this.
+	// However, if the number of files increases too much, it will not be possible to open at the same time due to OS restrictions.
+	// There should have been a limit of 512 per process on Windows, so you can open here as 500,
+	// The current setting is 500 files x 20M = 10G = 10 billion phases.
 
 	PSVector buf;
 	buf.resize(buffer_size);
-	// ↑��ッファ�����使���を示�マーカー
+	// ↑ buffer, a marker that indicates how much you have used
 	uint64_t buf_write_marker = 0;
 
-	// 書�出�ファイル�(連番���インクリメンタルカウンター)
+	// File name to write (incremental counter because it is a serial number)
 	uint64_t write_file_count = 0;
 
-	// シャッフル�る���乱数
+	// random number to shuffle
 	PRNG prng((std::random_device())());
 
-	// テン�ラリファイル���を生��る
+	// generate the name of the temporary file
 	auto make_filename = [](uint64_t i)
 	{
 		return "tmp/" + to_string(i) + ".bin";
 	};
 
-	// 書�出��tmp/フォルダ�ファイル��れ�れ�格��れ��る教師局��数
+	// Exported files in tmp/ folder, number of teacher positions stored in each
 	vector<uint64_t> a_count;
 
 	auto write_buffer = [&](uint64_t size)
 	{
-		// buf[0]～buf[size-1]��をshuffle
+		// shuffle from buf[0] to buf[size-1]
 		for (uint64_t i = 0; i < size; ++i)
 			swap(buf[i], buf[(uint64_t)(prng.rand(size - i) + i)]);
 
-		// ファイル�書�出�
+		// write to a file
 		fstream fs;
 		fs.open(make_filename(write_file_count++), ios::out | ios::binary);
 		fs.write((char*)&buf[0], size * sizeof(PackedSfenValue));
@@ -2316,7 +2317,7 @@ void shuffle_files(const vector<string>& filenames , const string& output_file_n
 
 	Dependency::mkdir("tmp");
 
-	// 10M局��細切れファイル���シャッフル��書�出�。
+	// Shuffle and export as a 10M phase shredded file.
 	for (auto filename : filenames)
 	{
 		fstream fs(filename, ios::in | ios::binary);
@@ -2325,57 +2326,57 @@ void shuffle_files(const vector<string>& filenames , const string& output_file_n
 			if (++buf_write_marker == buffer_size)
 				write_buffer(buffer_size);
 
-		// sizeof(PackedSfenValue)���読�込ん����
-		// 最後�残���る端数�無視�る。(fs.read�失敗�る��whileを抜�る)
-		// (最後�残���る端数��教師生�時�途中��止������出��中途�端�データ����れる。)
+		// Read in units of sizeof(PackedSfenValue),
+		// Ignore the last remaining fraction. (Fails in fs.read, so exit while)
+		// (The remaining fraction seems to be half-finished data that was created because it was stopped halfway during teacher generation.)
 
 	}
 
 	if (buf_write_marker != 0)
 		write_buffer(buf_write_marker);
 
-	// シャッフル�れ�ファイル�write_file_count個��書�出�れ�。
-	// 2pass目�����れを����時�オープン��ランダム�1����択��1局���読�込��
-	// �れ��シャッフル�れ�����る。
+	// Only shuffled files have been written write_file_count.
+	// As a second pass, if you open all of them at the same time, select one at random and load one phase at a time
+	// Now you have shuffled.
 
-	// シャツフル�る元ファイル+tmpファイル+書�出�ファイル�元ファイル�3��ストレージ容��必���る。
-	// 100億局�400GB���シャッフル�る���1TB�SSD��足り��。
-	// tmp�書�出��終�����タイミング�元ファイルを消�(�る��手�削除�����)�ら�
-	// 元ファイル�2�程度�ストレージ容��済む。
-	// ��ら�元ファイルを消����オプションを用�����も知れ��。
+	// Original file for shirt full + tmp file + file to write requires 3 times the storage capacity of the original file.
+	// 1 billion SSD is not enough for shuffling because it is 400GB for 10 billion phases.
+	// If you want to delete (or delete by hand) the original file at this point after writing to tmp,
+	// The storage capacity is about twice that of the original file.
+	// So, maybe we should have an option to delete the original file.
 
-	// ファイル��時openを���る。�れ�FOPEN_MAX��を超�る�能性�高�。
-	// ��場��buffer_sizeを調整���ファイル�数を減ら�より��。
+	// Files are opened at the same time. It is highly possible that this will exceed FOPEN_MAX.
+	// In that case, rather than adjusting buffer_size to reduce the number of files.
 
 	vector<fstream> afs;
 	for (uint64_t i = 0; i < write_file_count; ++i)
 		afs.emplace_back(fstream(make_filename(i),ios::in | ios::binary));
 
-	// 下請�関数�丸投���終�り。
+	// Throw to the subcontract function and end.
 	shuffle_write(output_file_name, prng, afs, a_count);
 }
 
-// 教師局��シャッフル "learn shuffleq"コマンド�下請�。
-// ��ら�1pass�書�出�。
-// output_file_name : シャッフル�れ�教師局��書�出�れる出力ファイル�
+// Subcontracting the teacher shuffle "learn shuffleq" command.
+// This is written in 1 pass.
+// output_file_name: name of the output file where the shuffled teacher positions will be written
 void shuffle_files_quick(const vector<string>& filenames, const string& output_file_name)
 {
-	// 読�込ん�局�数
+	// number of phases read
 	uint64_t read_sfen_count = 0;
 
-	// シャッフル�る���乱数
+	// random number to shuffle
 	PRNG prng((std::random_device())());
 
-	// ファイル�数
+	// number of files
 	size_t file_count = filenames.size();
 
-	// filenames�ファイル�れ�れ�格��れ��る教師局��数
+	// Number of teacher positions stored in each file in filenames
 	vector<uint64_t> a_count(file_count);
 
-	// �れ�れ�ファイル�教師局��数をカウント�る。
+	// Count the number of teacher aspects in each file.
 	vector<fstream> afs(file_count);
 
-	for (size_t i = 0; i < file_count ; ++i)
+	for (size_t i = 0; i <file_count ;++i)
 	{
 		auto filename = filenames[i];
 		auto& fs = afs[i];
@@ -2383,28 +2384,28 @@ void shuffle_files_quick(const vector<string>& filenames, const string& output_f
 		fs.open(filename, ios::in | ios::binary);
 		fs.seekg(0, fstream::end);
 		uint64_t eofPos = (uint64_t)fs.tellg();
-		fs.clear(); // �れを����次�seek�失敗�る����る。
+		fs.clear(); // Otherwise, the next seek may fail.
 		fs.seekg(0, fstream::beg);
 		uint64_t begPos = (uint64_t)fs.tellg();
 		uint64_t file_size = eofPos - begPos;
 		uint64_t sfen_count = file_size / sizeof(PackedSfenValue);
 		a_count[i] = sfen_count;
 
-		// �ファイル�格��れ���sfen�数を出力�る。
+		// Output the number of sfen stored in each file.
 		cout << filename << " = " << sfen_count << " sfens." << endl;
 	}
 
-	// �れ�れ�ファイル�ファイルサイズ��������
-	// �れらを����時�オープン�(���オープン�れ��る)�
-	// ランダム�1����択��1局���読�込��
-	// �れ��シャッフル�れ�����る。
+	// Since we know the file size of each file,
+	// open them all at once (already open),
+	// Select one at a time and load one phase at a time
+	// Now you have shuffled.
 
-	// 下請�関数�丸投���終�り。
+	// Throw to the subcontract function and end.
 	shuffle_write(output_file_name, prng, afs, a_count);
 }
 
-// 教師局��シャッフル "learn shufflem"コマンド�下請�。
-// メモリ�丸読���指定ファイル��書�出�。
+// Subcontracting the teacher shuffle "learn shufflem" command.
+// Read the whole memory and write it out with the specified file name.
 void shuffle_files_on_memory(const vector<string>& filenames,const string output_file_name)
 {
 	PSVector buf;
@@ -2414,14 +2415,14 @@ void shuffle_files_on_memory(const vector<string>& filenames,const string output
 		std::cout << "read : " << filename << std::endl;
 		read_file_to_memory(filename, [&buf](uint64_t size) {
 			assert((size % sizeof(PackedSfenValue)) == 0);
-			// �ッファを拡充����回�末尾以��読�込む。
+			// Expand the buffer and read after the last end.
 			uint64_t last = buf.size();
 			buf.resize(last + size / sizeof(PackedSfenValue));
 			return (void*)&buf[last];
 		});
 	}
 
-	// buf[0]～buf[size-1]��をshuffle
+	// shuffle from buf[0] to buf[size-1]
 	PRNG prng((std::random_device())());
 	uint64_t size = (uint64_t)buf.size();
 	std::cout << "shuffle buf.size() = " << size << std::endl;
@@ -2430,7 +2431,7 @@ void shuffle_files_on_memory(const vector<string>& filenames,const string output
 
 	std::cout << "write : " << output_file_name << endl;
 
-	// 書�出�ファイル�2GBを超�る�fstream::write一発��書�出�����wrapperを用�る。
+	// If the file to be written exceeds 2GB, it cannot be written in one shot with fstream::write, so use wrapper.
 	write_memory_to_file(output_file_name, (void*)&buf[0], (uint64_t)sizeof(PackedSfenValue)*(uint64_t)buf.size());
 
 	std::cout << "..shuffle_on_memory done." << std::endl;
@@ -2443,7 +2444,7 @@ void convert_bin(const vector<string>& filenames, const string& output_file_name
 	uint64_t filtered_size = 0;
 	auto th = Threads.main();
 	auto &tpos = th->rootPos;
-	// plain形��雑巾をや��ら王用�packedsfenvalue�変��る
+	// convert plain rag to packed sfenvalue for Yaneura king
 	fs.open(output_file_name, ios::app | ios::binary);
 	StateListPtr states;
 	for (auto filename : filenames) {
@@ -2454,9 +2455,8 @@ void convert_bin(const vector<string>& filenames, const string& output_file_name
 		PackedSfenValue p;
 		data_size = 0;
 		filtered_size = 0;
-		p.gamePly = 1; // apery形�����れ��。一応�期化�る��
+		p.gamePly = 1; // Not included in apery format. Should be initialized
 		bool ignore_flag = false;
-
 		while (std::getline(ifs, line)) {
 			std::stringstream ss(line);
 			std::string token;
@@ -2480,7 +2480,7 @@ void convert_bin(const vector<string>& filenames, const string& output_file_name
 				if(temp < ply_minimum || temp > ply_maximum){
 				  ignore_flag = true;
 				}
-				p.gamePly = uint16_t(temp); // 此処�キャスト�ら��？
+				p.gamePly = uint16_t(temp); // No cast here?
 				if (interpolate_eval != 0){
 				  p.score = min(3000, interpolate_eval * temp);
 				}
@@ -2488,7 +2488,7 @@ void convert_bin(const vector<string>& filenames, const string& output_file_name
 			else if (token == "result") {
 				int temp;
 				ss >> temp;
-				p.game_result = int8_t(temp); // 此処�キャスト�ら��？
+				p.game_result = int8_t(temp); // Do you need a cast here?
 				if (interpolate_eval){
 				  p.score = p.score * p.game_result;
 				}
@@ -2702,7 +2702,6 @@ void convert_bin_from_pgn_extract(const vector<string>& filenames, const string&
 	std::cout << now_string() << " all done" << std::endl;
 	ofs.close();
 }
-
 //void convert_plain(const vector<string>& filenames , const string& output_file_name)
 //{
 //	Position tpos;
@@ -2711,14 +2710,14 @@ void convert_bin_from_pgn_extract(const vector<string>& filenames, const string&
 //	for (auto filename : filenames) {
 //		std::cout << "convert " << filename << " ... ";
 //
-//		// ���らpackedsfenvalueをテキスト�変��る
+// 		// Just convert packedsfenvalue to text
 //		std::fstream fs;
 //		fs.open(filename, ios::in | ios::binary);
 //		PackedSfenValue p;
 //		while (true)
 //		{
 //			if (fs.read((char*)&p, sizeof(PackedSfenValue))) {
-//				// plain text���書�込む
+// 				// write as plain text
 //				ofs << "sfen " << tpos.sfen_unpack(p.sfen) << std::endl;
 //				ofs << "move " << to_usi_string(Move(p.move)) << std::endl;
 //				ofs << "score " << p.score << std::endl;
@@ -2737,7 +2736,7 @@ void convert_bin_from_pgn_extract(const vector<string>& filenames, const string&
 //	std::cout << "all done" << std::endl;
 //}
 
-// 生���棋譜�ら�学習
+// Learning from the generated game record
 void learn(Position&, istringstream& is)
 {
 	auto thread_num = (int)Options["Threads"];
@@ -2746,62 +2745,62 @@ void learn(Position&, istringstream& is)
 	LearnerThink learn_think(sr);
 	vector<string> filenames;
 
-	// mini_batch_size デフォルト�1M局�。�れを大����る。
+	// mini_batch_size 1M aspect by default. This can be increased.
 	auto mini_batch_size = LEARN_MINI_BATCH_SIZE;
 
-	// ループ回数(��回数��棋譜ファイルを読�込む)
+	// Number of loops (read the game record file this number of times)
 	int loop = 1;
 
-	// 棋譜ファイル格�フォルダ(���ら相対path�棋譜ファイルを�得)
+	// Game file storage folder (get game file with relative path from here)
 	string base_dir;
 
 	string target_dir;
 
-	// 0��れ��デフォルト値��る。
+	// If 0, it will be the default value.
 	double eta1 = 0.0;
 	double eta2 = 0.0;
 	double eta3 = 0.0;
-	uint64_t eta1_epoch = 0; // default��eta2��用�れ��
-	uint64_t eta2_epoch = 0; // default��eta3��用�れ��
+	uint64_t eta1_epoch = 0; // eta2 is not applied by default
+	uint64_t eta2_epoch = 0; // eta3 is not applied by default
 
 #if defined(USE_GLOBAL_OPTIONS)
-	// ���復元�る����存����。
+	// Save it for later restore.
 	auto oldGlobalOptions = GlobalOptions;
-	// eval hash�hit�る�rmse���計算������る��オフ�����。
+	// If you hit the eval hash, you can not calculate rmse etc. so turn it off.
 	GlobalOptions.use_eval_hash = false;
-	// 置�表�hit�る����以��評価値��刈り��れる����る��オフ�����。
+	// If you hit the replacement table, pruning may occur at the previous evaluation value, so turn it off.
 	GlobalOptions.use_hash_probe = false;
 #endif
 
-	// --- 教師局�をシャッフル�る���機能
+	// --- Function that only shuffles the teacher aspect
 
-	// 通常シャッフル
+	// normal shuffle
 	bool shuffle_normal = false;
 	uint64_t buffer_size = 20000000;
-	// �れ�れ�ファイル�シャッフル�れ��る�仮定���高速シャッフル
+	// fast shuffling assuming each file is shuffled
 	bool shuffle_quick = false;
-	// メモリ�ファイルを丸読���シャッフル�る機能。(��ファイルサイズ�メモリ)
+	// A function to read the entire file in memory and shuffle it. (Requires file size memory)
 	bool shuffle_on_memory = false;
-	// packed sfen�変�。plain��sfen(string), 評価値(整数), 指�手(例：7g7f, string)��果(負�-1���1�引�分�0)�ら�る
+	// Conversion of packed sfen. In plain, it consists of sfen(string), evaluation value (integer), move (eg 7g7f, string), result (loss-1, win 1, draw 0)
 	bool use_convert_plain = false;
-	// plain形��教師をや��ら王�bin�変��る
+	// convert plain format teacher to Yaneura King's bin
 	bool use_convert_bin = false;
 	int ply_minimum = 0;
 	int ply_maximum = 114514;
 	bool interpolate_eval = 0;
-	// pgn-extract形��教師をや��ら王�bin�変��る
+	// convert teacher in pgn-extract format to Yaneura King's bin
 	bool use_convert_bin_from_pgn_extract = false;
-	// �れら����書�出�ファイル�(デフォルト��"shuffled_sfen.bin")
+	// File name to write in those cases (default is "shuffled_sfen.bin")
 	string output_file_name = "shuffled_sfen.bin";
 
-	// 教師局��深�探索��評価値�絶対値����値を超����ら��局����る。
+	// If the absolute value of the evaluation value in the deep search of the teacher phase exceeds this value, that phase is discarded.
 	int eval_limit = 32000;
 
-	// 評価関数ファイル��存�終了間際�1回��定�る��フラグ。
+	// Flag to save the evaluation function file only once near the end.
 	bool save_only_once = false;
 
-	// 教師局�を先読����る分�関��シャッフル�る。(1000万局����ら��シャッフル)
-	// 事��シャッフル�れ��るファイルを渡��らオン��れ�良�。
+	// Shuffle about what you are pre-reading on the teacher aspect. (Shuffle of about 10 million phases)
+	// Turn on if you want to pass a pre-shuffled file.
 	bool no_shuffle = false;
 
 #if defined (LOSS_FUNCTION_IS_ELMO_METHOD)
@@ -2811,15 +2810,15 @@ void learn(Position&, istringstream& is)
 	ELMO_LAMBDA_LIMIT = 32000;
 #endif
 
-	// 割引率。�れを0以外��る��PV終端以外�も勾�を加算�る。(�������割引率を�用�る)
+	// Discount rate. If this is set to a value other than 0, the slope will be added even at other than the PV termination. (At that time, apply this discount rate)
 	double discount_rate = 0;
 
-	// if (gamePly < rand(reduction_gameply)) continue;
-	// �よ������盤を学習対象�ら程よ�除外�る���オプション
-	// 1����る�rand(1)==0����何も除外�れ��。
+	// if (gamePly <rand(reduction_gameply)) continue;
+	// An option to exclude the early stage from the learning target moderately like
+	// If set to 1, rand(1)==0, so nothing is excluded.
 	int reduction_gameply = 1;
 
-	// KK/KKP/KPP/KPPPを学習����オプション項目
+	// Optional item that does not let you learn KK/KKP/KPP/KPPP
 	array<bool,4> freeze = {};
 
 #if defined(EVAL_NNUE)
@@ -2835,7 +2834,7 @@ void learn(Position&, istringstream& is)
 
 	string validation_set_file_name;
 
-	// ファイル��後���ら�ら�書�れ��る�仮定���る。
+	// Assume the filenames are staggered.
 	while (true)
 	{
 		string option;
@@ -2844,26 +2843,26 @@ void learn(Position&, istringstream& is)
 		if (option == "")
 			break;
 
-		// mini-batch�局�数を指定
+		// specify the number of phases of mini-batch
 		if (option == "bat")
 		{
 			is >> mini_batch_size;
-			mini_batch_size *= 10000; // ���万
+			mini_batch_size *= 10000; // Unit is ten thousand
 		}
 
-		// 棋譜�格��れ��るフォルダを指定���根���対象��る。
+		// Specify the folder in which the game record is stored and make it the rooting target.
 		else if (option == "targetdir") is >> target_dir;
 
-		// ループ回数�指定
+		// Specify the number of loops
 		else if (option == "loop")      is >> loop;
 
-		// 棋譜ファイル格�フォルダ(���ら相対path�棋譜ファイルを�得)
+		// Game file storage folder (get game file with relative path from here)
 		else if (option == "basedir")   is >> base_dir;
 
-		// ミニ�ッ��サイズ
+		// Mini batch size
 		else if (option == "batchsize") is >> mini_batch_size;
 
-		// 学習率
+		// learning rate
 		else if (option == "eta")        is >> eta1;
 		else if (option == "eta1")       is >> eta1; // alias
 		else if (option == "eta2")       is >> eta2;
@@ -2874,10 +2873,10 @@ void learn(Position&, istringstream& is)
 		else if (option == "use_draw_in_training") is >> use_draw_in_training;
 		else if (option == "use_draw_in_validation") is >> use_draw_in_validation;
 		else if (option == "use_hash_in_training") is >> use_hash_in_training;
-		// 割引率
+		// Discount rate
 		else if (option == "discount_rate") is >> discount_rate;
 
-		// KK/KKP/KPP/KPPP�学習��。
+		// No learning of KK/KKP/KPP/KPPP.
 		else if (option == "freeze_kk")    is >> freeze[0];
 		else if (option == "freeze_kkp")   is >> freeze[1];
 		else if (option == "freeze_kpp")   is >> freeze[2];
@@ -2899,7 +2898,7 @@ void learn(Position&, istringstream& is)
 #endif
 		else if (option == "reduction_gameply") is >> reduction_gameply;
 
-		// シャッフル関連
+		// shuffle related
 		else if (option == "shuffle")	shuffle_normal = true;
 		else if (option == "buffer_size") is >> buffer_size;
 		else if (option == "shuffleq")	shuffle_quick = true;
@@ -2909,7 +2908,7 @@ void learn(Position&, istringstream& is)
 		else if (option == "eval_limit") is >> eval_limit;
 		else if (option == "save_only_once") save_only_once = true;
 		else if (option == "no_shuffle") no_shuffle = true;
-		
+
 #if defined(EVAL_NNUE)
 		else if (option == "nn_batch_size") is >> nn_batch_size;
 		else if (option == "newbob_decay") is >> newbob_decay;
@@ -2920,13 +2919,13 @@ void learn(Position&, istringstream& is)
 		else if (option == "loss_output_interval") is >> loss_output_interval;
 		else if (option == "mirror_percentage") is >> mirror_percentage;
 		else if (option == "validation_set_file_name") is >> validation_set_file_name;
-		
-		// 雑巾�convert関連
+
+		// Rabbit convert related
 		else if (option == "convert_plain") use_convert_plain = true;
 		else if (option == "convert_bin") use_convert_bin = true;
 		else if (option == "interpolate_eval") is >> interpolate_eval;
-		else if (option == "convert_bin_from_pgn-extract") use_convert_bin_from_pgn_extract = true;
-		// �も�����れ�ファイル���る。
+		else if (option == "convert_bin_from_pgn-extract") use_convert_bin_from_pgn_extract = true;		
+		// Otherwise, it's a filename.
 		else
 			filenames.push_back(option);
 	}
@@ -2935,25 +2934,25 @@ void learn(Position&, istringstream& is)
 
 	cout << "learn command , ";
 
-	// OpenMP無効�ら警告を出�よ��。
+	// Issue a warning if OpenMP is disabled.
 #if !defined(_OPENMP)
 	cout << "Warning! OpenMP disabled." << endl;
 #endif
 
-	// 学習棋譜ファイル�表示
+	// Display learning game file
 	if (target_dir != "")
 	{
 		string kif_base_dir = Path::Combine(base_dir, target_dir);
 
-		// ��フォルダを根����る。base_dir相対�����。
+		// Remove this folder. Keep it relative to base_dir.
 #if defined(_MSC_VER)
-		// std::tr2を使用�る�waring C4996�出る��抑制。
-		// ※　std::tr2��std:c++14 �下��既定��推奨�警告を出��/std:c++17 ��既定�削除�れ�。
+		// If you use std::tr2, warning C4996 will appear, so suppress it.
+		// * std::tr2 issued a deprecation warning by default under std:c++14, and was deleted by default in /std:c++17.
 		#pragma warning(push)
 		#pragma warning(disable:4996)
 
 		namespace sys = std::filesystem;
-		sys::path p(kif_base_dir); // 列挙�起点
+		sys::path p(kif_base_dir); // Origin of enumeration
 		std::for_each(sys::directory_iterator(p), sys::directory_iterator(),
 			[&](const sys::path& p) {
 			if (sys::is_regular_file(p))
@@ -2969,17 +2968,17 @@ void learn(Position&, istringstream& is)
 			return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
 		};
 
-		// 仕方����dirent.hを用��読�込む。
-		DIR *dp;       // ディレクトリ���インタ
-		dirent* entry; // readdir() �返�れるエントリー�イント
+		// It can't be helped, so read it using dirent.h.
+		DIR *dp; // pointer to directory
+		dirent* entry; // entry point returned by readdir()
 
 		dp = opendir(kif_base_dir.c_str());
 		if (dp != NULL)
 		{
 			do {
 				entry = readdir(dp);
-				// ".bin"�終�るファイル��を列挙
-				// →　連番�ファイル生��る�����制約�ょ��嫌��…。
+				// Only list files ending with ".bin"
+				// →I hate this restriction when generating files with serial numbers...
 				if (entry != NULL  && ends_with(entry->d_name, ".bin")  )
 				{
 					//cout << entry->d_name << endl;
@@ -3003,7 +3002,7 @@ void learn(Position&, istringstream& is)
 	cout << "base dir        : " << base_dir   << endl;
 	cout << "target dir      : " << target_dir << endl;
 
-	// シャッフルモード
+	// shuffle mode
 	if (shuffle_normal)
 	{
 		cout << "buffer_size     : " << buffer_size << endl;
@@ -3025,11 +3024,11 @@ void learn(Position&, istringstream& is)
 	}
 	//if (use_convert_plain)
 	//{
-	//  	is_ready(true);
-	//	cout << "convert_plain.." << endl;
-	//	convert_plain(filenames,output_file_name);
-	//	return;
-	//	
+	// 		is_ready(true);
+	//  cout << "convert_plain.." << endl;
+	//  convert_plain(filenames,output_file_name);
+	//  return;
+	//
 	//}
 	if (use_convert_bin)
 	{
@@ -3052,9 +3051,9 @@ void learn(Position&, istringstream& is)
 	cout << "save_only_once    : " << (save_only_once ? "true" : "false") << endl;
 	cout << "no_shuffle        : " << (no_shuffle ? "true" : "false") << endl;
 
-	// ループ回数分��ファイル�を��込む。
+	// Insert the file name for the number of loops.
 	for (int i = 0; i < loop; ++i)
-		// sfen reader�逆順�読む�ら���reverse����。��ん�。
+		// sfen reader, I'll read it in reverse order so I'll reverse it here. I'm sorry.
 		for (auto it = filenames.rbegin(); it != filenames.rend(); ++it)
 			sr.filenames.push_back(Path::Combine(base_dir, *it));
 
@@ -3079,7 +3078,7 @@ void learn(Position&, istringstream& is)
 #endif
 	cout << "discount rate     : " << discount_rate     << endl;
 
-	// reduction_gameply�0を設定�れる�rand(0)�0除算���������1�補正。
+	// If reduction_gameply is set to 0, rand(0) will be divided by 0, so correct it to 1.
 	reduction_gameply = max(reduction_gameply, 1);
 	cout << "reduction_gameply : " << reduction_gameply << endl;
 
@@ -3101,18 +3100,18 @@ void learn(Position&, istringstream& is)
 #endif
 
 	// -----------------------------------
-	//            �種�期化
+	// various initialization
 	// -----------------------------------
 
 	cout << "init.." << endl;
 
-	// 評価関数パラメーター�読�込�
+	// Read evaluation function parameters
 	is_ready(true);
 
 #if !defined(EVAL_NNUE)
 	cout << "init_grad.." << endl;
 
-	// 評価関数パラメーター�勾��列��期化
+	// Initialize gradient array of merit function parameters
 	Eval::init_grad(eta1,eta1_epoch,eta2,eta2_epoch,eta3);
 #else
 	cout << "init_training.." << endl;
@@ -3125,7 +3124,7 @@ void learn(Position&, istringstream& is)
 #endif
 
 #if 0
-	// 平手��期局��対��1.0�勾�を与���るテスト。
+	// A test to give a gradient of 1.0 to the initial stage of Hirate.
 	pos.set_hirate();
 	cout << Eval::evaluate(pos) << endl;
 	//Eval::print_eval_stat(pos);
@@ -3138,7 +3137,7 @@ void learn(Position&, istringstream& is)
 
 	cout << "init done." << endl;
 
-	// ��他�オプション設定を�映��る。
+	// Reflect other option settings.
 	learn_think.discount_rate = discount_rate;
 	learn_think.eval_limit = eval_limit;
 	learn_think.save_only_once = save_only_once;
@@ -3154,20 +3153,20 @@ void learn(Position&, istringstream& is)
 	learn_think.loss_output_interval = loss_output_interval;
 	learn_think.mirror_percentage = mirror_percentage;
 
-	// 局�ファイルを�ックグラウンド�読�込むスレッドを起動
-	// (�れを開始����mse�計算�出���。)
+	// Start a thread that loads the phase file in the background
+	// (If this is not started, mse cannot be calculated.)
 	learn_think.start_file_read_worker();
 
 	learn_think.mini_batch_size = mini_batch_size;
 
 	if (validation_set_file_name.empty()) {
-		// mse計算用�データ1万件���得����。
+	// Get about 10,000 data for mse calculation.
 		sr.read_for_mse();
 	} else {
 		sr.read_validation_set(validation_set_file_name, eval_limit);
 	}
 
-	// ��時点�一度rmseを計算(0 sfen�タイミング)
+	// Calculate rmse once at this point (timing of 0 sfen)
 	// sr.calc_rmse();
 #if defined(EVAL_NNUE)
 	if (newbob_decay != 1.0) {
@@ -3180,17 +3179,17 @@ void learn(Position&, istringstream& is)
 #endif
 
 	// -----------------------------------
-	//   評価関数パラメーター�学習�開始
+	// start learning evaluation function parameters
 	// -----------------------------------
 
-	// 学習開始。
+	// Start learning.
 	learn_think.go_think();
 
-	// 最後�一度�存。
+	// Save once at the end.
 	learn_think.save(true);
 
 #if defined(USE_GLOBAL_OPTIONS)
-	// GlobalOptions�復元。
+	// Restore Global Options.
 	GlobalOptions = oldGlobalOptions;
 #endif
 }
@@ -3203,4 +3202,4 @@ void learn(Position&, istringstream& is)
 #endif
 
 
-#endif // EVAL_LEARN
+#endif // EVAL_LEARN
\ No newline at end of file
diff --git a/src/learn/learning_tools.cpp b/src/learn/learning_tools.cpp
index d3a7858f..e3bd6f68 100644
--- a/src/learn/learning_tools.cpp
+++ b/src/learn/learning_tools.cpp
@@ -23,15 +23,15 @@ namespace EvalLearningTools
 
 	std::vector<bool> min_index_flag;
 
-	// --- 個別�テーブル����期化
+	// --- initialization for each individual table
 
 	void init_min_index_flag()
 	{
-		// mir_piece�inv_piece��期化�終������れ��ら��。
+		// Initialization of mir_piece and inv_piece must be completed.
 		assert(mir_piece(Eval::f_pawn) == Eval::e_pawn);
 
-		// 次元下�用フラグ�列��期化
-		// KPPP�関���関与���。
+		// Initialize the flag array for dimension reduction
+		// Not involved in KPPP.
 
 		KK g_kk;
 		g_kk.set(SQUARE_NB, Eval::fe_end, 0);
@@ -46,9 +46,9 @@ namespace EvalLearningTools
 #pragma omp parallel
 		{
 #if defined(_OPENMP)
-			// Windows環境下�CPU�２��る����論�64コア����使用�れ���を防����
-			// ���明示的�CPU�割り当�る
-			int thread_index = omp_get_thread_num();    // 自分�thread numberを�得
+			// To prevent the logical 64 cores from being used when there are two CPUs under Windows
+			// explicitly assign to CPU here
+			int thread_index = omp_get_thread_num(); // get your thread number
 			WinProcGroup::bindThisThread(thread_index);
 #endif
 
@@ -56,20 +56,20 @@ namespace EvalLearningTools
 
 			for (int64_t index_ = 0; index_ < (int64_t)size; ++index_)
 			{
-				// OpenMP�制約�らループ変数�符�型��������ら������
-				// ����使����。
+				// It seems that the loop variable must be a sign type due to OpenMP restrictions, but
+				// It's really difficult to use.
 				uint64_t index = (uint64_t)index_;
 
 				if (g_kk.is_ok(index))
 				{
-					// index�ら�変��逆変��よ��元�index�戻る��を確�����。
-					// 起動時�1回��実行���処����assert�書����。
+					// Make sure that the original index will be restored by conversion from index and reverse conversion.
+					// It is a process that is executed only once at startup, so write it in assert.
 					assert(g_kk.fromIndex(index).toIndex() == index);
 
 					KK a[KK_LOWER_COUNT];
 					g_kk.fromIndex(index).toLowerDimensions(a);
 
-					// 次元下��1�目��素�元�index��一��る��を確�����。
+					// Make sure that the first element of dimension reduction is the same as the original index.
 					assert(a[0].toIndex() == index);
 
 					uint64_t min_index = UINT64_MAX;
@@ -118,9 +118,9 @@ namespace EvalLearningTools
 	void learning_tools_unit_test_kpp()
 	{
 
-		// KPP�三角�列化��グ����テスト�る
-		// k-p0-p1�����組�������ん�KPP�扱�対象�������������次元下��
-		// 正���を判定�る。
+		// test KPP triangulation for bugs
+		// All combinations of k-p0-p1 are properly handled by KPP, and the dimension reduction at that time is
+		// Determine if it is correct.
 
 		KK g_kk;
 		g_kk.set(SQUARE_NB, Eval::fe_end, 0);
@@ -159,24 +159,24 @@ namespace EvalLearningTools
 					f[index - g_kpp.min_index()] = f[index2-g_kpp.min_index()] = true;
 				}
 
-		// 抜��るindex�������確�。
+		// Check if there is no missing index.
 		for(size_t index = 0 ; index < f.size(); index++)
 			if (!f[index])
 			{
-				std::cout << index << g_kpp.fromIndex(index + g_kpp.min_index()) <<  std::endl;
+				std::cout << index << g_kpp.fromIndex(index + g_kpp.min_index()) << std::endl;
 			}
 	}
 
 	void learning_tools_unit_test_kppp()
 	{
-		// KPPP�計算�抜�����をテスト�る
+		// Test for missing KPPP calculations
 
 		KPPP g_kppp;
 		g_kppp.set(15, Eval::fe_end,0);
 		uint64_t min_index = g_kppp.min_index();
 		uint64_t max_index = g_kppp.max_index();
 
-		// 最後��素�確�。
+		// Confirm last element.
 		//KPPP x = KPPP::fromIndex(max_index-1);
 		//std::cout << x << std::endl;
 
@@ -208,10 +208,10 @@ namespace EvalLearningTools
 	void learning_tools_unit_test_kkpp()
 	{
 		KKPP g_kkpp;
-		g_kkpp.set(SQUARE_NB, 10000 , 0);
+		g_kkpp.set(SQUARE_NB, 10000, 0);
 		uint64_t n = 0;
 		for (int k = 0; k<SQUARE_NB; ++k)
-			for (int i = 0; i<10000; ++i) // 試�����り大��fe_endを想定��10000�回���る。
+			for (int i = 0; i<10000; ++i) // As a test, assuming a large fe_end, try turning at 10000.
 				for (int j = 0; j < i; ++j)
 				{
 					auto kkpp = g_kkpp.fromKKPP(k, (BonaPiece)i, (BonaPiece)j);
@@ -222,27 +222,27 @@ namespace EvalLearningTools
 				}
 	}
 
-	// ��EvalLearningTools全体��期化
+	// Initialize this entire EvalLearningTools
 	void init()
 	{
-		// �期化��起動後1回�り�良��������フラグ。
+		// Initialization is required only once after startup, so a flag for that.
 		static bool first = true;
 
 		if (first)
 		{
 			std::cout << "EvalLearningTools init..";
 
-			// mir_piece()�inv_piece()を利用�能��る。
-			// ����min_index_flag��期化を行�������
-			// �れ��存���る�����らを先�行��必���る。
+			// Make mir_piece() and inv_piece() available.
+			// After this, the min_index_flag is initialized, but
+			// It depends on this, so you need to do this first.
 			init_mir_inv_tables();
 
 			//learning_tools_unit_test_kpp();
 			//learning_tools_unit_test_kppp();
 			//learning_tools_unit_test_kkpp();
 
-			// UnitTestを実行�る�最後�も良�����init_min_index_flag()���も時間���る��
-			// デ�ッグ時���タイミング�行���。
+			// It may be the last time to execute UnitTest, but since init_min_index_flag() takes a long time,
+			// I want to do this at the time of debugging.
 
 			init_min_index_flag();
 
@@ -253,4 +253,4 @@ namespace EvalLearningTools
 	}
 }
 
-#endif
+#endif
\ No newline at end of file
diff --git a/src/learn/learning_tools.h b/src/learn/learning_tools.h
index 2bcd3f35..f95ea2d9 100644
--- a/src/learn/learning_tools.h
+++ b/src/learn/learning_tools.h
@@ -1,7 +1,7 @@
 #ifndef __LEARN_WEIGHT_H__
 #define __LEARN_WEIGHT_H__
 
-// 評価関数�機械学習����用�る���列���関�る機械学習用ツール類一�
+// A set of machine learning tools related to the weight array used for machine learning of evaluation functions
 
 #include "learn.h"
 #if defined (EVAL_LEARN)
@@ -18,28 +18,28 @@
 namespace EvalLearningTools
 {
 	// -------------------------------------------------
-	//                     �期化
+	//                  Initialization
 	// -------------------------------------------------
 
-	// ��EvalLearningTools��空間��るテーブル類を�期化�る。
-	// 学習�開始���必�一度呼�出���。
-	// ��関数�����init_mir_inv_tables()も呼�出���る。
-	// (��関数を呼�����init_mir_inv_tables()を呼�出�必����。)
+	// Initialize the tables in this EvalLearningTools namespace.
+	// Be sure to call once before learning starts.
+	// In this function, we also call init_mir_inv_tables().
+	// (It is not necessary to call init_mir_inv_tables() when calling this function.)
 	void init();
 
 	// -------------------------------------------------
 	//                     flags
 	// -------------------------------------------------
 
-	// 次元下������������一番���index��る���
-	// �����るindex�対��true�����るフラグ�列。
-	// ���列もinit()�よ���期化�れる。
-	// KPPP�関����関与���。
-	// ゆ������列�有効�index�範囲��KK::min_index()～KPP::max_index()��。
+	// When the dimension is lowered, it may become the smallest index among them
+	// A flag array that is true for the known index.
+	// This array is also initialized by init().
+	// KPPP is not involved.
+	// Therefore, the valid index range of this array is from KK::min_index() to KPP::max_index().
 	extern std::vector<bool> min_index_flag;
 
 	// -------------------------------------------------
-	//       勾�等を格����る学習用��列
+	//   Array for learning that stores gradients etc.
 	// -------------------------------------------------
 
 #if defined(_MSC_VER)
@@ -49,21 +49,21 @@ namespace EvalLearningTools
 #endif
 	struct Weight
 	{
-		// mini-batch 1回分�勾��累�値
+		// cumulative value of one mini-batch gradient
 		LearnFloatType g = LearnFloatType(0);
 
-		// ADA_GRAD_UPDATE���。LearnFloatType == float����
-		// �計 4*2 + 4*2 + 1*2 = 18 bytes
-		// 1GB�評価関数パラメーター�対����4.5��サイズ�Weight�列�確���れ�良�。
-		// ����構造体�アライメント�4�イト�������る�sizeof(Weight)==20�コード�生��れる��
-		// pragma pack(2)を指定����。
+		// When ADA_GRAD_UPDATE. LearnFloatType == float,
+		// total 4*2 + 4*2 + 1*2 = 18 bytes
+		// It suffices to secure a Weight array that is 4.5 times the size of the evaluation function parameter of 1GB.
+		// However, sizeof(Weight)==20 code is generated if the structure alignment is in 4-byte units, so
+		// Specify pragma pack(2).
 
-		// SGD_UPDATE �場����構造体��ら�10�イト減���8�イト�済む。
+		// For SGD_UPDATE, this structure is reduced by 10 bytes to 8 bytes.
 
-		// AdaGrad���学習率η(eta)。
-		// updateFV()�呼�出�れる���eta1,2,3,eta1_epoch,eta2_epoch�設定�れ��るも���る。
-		// update_weights()�epoch��eta1_epoch��eta1�ら�々�eta2�変化�る。
-		// eta2_epoch以���eta2�ら�々�eta3�変化�る。
+		// Learning rate η(eta) such as AdaGrad.
+		// It is assumed that eta1,2,3,eta1_epoch,eta2_epoch have been set by the time updateFV() is called.
+		// The epoch of update_weights() gradually changes from eta1 to eta2 until eta1_epoch.
+		// After eta2_epoch, gradually change from eta2 to eta3.
 		static double eta;
 		static double eta1;
 		static double eta2;
@@ -71,7 +71,7 @@ namespace EvalLearningTools
 		static uint64_t eta1_epoch;
 		static uint64_t eta2_epoch;
 
-		// eta�一括�期化。0�渡�れ�場��デフォルト値�設定�れる。
+		// Batch initialization of eta. If 0 is passed, the default value will be set.
 		static void init_eta(double eta1, double eta2, double eta3, uint64_t eta1_epoch, uint64_t eta2_epoch)
 		{
 			Weight::eta1 = (eta1 != 0) ? eta1 : 30.0;
@@ -81,15 +81,15 @@ namespace EvalLearningTools
 			Weight::eta2_epoch = (eta2_epoch != 0) ? eta2_epoch : 0;
 		}
 
-		// epoch�応��etaを設定��やる。
+		// Set eta according to epoch.
 		static void calc_eta(uint64_t epoch)
 		{
-			if (Weight::eta1_epoch == 0) // eta2�用除外
+			if (Weight::eta1_epoch == 0) // Exclude eta2
 				Weight::eta = Weight::eta1;
 			else if (epoch < Weight::eta1_epoch)
-				// 按分�る
+				// apportion
 				Weight::eta = Weight::eta1 + (Weight::eta2 - Weight::eta1) * epoch / Weight::eta1_epoch;
-			else if (Weight::eta2_epoch == 0) // eta3�用除外
+			else if (Weight::eta2_epoch == 0) // Exclude eta3
 				Weight::eta = Weight::eta2;
 			else if (epoch < Weight::eta2_epoch)
 				Weight::eta = Weight::eta2 + (Weight::eta3 - Weight::eta2) * (epoch - Weight::eta1_epoch) / (Weight::eta2_epoch - Weight::eta1_epoch);
@@ -101,26 +101,26 @@ namespace EvalLearningTools
 
 #if defined (ADA_GRAD_UPDATE)
 
-		// float�正確�計算��る最大値�INT16_MAX*256-1����れより
-		// ���値をマーカー�����。
+		// Since the maximum value that can be accurately calculated with float is INT16_MAX*256-1
+		// Keep the small value as a marker.
 		const LearnFloatType V0_NOT_INIT = (INT16_MAX * 128);
 
-		// vを内部的������るも�。以��実装��メモリ�節約����固定�数��数部��を�������
-		// 精度的�怪����見通��悪��る��廃止��。
+		// What holds v internally. The previous implementation kept a fixed decimal with only a fractional part to save memory,
+		// Since it is doubtful in accuracy and the visibility is bad, it was abolished.
 		LearnFloatType v0 = LearnFloatType(V0_NOT_INIT);
 
-		// AdaGrad�g2
+		// AdaGrad g2
 		LearnFloatType g2 = LearnFloatType(0);
 
-		// AdaGrad�update�る
-		// ��関数を実行���る���g�値やメン�ー�書�変�ら�����
-		// 呼�出����証�れ��る。atomic演算��る必����。
-		// k�eta�掛�る係数。普通�1.0�良�。手番項�対��etaを下��������を1/8.0����る。
+		// update with AdaGrad
+		// When executing this function, the value of g and the member do not change
+		// Guaranteed by the caller. It does not have to be an atomic operation.
+		// k is a coefficient for eta. 1.0 is usually sufficient. If you want to lower eta for your turn item, set this to 1/8.0 etc.
 		template <typename T>
 		void updateFV(T& v,double k)
 		{
-			// AdaGrad�更新�
-			//   勾�ベクトルをg�更新���ベクトルをv�η(eta)�定数����
+			// AdaGrad update formula
+			// Gradient vector is g, vector to be updated is v, η(eta) is a constant,
 			//     g2 = g2 + g^2
 			//     v = v - ηg/sqrt(g2)
 
@@ -131,48 +131,48 @@ namespace EvalLearningTools
 
 			g2 += g * g;
 
-			// v0�V0_NOT_INIT��る�ら�値�KK/KKP/KPP�列�値��期化�れ�����������ら�
-			// ��場��v�値を引数�渡�れ�も��ら読�込む。
+			// If v0 is V0_NOT_INIT, it means that the value is not initialized with the value of KK/KKP/KPP array,
+			// In this case, read the value of v from the one passed in the argument.
 			double V = (v0 == V0_NOT_INIT) ? v : v0;
 
 			V -= k * eta * (double)g / sqrt((double)g2 + epsilon);
 
-			// V�値を型�範囲���るよ��制��る。
-			// �����windows.h�min,maxマクロを定義��������れを回��る����
-			// ����括弧�括る���関数形�マクロ���扱�れ��よ�����る。
+			// Limit the value of V to be within the range of types.
+			// By the way, windows.h defines the min and max macros, so to avoid it,
+			// Here, it is enclosed in parentheses so that it is not treated as a function-like macro.
 			V = (std::min)((double)(std::numeric_limits<T>::max)() , V);
 			V = (std::max)((double)(std::numeric_limits<T>::min)() , V);
 
 			v0 = (LearnFloatType)V;
 			v = (T)round(V);
 
-			// ���素�関�るmini-batch�1回分�更新�終�����gをクリア
+			// Clear g because one update of mini-batch for this element is over
 			// g[i] = 0;
-			// →次元下���題��る����れ�呼�出���行������る。
+			// → There is a problem of dimension reduction, so this will be done by the caller.
 		}
 
 #elif defined(SGD_UPDATE)
 
-		// 勾��符���見るSGD�update�る
-		// ��関数を実行���る���g�値やメン�ー�書�変�ら�����
-		// 呼�出����証�れ��る。atomic演算��る必����。
+		// See only the sign of the gradient Update with SGD
+		// When executing this function, the value of g and the member do not change
+		// Guaranteed by the caller. It does not have to be an atomic operation.
 		template <typename T>
 		void updateFV(T & v , double k)
 		{
 			if (g == 0)
 				return;
 
-			// g�符���見�update�る。
-			// g < 0 �ら vを少�足�。
-			// g > 0 �ら vを少�引�。
+			// See only the sign of g and update.
+			// If g <0, add v a little.
+			// If g> 0, subtract v slightly.
 
-			// 整数��足������数部��。
+			// Since we only add integers, no decimal part is required.
 
-			// 0～5�ら���動����よ��。
-			// ガウス分布������良���5bit�乱数を発生���(�れ�れ�bit�1/2�確率�1��る)�
-			// �れをpop_count()�る。�����二項分布�����る。
+			// It's a good idea to move around 0-5.
+			// It is better to have a Gaussian distribution, so generate a 5-bit random number (each bit has a 1/2 probability of 1),
+			// Pop_count() it. At this time, it has a binomial distribution.
 			//int16_t diff = (int16_t)POPCNT32((u32)prng.rand(31));
-			// →　�れ80スレッド�や��ら���AsyncPRNG::rand()�lock�る��slow down��。��実装良���。
+			// → If I do this with 80 threads, this AsyncPRNG::rand() locks, so I slowed down. This implementation is not good.
 			int16_t diff = 1;
 
 			double V = v;
@@ -189,10 +189,10 @@ namespace EvalLearningTools
 
 #endif
 
-		// grad�設定
+		// grad setting
 		template <typename T> void set_grad(const T& g_) { g = g_; }
 
-		// grad�加算
+		// Add grad
 		template <typename T> void add_grad(const T& g_) { g += g_; }
 
 		LearnFloatType get_grad() const { return g; }
@@ -203,13 +203,13 @@ namespace EvalLearningTools
 #pragma pack(0)
 #endif
 
-	// 手番���weight�列
-	// ��的�扱�るよ���る����Weight���メン�を�������やる。
+	// Turned weight array
+	// In order to be able to handle it transparently, let's have the same member as Weight.
 	struct Weight2
 	{
 		Weight w[2];
 
-		// 手番評価�etaを1/8�評価����。
+		//Evaluate your turn, eta 1/8.
 		template <typename T> void updateFV(std::array<T, 2>& v) { w[0].updateFV(v[0] , 1.0); w[1].updateFV(v[1],1.0/8.0); }
 
 		template <typename T> void set_grad(const std::array<T, 2>& g) { for (int i = 0; i<2; ++i) w[i].set_grad(g[i]); }
@@ -218,42 +218,42 @@ namespace EvalLearningTools
 		std::array<LearnFloatType, 2> get_grad() const { return std::array<LearnFloatType, 2>{w[0].get_grad(), w[1].get_grad()}; }
 	};
 
-	// -------------------------------------------------
-	// Weight�列を直列化�����indexを計算��り�るヘルパー。
-	// -------------------------------------------------
+	// ------------------------------------------------ -
+	// A helper that calculates the index when the Weight array is serialized.
+	// ------------------------------------------------ -
 
-	// KK,KKP,KPP,KKPP�基底クラス
-	// �れら�クラス�使�方
-	// 
-	// 1. ��set()��期化�る。例) KK g_kk; g_kk.set(SQUARE_NB,fe_end,0);
-	// 2. 次�fromIndex(),fromKK()���インスタンスを生�
-	// 3. king(),piece0(),piece1()���プロパティを用��アクセス。
-	// 
-	// ��説明������り����も知れ����学習部�init_grad(),add_grad(),update_weights()��を見れ�
-	// 必�性を����解��る���。
+	// Base class for KK,KKP,KPP,KKPP
+	// How to use these classes
 	//
-	// 注� : ��派生クラス��次元下�����上記�inv_piece/mir_pieceを間接的��照�る����る���
-	// 最��EvalLearningTools::init()�init_mir_inv_tables()を呼�出���期化�る��。
+	// 1. Initialize with set() first. Example) KK g_kk; g_kk.set(SQUARE_NB,fe_end,0);
+	// 2. Next create an instance with fromIndex(), fromKK(), etc.
+	// 3. Access using properties such as king(), piece0(), piece1().
 	//
-	// 備考) 派生クラス��override�������関数���/*final*/�書���る。
-	//       派生クラス��override���関数� "= 0"を����純粋仮想関数����る。
-	//       派生クラス��override��も����も良�関数�virtual������る。
+	// It may be difficult to understand just by this explanation, but if you look at init_grad(), add_grad(), update_weights() etc. in the learning part
+	// I think you can understand it including the necessity.
+	//
+	// Note: this derived class may indirectly reference the above inv_piece/mir_piece for dimension reduction, so
+	// Initialize by calling EvalLearningTools::init() or init_mir_inv_tables() first.
+	//
+	// Remarks) /*final*/ is written for the function name that should not be overridden on the derived class side.
+	// The function that should be overridden on the derived class side is a pure virtual function with "= 0".
+	// Only virtual functions are added to the derived class that may or may not be overridden.
 	//
 	struct SerializerBase
 	{
 
-		// KK,KKP,KPP�列を直列化�る���通�番��最�値�最大値+1。
+		// Minimum value and maximum value of serial number +1 when serializing KK, KKP, KPP arrays.
 		/*final*/ uint64_t min_index() const { return min_index_; }
 		/*final*/ uint64_t max_index() const { return min_index() + max_raw_index_; }
 
-		// max_index() - min_index()�値。
-		// 派生クラス��max_king_sq_,fe_end_���ら�値を計算��返�よ���る。
+		// max_index() - min_index() the value of.
+		// Calculate the value from max_king_sq_,fe_end_ etc. on the derived class side and return it.
 		virtual uint64_t size() const = 0;
 
-		// 与�られ�index��min_index()以上�max_index()未満��る�を判定�る。
+		// Determine if the given index is more than min_index() and less than max_index().
 		/*final*/ bool is_ok(uint64_t index) { return min_index() <= index && index < max_index(); }
 
-		// 必���set()を呼�出��使�。�も����派生クラス��fromKK()/fromIndex()���インスタンスを構築��使�。
+		// Make sure to call this set(). Otherwise, construct an instance using fromKK()/fromIndex() etc. on the derived class side.
 		virtual void set(int max_king_sq, uint64_t fe_end, uint64_t min_index)
 		{
 			max_king_sq_ = max_king_sq;
@@ -262,26 +262,26 @@ namespace EvalLearningTools
 			max_raw_index_ = size();
 		}
 
-		// �在�メン��値�基���直列化�れ����indexを�得�る。
+		// Get the index when serialized, based on the value of the current member.
 		/*final*/ uint64_t toIndex() const {
 			return min_index() + toRawIndex();
 		}
 
-		// 直列化�る���indexを返�。(min_index()�値�加算�る��も�)
+		// Returns the index when serializing. (The value of min_index() is before addition)
 		virtual uint64_t toRawIndex() const = 0;
 
 	protected:
-		// ��クラス�返�min_index()�値
+		// The value of min_index() returned by this class
 		uint64_t min_index_;
 
-		// ��クラス�返�max_index()�値 = min_index() + max_raw_index_
-		// ��変数�派生クラス�size()�計算�れ�も�。
+		// The value of max_index() returned by this class = min_index() + max_raw_index_
+		// This variable is calculated by size() of the derived class.
 		uint64_t max_raw_index_;
 
-		// サ�ート�る玉���数(通常SQUARE_NB)
+		// The number of balls to support (normally SQUARE_NB)
 		int max_king_sq_;
 
-		// サ�ート�るBonaPiece�最大値
+		// Maximum BonaPiece value supported
 		uint64_t fe_end_;
 
 	};
@@ -295,10 +295,10 @@ namespace EvalLearningTools
 
 		virtual uint64_t size() const { return max_king_sq_ * max_king_sq_; }
 
-		// index(通�番�)�らKK�オブジェクトを生��るbuilder
+		// builder that creates KK object from index (serial number)
 		KK fromIndex(uint64_t index) const { assert(index >= min_index()); return fromRawIndex(index - min_index()); }
 
-		// raw_index(通�番�����0�ら始�る番�)�らKK�オブジェクトを生��るbuilder
+		// builder that creates KK object from raw_index (number starting from 0, not serial number)
 		KK fromRawIndex(uint64_t raw_index) const
 		{
 			int king1 = (int)(raw_index % SQUARE_NB);
@@ -309,18 +309,18 @@ namespace EvalLearningTools
 		}
 		KK fromKK(Square king0, Square king1 , bool inverse) const
 		{
-			// kk���変数��Eval::kk�列���使���る��別�����る必���る。(以下�KKP,KPPクラス���も�様)
+			// The variable name kk is used in the Eval::kk array etc., so it needs to be different. (The same applies to KKP, KPP classes, etc.)
 			KK my_kk(king0, king1, inverse);
 			my_kk.set(max_king_sq_, fe_end_, min_index());
 			return my_kk;
 		}
 		KK fromKK(Square king0, Square king1) const { return fromKK(king0, king1, false); }
 
-		// fromIndex()を用����オブジェクトを構築������以下�アクセッサ�情報�得られる。
+		// When you construct this object using fromIndex(), you can get information with the following accessors.
 		Square king0() const { return king0_; }
 		Square king1() const { return king1_; }
 
-// 次元下��数
+// number of dimension reductions
 #if defined(USE_KK_INVERSE_WRITE)
 	#define KK_LOWER_COUNT 4
 #elif defined(USE_KK_MIRROR_WRITE)
@@ -330,14 +330,14 @@ namespace EvalLearningTools
 #endif
 
 #if defined(USE_KK_INVERSE_WRITE) && !defined(USE_KK_MIRROR_WRITE) 
-		// USE_KK_INVERSE_WRITE�使��らUSE_KK_MIRROR_WRITEも定義��欲��。
+		// USE_KK_INVERSE_WRITE If you use it, please also define USE_KK_MIRROR_WRITE.
 		static_assert(false, "define also USE_KK_MIRROR_WRITE!");
 #endif
 
-		// 低次元��列�indexを得る。
-		// USE_KK_INVERSE_WRITE�有効������れらをinverse��も��[2],[3]�入る。
-		// ��次元下��関���grad�符���転�����������注��る��。
-		// is_inverse()�判定��る���れを利用�る�良�。
+		// Get the index of the low-dimensional array.
+		// When USE_KK_INVERSE_WRITE is enabled, the inverse of them will be in [2] and [3].
+		// Note that the sign of grad must be reversed for this dimension reduction.
+		// You can use is_inverse() because it can be determined.
 		void toLowerDimensions(/*out*/KK kk_[KK_LOWER_COUNT]) const {
 			kk_[0] = fromKK(king0_, king1_,false);
 #if defined(USE_KK_MIRROR_WRITE)
@@ -349,24 +349,24 @@ namespace EvalLearningTools
 #endif
 		}
 
-		// ��クラス�min_index()�値を0���数�����indexを�得�る。
+		// Get the index when counting the value of min_index() of this class as 0.
 		virtual uint64_t toRawIndex() const {
 			return (uint64_t)king0_ * (uint64_t)max_king_sq_ + (uint64_t)king1_;
 		}
 
-		// toLowerDimensions�次元下���も��inverse��も���る�を返�。
+		// Returns whether or not the dimension lowered with toLowerDimensions is inverse.
 		bool is_inverse() const {
 			return inverse_sign;
 		}
 
-		// is_inverse() == true�����grad�手番�������符�を�転���返�。
+		// When is_inverse() == true, reverse the sign that is not grad's turn and return it.
 		template <typename T>
 		std::array<T, 2> apply_inverse_sign(const std::array<T, 2>& rhs)
 		{
 			return !is_inverse() ? rhs : std::array<T, 2>{-rhs[0], rhs[1]};
 		}
 
-		// 比較演算�
+		// comparison operator
 		bool operator==(const KK& rhs) { return king0() == rhs.king0() && king1() == rhs.king1(); }
 		bool operator!=(const KK& rhs) { return !(*this == rhs); }
 
@@ -375,14 +375,14 @@ namespace EvalLearningTools
 		bool inverse_sign;
 	};
 
-	// デ�ッグ用出力。
+	// Output for debugging.
 	static std::ostream& operator<<(std::ostream& os, KK rhs)
 	{
 		os << "KK(" << rhs.king0() << "," << rhs.king1() << ")";
 		return os;
 	}
 
-	// KK����。KKP用。
+		// Same as KK. For KKP.
 	struct KKP : public SerializerBase
 	{
 	protected:
@@ -393,10 +393,10 @@ namespace EvalLearningTools
 
 		virtual uint64_t size() const { return (uint64_t)max_king_sq_*(uint64_t)max_king_sq_*(uint64_t)fe_end_; }
 
-		// index(通�番�)�らKKP�オブジェクトを生��るbuilder
+		// builder that creates KKP object from index (serial number)
 		KKP fromIndex(uint64_t index) const { assert(index >= min_index()); return fromRawIndex(index - min_index()); }
 
-		// raw_index(通�番�����0�ら始�る番�)�らKKP�オブジェクトを生��るbuilder
+		// A builder that creates a KKP object from raw_index (a number that starts from 0, not a serial number)
 		KKP fromRawIndex(uint64_t raw_index) const
 		{
 			int piece = (int)(raw_index % Eval::fe_end);
@@ -416,12 +416,12 @@ namespace EvalLearningTools
 		}
 		KKP fromKKP(Square king0, Square king1, Eval::BonaPiece p) const { return fromKKP(king0, king1, p, false); }
 
-		// fromIndex()を用����オブジェクトを構築������以下�アクセッサ�情報�得られる。
+		// When you construct this object using fromIndex(), you can get information with the following accessors.
 		Square king0() const { return king0_; }
 		Square king1() const { return king1_; }
 		Eval::BonaPiece piece() const { return piece_; }
 
-		// KKP�次元下��数
+		// Number of KKP dimension reductions
 #if defined(USE_KKP_INVERSE_WRITE)
 		#define KKP_LOWER_COUNT 4
 #elif defined(USE_KKP_MIRROR_WRITE)
@@ -431,14 +431,14 @@ namespace EvalLearningTools
 #endif
 
 #if defined(USE_KKP_INVERSE_WRITE) && !defined(USE_KKP_MIRROR_WRITE) 
-		// USE_KKP_INVERSE_WRITE�使��らUSE_KKP_MIRROR_WRITEも定義��欲��。
+		// USE_KKP_INVERSE_WRITE If you use it, please also define USE_KKP_MIRROR_WRITE.
 		static_assert(false, "define also USE_KKP_MIRROR_WRITE!");
 #endif
 
-		// 低次元��列�indexを得る。ミラー��も��kkp_[1]�返る。
-		// USE_KKP_INVERSE_WRITE�有効������れらをinverse��も��[2],[3]�入る。
-		// ��次元下��関���grad�符���転�����������注��る��。
-		// is_inverse()�判定��る���れを利用�る�良�。
+		// Get the index of the low-dimensional array. The mirrored one is returned to kkp_[1].
+		// When USE_KKP_INVERSE_WRITE is enabled, the inverse of them will be in [2] and [3].
+		// Note that the sign of grad must be reversed for this dimension reduction.
+		// You can use is_inverse() because it can be determined.
 		void toLowerDimensions(/*out*/ KKP kkp_[KKP_LOWER_COUNT]) const {
 			kkp_[0] = fromKKP(king0_, king1_, piece_,false);
 #if defined(USE_KKP_MIRROR_WRITE)
@@ -450,24 +450,24 @@ namespace EvalLearningTools
 #endif
 		}
 
-		// ��クラス�min_index()�値を0���数�����indexを�得�る。
+		// Get the index when counting the value of min_index() of this class as 0.
 		virtual uint64_t toRawIndex() const {
 			return  ((uint64_t)king0_ * (uint64_t)max_king_sq_ + (uint64_t)king1_) * (uint64_t)fe_end_ + (uint64_t)piece_;
 		}
 
-		// toLowerDimensions�次元下���も��inverse��も���る�を返�。
+		// Returns whether or not the dimension lowered with toLowerDimensions is inverse.
 		bool is_inverse() const {
 			return inverse_sign;
 		}
 
-		// is_inverse() == true�����grad�手番�������符�を�転���返�。
+		// When is_inverse() == true, reverse the sign that is not grad's turn and return it.
 		template <typename T>
 		std::array<T, 2> apply_inverse_sign(const std::array<T, 2>& rhs)
 		{
 			return !is_inverse() ? rhs : std::array<T, 2>{-rhs[0], rhs[1]};
 		}
 
-		// 比較演算�
+		// comparison operator
 		bool operator==(const KKP& rhs) { return king0() == rhs.king0() && king1() == rhs.king1() && piece() == rhs.piece(); }
 		bool operator!=(const KKP& rhs) { return !(*this == rhs); }
 
@@ -477,7 +477,7 @@ namespace EvalLearningTools
 		bool inverse_sign;
 	};
 
-	// デ�ッグ用出力。
+	// Output for debugging.
 	static std::ostream& operator<<(std::ostream& os, KKP rhs)
 	{
 		os << "KKP(" << rhs.king0() << "," << rhs.king1() << "," << rhs.piece() << ")";
@@ -485,7 +485,7 @@ namespace EvalLearningTools
 	}
 
 
-	// KK,KKP��様。KPP用
+	// Same as KK and KKP. For KPP
 	struct KPP : public SerializerBase
 	{
 	protected:
@@ -494,28 +494,28 @@ namespace EvalLearningTools
 	public:
 		KPP() {}
 
-		// KK,KKP,KPP�列を直列化�る���通�番���KPP�最�値�最大値。
+		// The minimum and maximum KPP values ​​of serial numbers when serializing KK, KKP, KPP arrays.
 #if !defined(USE_TRIANGLE_WEIGHT_ARRAY)
 		virtual uint64_t size() const { return (uint64_t)max_king_sq_*(uint64_t)fe_end_*(uint64_t)fe_end_; }
 #else
-		// kpp[SQUARE_NB][fe_end][fe_end]�[fe_end][fe_end]�正方�列�部分を三角�列化�る。
-		// kpp[SQUARE_NB][triangle_fe_end]��る����三角�列�1行目��素1個�2行目�2個�…。
-		// ゆ���triangle_fe_end = 1 + 2 + .. + fe_end = fe_end * (fe_end + 1) / 2
+		// Triangularize the square array part of [fe_end][fe_end] of kpp[SQUARE_NB][fe_end][fe_end].
+		// If kpp[SQUARE_NB][triangle_fe_end], the first row of this triangular array has one element, the second row has two elements, and so on.
+		// hence triangle_fe_end = 1 + 2 + .. + fe_end = fe_end * (fe_end + 1) / 2
 		virtual uint64_t size() const { return (uint64_t)max_king_sq_*(uint64_t)triangle_fe_end; }
 #endif
 
 		virtual void set(int max_king_sq, uint64_t fe_end, uint64_t min_index)
 		{
-			// ��値�size()�用�����SerializerBase::set()�size()を使���先�計算�る。
+		// This value is used in size(), and size() is used in SerializerBase::set(), so calculate first.
 			triangle_fe_end = (uint64_t)fe_end*((uint64_t)fe_end + 1) / 2;
 
 			SerializerBase::set(max_king_sq, fe_end, min_index);
 		}
 
-		// index(通�番�)�らKPP�オブジェクトを生��るbuilder
+		// builder that creates KPP object from index (serial number)
 		KPP fromIndex(uint64_t index) const { assert(index >= min_index()); return fromRawIndex(index - min_index()); }
 
-		// raw_index(通�番�����0�ら始�る番�)�らKPP�オブジェクトを生��るbuilder
+		// A builder that creates KPP objects from raw_index (a number that starts from 0, not a serial number)
 		KPP fromRawIndex(uint64_t raw_index) const
 		{
 			const uint64_t triangle_fe_end = (uint64_t)fe_end_*((uint64_t)fe_end_ + 1) / 2;
@@ -528,13 +528,13 @@ namespace EvalLearningTools
 #else
 			uint64_t index2 = raw_index % triangle_fe_end;
 
-			// ���index2�らpiece0,piece1を求�る�を書�。
-			// �れ� index2 = i * (i+1) / 2 + j �逆関数��る。
-			// j = 0 �場��i^2 + i - 2 * index2 == 0���
-			// 2次方程��解�公��ら i = (sqrt(8*index2+1) - 1) / 2��る。
-			// iを整数化������j = index2 - i * (i + 1) / 2���jを求�れ�良�。
+			// Write the expression to find piece0, piece1 from index2 here.
+			// This is the inverse function of index2 = i * (i+1) / 2 + j.
+			// If j = 0, i^2 + i-2 * index2 == 0
+			// From the solution formula of the quadratic equation i = (sqrt(8*index2+1)-1) / 2.
+			// After i is converted into an integer, j can be calculated as j = index2-i * (i + 1) / 2.
 
-			// BonaPiece�32bit(16bit���ら���能性)を想定���る����掛�算�64bit��������。
+			// BonaPiece assumes 32bit (may not fit in 16bit), so this multiplication must be 64bit.
 			int piece1 = int(sqrt(8 * index2 + 1) - 1) / 2;
 			int piece0 = int(index2 - (uint64_t)piece1*((uint64_t)piece1 + 1) / 2);
 
@@ -556,13 +556,13 @@ namespace EvalLearningTools
 			return my_kpp;
 		}
 
-		// fromIndex()を用����オブジェクトを構築������以下�アクセッサ�情報�得られる。
+		// When you construct this object using fromIndex(), you can get information with the following accessors.
 		Square king() const { return king_; }
 		Eval::BonaPiece piece0() const { return piece0_; }
 		Eval::BonaPiece piece1() const { return piece1_; }
 
 
-		// 次元下��数
+// number of dimension reductions
 #if defined(USE_KPP_MIRROR_WRITE)
 	#if !defined(USE_TRIANGLE_WEIGHT_ARRAY)
 		#define KPP_LOWER_COUNT 4
@@ -577,18 +577,18 @@ namespace EvalLearningTools
 	#endif
 #endif
 
-		// 低次元��列�indexを得る。p1,p2を入れ替��も��ミラー��も����返る。
+		// Get the index of the low-dimensional array. The ones with p1 and p2 swapped, the ones mirrored, etc. are returned.
 		void toLowerDimensions(/*out*/ KPP kpp_[KPP_LOWER_COUNT]) const {
 
 #if defined(USE_TRIANGLE_WEIGHT_ARRAY)
-			// 三角�列を用�る場���piece0�piece1を入れ替��も��返ら����注�。
+			// Note that if you use a triangular array, the swapped piece0 and piece1 will not be returned.
 			kpp_[0] = fromKPP(king_, piece0_, piece1_);
 #if defined(USE_KPP_MIRROR_WRITE)
 			kpp_[1] = fromKPP(Mir(king_), mir_piece(piece0_), mir_piece(piece1_));
 #endif
 
 #else
-			// 三角�列を用���場�
+			// When not using triangular array
 			kpp_[0] = fromKPP(king_, piece0_, piece1_);
 			kpp_[1] = fromKPP(king_, piece1_, piece0_);
 #if defined(USE_KPP_MIRROR_WRITE)
@@ -598,7 +598,7 @@ namespace EvalLearningTools
 #endif
 		}
 
-		// ��クラス�min_index()�値を0���数�����indexを�得�る。
+		// Get the index when counting the value of min_index() of this class as 0.
 		virtual uint64_t toRawIndex() const {
 
 #if !defined(USE_TRIANGLE_WEIGHT_ARRAY)
@@ -606,15 +606,15 @@ namespace EvalLearningTools
 			return ((uint64_t)king_ * (uint64_t)fe_end_ + (uint64_t)piece0_) * (uint64_t)fe_end_ + (uint64_t)piece1_;
 
 #else
-			// Bonanza6.0�使�れ��る��似��マクロ
+			// Macro similar to that used in Bonanza 6.0
 			auto PcPcOnSq = [&](Square k, Eval::BonaPiece i, Eval::BonaPiece j)
 			{
 
-				// ��三角�列�(i,j)��i行目�j列目��素。
-				// i行目0列目��������素��計��る�ら�1 + 2 + ... + i = i * (i+1) / 2
-				// i行目j列目���れ�jを足��も�。i * (i + 1) /2 + j
+				// (i,j) in this triangular array is the element in the i-th row and the j-th column.
+				// 1st row + 2 + ... + i = i * (i+1) / 2 because the i-th row and 0th column is the total of the elements up to that point
+				// The i-th row and the j-th column is j plus this. i*(i+1)/2+j
 
-				// BonaPiece型��32bitを想定���る��掛�算��気を�����オー�ーフロー�る。
+				// BonaPiece type is assumed to be 32 bits, so if you do not pay attention to multiplication, it will overflow.
 				return (uint64_t)k * triangle_fe_end + (uint64_t)(uint64_t(i)*(uint64_t(i)+1) / 2 + uint64_t(j));
 			};
 
@@ -626,18 +626,18 @@ namespace EvalLearningTools
 #endif
 		}
 
-		// toLowerDimensions�次元下���も��inverse��も���る�を返�。
-		// KK,KKP�interfaceを��る���用����る。��KPPクラス�����メソッド�常�falseを返�。
+		// Returns whether or not the dimension lowered with toLowerDimensions is inverse.
+		// Prepared to match KK, KKP and interface. This method always returns false for this KPP class.
 		bool is_inverse() const {
 			return false;
 		}
 
-		// 比較演算�
+		// comparison operator
 		bool operator==(const KPP& rhs) {
 			return king() == rhs.king() &&
 				((piece0() == rhs.piece0() && piece1() == rhs.piece1())
 #if defined(USE_TRIANGLE_WEIGHT_ARRAY)
-					// 三角�列を用�る���piece0�piece1�入れ替�りを許容�る。
+					// When using a triangular array, allow swapping of piece0 and piece1.
 				|| (piece0() == rhs.piece1() && piece1() == rhs.piece0())
 #endif
 					); }
@@ -651,24 +651,24 @@ namespace EvalLearningTools
 		uint64_t triangle_fe_end; // = (uint64_t)fe_end_*((uint64_t)fe_end_ + 1) / 2;
 	};
 
-	// デ�ッグ用出力。
+	// Output for debugging.
 	static std::ostream& operator<<(std::ostream& os, KPP rhs)
 	{
 		os << "KPP(" << rhs.king() << "," << rhs.piece0() << "," << rhs.piece1() << ")";
 		return os;
 	}
 
-	// KPPP�4駒関係。����手番�り�ミラー等を考慮����学習�2TB以上�メモリ�必�…。
-	// 三角�列を使��も学習����50GB×12�イト = 600GB必�。
-	// ミラー��も���を格��るよ����も��分�ら�必�。
-	// �����三角�列�必�用�����ミラー��も�を格��るも���る。
+	// 4 pieces related to KPPP. However, if there is a turn and you do not consider mirrors etc., memory of 2 TB or more is required for learning.
+	// Even if you use a triangular array, you need 50GB x 12 bytes = 600GB for learning.
+	// It takes about half as much as storing only the mirrored one.
+	// Here, the triangular array is always used and the mirrored one is stored.
 	//
-	// �����クラス�king()��実際�king�Square���ら�����0～(king_sq-1)���値�返る。
-	// �れ��ミラーを利用��圧縮を行��場����利用���切�玉��置�変���やる必���る。
-	// 
-	// �����クラス�返�piece0,1,2�関���
-	//   piece0() > piece1() > piece2()
-	// ��り�コンストラクタ�piece0,1,2を渡���も���制約を守る必���る。
+	// Also, king() of this class is not limited to Square of the actual king, but a value from 0 to (king_sq-1) is simply returned.
+	// This needs to be converted to an appropriate ball position on the user side when performing compression using a mirror.
+	//
+	// Later, regarding the pieces0,1,2 returned by this class,
+	// piece0() >piece1() >piece2()
+	// It is, and it is necessary to keep this constraint when passing piece0,1,2 in the constructor.
 	struct KPPP : public SerializerBase
 	{
 	protected:
@@ -684,21 +684,21 @@ namespace EvalLearningTools
 
 		virtual uint64_t size() const { return (uint64_t)max_king_sq_*triangle_fe_end; }
 
-		// fe_end�king_sqを設定�る。
-		// fe_end : ��KPPPクラス�想定�るfe_end
-		// king_sq : KPPP����扱�玉���数。
-		//  3段×ミラー�ら3段×5筋 = 15����感�。
-		//  2段×ミラー���ら2×9筋 = 18����感�。
-		//  �れを��KPPPクラスを使���set()を用��最��設定�る。
+		// Set fe_end and king_sq.
+		// fe_end: fe_end assumed by this KPPP class
+		// king_sq: Number of balls to handle in KPPP.
+		// 3 layers x 3 mirrors = 3 layers x 5 lines = 15
+		// 2 steps x 2 mirrors without mirror = 18
+		// Set this first using set() on the side that uses this KPPP class.
 		virtual void set(int max_king_sq, uint64_t fe_end,uint64_t min_index) {
-			// ��値�size()�用�����SerializerBase::set()�size()を使���先�計算�る。
+			// This value is used in size(), and size() is used in SerializerBase::set(), so calculate first.
 			triangle_fe_end = fe_end * (fe_end - 1) * (fe_end - 2) / 6;
 
 			SerializerBase::set(max_king_sq, fe_end, min_index);
 		}
 
-		// 次元下��数
-		// �り����ミラー�次元下��対応。���やる��も����…。
+		// number of dimension reductions
+		// For the time being, the dimension reduction of the mirror is not supported. I wonder if I'll do it here...
 /*
 #if defined(USE_KPPP_MIRROR_WRITE)
 #define KPPP_LOWER_COUNT 2
@@ -708,70 +708,70 @@ namespace EvalLearningTools
 */
 #define KPPP_LOWER_COUNT 1
 
-		// 低次元��列�indexを得る。
-		// p0,p1,p2を入れ替��も��返ら����注�。
-		// ��ミラー��も�も�USE_KPPP_MIRROR_WRITE�有効�����返���。
+		// Get the index of the low-dimensional array.
+		// Note that the one with p0,p1,p2 swapped will not be returned.
+		// Also, the mirrored one is returned only when USE_KPPP_MIRROR_WRITE is enabled.
 		void toLowerDimensions(/*out*/ KPPP kppp_[KPPP_LOWER_COUNT]) const
 		{
 			kppp_[0] = fromKPPP(king_, piece0_, piece1_,piece2_);
 #if KPPP_LOWER_COUNT > 1
-			// mir_piece�る�sort�れ���状態��る。sort�るコード�必�。
+			// If mir_piece is done, it will be in a state not sorted. Need code to sort.
 			Eval::BonaPiece p_list[3] = { mir_piece(piece2_), mir_piece(piece1_), mir_piece(piece0_) };
 			my_insertion_sort(p_list, 0, 3);
 			kppp_[1] = fromKPPP((int)Mir((Square)king_), p_list[2] , p_list[1], p_list[0]);
 #endif
 		}
 
-		// index(通�番�)�らKPPP�オブジェクトを生��るbuilder
+		// builder that creates KPPP object from index (serial number)
 		KPPP fromIndex(uint64_t index) const { assert(index >= min_index()); return fromRawIndex(index - min_index()); }
 
-		// raw_index(通�番�����0�ら始�る番�)�らKPPP�オブジェクトを生��るbuilder
+		// A builder that creates KPPP objects from raw_index (a number that starts from 0, not a serial number)
 		KPPP fromRawIndex(uint64_t raw_index) const
 		{
 			uint64_t index2 = raw_index % triangle_fe_end;
 
-			// ���index2�らpiece0,piece1,piece2を求�る�を書�。
-			// �れ� index2 = i(i-1)(i-2)/6-1 + j(j+1)/2 + k �逆関数��る。
-			// j = k = 0 �場��3次方程��解�公��ら実根�� i = ...��る。(以下�) 
-			// ���index2�0,1����実数解�複数�る。�れを考慮��������。計算精度�足り�����対�る対策必�。
-			// i�求������iを整数化������最����入れ�KPP����様�jを求�れ�良�。
+			// Write the expression to find piece0, piece1, piece2 from index2 here.
+			// This is the inverse function of index2 = i(i-1)(i-2)/6-1 + j(j+1)/2 + k.
+			// For j = k = 0, the real root is i = ... from the solution formula of the cubic equation. (The following formula)
+			// However, if index2 is 0 or 1, there are multiple real solutions. You have to consider this. It is necessary to take measures against insufficient calculation accuracy.
+			// After i is calculated, i can be converted into an integer, then put in the first expression and then j can be calculated in the same way as in KPP.
 
-			// ��処��数値計算����り�難��。色々工夫�必�。
+			// This process is a relatively difficult numerical calculation. Various ideas are needed.
 
 			int piece0;
 			if (index2 <= 1)
 			{
-				// index2 == 0,1�����実数解�複数�る。
+				// There are multiple real solutions only when index2 == 0,1.
 				piece0 = (int)index2 + 2;
 
 			} else {
 
-				//double t = pow(sqrt((243 *index2 * index2 - 1) * 3) + 27 * index2, 1.0 / 3);
-				// →　�れ��index2�大���る�sqrt()�中身�オー�ーフロー�る。
+				//double t = pow(sqrt((243 *index2 * index2-1) * 3) + 27 * index2, 1.0 / 3);
+				// → In this case, the content of sqrt() will overflow if index2 becomes large.
 
-				// sqrt()�中身�オー�ーフロー�る���sqrt����3.0を掛���sqrt�外��sqrt(3.0)を掛�る。
-				// sqrt()�中身�オー�ーフロー�る���index2�大�����近似�を用�る。
+				// Since the contents of sqrt() overflow, do not multiply 3.0 in sqrt, but multiply sqrt(3.0) outside sqrt.
+				// Since the contents of sqrt() will overflow, use an approximate expression when index2 is large.
 
 				double t;
 				
 				if (index2 < 100000000)
 					t = pow(sqrt((243.0 *index2 * index2 - 1)) * sqrt(3.0) + 27 * index2, 1.0 / 3);
 				else
-					// index2��常�大�����sqrt�中身�近似的� √243 * index2����る���。
+					// If index2 is very large, we can think of the contents of sqrt as approximately √243 * index2.
 					t = pow( index2 * sqrt(243 * 3.0) + 27 * index2, 1.0 / 3);
-				
-				// 丸�����計算誤差�����足り���を防���デルタを加算�る。
-				// 大���る�1大��数�������時��る��調整�必�。
-				
+
+				// Add deltas to avoid a slight calculation error when rounding.
+				// If it is too large, it may increase by 1 so adjustment is necessary.
+
 				const double delta = 0.000000001;
 
 				piece0 = int(t / pow(3.0, 2.0 / 3) + 1.0 / (pow(3.0, 1.0 / 3) * t) + delta) + 1;
-				// ���。�ん���ん����ん���ん��？(´ω｀)
+				// Uuu. Is it really like this? ('Ω`)
 			}
 
-			// piece2�求������上��i(i-1)(i-2)/6(=a��る)�i�piece2を代入。���k = 0を代入。
-			// j(j+1)/2 = index2 - a
-			// �れ��2次方程��解�公�より..
+			//Since piece2 is obtained, substitute piece2 for i of i(i-1)(i-2)/6 (=a) in the above formula. Also substitute k = 0.
+			// j(j+1)/2 = index2-a
+			// This is from the solution formula of the quadratic equation..
 
 			uint64_t a = (uint64_t)piece0*((uint64_t)piece0 - 1)*((uint64_t)piece0 - 2) / 6;
 			int piece1 = int((1 + sqrt(8.0 * (index2 - a ) + 1)) / 2);
@@ -796,12 +796,12 @@ namespace EvalLearningTools
 			int king = (int)(raw_index  /* % SQUARE_NB */);
 			assert(king < max_king_sq_);
 
-			// king_sq�fe_end�関����播��る。
+			// Propagate king_sq and fe_end.
 			return fromKPPP((Square)king, (Eval::BonaPiece)piece0, (Eval::BonaPiece)piece1 , (Eval::BonaPiece)piece2);
 		}
 
-		// k,p0,p1,p2を指定��KPPP�インスタンスをbuild�る。
-		// 内部的������るset()�渡�れ�king_sq�fe_end�引�継�。
+		// Specify k,p0,p1,p2 to build KPPP instance.
+		// The king_sq and fe_end passed by set() which is internally retained are inherited.
 		KPPP fromKPPP(int king, Eval::BonaPiece p0, Eval::BonaPiece p1, Eval::BonaPiece p2) const
 		{
 			KPPP kppp(king, p0, p1, p2);
@@ -809,21 +809,21 @@ namespace EvalLearningTools
 			return kppp;
 		}
 
-		// ��クラス�min_index()�値を0���数�����indexを�得�る。
+		// Get the index when counting the value of min_index() of this class as 0.
 		virtual uint64_t toRawIndex() const {
 
-			// Bonanza 6.0�使�れ��る��似��マクロ
-			// ���件) i > j > k ��る��。
-			// i==j,j==k�ケース�NG。
+			// Macro similar to the one used in Bonanza 6.0
+			// Precondition) i> j> k.
+			// NG in case of i==j,j==k.
 			auto PcPcPcOnSq = [this](int king, Eval::BonaPiece i, Eval::BonaPiece j , Eval::BonaPiece k)
 			{
-				// ��三角�列�(i,j,k)��i行目�j列目��素。
-				// i行目0列0番目��������素��計��る�ら�0 + 0 + 1 + 3 + 6 + ... + (i)*(i-1)/2 = i*(i-1)*(i-2)/ 6
-				// i行目j列0番目�����jを加味��も�。 + j*(j-1) / 2
-				// i行目j列k番目�����kを足��も�。   + k
+				// (i,j,k) in this triangular array is the element in the i-th row and the j-th column.
+				// 0th row 0th column 0th is the sum of the elements up to that point, so 0 + 0 + 1 + 3 + 6 + ... + (i)*(i-1)/2 = i*( i-1)*(i-2)/6
+				// i-th row, j-th column, 0-th is j with j added. + j*(j-1) / 2
+				// i-th row, j-th column and k-th row is k plus it. + k
 				assert(i > j && j > k);
 
-				// BonaPiece型��32bitを想定���る��掛�算��気を�����オー�ーフロー�る。
+				// BonaPiece type is assumed to be 32 bits, so if you do not pay attention to multiplication, it will overflow.
 				return (uint64_t)king * triangle_fe_end + (uint64_t)(
 						  uint64_t(i)*(uint64_t(i) - 1) * (uint64_t(i) - 2) / 6
 						+ uint64_t(j)*(uint64_t(j) - 1) / 2
@@ -834,24 +834,24 @@ namespace EvalLearningTools
 			return PcPcPcOnSq(king_, piece0_, piece1_, piece2_);
 		}
 
-		// fromIndex()を用����オブジェクトを構築������以下�アクセッサ�情報�得られる。
+		// When you construct this object using fromIndex(), you can get information with the following accessors.
 		int king() const { return king_; }
 		Eval::BonaPiece piece0() const { return piece0_; }
 		Eval::BonaPiece piece1() const { return piece1_; }
 		Eval::BonaPiece piece2() const { return piece2_; }
-		// toLowerDimensions�次元下���も��inverse��も���る�を返�。
-		// KK,KKP�interfaceを��る���用����る。��KPPPクラス�����メソッド�常�falseを返�。
+		// Returns whether or not the dimension lowered with toLowerDimensions is inverse.
+		// Prepared to match KK, KKP and interface. This method always returns false for this KPPP class.
 		bool is_inverse() const {
 			return false;
 		}
 
-		// 3角�列化������素�数を返�。kppp�列��以下�よ��2次元�列��想定���る。
-		//   kppp[king_sq][triangle_fe_end];
+		// Returns the number of elements in a triangular array. It is assumed that the kppp array is the following two-dimensional array.
+		// kppp[king_sq][triangle_fe_end];
 		uint64_t get_triangle_fe_end() const { return triangle_fe_end; }
 
-		// 比較演算�
+		// comparison operator
 		bool operator==(const KPPP& rhs) {
-			// piece0 > piece1 > piece2を����る���入れ替�り��能性���。
+			// piece0> piece1> piece2 is assumed, so there is no possibility of replacement.
 			return king() == rhs.king() && piece0() == rhs.piece0() && piece1() == rhs.piece1() && piece2() == rhs.piece2();
 		}
 		bool operator!=(const KPPP& rhs) { return !(*this == rhs); }
@@ -861,33 +861,33 @@ namespace EvalLearningTools
 		int king_;
 		Eval::BonaPiece piece0_, piece1_,piece2_;
 
-		// kppp[king_sq][fe_end][fe_end][fe_end]�[fe_end][fe_end][fe_end]�正方�列�部分を三角�列化�る。
-		// kppp[king_sq][triangle_fe_end]��る����三角�列�0行目�ら�素数��0,0,1,3,…,n行目�n(n-1)/2個。
-		// ゆ���
+		// The part of the square array of [fe_end][fe_end][fe_end] of kppp[king_sq][fe_end][fe_end][fe_end] is made into a triangular array.
+		// If kppp[king_sq][triangle_fe_end], the number of elements from the 0th row of this triangular array is 0,0,1,3,..., The nth row is n(n-1)/2.
+		// therefore,
 		// triangle_fe_end = Σn(n-1)/2 , n=0..fe_end-1
 		//                 =  fe_end * (fe_end - 1) * (fe_end - 2) / 6
 		uint64_t triangle_fe_end; // ((uint64_t)Eval::fe_end)*((uint64_t)Eval::fe_end - 1)*((uint64_t)Eval::fe_end - 2) / 6;
 	};
 
-	// デ�ッグ用出力。
+	// Output for debugging.
 	static std::ostream& operator<<(std::ostream& os, KPPP rhs)
 	{
 		os << "KPPP(" << rhs.king() << "," << rhs.piece0() << "," << rhs.piece1() << "," << rhs.piece2() << ")";
 		return os;
 	}
 
-	// KKPP�よる4駒関係�学習用。
+	// For learning about 4 pieces by KKPP.
 	//
-	// KPPPクラス���設計。KPPPクラス��p�一枚少��も����扱�。
-	// ２��玉��置�0～king_sq-1���値���encode�れ��るも���る。
+	// Same design as KPPP class. In KPPP class, treat as one with less p.
+	// The positions of the two balls are encoded as values ​​from 0 to king_sq-1.
 	//
-	// �����クラス�返�piece0,1�関���
-	//   piece0() > piece1()
-	// ��り�コンストラクタ�piece0,1を渡���も���制約を守る必���る。
+	// Later, regarding the pieces0 and 1 returned by this class,
+	// piece0() >piece1()
+	// It is, and it is necessary to keep this constraint even when passing piece0,1 in the constructor.
 	//
-	// ��制約�ら�BonaPieceZeroをpiece0,piece1��時�代入��渡����出���。
-	// 駒���学習�対応��る�らevaluate()�工夫�必�。
-	struct KKPP : SerializerBase
+	// Due to this constraint, BonaPieceZero cannot be assigned to piece0 and piece1 at the same time and passed.
+	// If you want to support learning of dropped frames, you need to devise with evaluate().
+	struct KKPP: SerializerBase
 	{
 	protected:
 		KKPP(int king, Eval::BonaPiece p0, Eval::BonaPiece p1) :
@@ -902,45 +902,45 @@ namespace EvalLearningTools
 
 		virtual uint64_t size() const { return (uint64_t)max_king_sq_*triangle_fe_end; }
 
-		// fe_end�king_sqを設定�る。
-		// fe_end : ��KPPPクラス�想定�るfe_end
-		// king_sq : KPPP����扱�玉���数。
-		//  9段×ミラー�ら9段×5筋�2乗(先後�玉) = 45*45 = 2025 ����感�。
-		//  �れを��KKPPクラスを使���set()を用��最��設定�る。
+		// Set fe_end and king_sq.
+		// fe_end: fe_end assumed by this KPPP class
+		// king_sq: Number of balls to handle in KPPP.
+		// 9 steps x mirrors 9 steps x 5 squared squares (balls before and after) = 45*45 = 2025.
+		// Set this first using set() on the side that uses this KKPP class.
 		void set(int max_king_sq, uint64_t fe_end , uint64_t min_index) {
-			// ��値�size()�用�����SerializerBase::set()�size()を使���先�計算�る。
+			// This value is used in size(), and size() is used in SerializerBase::set(), so calculate first.
 			triangle_fe_end = fe_end * (fe_end - 1) / 2;
 
 			SerializerBase::set(max_king_sq, fe_end, min_index);
 		}
 
-		// 次元下��数
-		// �り����ミラー�次元下��対応。���やる��も����…。(学習用�メモリ�も�������)
+		// number of dimension reductions
+		// For the time being, the dimension reduction of the mirror is not supported. I wonder if I'll do it here... (Because the memory for learning is a waste)
 #define KKPP_LOWER_COUNT 1
 
-		// 低次元��列�indexを得る。
-		// p0,p1,p2を入れ替��も��返ら����注�。
-		// ��ミラー��も�も�USE_KPPP_MIRROR_WRITE�有効�����返���。
+		// Get the index of the low-dimensional array.
+		//Note that the one with p0,p1,p2 swapped will not be returned.
+		// Also, the mirrored one is returned only when USE_KPPP_MIRROR_WRITE is enabled.
 		void toLowerDimensions(/*out*/ KKPP kkpp_[KPPP_LOWER_COUNT]) const
 		{
 			kkpp_[0] = fromKKPP(king_, piece0_, piece1_);
 
-			// ミラー�る場��mir_piece�る�sort�れ���状態��る。sort�るコード�必�。
-			// ��king_�対�るミラーを定義�る必�も。
+			// When mirroring, mir_piece will not be sorted. Need code to sort.
+			// We also need to define a mirror for king_.
 		}
 
-		// index(通�番�)�らKKPP�オブジェクトを生��るbuilder
+		// builder that creates KKPP object from index (serial number)
 		KKPP fromIndex(uint64_t index) const { assert(index >= min_index()); return fromRawIndex(index - min_index()); }
 
-		// raw_index(通�番�����0�ら始�る番�)�らKKPP�オブジェクトを生��るbuilder
+		// builder that creates KKPP object from raw_index (number starting from 0, not serial number)
 		KKPP fromRawIndex(uint64_t raw_index) const
 		{
 			uint64_t index2 = raw_index % triangle_fe_end;
 
-			// ���index2�らpiece0,piece1,piece2を求�る�を書�。
-			// �れ� index2 = i(i-1)/2 + j �逆関数��る。
-			// j=0����二次方程��解�公�を用�る。
-			// index2=0�����根��������i>jを満������無視。
+			// Write the expression to find piece0, piece1, piece2 from index2 here.
+			// This is the inverse function of index2 = i(i-1)/2 + j.
+			// Use the formula of the solution of the quadratic equation with j=0.
+			// When index2=0, it is a double root, but the smaller one does not satisfy i>j and is ignored.
 
 			int piece0 = (int(sqrt(8 * index2 + 1)) + 1)/2;
 			int piece1 = int(index2 - piece0 * (piece0 - 1) /2 );
@@ -955,12 +955,12 @@ namespace EvalLearningTools
 			int king = (int)(raw_index  /* % SQUARE_NB */);
 			assert(king < max_king_sq_);
 
-			// king_sq�fe_end�関����播��る。
+			// Propagate king_sq and fe_end.
 			return fromKKPP(king, (Eval::BonaPiece)piece0, (Eval::BonaPiece)piece1);
 		}
 
-		// k,p0,p1を指定��KKPP�インスタンスをbuild�る。
-		// 内部的������るset()�渡�れ�king_sq�fe_end�引�継�。
+		// Specify k,p0,p1 to build KKPP instance.
+		// The king_sq and fe_end passed by set() which is internally retained are inherited.
 		KKPP fromKKPP(int king, Eval::BonaPiece p0, Eval::BonaPiece p1) const
 		{
 			KKPP kkpp(king, p0, p1);
@@ -968,17 +968,17 @@ namespace EvalLearningTools
 			return kkpp;
 		}
 
-		// ��クラス�min_index()�値を0���数�����indexを�得�る。
+		// Get the index when counting the value of min_index() of this class as 0.
 		virtual uint64_t toRawIndex() const {
 
-			// Bonanza 6.0�使�れ��る��似��マクロ
-			// ���件) i > j��る��。
-			// i==j,j==k�ケース�NG。
+			// Macro similar to the one used in Bonanza 6.0
+			// Precondition) i> j.
+			// NG in case of i==j,j==k.
 			auto PcPcOnSq = [this](int king, Eval::BonaPiece i, Eval::BonaPiece j)
 			{
 				assert(i > j);
 
-				// BonaPiece型��32bitを想定���る��掛�算��気を�����オー�ーフロー�る。
+				// BonaPiece type is assumed to be 32 bits, so if you do not pay attention to multiplication, it will overflow.
 				return (uint64_t)king * triangle_fe_end + (uint64_t)(
 					+ uint64_t(i)*(uint64_t(i) - 1) / 2
 					+ uint64_t(j)
@@ -988,24 +988,24 @@ namespace EvalLearningTools
 			return PcPcOnSq(king_, piece0_, piece1_);
 		}
 
-		// fromIndex(),fromKKPP()を用����オブジェクトを構築������以下�アクセッサ�情報�得られる。
+		// When you construct this object using fromIndex(), fromKKPP(), you can get information with the following accessors.
 		int king() const { return king_; }
 		Eval::BonaPiece piece0() const { return piece0_; }
 		Eval::BonaPiece piece1() const { return piece1_; }
 
-		// toLowerDimensions�次元下���も��inverse��も���る�を返�。
-		// KK,KKP�interfaceを��る���用����る。��KKPPクラス�����メソッド�常�falseを返�。
+		// Returns whether or not the dimension lowered with toLowerDimensions is inverse.
+		// Prepared to match KK, KKP and interface. In this KKPP class, this method always returns false.
 		bool is_inverse() const {
 			return false;
 		}
 
-		// 3角�列化������素�数を返�。kkpp�列��以下�よ��2次元�列��想定���る。
+		//Returns the number of elements in a triangular array. It is assumed that the kkpp array is the following two-dimensional array.
 		//   kkpp[king_sq][triangle_fe_end];
 		uint64_t get_triangle_fe_end() const { return triangle_fe_end; }
 
-		// 比較演算�
+		// comparison operator
 		bool operator==(const KKPP& rhs) {
-			// piece0 > piece1を����る���入れ替�り��能性���。
+			// Since piece0> piece1 is assumed, there is no possibility of replacement.
 			return king() == rhs.king() && piece0() == rhs.piece0() && piece1() == rhs.piece1();
 		}
 		bool operator!=(const KKPP& rhs) { return !(*this == rhs); }
@@ -1015,12 +1015,12 @@ namespace EvalLearningTools
 		int king_;
 		Eval::BonaPiece piece0_, piece1_;
 
-		// kppp[king_sq][fe_end][fe_end]�[fe_end][fe_end]�正方�列�部分を三角�列化�る。
+		// Triangularize the square array part of [fe_end][fe_end] of kppp[king_sq][fe_end][fe_end].
 		uint64_t triangle_fe_end = 0;
 		
 	};
 
-	// デ�ッグ用出力。
+	// Output for debugging.
 	static std::ostream& operator<<(std::ostream& os, KKPP rhs)
 	{
 		os << "KKPP(" << rhs.king() << "," << rhs.piece0() << "," << rhs.piece1() << ")";
@@ -1031,4 +1031,4 @@ namespace EvalLearningTools
 }
 
 #endif // defined (EVAL_LEARN)
-#endif
+#endif
\ No newline at end of file
diff --git a/src/learn/multi_think.cpp b/src/learn/multi_think.cpp
index 2dcb5b46..34f5373d 100644
--- a/src/learn/multi_think.cpp
+++ b/src/learn/multi_think.cpp
@@ -10,67 +10,67 @@
 
 void MultiThink::go_think()
 {
-	// ���Options�設定を復元�る���コピー�������。
+	// Keep a copy to restore the Options settings later.
 	auto oldOptions = Options;
 
-	// 定跡を用�る場��on the fly�行������時間���る＆ファイルアクセスを行��部分�
-	// thread safe�������メモリ�丸読��れ��る状態��る��を����証�る。
+	// When using the constant track, it takes a lot of time to perform on the fly & the part to access the file is
+	// Since it is not thread safe, it is guaranteed here that it is being completely read in memory.
 	Options["BookOnTheFly"] = std::string("false");
 
-	// 評価関数�読�込�等
-	// learnコマンド�場��評価関数読�込�後�評価関数�値を補正���る�能性��る���
-	// メモリ�破��ェック��略�る。
+	// Read evaluation function, etc.
+	// In the case of the learn command, the value of the evaluation function may be corrected after reading the evaluation function, so
+	// Skip memory corruption check.
 	is_ready(true);
 
-	// 派生クラス�init()を呼�出�。
+	// Call the derived class's init().
 	init();
 
-	// ループ上��set_loop_max()�設定�れ��るも���る。
+	// The loop upper limit is set with set_loop_max().
 	loop_count = 0;
 	done_count = 0;
 
-	// threadをOptions["Threads"]�数��生����考開始。
+	// Create threads as many as Options["Threads"] and start thinking.
 	std::vector<std::thread> threads;
 	auto thread_num = (size_t)Options["Threads"];
 
-	// worker thread�終了フラグ�確�
+	// Secure end flag of worker thread
 	thread_finished.resize(thread_num);
 	
-	// worker thread�起動
+	// start worker thread
 	for (size_t i = 0; i < thread_num; ++i)
 	{
 		thread_finished[i] = 0;
 		threads.push_back(std::thread([i, this]
 		{ 
-			// プロセッサ�全スレッドを使�切る。
+			// exhaust all processor threads.
 			WinProcGroup::bindThisThread(i);
 
-			// オー�ーライド�れ��る処�を実行
+			// execute the overridden process
 			this->thread_worker(i);
 
-			// スレッド�終了����終了フラグを立�る
+			// Set the end flag because the thread has ended
 			this->thread_finished[i] = 1;
 		}));
 	}
 
-	// ����thread�終了待�を
-	// for (auto& th : threads)
-	//  th.join();
-	// �よ��書��スレッド���仕事を���る状態�����入�る���
-	// ��間�callback_func()�呼�出���セーブ�����る。
-	// ���終了フラグを自���ェック�る必���る。
+	// wait for all threads to finish
+	// for (auto& th :threads)
+	// th.join();
+	// If you write like, the thread will rush here while it is still working,
+	// During that time, callback_func() cannot be called and you cannot save.
+	// Therefore, you need to check the end flag yourself.
 
-	// ����スレッド�終了���を判定�る関数
+	// function to determine if all threads have finished
 	auto threads_done = [&]()
 	{
-		// ����も終了�����れ�falseを返�
+		// returns false if no one is finished
 		for (auto& f : thread_finished)
 			if (!f)
 				return false;
 		return true;
 	};
 
-	// コール�ック関数�設定�れ��る�らコール�ック�る。
+	// Call back if the callback function is set.
 	auto do_a_callback = [&]()
 	{
 		if (callback_func)
@@ -80,44 +80,44 @@ void MultiThink::go_think()
 
 	for (uint64_t i = 0 ; ; )
 	{
-		// 全スレッド�終了����ら�ループを抜�る。
+		// If all threads have finished, exit the loop.
 		if (threads_done())
 			break;
 
 		sleep(1000);
 
-		// callback_seconds���callback_func()�呼�出�れる。
+		// callback_func() is called every callback_seconds.
 		if (++i == callback_seconds)
 		{
 			do_a_callback();
-			// ↑�ら戻�����らカウンターをリセット���る���
-			// do_a_callback()����save()����れ��時間������
-			// 次�呼�出�������ら一定時間�経�を��る。
+			// Since I am returning from ↑, I reset the counter, so
+			// no matter how long it takes to save() etc. in do_a_callback()
+			// The next call will take a certain amount of time.
 			i = 0;
 		}
 	}
 
-	// 最後��存。
+	// Last save.
 	std::cout << std::endl << "finalize..";
 
 	// do_a_callback();
-	// →　呼�出�元��存�る���������ら��気��る。
+	// → It should be saved by the caller, so I feel that it is not necessary here.
 
-	// 終了��フラグ�立���る�スレッド�終了コード�実行中��る�������り�る��
-	// join()���終了を待�必���る。
+	// It is possible that the exit code of the thread is running but the exit code of the thread is running, so
+	// We need to wait for the end with join().
 	for (auto& th : threads)
 		th.join();
 
-	// 全スレッド�終了�����file�書�出�スレッド�����動����
-	// 作業自体�完了������能性��る��スレッド����終了������出力�る。
+	// The file writing thread etc. are still running only when all threads are finished
+	// Since the work itself may not have completed, output only that all threads have finished.
 	std::cout << "all threads are joined." << std::endl;
 
-	// Optionsを書������復元。
-	// 値を代入�����ンドラ�起動�������や��復元�る。
+	// Restored because Options were rewritten.
+	// Restore the handler because the handler will not start unless you assign a value.
 	for (auto& s : oldOptions)
 		Options[s.first] = std::string(s.second);
 
 }
 
 
-#endif // defined(EVAL_LEARN)
+#endif // defined(EVAL_LEARN)
\ No newline at end of file
diff --git a/src/learn/multi_think.h b/src/learn/multi_think.h
index ad6baa5e..a2ef8cde 100644
--- a/src/learn/multi_think.h
+++ b/src/learn/multi_think.h
@@ -11,9 +11,9 @@
 
 #include <atomic>
 
-// 棋譜�ら�学習や�自ら�考���定跡を生��る�����
-// 複数スレッド�個別�Search::think()を呼�出������用�るヘルパクラス。
-// ��クラスを派生���用�る。
+// Learning from a game record, when making yourself think and generating a fixed track, etc.
+// Helper class used when multiple threads want to call Search::think() individually.
+// Derive and use this class.
 struct MultiThink
 {
 	MultiThink() : prng(21120903)
@@ -21,43 +21,43 @@ struct MultiThink
 		loop_count = 0;
 	}
 
-	// マスタースレッド�ら��関数を呼�出���スレッド��れ�れ�考���
-	// �考終了�件を満�������制御を返�。
-	// 他�や���れる��。
-	// ・�スレッド�Learner::search(),qsearch()を呼�出��も安全�よ��
-	// 　置�表をスレッド���分離���れる。(終了後�元�戻���れる。)
-	// ・book�on the flyモード��thread safe���������モードを一時的�
-	// 　オフ����れる。
-	// [�件]
-	// 1) thread_worker()�オー�ーライド
-	// 2) set_loop_max()�ループ回数�設定
-	// 3) 定期的�callback�れる関数を設定�る(必��ら)
-	//   callback_func�callback_interval
+	// Call this function from the master thread, each thread will think,
+	// Return control when the thought ending condition is satisfied.
+	// Do something else.
+	// ・It is safe for each thread to call Learner::search(),qsearch()
+	// Separates the substitution table for each thread. (It will be restored after the end.)
+	// ・Book is not thread safe when in on the fly mode, so temporarily change this mode.
+	// Turn it off.
+	// [Requirements]
+	// 1) Override thread_worker()
+	// 2) Set the loop count with set_loop_max()
+	// 3) set a function to be called back periodically (if necessary)
+	// callback_func and callback_interval
 	void go_think();
 
-	// 派生クラス���期化���も���れ��れをoverride������
-	// go_think()��期化�終���タイミング�呼�出�れる。
-	// 定跡�読�込������タイミング�行��良�。
+	// If there is something you want to initialize on the derived class side, override this,
+	// Called when initialization is completed with go_think().
+	// It is better to read the fixed trace at that timing.
 	virtual void init() {}
 
-	// go_think()�����スレッドを生���呼�出�れるthread worker
-	// �れをoverride��用�る。
+	// A thread worker that is called by creating a thread when you go_think()
+	// Override and use this.
 	virtual void thread_worker(size_t thread_id) = 0;
 
-	// go_think()�����callback_seconds[秒]���callback�れる。
+	// Called back every callback_seconds [seconds] when go_think().
 	std::function<void()> callback_func;
 	uint64_t callback_seconds = 600;
 
-	// worker�処��る(Search::think()を呼�出�)回数を設定�る。
+	// Set the number of times worker processes (calls Search::think()).
 	void set_loop_max(uint64_t loop_max_) { loop_max = loop_max_; }
-	
-	// set_loop_max()�設定��値を�得�る。
+
+	// Get the value set by set_loop_max().
 	uint64_t get_loop_max() const { return loop_max; }
 
-	// [ASYNC] ループカウンター�値を�り出����り出�後�ループカウンターを加算�る。
-	// も�ループカウンター�loop_max������らUINT64_MAXを返�。
-	// 局�を生��る場�����局�を生��るタイミング���関数を呼�出�よ�������
-	// 生���局�数��カウンター�値�一致�����������注��る��。
+	// [ASYNC] Take the value of the loop counter and add the loop counter after taking it out.
+	// If the loop counter has reached loop_max, return UINT64_MAX.
+	// If you want to generate a phase, you must call this function at the time of generating the phase,
+	// Please note that the number of generated phases and the value of the counter will not match.
 	uint64_t get_next_loop_count() {
 		std::unique_lock<std::mutex> lk(loop_mutex);
 		if (loop_count >= loop_max)
@@ -65,46 +65,46 @@ struct MultiThink
 		return loop_count++;
 	}
 
-	// [ASYNC] 処���個数を返�用。呼�出�れる���インクリメント�れ�カウンター�返る。
+	// [ASYNC] For returning the processed number. Each time it is called, it returns a counter that is incremented.
 	uint64_t get_done_count() {
 		std::unique_lock<std::mutex> lk(loop_mutex);
 		return ++done_count;
 	}
 
-	// worker thread�I/O�アクセス�る���mutex
+	// Mutex when worker thread accesses I/O
 	std::mutex io_mutex;
 
 protected:
-	// 乱数発生器本体
+	// Random number generator body
 	AsyncPRNG prng;
 
 private:
-	// worker�処��る(Search::think()を呼�出�)回数
+	// number of times worker processes (calls Search::think())
 	std::atomic<uint64_t> loop_max;
-	// worker�処���(Search::think()を呼�出��)回数
+	// number of times the worker has processed (calls Search::think())
 	std::atomic<uint64_t> loop_count;
-	// 処���回数を返�用。
+	// To return the number of times it has been processed.
 	std::atomic<uint64_t> done_count;
 
-	// ↑�変数を変更�る���mutex
+	// Mutex when changing the variables in ↑
 	std::mutex loop_mutex;
 
-	// スレッド�終了フラグ。
-	// vector<bool>��る�複数スレッド�ら書���よ�������正���映�れ������る…��。
+	// Thread end flag.
+	// vector<bool> may not be reflected properly when trying to rewrite from multiple threads...
 	typedef uint8_t Flag;
 	std::vector<Flag> thread_finished;
 
 };
 
-// idle時間�taskを処��る仕組�。
-// master�好�����push_task_async()�taskを渡�。
-// slave�暇����on_idle()を実行�る��taskを一��り出��queue����る��実行を続�る。
-// MultiThink�thread workerをmaster-slave方��書������用�る�便利。
+// Mechanism to process task during idle time.
+// master passes the task with push_task_async() whenever you like.
+// When slave executes on_idle() in its spare time, it retrieves one task and continues execution until there is no queue.
+// Convenient to use when you want to write MultiThink thread worker in master-slave method.
 struct TaskDispatcher
 {
 	typedef std::function<void(size_t /* thread_id */)> Task;
 
-	// slave�idle中���関数を呼�出�。
+	// slave calls this function during idle.
 	void on_idle(size_t thread_id)
 	{
 		Task task;
@@ -114,24 +114,24 @@ struct TaskDispatcher
 		sleep(1);
 	}
 
-	// [ASYNC] taskを一��む。
+	// Stack [ASYNC] task.
 	void push_task_async(Task task)
 	{
 		std::unique_lock<std::mutex> lk(task_mutex);
 		tasks.push_back(task);
 	}
 
-	// task用��列��素をsize分��事��確��る。
+	// Allocate size array elements for task in advance.
 	void task_reserve(size_t size)
 	{
 		tasks.reserve(size);
 	}
 
 protected:
-	// task�集�
+	// set of tasks
 	std::vector<Task> tasks;
 
-	// [ASYNC] taskを一��り出�。on_idle()�ら呼�出�れる。
+	// Take out one [ASYNC] task. Called from on_idle().
 	Task get_task_async()
 	{
 		std::unique_lock<std::mutex> lk(task_mutex);
@@ -142,10 +142,10 @@ protected:
 		return task;
 	}
 
-	// tasks�アクセス�る��用�mutex
+	// a mutex for accessing tasks
 	std::mutex task_mutex;
 };
 
 #endif // defined(EVAL_LEARN) && defined(YANEURAOU_2018_OTAFUKU_ENGINE)
 
-#endif
+#endif
\ No newline at end of file