Kevin Shepherd's solution:

#include <iostream>
#include <map>
#include <set>
#include <fstream>
#include <string>
#include <list>
#include <unistd.h>
#include <dirent.h>

#define MAX_CELL_DIM 0xFF
#define MAX_TARGET_COUNT 123
#define MAX_X_DIM	2048
#define MAX_Y_DIM	2048

#define POS_X_MASK	0x001FFFFF
#define POS_X_BITS	0x7FF
#define POS_X_ROLL	21

#define POS_Y_MASK	0xFFE003FF
#define POS_Y_BITS	0x7FF
#define POS_Y_ROLL	10

#define VEL_X_MASK	0xFFFFFC1F
#define VEL_X_BITS	0xF
#define VEL_X_SIGN	0x200
#define VEL_X_ROLL	5

#define VEL_Y_MASK	0xFFFFFFE0
#define VEL_Y_BITS	0xF
#define VEL_Y_SIGN	0x10
#define VEL_Y_ROLL	0

#define VEL_MASK 0x000001EF

#define CELL_CLEAR	0
#define CELL_WALL	1
#define CELL_UNREACHABLE	2
#define CELL_START	3
#define CELL_TARGET	4

/*
random.txt
Cells: 100x75
Open Cell Count: 3418
Map size: 1000x750
Target count 1

big.txt
Cells: 173x173
Open Cell Count: 14854
Map size: 1730x1730
Target count 1

random2.txt
Cells: 100x75
Open Cell Count: 3418
Map size: 1000x750
Target count 25

big2.txt
Cells: 173x173
Open Cell Count: 14854
Map size: 1730x1730
Target count 38

*/

bool _opt_fuel = false;

struct CellCoord
	{
	unsigned char	x, y;
	bool operator<(const CellCoord & __other)	const
		{
		return (x < __other.x?true:(x > __other.x?false:y < __other.y));
		}
	bool operator==(const CellCoord & __other)	const
		{
		return (x == __other.x && y == __other.y);
		}
	};

class State
	{
public:
	State()
	:packed(0)
		{}
	State(const State & __other)
	:packed(__other.packed)
		{}
	State & operator=(const State & __other)
		{
		packed = __other.packed;
		}


	bool operator<(const State & __other)	const
		{
		return packed<__other.packed;
 		}
	bool operator==(const State & __other)	const
		{
		return (packed == __other.packed);
		}
	void	set_packed(unsigned long __packed)
		{
		packed = __packed;
		}
	short get_x() const
		{
		return (short)((packed >> POS_X_ROLL) & POS_X_BITS);
		}
	void set_x(short __x)
		{
		packed &= POS_X_MASK;
		packed |= ((unsigned long)__x << POS_X_ROLL);
		}
	short get_y() const
		{
		return (short)((packed >> POS_Y_ROLL) & POS_Y_BITS);
		}
	void set_y(short __y)
		{
		packed &= POS_Y_MASK;
		packed |= ((unsigned long)__y << POS_Y_ROLL);
		}
	short get_vel_x() const
		{
		return (packed & VEL_X_SIGN)?-(short)((packed >> VEL_X_ROLL) & VEL_X_BITS):+(short)((packed >> VEL_X_ROLL) & VEL_X_BITS);
		}
	void set_vel_x(short __vx)
		{
		packed &= VEL_X_MASK;
		if (__vx < 0)
			{
			packed |= VEL_X_SIGN;
			__vx = - __vx;
			}
		if (__vx > 10)
			__vx = 10;
		packed |= ((unsigned long)__vx << VEL_X_ROLL);
		}
	short get_vel_y() const
		{
		return (packed & VEL_Y_SIGN)?-(short)((packed >> VEL_Y_ROLL) & VEL_Y_BITS):+(short)((packed >> VEL_Y_ROLL) & VEL_Y_BITS);
		}
	void set_vel_y(short __vy)
		{
		packed &= VEL_Y_MASK;
		if (__vy < 0)
			{
			packed |= VEL_Y_SIGN;
			__vy = - __vy;
			}
		if (__vy > 10)
			__vy = 10;
		packed |= ((unsigned long)__vy << VEL_Y_ROLL);
		}
	bool has_vel() const
		{
		return ((packed & VEL_MASK) != 0);
		}

	unsigned long	packed;
	};

