#include <iostream>
#include <cstring>
#include <fstream>

using namespace std;

const int DMAX = 100; //Dimensiunea maxima a labirintului
struct pozitie
{
    int x, y;
};
struct matrice
{
    int v, t;
} L[DMAX + 2][DMAX + 2];
int M, N, D, X, Y, TIMP;
char linie[DMAX + 2];
pozitie C1[DMAX * DMAX + 1], C2[DMAX * DMAX + 1];
int p1, u1, p2, u2;

pozitie ps;
pozitie pc;

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

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

void afisare()
{
    for (int i = 1; i <= N; i++)
    {
        for (int j = 1; j <= M; j++)
            g << L[i][j].t << ' ';
        g << '\n';
    }
    g << '\n';
}

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

void Lee()
{
    pozitie vec1, crt1, vec2, crt2;
    p1 = u1 = 1;
    p2 = u2 = 1;
    C1[1] = ps;
    C2[1] = pc;
    L[ps.x][ps.y].t=1;
    L[pc.x][pc.y].t=1;
    while (p1 <= u1 && p2 <= u2)
    {
        crt1 = C1[p1++];
        crt2 = C2[p2++];
        for (int k = 0; k < 8; k++)
        {
            vec1.x = crt1.x + d[k][0];
            vec1.y = crt1.y + d[k][1];
            vec2.x = crt2.x + d[k][0];
            vec2.y = crt2.y + d[k][1];
            if (L[vec1.x][vec1.y].v == 0)
            {
                L[vec1.x][vec1.y].v = L[crt1.x][crt1.y].v;
                L[vec1.x][vec1.y].t = L[crt1.x][crt1.y].t + 1;
                C1[++u1] = vec1;
            }
            else if (L[vec1.x][vec1.y].v == 3)
            {
                if (L[vec1.x][vec1.y].t >= L[crt1.x][crt1.y].t+1)
                {
                    X = vec1.x;
                    Y = vec1.y;
                    TIMP = L[crt1.x][crt1.y].t+1;
                }
                else
                {
                    X = crt1.x;
                    Y = crt1.y;
                    TIMP = L[vec1.x][vec1.y].t+1;
                }
                p1 = u1 + 1;
                break;
            }
            if (L[vec2.x][vec2.y].v == 0)
            {
                L[vec2.x][vec2.y].v = L[crt2.x][crt2.y].v;
                L[vec2.x][vec2.y].t = L[crt2.x][crt2.y].t + 1;
                C2[++u2] = vec2;
            }
            else if (L[vec2.x][vec2.y].v == 2)
            {
                if (L[vec2.x][vec2.y].t >= L[crt2.x][crt2.y].t+1)
                {
                    X = vec2.x;
                    Y = vec2.y;
                    TIMP = L[crt2.x][crt2.y].t+1;
                }
                else
                {
                    X = crt2.x;
                    Y = crt2.y;
                    TIMP = L[vec2.x][vec2.y].t+1;
                }

                p2 = u2 + 1;
                break;
            }
        }
        //afisare();
    }
}


int main()
{
    f >> M >> N;
    f.getline (linie, 100);
    for (int i = 1; i <= M; i++)
    {
        f.getline (linie, 100);
        for (int j = 0; j < N; j++)
            if (linie[j] == 'R')
                ps.x = i, ps.y = j + 1, L[ps.x][ps.y].v = 2;
            else if (linie[j] == 'J')
                pc.x = i, pc.y = j + 1, L[pc.x][pc.y].v = 3;
            else if (linie[j] == 'X')
                L[i][j + 1].v = -1;
    }

    bordare();
    Lee();

    g << TIMP << ' ' << X << ' ' << Y;
    return 0;
}