#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

char input[1010][1010];
ifstream in("barbar.in");
ofstream out("barbar.out");
int n,m;
int lStart,cStart;
int lFinish,cFinish;
int minim;
bool solution;
int matrix[1010][1010];
bool parcurs[1010][1010];
struct position
{
	int line;
	int column;
}A;
int debug;
vector <position> dragons;

void read()
{
	in>>n>>m;
	int rez = n * m + 1;
	for(int i=1; i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			in>>input[i][j];
			matrix[i][j] = rez;
			if(input[i][j]=='D')
			{
				A.line = i;
				A.column = j;
				matrix[i][j] = 0;
				dragons.push_back(A);
			}
			else
			{
				if(input[i][j] == 'I')
				{
					lStart = i;
					cStart = j;
				}
				else
				{
					if(input[i][j] == 'O')
					{
						lFinish = i;
						cFinish = j;
						input[i][j] = '.';
					}
					else
                    {
                        if(input[i][j] == '*')
                        {
                            parcurs[i][j] = true;
                        }
                    }
				}
			}
		}
	}
}

void setdf(int line, int column,int k)
{
	matrix[line][column] = k;
	k = k + 1;

	if((matrix[line-1][column]>k && input[line-1][column] =='.'))
	{
		setdf(line-1,column,k);
	}

	if(matrix[line+1][column]>k && input[line+1][column] =='.')
	{
		setdf(line+1,column,k);
	}

	if(matrix[line][column-1]>k && input[line][column-1]=='.')
	{
		setdf(line,column-1,k);
	}

	if(matrix[line][column+1]>k && input[line][column+1]=='.')
	{
		setdf(line,column+1,k);
	}
}

void dragonList()
{
	for (vector<position>::iterator it = dragons.begin() ; it != dragons.end(); it++)
	{
		A = *it;
		setdf(A.line,A.column,0);
	}
}

void df(int line, int column)
{
    parcurs[line][column] = true;
    if((lFinish == line) && (cFinish == column))
    {
        solution = true;
    }
    else
    {
        if(solution == false)
        {
            if(line > 1)
            {
                if((matrix[line-1][column] >= minim) && (parcurs[line-1][column] == false))
                {
                    df(line-1,column);
                }
            }
            if(line<n)
            {
                if((matrix[line+1][column] >= minim) && (parcurs[line+1][column] == false))
                {
                    df(line+1,column);
                }
            }
            if(column>1)
            {
                if((matrix[line][column-1] >= minim) && (parcurs[line][column-1] == false))
                   {
                       df(line,column-1);
                   }
            }
            if(column<m)
            {
                if((matrix[line][column+1] >= minim) && (parcurs[line][column+1] == false))
                   {
                       df(line,column+1);
                   }
            }
        }
    }
    parcurs[line][column] = false;
}

int binary_search()
{
    int i, step;
    for (step = 1; step < n + m + 1; step <<= 1)
    {

    }

    for (i = 0; step; step >>= 1)
    {
        solution = false;
        if(i + step < n*m+1)
        {
            solution = false;
            minim = i + step;
            df(lStart,cStart);
            if(solution == true)
            {
                i = i + step;
            }
        }
    }
    return i;
}

int solve()
{
	dragonList();

    minim = 2;
    df(lStart,cStart);
    return binary_search();
}

void write(int c)
{
    solution = false;
    minim = c;
    df(lStart,cStart);
    if(solution == true)
    {
        out<<c;
    }
    else
    {
        out<<-1;
    }
}

int main()
{
    read();
    write(solve());
}