#include <fstream>
#include <string>

using namespace std;

const int DMAX = 1000;

struct pozitie
{
    short int x, y;
};

int N, M;
int L1[DMAX + 2][DMAX + 2];
int L2[DMAX + 2][DMAX + 2];

pozitie C[DMAX * DMAX + 1];
int p, u;

pozitie pj, pr;

int d[8][2] =
{
    {-1,-1}, {-1,0}, {-1,1},
    {0,-1},           {0,1},
    {1,-1},  {1,0},   {1,1}
};

ifstream f("rj.in");
ofstream g("rj.out");

void bordare()
{
    for(int i = 0; i <= N + 1; i++)
    {
        L1[i][0] = L1[i][M + 1] = -1;
        L2[i][0] = L2[i][M + 1] = -1;
    }

    for(int i = 0; i <= M + 1; i++)
    {
        L1[0][i] = L1[N + 1][i] = -1;
        L2[0][i] = L2[N + 1][i] = -1;
    }
}

void citire()
{
    char c;

    f >> N >> M;
    f.get();

    for(int i = 1; i <= N; i++)
    {
        for(int j = 1; j <= M; j++)
        {
            f.get(c);

            if(c == 'X')
            {
                L1[i][j] = -1;
                L2[i][j] = -1;
            }
            else
            {
                L1[i][j] = 0;
                L2[i][j] = 0;

                if(c == 'R')
                {
                    pr.x = i;
                    pr.y = j;
                }

                if(c == 'J')
                {
                    pj.x = i;
                    pj.y = j;
                }
            }
        }

        f.get();
    }
}

void Lee(pozitie start, int L[][DMAX + 2])
{
    pozitie crt, vec;

    p = u = 1;
    C[1] = start;

    L[start.x][start.y] = 1;

    while(p <= u)
    {
        crt = C[p++];

        for(int k = 0; k < 8; k++)
        {
            vec.x = crt.x + d[k][0];
            vec.y = crt.y + d[k][1];

            if(L[vec.x][vec.y] == 0)
            {
                L[vec.x][vec.y] = L[crt.x][crt.y] + 1;
                C[++u] = vec;
            }
        }
    }
}

int main()
{
    citire();

    bordare();

    Lee(pr, L1);
    Lee(pj, L2);

    int tmin = 1000000000;
    int xmin, ymin;

    for(int i = 1; i <= N; i++)
    {
        for(int j = 1; j <= M; j++)
        {
            if(L1[i][j] > 0 &&
               L1[i][j] == L2[i][j] &&
               L1[i][j] < tmin)
            {
                tmin = L1[i][j];
                xmin = i;
                ymin = j;
            }
        }
    }

    g << tmin << ' ' << xmin << ' ' << ymin;

    return 0;
}