A map of some object is a rectangular field consisting of n rows and n columns. Each cell is initially occupied by the sea but you can cover some some cells of the map with sand so that exactly k islands appear on the map. We will call a set of sand cells to be island if it is possible to get from each of them to each of them by moving only through sand cells and by moving from a cell only to a side-adjacent cell. The cells are called to be side-adjacent if they share a vertical or horizontal side. It is easy to see that islands do not share cells (otherwise they together form a bigger island).

Find a way to cover some cells with sand so that exactly k islands appear on the n × n map, or determine that no such way exists. 

Input

The single line contains two positive integers n, k (1 ≤ n ≤ 100, 0 ≤ k ≤ n2) — the size of the map and the number of islands you should form.

Output

If the answer doesn't exist, print "NO" (without the quotes) in a single line.

Otherwise, print "YES" in the first line. In the next n lines print the description of the map. Each of the lines of the description must consist only of characters 'S' and 'L', where 'S' is a cell that is occupied by the sea and 'L' is the cell covered with sand. The length of each line of the description must equal n.

If there are multiple answers, you may print any of them.

You should not maximize the sizes of islands.

Examples

Input

5 2


Output

YES
SSSSS
LLLLL
SSSSS
LLLLL
SSSSS


Input

5 25


Output

NO
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
enum status { path = 0, cycle = 1 };
bool is_prime(long long n) {
  if (n <= 1) return false;
  for (int i = 2; i * i <= n; i++) {
    if (n % i == 0) return false;
  }
  return true;
}
long long sum(long long n) { return (n * (n + 1) / 2); }
long long sum_interval(long long st, long long en) {
  if (st <= 1) return sum(en);
  return (sum(en) - sum(st - 1));
}
bool is_even(int n) { return !(n % 2); }
void swap_two(int &x, int &y) {
  int temp = x;
  x = y;
  y = temp;
}
int sum_except(vector<int> cookies, int indx) {
  int bagsl = cookies.size(), sum_all = 0;
  for (int i = 0; i < bagsl; i++) {
    if (i != indx) sum_all += cookies[i];
  }
  return sum_all;
}
bool is_palindromic(string s) {
  string orgstr = s;
  reverse(s.begin(), s.end());
  string revstr = s;
  return (orgstr == revstr);
}
long long fib(int n) {
  long long res, first = 1, second = 1;
  if (n == 1 || n == 2) return 1;
  for (int i = 3; i < n; i++) {
    res = first + second;
    first = second;
    second = res;
  }
  return res;
}
unsigned long long min_shots(unsigned long long N) {
  int bottle_shots[3] = {5, 10, 15};
  unsigned long long min_nshots = 0;
  int indx = 2;
  while (N > 0 && indx >= 0) {
    if (N >= bottle_shots[indx]) {
      min_nshots += (N / bottle_shots[indx]);
      N %= bottle_shots[indx];
    } else
      indx--;
  }
  return min_nshots;
}
long long nCr(int n, int r) {
  if (r > (n / 2)) r = n - r;
  long long ans = 1;
  for (int i = 1; i < r + 1; i++) ans *= (n - r + i), ans /= i;
  return ans;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long quick_mod(long long a, long long b) {
  long long ans = 1;
  while (b) {
    if (b & 1) ans = (ans * a) % mod;
    b >>= 1;
    a = (a * a) % mod;
  }
  return ans;
}
long long count_bin_digits(long long n) {
  long long digits = 0;
  while (n) {
    digits++;
    n /= 2;
  }
  return digits;
}
long long sum_arr(vector<int> vec) {
  int sum = 0, vecs = vec.size();
  for (int i = 0; i < vecs; i++) sum += vec[i];
  return sum;
}
bool isSubSequence(string str1, string str2, int m, int n) {
  if (m == 0) return true;
  if (n == 0) return false;
  if (str1[m - 1] == str2[n - 1])
    return isSubSequence(str1, str2, m - 1, n - 1);
  return isSubSequence(str1, str2, m, n - 1);
}
bool check_sub(string s1, string s2) {
  int c, d, s1ln = s1.length(), s2ln = s2.length();
  c = d = 0;
  while (s1[c] != '\0') {
    while ((s1[c] != s2[d]) && s2[d] != '\0') {
      d++;
    }
    if (s2[d] == '\0') break;
    d++;
    c++;
  }
  if (s1[c] == '\0')
    return 1;
  else
    return 0;
}
pair<int, int> max_element(vector<int> nums) {
  pair<int, int> mx_indx;
  int vln = nums.size();
  mx_indx.first = INT32_MIN;
  for (int i = 0; i < vln; i++) {
    if (nums[i] > mx_indx.first) {
      mx_indx.first = nums[i];
      mx_indx.second = i;
    }
  }
  return mx_indx;
}
double ecdDistance(int x1, int x2, int y1, int y2) {
  return sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2));
}
int dp[(int)1e6 + 1];
int findDiv(int n) {
  int &ret = dp[n];
  if (ret) return ret;
  int I, K, p, NOD = 1, power;
  for (p = 2; p * p <= n; p++) {
    power = 0;
    if (n % p == 0) {
      while (n % p == 0) {
        power++;
        n /= p;
      }
      NOD *= (power + 1);
    }
  }
  if (n > 1) NOD <<= 1;
  return ret = NOD;
}
int n, e, m;
vector<vector<int>> adj;
vector<bool> visted;
int dx[8] = {1, 0, -1, 0, -1, 1, -1, 1};
int dy[8] = {0, 1, 0, -1, -1, 1, 1, -1};
map<unsigned long long, unsigned long long> mp;
char grid[100][100];
void dfs(int cur_node, int req_node, int color) {
  if (visted[cur_node]) return;
  visted[cur_node] = true;
  for (auto child_node : adj[cur_node])
    if (color == child_node) dfs(child_node, req_node, color);
}
bool bfs(long long a) {
  queue<unsigned long long> q;
  mp[a] = 1;
  q.push(a);
  while (q.size()) {
    unsigned long long u = q.front();
    q.pop();
    if (mp[u] == n) return true;
  }
  mp.clear();
  return false;
}
int main() {
  ios_base::sync_with_stdio(0), cin.tie(0);
  ;
  cin >> n >> m;
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) grid[i][j] = 'S';
  for (int i = 0; i < n; i++)
    for (int j = i & 1; j < n; j += 2)
      if (m) grid[i][j] = 'L', m--;
  if (m) {
    printf("NO\n");
    return 0;
  }
  printf("YES\n");
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      (j == (n - 1)) ? printf("%c\n", grid[i][j]) : printf("%c", grid[i][j]);
  return 0;
}
