Index: score_memo.txt
==================================================================
--- score_memo.txt
+++ score_memo.txt
@@ -17,10 +17,10 @@
 trampoline2 1728?
 trampoline3  698    // "上に岩" ワープゾーン版
 beard1       856?
 beard2      2792    // 崩すの怖がりすぎて間に合わなくなって溺死
 beard3       811    // 無理ゲー：速攻で髭刈らないといけない
-beard4       677    // 岩が落ちてきてデッドエンド
+beard4      1950    // 髭を解放しないように動くゲー
 beard5       665    // これクリアできるの
 horock1      333
 horock2      235
 horock3     1542

Index: src/solver.d
==================================================================
--- src/solver.d
+++ src/solver.d
@@ -315,37 +315,51 @@
 	}
 }
 
 class Solver_2(SubSolver) : Solver
 {
-	static const PredictFuture = 10;
+	// Parameters.
+	static const   PredictFuture = 10;
+	const string[] RandomChoicePattern; // PF*RCP exhaustive search for RL steps
+	const          ReplanLength  = 400; // O(PF*RCP*RL*SubSolver.single_step)
 
 	Game      current_game;
 	SubSolver sub_solver;
 
 	enum {Tentative, Tentative_Stuck, Fixed};
 	string plan;
 	int    plan_state;
+	int    replan_limit;
 
 	this(in Game g)
 	{
 		current_game = g.clone();
 		plan         = "";
 		plan_state   = Tentative;
+		replan_limit = PredictFuture;
+		if(g.map.W*g.map.H <= 400)
+			RandomChoicePattern = ["UU","UD","UL","UR",
+			                       "DU","DD","DL","DR",
+			                       "LU","LD","LL","LR",
+			                       "RU","RD","RL","RR","UUU","UUUU","UUUUU"];
+		else if(g.map.W*g.map.H <= 4096)
+			RandomChoicePattern = ["UUU","U","D","L","R","UD","DU","LR","RL"];
+		else
+			RandomChoicePattern = ["U","D","L","R"];
 	}
 
 	char single_step()
 	{
 		if(current_game.dead || current_game.cleared)
 			return 'A';
 
 		// Make enough prediction.
-		while( plan_state==Tentative && plan.length<PredictFuture )
+		while( plan_state==Tentative && plan.length<replan_limit )
 			single_step_predict();
 
 		// If the future is bad, correct.
-		if( plan_state==Tentative_Stuck && plan.length<PredictFuture )
+		if( plan_state==Tentative_Stuck && plan.length<replan_limit )
 			replan();
 
 		// Follow the predicted plan.
 		if( plan.empty )
 			return 'A';
@@ -393,68 +407,69 @@
 	void replan()
 	{
 stderr.writeln("replan!");
 		// Try to replace every step of the plan by another move.
 		Game g = current_game.clone();
-		Tuple!(long, SubSolver, string, int) cand =
-			tuple(sub_solver.g.score, sub_solver, plan, Tentative_Stuck);
+		Tuple!(SubSolver, string, int) cand = tuple(sub_solver, plan, Tentative_Stuck);
+		bool tiebreak_by_turn = false;
 		for(int i=0; i<plan.length; ++i) {
-			foreach(string prefix; ["U","D","L","R","UD","DU","LR","RL"])
+			foreach(string prefix; RandomChoicePattern)
 				if(prefix[0] != plan[i]) {
-					Tuple!(long, SubSolver, string, int) r = try_plan(g, prefix);
-					if(cand[0] < r[0]) {
-						r[2] = plan[0..i] ~ prefix ~ r[2];
-						cand = r;
+					Tuple!(SubSolver, string, int) r = try_plan(g, prefix);
+					r[1] = plan[0..i] ~ prefix ~ r[1];
+					bool better = false, tbt=false;
+					if(!cand[0].g.cleared && r[0].g.cleared)
+						better = true;
+					else if(cand[0].g.cleared && r[0].g.cleared) {
+						better = cand[0].g.score < r[0].g.score;
+					}
+					else if(!cand[0].g.cleared && !r[0].g.cleared) {
+						if(cand[0].g.map.collected_lambda < r[0].g.map.collected_lambda)
+							better = true;
+						else if(cand[0].g.map.collected_lambda == r[0].g.map.collected_lambda) {
+							if(cand[0].g.dead && !r[0].g.dead)
+								better = true;
+							else if(cand[0].g.dead == r[0].g.dead) {
+								better = (cand[1].length < r[1].length);
+								tbt = true;
+							}
+						}
 					}
+					if(better) {
+						cand = r;
+						tiebreak_by_turn = true;
+writeln(cand);
+}
 				}
 			g.command(plan[i]);
 		}
 
-		sub_solver = cand[1];
-		plan       = cand[2];
-		plan_state = (plan.length < PredictFuture ? Fixed : cand[3]);
+		sub_solver   = cand[0];
+		plan         = cand[1];
+		plan_state   = (plan.length < PredictFuture ? Fixed : cand[2]);
+		replan_limit = tiebreak_by_turn ? min(PredictFuture, plan.length/2) : PredictFuture;
 	}
 
-	Tuple!(long, SubSolver, string, int) try_plan(in Game g, string prefix)
+	Tuple!(SubSolver, string, int) try_plan(in Game g, string prefix)
 	{
 		SubSolver s = new SubSolver(g);
 		foreach(char c; prefix)
 			s.force(c);
 		string log;
 		int state = Tentative;
-		while(!s.g.cleared && !s.g.dead && log.length<=g.map.H*g.map.W) {
+		while(!s.g.cleared && !s.g.dead && log.length<=ReplanLength && log.length<=g.map.W*g.map.H) {
 			char c = s.single_step();
 			if( c == 'A' ) {
 				state = Tentative_Stuck;
 				break;
 			}
 			log ~= c;
 		}
 		if(s.g.cleared) state = Fixed;
 		else if(s.g.dead) state = Tentative_Stuck;
-		return tuple(s.g.score, s, log, state);
+		return tuple(s, log, state);
 	}
 }
-/*
-class MasterSolver : Solver
-{
-	this(in Game g)
-	{
-		int SIZE = g.map.H * g.map.W;
-		if( SIZE <= 32*32 )
-			sub = new Solver_2!(Solver_1)(g);
-		else if( SIZE <= 100*100 )
-			sub = new Solver_1(g);
-		else
-			sub = new Solver_1(g);
-	}
 
-	private Solver sub;
-	char single_step() { return sub.single_step(); }
-	void force(char c) { sub.force(c); }
-}
-
-alias MasterSolver MainSolver;
-*/
 alias Solver_2!(Solver_1) MainSolver;
 //alias Solver_1 MainSolver;
 //alias Solver_0 MainSolver;