struct Active
	{
	State	st;
	unsigned short primary, secondary;
	std::string	path;
	Active()
		{}
	Active(const Active & __other)
	:st(__other.st), primary(__other.primary), secondary(__other.secondary), path(__other.path)
		{}
	Active & operator=(const Active & __other)
		{
		st = __other.st;
		primary = __other.primary;
		secondary = __other.secondary;
		path = __other.path;
		}
	};

typedef std::list<Active>	ActiveList;
typedef std::map<unsigned long, ActiveList::iterator>	NewState;

unsigned long * state_array;
ActiveList	current_states;
NewState	new_states;
unsigned char cell_map[MAX_CELL_DIM+1][MAX_CELL_DIM+1];
unsigned short cell_number[MAX_CELL_DIM+1][MAX_CELL_DIM+1];
unsigned long _cell_width = 0, _cell_height = 0;
unsigned long _pixel_width = 0, _pixel_height = 0;
unsigned long state_count = 0;
unsigned long _solution_count = 0;
unsigned short _min_primary = 0, _min_secondary = 0;

inline unsigned long compress(State _st)
	{
	unsigned long x = (unsigned long)_st.get_x();
	unsigned long y = (unsigned long)_st.get_y();

	return (cell_number[x/10][y/10] * 44100)+((x % 10) * 4410)+((y % 10) * 441)+((_st.get_vel_x() + 10) * 21)+(_st.get_vel_y() + 10);
	}

inline bool is_set_state(unsigned long _compressed)
	{
	return ( state_array[_compressed >> 5] & (1 << (_compressed & 0x1F) ) ) != 0;
	}

inline void set_state(unsigned long _compressed)
	{
	state_array[_compressed >> 5] |= (1 << (_compressed & 0x1F) );
	}

bool set_state_if(unsigned long _compressed)
	{
	bool _new_set = false;
	unsigned long _offset = _compressed >> 5;
	unsigned long _value = 1 << (_compressed & 0x1F);
	if ( ( state_array[_offset] & _value ) == 0)
		{
		state_array[_offset] |= _value;
		_new_set = true;
		}
	return _new_set;
	}

void transition (unsigned char __impulse, unsigned char __primary_delta, unsigned char __secondary_delta, const Active & __from);
void add_trans(const Active & _to);
unsigned long report(const ActiveList & current_states, ActiveList::const_iterator __start, unsigned long _iter);
void check_cells(unsigned char x, unsigned char y);

