Index: score_memo.txt
==================================================================
--- score_memo.txt
+++ score_memo.txt
@@ -1,22 +1,22 @@
 contest1     212!
 contest2     280?
 contest3     275!
 contest4     561?
 contest5    1281?
-contest6     737
+contest6     737   // deadend trap
 contest7     867?
-contest8    1245
+contest8    1245   // tricky
 contest9    3042?
-contest10   2076
-flood1       569
+contest10   2076   // * on lambda, must move * first
+flood1       569   // too slow, because of 1-left danger lambda 
 flood2       280?
-flood3       802
-flood4       970
+flood3       802   // too slow, drown
+flood4       970   // incorrect order of digging
 flood5       561?
-trampoline1  291
+trampoline1  291   // * on trampoline. must move * first
 trampoline2 1728?
-trampoline3  698
+trampoline3  698   // * on trampoline target. must move * first.
 beard1       856?
-beard2      2792
-beard3       811
-beard4       677
+beard2      2792   // hutsu-ni muzui
+beard3       811   // tricky. must hurry to cut hige.
+beard4       677   // deadend trap

Index: src/cui_auto_main.d
==================================================================
--- src/cui_auto_main.d
+++ src/cui_auto_main.d
@@ -16,10 +16,12 @@
 }
 
 void main(string[] args)
 {
 	Driver d = new Driver(stdin);
-	d.addObserver!(GuardedOutput)();
-	auto c = d.addObserver!(CUI!MainSolver)();
+//	d.addObserver!(GuardedOutput)();
+	d.addObserver!(StdOutput)();
+//	auto c = d.addObserver!(CUI!MainSolver)();
+	auto c = d.addObserver!(CUI!Solver_0)();
 	while(!c.fin)
 		d.command(c.solver.single_step());
 }

Index: src/game.d
==================================================================
--- src/game.d
+++ src/game.d
@@ -235,11 +235,11 @@
 		for(int x=1; x<=W; ++x)
 			if(this[y,x] == 'L' || this[y,x] == 'O')
 				return false;
 		return true;
 	}
