@@ -236,9 +236,9 @@
 			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);
@@ -349,9 +349,9 @@
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-/*
+
 class Game
 {
 	mixin DeriveShow;
 
@@ -443,440 +443,4 @@
 		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); }
-		const(Pos)[] trampoline_rev(char c) {
-			const(Pos)[] pp;
-			if(c in trampoline_rev_) {
-				foreach(ch; trampoline_rev_[c])
-					pp ~= trampoline_pos_[ch];
-			}
-			return pp;
-		}
-		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(Pos) robot() { return robot_pos_; }
-		const(Pos) lift() { return lift_pos_; }
-		Pos[] lambdas() {
-			Pos[] pp;
-			foreach(p; lambda_pos_)
-				pp ~= p.clone();
-			return pp;
-		}
-		Pos[] razors() {
-			Pos[] pp;
-			foreach(p; razor_pos_)
-				pp ~= p.clone();
-			return pp;
-		}
-		const(Pos)[] higes() {
-			const(Pos)[] pp;
-			foreach(p,c; dynamic_objects_)
-				if(c=='W')
-					pp ~= p;
-			return pp;
-		}
-	}
-	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)
-		{
-			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] = ' ';
-	}
-
-public:
-	Game clone() const { return new Game(this); }
-	this(in Game g) {
-		H_ = g.H_;
-		W_ = g.W_;
-		raw_data_ = new char[][g.raw_data_.length];
-		foreach(i,d; g.raw_data_) raw_data_[i] = d.dup;
-		trampoline_pos_ = cast(Pos[char]) g.trampoline_pos_;
-		razor_pos_  = (cast(Game)g).razor_pos_.dup;
-		lambda_pos_ = (cast(Game)g).lambda_pos_.dup;
-		lift_pos_   = g.lift_pos_.clone();
-		robot_pos_  = g.robot_pos_.clone();
-		dynamic_objects_ = dup(g.dynamic_objects_);
-		trampoline_     = (cast(Game)g).trampoline_;
-		trampoline_rev_ = (cast(Game)g).trampoline_rev_;
-		water_base_ = g.water_base_;
-		water_pace_ = g.water_pace_;
-		max_air_    = g.max_air_;
-		hige_pace_  = g.hige_pace_;
-		num_razor_  = g.num_razor_;
-		num_lambda_ = g.num_lambda_;
-		turn_       = g.turn_;
-		air_left_   = g.air_left_;
-		cleared_    = g.cleared_;
-		dead_       = g.dead_;
-		may_update_ = dup(g.may_update_);
-	}
-
-	V[K] dup(V,K)(in V[K] aa) {
-		V[K] aa2;
-		foreach(k,v; aa) aa2[k] = v;
-		return aa2;
-	}
-
-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_;
-}