int main(int _argc, char * _argv[])
	{
	time_t _start_time = time(0);
	if (_argc < 2 )
		{
		std::cerr << "Usage: " << _argv[0] << " [--fuel] <map-name>" << std::endl;
		return 1;
		}
	std::string _map_name, _prefix_name;
	if (!strcmp(_argv[1], "--fuel"))
		{
		_opt_fuel = true;
		if (_argc < 3 )
			{
			std::cerr << "Usage: " << _argv[0] << " [--fuel] <map-name>" << std::endl;
			return 1;
			}
		_map_name.assign(_argv[2]);
		_prefix_name.assign(_map_name);
		_prefix_name.append("-fuel");
		}
	else
		{
		_map_name.assign(_argv[1]);
		_prefix_name.assign(_map_name);
		_prefix_name.append("-step");
		}
	_map_name.append(".txt");
	if (access(_map_name.c_str(), R_OK))
		{
		std::cerr << "Could not open file: " << _map_name << std::endl;
		std::cerr << "Usage: " << _argv[0] << " [--fuel] <map-name>" << std::endl;
		return 1;
		}
	std::ifstream _in(_map_name.c_str());
	_in >> _cell_width;
	_in >> _cell_height;
	std::cout << "Cells: " << _cell_width << "x" << _cell_height << std::endl;
	if (_cell_width == 0 || _cell_width > MAX_CELL_DIM ||
		_cell_height == 0 || _cell_height > MAX_CELL_DIM)
		{
		std::cerr << "Wrong cell dimensions 0 < cell < " << MAX_CELL_DIM << std::endl;
		return 1;
		}
	bool _has_input = false;
	{
	DIR * _fdir = opendir(".");
	if (_fdir)
		{
		struct dirent _entry, * _result;
		while (!readdir_r(_fdir, & _entry, & _result))
			{
			int _len = strlen(_entry.d_name);
			if (_len > _prefix_name.size() && !strncmp( _entry.d_name, _prefix_name.c_str(), _prefix_name.size()))
				{
				_has_input = true;
				_prefix_name.assign(_entry.d_name);
				break;
				}
			}
		closedir(_fdir);
		}
	}

	unsigned long _target_count = 0, _active_targets = 0;
	Active _initial_state;
	_initial_state.primary = 0;
	_initial_state.secondary = 0;
	CellCoord	_cell_pos;
	_cell_pos.y = 0;
	memset(cell_map, CELL_CLEAR, sizeof(unsigned char [MAX_CELL_DIM+1][MAX_CELL_DIM+1]));
	memset(cell_number, 0, sizeof(unsigned short [MAX_CELL_DIM+1][MAX_CELL_DIM+1]));
	while (_in.good() && _cell_pos.y < _cell_height)
		{
		std::string _line;
		std::getline(_in, _line);
		if (_line.size() >= _cell_width)
			{
			for (_cell_pos.x = 0; _cell_pos.x < _cell_width; ++ _cell_pos.x)
				{
				switch (_line[_cell_pos.x])
					{
				case '#':
					cell_map[_cell_pos.x][_cell_pos.y] = CELL_WALL;
					break;
				case 'O':
					cell_map[_cell_pos.x][_cell_pos.y] = CELL_START;
					_initial_state.st.set_x(_cell_pos.x * 10);
					_initial_state.st.set_y(_cell_pos.y * 10);
					break;
				case '+':
					{
					bool _is_active = true;
					if (_has_input)
						{
						char _buf[4];
						sprintf(_buf, "-%02d", _target_count);
						if (_prefix_name.find(_buf) != std::string::npos)
							_is_active = false;
						}
					if (_is_active)
						{
						cell_map[_cell_pos.x][_cell_pos.y] = (unsigned char)(_target_count + CELL_TARGET) | 0x80;
						++ _active_targets;
						}
					else
						{
						cell_map[_cell_pos.x][_cell_pos.y] = CELL_CLEAR | 0x80;
						}
					++ _target_count;
					}
					break;
				case ' ':
				default:
					cell_map[_cell_pos.x][_cell_pos.y] = CELL_CLEAR | 0x80;
					break;
					}
				}
			++ _cell_pos.y;
			}
		}
	bool _is_final = false;
	if (!_active_targets)
		{
		cell_map[_initial_state.st.get_x() / 10][_initial_state.st.get_y() / 10] = (unsigned char)(_target_count + CELL_TARGET) | 0x80;
		++ _active_targets;
		++ _target_count;
		_is_final = true;
		}
	_pixel_width = _cell_width * 10;
	_pixel_height = _cell_height * 10;
	std::cerr << "Map size: " << _pixel_width << "x" << _pixel_height << std::endl;
	std::cout << "Active Target count " << _active_targets << std::endl;

// Find unreachable cells
	_cell_pos.x = _initial_state.st.get_x() / 10;
	_cell_pos.y = _initial_state.st.get_y() / 10;
	check_cells(_cell_pos.x, _cell_pos.y);
	unsigned short _open_cell_count = 0;
	for (_cell_pos.y = 0; _cell_pos.y < _cell_height; ++ _cell_pos.y)
		{
		for (_cell_pos.x = 0; _cell_pos.x < _cell_width; ++ _cell_pos.x)
			{
			if ( (cell_map[_cell_pos.x][_cell_pos.y] & 0x80) != 0)
				{
				if (cell_map[_cell_pos.x][_cell_pos.y] == 0x80)
					{
					cell_map[_cell_pos.x][_cell_pos.y] = CELL_UNREACHABLE;
					}
				else
					{
					std::cerr << "Unreachable target(s)" << std::endl;
					return 1;
					}
				}
			if (cell_map[_cell_pos.x][_cell_pos.y] != CELL_WALL && cell_map[_cell_pos.x][_cell_pos.y] != CELL_UNREACHABLE)
				{
				cell_number[_cell_pos.x][_cell_pos.y] = _open_cell_count;
				++ _open_cell_count;
				}
			}
		}

	std::cout << "Open Cell Count: " << _open_cell_count << std::endl;
	if (_pixel_width > MAX_X_DIM || _pixel_height > MAX_Y_DIM)
		{
		std::cerr << "Map too large " << _pixel_width << "x" << _pixel_height << " > " << MAX_X_DIM << "x" << MAX_Y_DIM << std::endl;
		return 1;
		}
	_pixel_width -= 9;
	_pixel_height -= 9;
	if (_target_count > MAX_TARGET_COUNT)
		{
		std::cerr << "Too many targets " << _target_count << " > " << MAX_TARGET_COUNT << std::endl;
		return 1;
		}
	unsigned long _state_array_size = 1379 * _open_cell_count;
	state_array = new unsigned long[_state_array_size];
	if (! state_array)
		{
		std::cerr << "Insufficient memory for state array unsigned long[" << _state_array_size << "]" << std::endl;
		return 1;
		}
	memset(state_array, 0, sizeof(unsigned long) * _state_array_size);

	ActiveList initial_states;
	if (_has_input)
		{
		std::ifstream _input(_prefix_name.c_str());
		unsigned long _in_count = 0;
		for (;;)
			{
			Active _from;
			short _value;
			_input >> _from.primary;
			_input >> _from.secondary;
			_input >> _value;
			_from.st.set_x(_value);
			_input >> _value;
			_from.st.set_y(_value);
			_input >> _value;
			_from.st.set_vel_x(_value);
			_input >> _value;
			_from.st.set_vel_y(_value);
			_input >> _from.path;
			if (!_input.good())
				break;
			initial_states.push_front(_from);
			++ _in_count;
			}
		std::cout << "Input " << _in_count << " Active states" << std::endl;
		}
	else
		{
		initial_states.push_back(_initial_state);
		}
	short _iter = initial_states.front().primary;
	-- _iter;

	current_states.push_back(Active());
	ActiveList::iterator _target_end = current_states.end();
	-- _target_end;
	
	if (_opt_fuel)
		{
		current_states.push_back(Active());
		ActiveList::iterator _end_2 = current_states.end();
		-- _end_2;

		current_states.push_back(Active());
		ActiveList::iterator _end_1 = current_states.end();
		-- _end_1;

		do
			{
			if (!initial_states.empty())
				{
				ActiveList::iterator _ix = initial_states.begin();
				for (ActiveList::iterator _iy = initial_states.end(); _ix != _iy; )
					{
					if ( (* _ix).primary > _iter + 1 )
						{
						break;
						}
					add_trans(* _ix);
					++ _ix;
					}
				initial_states.erase(initial_states.begin(), _ix);
				}
			ActiveList::iterator _start = _target_end;
			++ _start;
			ActiveList::iterator _ax = _start;
			for (; _ax != _end_2; ++ _ax)
				{
				transition(3, 2, 1, * _ax);
				transition(6, 2, 1, * _ax);
				}
			current_states.erase(_start, ++ _end_2);
			_ax = _target_end;
			for (++ _ax; _ax != _end_1; ++ _ax)
				{
				transition(1, 1, 1, * _ax);
				transition(2, 1, 1, * _ax);
				transition(4, 1, 1, * _ax);
				}
			_ax = _end_1;
			for (++ _ax; _ax != current_states.end(); ++ _ax)
				{
				transition(0, 0, 1, * _ax);
				}

			_end_2 = _end_1;
			current_states.push_back(Active());
			_end_1 = current_states.end();
			-- _end_1;

			for (NewState::const_iterator _nx = new_states.begin(), _ny = new_states.end(); _nx != _ny; ++ _nx)
				{
				set_state( (* _nx).first );
				}
			new_states.clear();
			++ _iter;
			std::cout << '.';
			}
		while ( (report(current_states, _target_end, _iter) > 2 || !initial_states.empty()) && (!_is_final || (current_states.begin() == _target_end)));
		}
	else
		{ // steps
		do
			{
			current_states.push_back(Active());
			ActiveList::iterator _partition = current_states.end();
			-- _partition;

			if (!initial_states.empty())
				{
				ActiveList::iterator _ix = initial_states.begin();
				for (ActiveList::iterator _iy = initial_states.end(); _ix != _iy; )
					{
					if ( (* _ix).primary > _iter + 1 )
						{
						break;
						}
					add_trans(* _ix);
					++ _ix;
					}
				initial_states.erase(initial_states.begin(), _ix);
				}

			ActiveList::iterator _start = _target_end;
			++ _start;
			for (ActiveList::iterator _ax = _start; _ax != _partition; ++ _ax)
				{
				transition(0, 1, 0, * _ax);
				transition(1, 1, 1, * _ax);
				transition(2, 1, 1, * _ax);
				transition(4, 1, 1, * _ax);
				transition(3, 1, 2, * _ax);
				transition(6, 1, 2, * _ax);
				}
			current_states.erase(_start, ++ _partition);

			for (NewState::const_iterator _nx = new_states.begin(), _ny = new_states.end(); _nx != _ny; ++ _nx)
				{
				set_state( (* _nx).first );
				}
			new_states.clear();
			++ _iter;
			std::cout << '.';
			}
		while ((report(current_states, _target_end, _iter) || !initial_states.empty()) && (!_is_final || (current_states.begin() == _target_end)));
		}
	delete[] state_array;
	time_t _time_taken = time(0) - _start_time;
	std::ofstream _log("marsrescue.log", std::ios_base::out | std::ios_base::app | std::ios_base::ate);
	std::cout << _solution_count << " solutions in " << _time_taken << " seconds, minimum: " << (_opt_fuel?"fuel":"steps") << " = " << _min_primary << " " << (_opt_fuel?"steps":"fuel") << " = " << _min_secondary << std::endl;
	_log << _prefix_name << ": " << _solution_count << " solutions in " << _time_taken << " seconds, minimum: " << (_opt_fuel?"fuel":"steps") << " = " << _min_primary << " " << (_opt_fuel?"steps":"fuel") << " = " << _min_secondary << std::endl;
	for (ActiveList::iterator _ax = current_states.begin(); _ax != _target_end; ++ _ax)
		{ // output targets
		if ( (* _ax).primary == _min_primary && (* _ax).secondary == _min_secondary)
			{
			std::cout << (* _ax).path << std::endl;
			_log << (* _ax).path << std::endl;
			}
		std::string _output_file;
		if (_is_final)
			_output_file.assign("final-");	
		_output_file.append(_prefix_name);
		short _hit_target = -1;
		short _new_x = (* _ax).st.get_x();
		short _new_y = (* _ax).st.get_y();
		bool _x_two_col = ((_new_x % 10) != 0);
		bool _y_two_col = ((_new_y % 10) != 0);
		CellCoord	_cell_pos;
		_cell_pos.x = _new_x / 10;
		_cell_pos.y = _new_y / 10;
		unsigned char _cell_content = cell_map[_cell_pos.x][_cell_pos.y];
		if ( _cell_content >= CELL_TARGET)
			{
			_hit_target = _cell_content - CELL_TARGET;
			}
		if (_x_two_col)
			{
			++ _cell_pos.x;
			_cell_content = cell_map[_cell_pos.x][_cell_pos.y];
			if ( _cell_content >= CELL_TARGET)
				{
				_hit_target = _cell_content - CELL_TARGET;
				}
			if (_y_two_col)
				{
				++ _cell_pos.y;
				_cell_content = cell_map[_cell_pos.x][_cell_pos.y];
				if ( _cell_content >= CELL_TARGET)
					{
					_hit_target = _cell_content - CELL_TARGET;
					}
				-- _cell_pos.y;
				}
			-- _cell_pos.x;
			}
		if (_y_two_col)
			{
			++ _cell_pos.y;
			_cell_content = cell_map[_cell_pos.x][_cell_pos.y];
			if ( _cell_content >= CELL_TARGET)
				{
				_hit_target = _cell_content - CELL_TARGET;
				}
			-- _cell_pos.y;
			}

		char _buf[4];
		sprintf(_buf, "-%02d", _hit_target);
		_output_file.append(_buf);
		std::ofstream _out(_output_file.c_str(), std::ios_base::out | std::ios_base::app | std::ios_base::ate);
		_out << (* _ax).primary << " " << (* _ax).secondary << " " << (* _ax).st.get_x() << " " << (* _ax).st.get_y() << " " << (* _ax).st.get_vel_x() << " " << (* _ax).st.get_vel_y() << " " << (* _ax).path << std::endl;
		}
	if (_has_input)
		{
		std::string _new_name("done-");
		_new_name.append(_prefix_name);
		unlink(_new_name.c_str());
		rename(_prefix_name.c_str(), _new_name.c_str());
		}
	return 0;
	}