-	
+
 	Tuple!(int,bool) command(char c, int turn)
 	{
 		assert( this[robot] == 'R' );
 		if(c=='R') return move( 0, +1, turn);
 		if(c=='L') return move( 0, -1, turn);
@@ -348,11 +348,11 @@
 		return dead;
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-
+/*
 class Game
 {
 	mixin DeriveShow;
 
 	static Game load(File input)
@@ -442,5 +442,378 @@
 		int water_until_rise() { return water.until_rise(turn); }
 		int hige_until_rise() { return map.hige.until_rise(turn); }
 		int hp() { return map.waterproof - under_water; }
 	}
 }
+*/
+
+////////////////////////////////////////////////////////////////////////////////
+
+class Game
+{
+public:
+	this(File input)
+	{
+		// Read map data
+		string[] map_data_lines;
+		for(string line; !(line=input.readln().chomp()).empty; )
+			map_data_lines ~= line;
+
+		// H*W
+		H_ = map_data_lines.length;
+		W_ = 0;
+		foreach(mdl; map_data_lines)
+			W_ = max(W_, mdl.length);
+
+		// Copy to modifiable buffer and adjust coordinates.
+		raw_data_ = new char[][H_+1];
+		foreach(i,mdl; map_data_lines) {
+			char[] buf = new char[mdl.length+1];
+			buf[0] = '#';
+			buf[1..$] = mdl[];
+			raw_data_[H_-i] = buf;
+		}
+
+		// Detect objects
+		for(int y=1; y<=H_; ++y)
+		for(int x=1; x<raw_data_[y].length; ++x)
+		{
+			char c = raw_data_[y][x];
+			switch(c)
+			{
+			case '#':
+			case '.':
+			case ' ':
+				break;
+			case 'L':
+			case 'O':
+				lift_pos_ = new Pos(y,x);
+				break;
+			case 'A': .. case 'I':
+			case '1': .. case '9':
+				trampoline_pos_[c] = new Pos(y,x);
+				break;
+			case '!':
+				razor_pos_ ~= new Pos(y,x);
+				break;
+			case '\\':
+				lambda_pos_ ~= new Pos(y,x);
+				break;
+
+			// Moving objects are erased from raw_data_
+			case 'R':
+				robot_pos_ = new Pos(y,x);
+				raw_data_[y][x] = ' ';
+				break;
+			case '*':
+			case 'W':
+				dynamic_objects_[new Pos(y,x)] = c;
+				raw_data_[y][x] = ' ';
+				if(c=='*')
+					may_update_[new Pos(y,x)] = true;
+				break;
+			default:
+				assert(false);
+			}
+		}
+
+		// Read other parameters
+		for(string line; !(line=input.readln()).empty; )
+		{
+			string[] ss = line.split();
+			if( ss.length == 2 )
+				switch(ss[0])
+				{
+				case "Water":      water_base_ = ss[1].to!int(); break;
+				case "Flooding":   water_pace_ = ss[1].to!int(); break;
+				case "Waterproof": max_air_    = ss[1].to!int(); break;
+				case "Growth":     hige_pace_  = ss[1].to!int(); break;
+				case "Razors":     num_razor_  = ss[1].to!int(); break;
+				default: assert(false);
+				}
+			if( ss.length == 4 && ss[0]=="Trampoline" && ss[2]=="targets" )
+			{
+				char fr=ss[1][0], to=ss[3][0];
+				trampoline_[fr] = to;
+				if(to !in trampoline_rev_) trampoline_rev_[to] = [];
+				trampoline_rev_[to] ~= fr;
+			}
+		}
+
+		air_left_ = max_air_;
+	}
+
+	@property const {
+		int H() { return H_; }
+		int W() { return W_; }
+		char trampoline(char c) { return (c in trampoline_ ? trampoline_[c] : 0); }
+		int water_level() {
+			return water_pace_ ? water_base_ + turn_/water_pace_ : water_base_;
+		}
+		int water_until_rise() {
+			return water_pace_ ? water_pace_ - turn_%water_pace_ : int.max;
+		}
+		int hige_until_rise() {
+			return hige_pace_ ? hige_pace_ - turn_%hige_pace_ : int.max;
+		}
+		bool is_hige_turn() {
+			return hige_pace_ ? turn_%hige_pace_ == hige_pace_-1 : false;
+		}
+		int hp() { return air_left_; }
+		int num_razor() { return num_razor_; }
+		bool cleared() { return cleared_; }
+		bool dead() { return dead_; }
+		long score() { return num_lambda_*(dead_ ? 25L : cleared_ ? 75L : 50L) - turn_; }
+	}
+	const {
+		char opIndex(in Pos p) { return opIndex(p.y, p.x); }
+		char opIndex(int y, int x) { return map_get(y, x); }
+	}
+
+public:
+	void command(char c)
+	{
+		if(dead || cleared)
+			return;
+
+		if(c == 'U') command_move(+1, 0);
+		if(c == 'D') command_move(-1, 0);
+		if(c == 'L') command_move(0, -1);
+		if(c == 'R') command_move(0, +1);
+		if(c == 'S') use_razor();
+		if(c == 'W') {}
+
+		if(cleared)
+			return;
+
+		map_update();
+		water_update();
+		turn_ ++;
+	}
+
+	void command_move(int dy, int dx)
+	{
+		int y = robot_pos_.y, x = robot_pos_.x;
+		char c = this[y+dy, x+dx];
+		Pos p = new Pos(y+dy, x+dx);
+
+		switch(c){
+		case 'O':
+			cleared_ = true;
+			move_robot_to(p);
+			break;
+		case '\\':
+			take_lambda_at(p);
+			move_robot_to(p);
+			break;
+		case '!':
+			take_razor_at(p);
+			move_robot_to(p);
+			break;
+		case 'A': .. case 'I':
+			enter_trampoline_at(p, c);
+			break;
+		case ' ':
+		case '.':
+			move_robot_to(p);
+			break;
+		case '*':
+			if(dy!=0 || this[y,x+dx*2]!=' ')
+				break;
+			move_robot_to(p);
+			push_rock(p, new Pos(y,x+dx*2));
+			break;
+		default:
+			break;
+		}
+	}
+
+	void use_razor()
+	{
+		if(num_razor_ == 0)
+			return;
+		num_razor_ --;
+
+		for(int dy=-1; dy<=+1; ++dy)
+		for(int dx=-1; dx<=+1; ++dx) if(dy||dx)
+		{
+			Pos p = new Pos(robot_pos_.y+dy, robot_pos_.x+dx);
+			if(auto it = p in dynamic_objects_)
+				if(*it == 'W') {
+					something_gone(p);
+					dynamic_objects_.remove(p);
+				}
+		}
+	}
+
+	void take_lambda_at(Pos p)
+	{
+		map_set_empty(p);
+		num_lambda_ ++;
+		lambda_pos_ = lambda_pos_.erase(p);
+	}
+
+	void take_razor_at(Pos p)
+	{
+		map_set_empty(p);
+		num_razor_ ++;
+		razor_pos_ = razor_pos_.erase(p);
+	}
+
+	void enter_trampoline_at(Pos p, char c)
+	{
+		char d = trampoline(c);
+		foreach(cc; trampoline_rev_[d]) {
+			Pos pp = trampoline_pos_[cc];
+			something_gone(pp);
+			map_set_empty(pp);
+		}
+		move_robot_to(trampoline_pos_[d]);
+	}
+
+	void move_robot_to(Pos p)
+	{
+		something_gone(robot_pos_);
+		map_set_empty(p.y, p.x);
+		robot_pos_ = p;
+	}
+
+	void push_rock(Pos fr, Pos to)
+	{
+		dynamic_objects_.remove(fr);
+		dynamic_objects_[to] = '*';
+		may_update_[to] = true;
+	}
+
+	void something_gone(Pos p)
+	{
+		for(int dy=0;  dy<=+1; ++dy)
+		for(int dx=-1; dx<=+1; ++dx) if(dy||dx)
+			may_update_[new Pos(p.y+dy,p.x+dx)] = true;
+	}
+
+	void map_update()
+	{
+		Pos[] may_update_list;
+		foreach(p,_; may_update_)
+			if(this[p] == '*')
+				may_update_list ~= p;
+		may_update_ = null;
+
+		if( is_hige_turn() )
+			foreach(p,c; dynamic_objects_)
+				if(c == 'W')
+					may_update_list ~= p;
+
+		sort(may_update_list);
+		char[Pos] to_be_written;
+		foreach(p; may_update_list)
+			if(is_hige_turn() && this[p]=='W')
+			{
+				for(int dy=-1; dy<=+1; ++dy)
+				for(int dx=-1; dx<=+1; ++dx) {
+					Pos q = new Pos(p.y+dy,p.x+dx);
+					if( this[q] == ' ' )
+						to_be_written[q] = 'W';
+				}
+			}
+			else
+			{
+				int y = p.y;
+				int x = p.x;
+				char below = this[y-1,x];
+				// *
+				// _
+				if(below==' ') {
+					Pos q = new Pos(y-1,x);
+					to_be_written[p] = ' ';
+					to_be_written[q] = '*';
+					may_update_[q] = true;
+				}
+				// *_      *_
+				// *_  or  \_
+				else if((below=='*'||below=='\\')&&this[y-1,x+1]==' '&&this[y,x+1]==' ') {
+					Pos q = new Pos(y-1,x+1);
+					to_be_written[p] = ' ';
+					to_be_written[q] = '*';
+					may_update_[q] = true;
+				}
+				// _*
+				// _*
+				else if(below=='*'&&this[y-1,x-1]==' '&&this[y,x-1]==' ') {
+					Pos q = new Pos(y-1,x-1);
+					to_be_written[p] = ' ';
+					to_be_written[q] = '*';
+					may_update_[q] = true;
+				}
+			}
+
+		foreach(p,c; to_be_written) {
+			dynamic_objects_[p] = c;
+			if(c=='*' && p.y==robot_pos_.y+1 && p.x==robot_pos_.x)
+				dead_ = true;
+		}
+
+		if(lambda_pos_.empty)
+			raw_data_[lift_pos_.y][lift_pos_.x] = 'O';
+	}
+
+	void water_update()
+	{
+		if( robot_pos_.y <= water_level() )
+			air_left_ --;
+		else
+			air_left_ = max_air_;
+		if( air_left_ < 0 )
+			dead_ = true;
+	}
+
+private:
+	char map_get(int y, int x) const
+	{
+		if( y<1 || H<y || x<1 || W<x ) return '#';
+		Pos p = new Pos(y,x);
+		if(p == robot_pos_)
+			return 'R';
+		if(auto it = (p in dynamic_objects_))
+			return *it;
+		if( x<0 || raw_data_[y].length<=x ) return ' ';
+		return raw_data_[y][x];
+	}
+
+	void map_set_empty(in Pos p)
+	{
+		return map_set_empty(p.y, p.x);
+	}
+
+	void map_set_empty(int y, int x)
+	{
+		if( y<1 || H<y || x<1 || W<x ) return;
+		if( x<0 || raw_data_[y].length<=x ) return;
+		raw_data_[y][x] = ' ';
+	}
+
+private:
+	int          H_;
+	int          W_;
+	char[][]     raw_data_;
+	Pos[char]    trampoline_pos_;
+	Pos[]        razor_pos_;
+	Pos[]        lambda_pos_;
+	Pos          lift_pos_;
+	Pos          robot_pos_;
+	char[Pos]    dynamic_objects_;
+	char[char]   trampoline_;
+	char[][char] trampoline_rev_;
+	int          water_base_ = 0;
+	int          water_pace_ = 0;
+	int          max_air_    = 10;
+	int          hige_pace_  = 25;
+	int          num_razor_  = 0;
+	int          num_lambda_ = 0;
+
+	int turn_     = 0;
+	int air_left_ = 0;
+	bool cleared_ = false;
+	bool dead_    = false;
+	bool[Pos] may_update_;
+}

Index: src/gui.d
==================================================================
--- src/gui.d
+++ src/gui.d
@@ -6,11 +6,11 @@
 class GUI(Solver) : Form, GameObserver
 {
 	this(in Game g)
 	{
 		this.solver = new Solver(g);
-		setup_size(g.map.W, g.map.H);
+		setup_size(g.W, g.H);
 		setup_resources(g);
 		draw(g);
 	}
 
 	private void delegate(char c) fn;
@@ -81,14 +81,11 @@
 		this.render['d'] = "☠";
 		this.render['L'] = "☒";
 		this.render['O'] = "☐";
 		this.render['W'] = "ꔣ";
 		this.render['!'] = "✄";
-		foreach(c,tp; g.map.tr_target) {
-			char d = g.map[tp];
-			this.render[c] = [cast(dchar)('☢'+d-'1')].to!string();
-		}
+		foreach(char c; 'A'..'J') this.render[c] = [cast(dchar)('☢'+g.trampoline(c)-'1')].to!string();
 		foreach(char c; '1'..':') this.render[c] = [cast(dchar)('☢'+c-'1')].to!string();
 		this.paint ~= (Control c, PaintEventArgs ev) {
 			graphicContext.copyTo(ev.graphics, Rect(0,0,this.clientSize.width,this.clientSize.height));
 		};
 	}
@@ -104,14 +101,14 @@
 		// Fill water.
 		int w = g.water_level();
 		graphicContext.fillRectangle(this.colors['w'], Rect(0, scrH-cell*w-1, scrW, cell*w+1));
 
 		// Paint map.
-		for(int y=1; y<=g.map.H; ++y)
-		for(int x=1; x<=g.map.W; ++x) {
+		for(int y=1; y<=g.H; ++y)
+		for(int x=1; x<=g.W; ++x) {
 			Rect r = Rect(cell*(x-1), scrH-cell*y, cell, cell);
-			char c = g.map[y,x];
+			char c = g[y,x];
 			if( c != ' ' ) {
 				if( c == 'R' && g.dead )
 					c = 'd';
 				graphicContext.drawText(this.render[c], font, this.colors[c], r);
 			}
@@ -121,11 +118,11 @@
 		this.text = .text(
 			"Score: ", g.score,
 			" Air: ", g.hp,
 			" Tide: ", g.water_until_rise,
 			" Wadler: ", g.hige_until_rise,
-			" Razor: ", g.map.razor);
+			" Razor: ", g.num_razor);
 		invalidate();
 	}
 
 private:
 	void setup_keyhandling()

Index: src/gui_main.d
==================================================================
--- src/gui_main.d
+++ src/gui_main.d
@@ -6,10 +6,12 @@
 pragma(lib, "dfl.lib");
 
 void main(string[] args)
 {
 	Driver d = new Driver(stdin);
-	d.addObserver!(GuardedOutput)();
-	auto g = d.addObserver!(GUI!MainSolver)();
+//	d.addObserver!(GuardedOutput)();
+	d.addObserver!(StdOutput)();
+//	auto g = d.addObserver!(GUI!MainSolver)();
+	auto g = d.addObserver!(GUI!Solver_0)();
 	g.set_fn(&d.command);
 	g.run();
 }

Index: src/output.d
==================================================================
--- src/output.d
+++ src/output.d
@@ -16,11 +16,11 @@
 	{
 		stdout.write(c);
 		stdout.flush();
 	}
 }
