#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;

const ld pi = 3.14159265358979323846;
const int MOD = 998244353;
const ll INF = 1e18;

// Precompute knight moves
const vector<pair<int, int>> knight_moves = {
    {-2, -1}, {-2, +1}, {-1, -2}, {-1, +2},
    {+1, -2}, {+1, +2}, {+2, -1}, {+2, +1}
};

const int N_MAX = 1e3 + 1; // Adjust based on problem constraints

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int n, m;
    cin >> n >> m;

    vector<string> grid(n);
    // d[i][j] will store the number of knights threatening cell (i, j)
    vector<vector<int>> d(n, vector<int>(m, 0));
    pair<int, int> start;

    // Function to update the d grid based on knight positions
    auto update_knight_threats = [&](int i, int j, int op) {
        for (const auto& move : knight_moves) {
            int ni = i + move.first;
            int nj = j + move.second;
            if (ni >= 0 && ni < n && nj >= 0 && nj < m) {
                d[ni][nj] += op;
            }
        }
    };

    // Read grid and initialize 'd' and start position
    for(int i = 0; i < n; i++) {
        cin >> grid[i];
        for(int j = 0; j < m; j++) {
            if(grid[i][j] == 'R') {
                start = {i, j};
            }
            if(grid[i][j] == 'K') {
                update_knight_threats(i, j, 1);
            }
        }
    }

    // Directions for BFS traversal: up, down, left, right
    const vector<pair<int, int>> directions = {
        {1, 0}, {-1, 0}, {0, 1}, {0, -1}
    };

    // Initialize visitation grid once
    vector<vector<int>> vis(n, vector<int>(m, 0));
    int iteration = 1;

    while (true) {
        queue<pair<int, int>> q;
        q.push(start);
        // Reset visitation for the new iteration
        for(int i = 0; i < n; i++) {
            fill(vis[i].begin(), vis[i].end(), 0);
        }
        vis[start.first][start.second] = 1;

        vector<pair<int, int>> removable_knights;

        while(!q.empty()) {
            pair<int, int> current = q.front(); q.pop();
            int x = current.first, y = current.second;

            for(const auto& dir : directions) {
                int dx = x + dir.first, dy = y + dir.second;
                while(dx >= 0 && dy >= 0 && dx < n && dy < m) {
                    if(grid[dx][dy] == 'K') {
                        if(d[dx][dy] == 0 && !vis[dx][dy]) {
                            vis[dx][dy] = 1;
                            removable_knights.emplace_back(dx, dy);
                        }
                        break; // Stop in this direction after encountering a 'K'
                    }
                    if(d[dx][dy] > 0 || vis[dx][dy]) {
                        // If the cell is threatened or already visited, do nothing
                    }
                    else {
                        vis[dx][dy] = 1;
                        if(grid[dx][dy] == 'T') {
                            cout << "yes\n";
                            return 0;
                        }
                        q.push({dx, dy});
                    }
                    dx += dir.first;
                    dy += dir.second;
                }
            }
        }

        if(removable_knights.empty()) {
            cout << "no\n";
            return 0;
        }
        else {
            for(auto &[i, j] : removable_knights) {
                grid[i][j] = '.'; // Remove the knight
                update_knight_threats(i, j, -1); // Update the threat grid
            }
        }
    }

    return 0;
}