void transition (unsigned char __impulse, unsigned char __primary_delta, unsigned char __secondary_delta, const Active & __from)
	{
	Active _to(__from);
	_to.primary += __primary_delta;
	_to.secondary += __secondary_delta;
	switch (__impulse)
		{
	case 0:
		_to.st.set_vel_y(_to.st.get_vel_y() + 1);
		break;
	case 1:
		_to.st.set_vel_x(_to.st.get_vel_x() - 2);
		_to.st.set_vel_y(_to.st.get_vel_y() + 1);
		break;
	case 2:
		_to.st.set_vel_y(_to.st.get_vel_y() - 1);
		break;
	case 3:
		_to.st.set_vel_x(_to.st.get_vel_x() - 2);
		_to.st.set_vel_y(_to.st.get_vel_y() - 1);
		break;
	case 4:
		_to.st.set_vel_x(_to.st.get_vel_x() + 2);
		_to.st.set_vel_y(_to.st.get_vel_y() + 1);
		break;
	case 6:
		_to.st.set_vel_x(_to.st.get_vel_x() + 2);
		_to.st.set_vel_y(_to.st.get_vel_y() - 1);
		break;
		}

	do
		{
		short _new_x = _to.st.get_x() + _to.st.get_vel_x();
		if (_new_x >= 0 && _new_x < _pixel_width)
			{
			short _new_y = _to.st.get_y() + _to.st.get_vel_y();
			if (_new_y >= 0 && _new_y < _pixel_height)
				{
				CellCoord	_cell_pos;
				_cell_pos.x = _new_x / 10;
				_cell_pos.y = _new_y / 10;
				if (cell_map[_cell_pos.x][_cell_pos.y] != CELL_WALL)
					{	
					bool _y_two_col = ((_new_y % 10) != 0);
					bool _collision = false;
					if ((_new_x % 10) != 0)
						{
						++ _cell_pos.x;
						if (cell_map[_cell_pos.x][_cell_pos.y] == CELL_WALL)
							_collision = true;
						else
							{	
							if (_y_two_col)
								{
								if (cell_map[_cell_pos.x][_cell_pos.y+1] == CELL_WALL)
									_collision = true;	
								}
							}
						-- _cell_pos.x;
						}
					if (_y_two_col)
						{
						++ _cell_pos.y;
						if (cell_map[_cell_pos.x][_cell_pos.y] == CELL_WALL)
							_collision = true;	
						}
					if (!_collision)
						break;
					}
				}
			}
		_to.st.set_vel_x(_to.st.get_vel_x() / 2);
		_to.st.set_vel_y(_to.st.get_vel_y() / 2);
		}
		while ( _to.st.has_vel() );

	short _new_x = _to.st.get_x() + _to.st.get_vel_x();
	short _new_y = _to.st.get_y() + _to.st.get_vel_y();
	CellCoord	_cell_pos;
	_cell_pos.x = _new_x / 10;
	_cell_pos.y = _new_y / 10;

	_to.st.set_x(_new_x);
	_to.st.set_y(_new_y);

	bool _hit_target = false;
	if ( cell_map[_cell_pos.x][_cell_pos.y] >= CELL_TARGET)
		_hit_target = true;
	else
		{
		bool _y_two_col = ((_new_y % 10) != 0);
		if ((_new_x % 10) != 0)
			{
			++ _cell_pos.x;
			if ( cell_map[_cell_pos.x][_cell_pos.y] >= CELL_TARGET)
				_hit_target = true;
			else
				{
				if (_y_two_col)
					{
					if ( cell_map[_cell_pos.x][_cell_pos.y+1] >= CELL_TARGET)
						_hit_target = true;
					}
				}
			-- _cell_pos.x;
			}
		if (_y_two_col)
			{
			++ _cell_pos.y;
			if ( cell_map[_cell_pos.x][_cell_pos.y] >= CELL_TARGET)
				_hit_target = true;
			}
		}

	unsigned long _compressed = compress(_to.st);
	if (!is_set_state(_compressed))
		{
		bool _should_add = true;

		NewState::iterator _ns = new_states.find(_compressed);
		if (_ns != new_states.end())
			{
			if ( (* ((* _ns).second) ).secondary > _to.secondary)
				{
				current_states.erase( (* _ns).second );
				-- state_count;
				}
			else
				{
				_should_add = false;
				}
			}
		if (_should_add)
			{
			char _buf[2];
			sprintf(_buf, "%d", (int)__impulse);
			_to.path.append(_buf);

			++ state_count;
			ActiveList::iterator _inserted;
			if (_hit_target)
				{
				if (_to.primary < _min_primary || (_to.primary == _min_primary && _to.secondary < _min_secondary) || !_solution_count )
					{
					_min_primary = _to.primary;
					_min_secondary = _to.secondary;
					}
				++ _solution_count; 
				current_states.push_front(_to);
				_inserted = current_states.begin();
				}
			else
				{
				current_states.push_back(_to);
				_inserted = current_states.end();
				-- _inserted;
				}
			new_states[_compressed] = _inserted;
			}
		}
	}