-
+/*
 class GuardedOutput : GameObserver
 {
 	this(in Game g)
 	{
 		setup_sigint_handling();
@@ -70,5 +70,6 @@
 		g_output = this;
 		extern(C) static void catch_sigint(int) { g_output.flush(); application_exit(); }
 		core.stdc.signal.signal(SIGINT, &catch_sigint);
 	}
 }
+*/

Index: src/solver.d
==================================================================
--- src/solver.d
+++ src/solver.d
@@ -5,11 +5,11 @@
 {
 	this(in Game g) {}
 	char single_step() { return 'W'; }
 	void force(char c) {}
 }
-
+/*
 class Solver_1
 {
 	int wait_count = 0;
 	int choke_count = 0;
 
@@ -385,7 +385,8 @@
 		else
 			plan = plan[1..$];
 	}
 }
 
-alias Solver_2!(Solver_1) MainSolver;
-//alias Solver_1 MainSolver;
+//alias Solver_2!(Solver_1) MainSolver;
+alias Solver_1 MainSolver;
+*/

Index: src/util.d
==================================================================
--- src/util.d
+++ src/util.d
@@ -5,10 +5,18 @@
 public import std.stdio;
 public import std.string;
 public import std.typecons;
 public import std.math;
 import std.c.stdlib;
+
+T[] erase(T,V)(T[] xs, V y)
+{
+	foreach(i,x; xs)
+		if(x == y)
+			return xs[0..i]~xs[i+1..$];
+	return xs;
+}
 
 // To avoide the following ICE:
 //   src\phobos\std\algorithm.d(4552):
 //     Error: function std.algorithm.count!("a == b",string,char).count
 //     compiler error, parameter 'value', bugzilla 2962?