/*
	if (_hit_target != -1)
		{
		char _buf[2];
		sprintf(_buf, "%d", (int)__impulse);
		_to.path.append(_buf);
		unsigned long _steps = _to.path.size();
		unsigned long _fuel = 0;
		for (std::string::size_type _pos = 0; _pos < _steps; ++ _pos)
			{
			switch (_to.path[_pos])
				{
			case '3':
			case '6':
				++ _fuel;
			case '1':
			case '2':
			case '4':
				++ _fuel;
			default:
				break;
				}
			}
		// target found
		}
*/
void add_trans(const Active & _to)
	{
	unsigned long _compressed = compress(_to.st);
	if (!is_set_state(_compressed))
		{
		bool _should_add = true;

		NewState::iterator _ns = new_states.find(_compressed);
		if (_ns != new_states.end())
			{
			if ( (* ((* _ns).second) ).secondary > _to.secondary)
				{
				current_states.erase( (* _ns).second );
				-- state_count;
				}
			else
				{
				_should_add = false;
				}
			}
		if (_should_add)
			{
			++ state_count;
			ActiveList::iterator _inserted;
			current_states.push_back(_to);
			_inserted = current_states.end();
			-- _inserted;

			new_states[_compressed] = _inserted;
			}
		}
	}

unsigned long report(const ActiveList & current_states, ActiveList::const_iterator __start, unsigned long _iter)
	{ // report
	unsigned char report_map[MAX_CELL_DIM+1][MAX_CELL_DIM+1];
	memcpy(report_map, cell_map, sizeof(unsigned char [MAX_CELL_DIM+1][MAX_CELL_DIM+1]));
	unsigned long _active_count = 0;
	for (ActiveList::const_iterator _ax = ++ __start, _ay = current_states.end(); _ax != _ay; ++ _ax)
		{
		unsigned char _content = report_map[ (* _ax).st.get_x() / 10 ][ (* _ax).st.get_y() / 10 ];
		report_map[ (* _ax).st.get_x() / 10 ][ (* _ax).st.get_y() / 10 ] = 0xFF;
		++ _active_count;
		}
	std::cout << std::endl;
	for (unsigned char y = 0; y < _cell_height; ++ y)
		{
		for (unsigned char x = 0; x < _cell_width; ++ x)
			{
			unsigned char _content = report_map[ x ][ y ];
			switch (_content)
				{
			case CELL_CLEAR:
				std::cout << ' ';
				break;
			case CELL_WALL:
				std::cout << '#';
				break;
			case CELL_UNREACHABLE:
				std::cout << 'X';
				break;
			case CELL_START:
				std::cout << 'O';
				break;
			case 0xFF:
				std::cout << '*';
				break;
			default:
				std::cout << '+';
				break;
				}
			}
		std::cout << std::endl;
		}
	std::cout << "Iteration: " << _iter << " Count: " << _active_count << " State Count: " << state_count << std::endl;
	return _active_count;
	}

void check_cell(unsigned char x, unsigned char y)
	{
	if ((cell_map[x][y] & 0x80) != 0)
		{
		cell_map[x][y] &= 0x7F;
		check_cells(x, y);
		}
	}

void check_cells(unsigned char x, unsigned char y)
	{
	if (y > 0)
		{
		if (x > 0)
			check_cell(x - 1, y - 1);
		check_cell(x, y - 1);
		if (x < (_cell_width - 1))
			check_cell(x + 1, y - 1);
		}
	if (x > 0)
		check_cell(x - 1, y);
	if (x < (_cell_width - 1))
		check_cell(x + 1, y);
	if (y < (_cell_height - 1))
		{
		if (x > 0)
			check_cell(x - 1, y + 1);
		check_cell(x, y + 1);
		if (x < (_cell_width - 1))
			check_cell(x + 1, y + 1);
		}
	}
/*
map-step: 18890 solutions in 1112 seconds, minimum: steps = 139 fuel = 85
6444422202022220200000222000222222000000222022222000000000000000000001111101133322222022222222020000000000002222202022222222220222242013100
6444422202022220200000222000222222000000222022222000000000000000000001111101133322222022222222020000000000002222202022222222220222242013010
6444422202022220200000222000222222000000222022222000000000000000000001111101133322222022222222020000000000002222202022222222220222206003110
6444422202022220200000222000222222000000222022222000000000000000000001111101133322222022222222020000000000002222202022222222220222206003101
map-step-00: 3534 solutions in 1015 seconds, minimum: steps = 282 fuel = 169
644442220202222020000022200022222200000022202222200000000000000000000111110113332222202222222202000000000000222220202222222222022220226100044446604010000046222222222222000222222020000000000022220222222222233131313130202000000000000002222222200000020002222222222202000000000000000000
644442220202222020000022200022222200000022202222200000000000000000000111110113332222202222222202000000000000222220202222222222022220226100044446604010000046222222222222000222222020000000000022220222222222233131313130202000000000000002222222200000020002222222222022000000000000000000
*/