#include <bits/stdc++.h>
using namespace std;
const int S = 30;
const int N = 2e5 + 10;
const long long MOD = 2038074713LL;
const long long BASE_MODULAR_INVERSE = 1019037357;
const int HASH_INT_SIZE = 20;
int nt, ns;
string s, t;
set<long long> t_hashes, seg_hashes;
unordered_map<long long, int> t_hash_to_char;
long long _char_hash_in_t[S];
long long pos_t[N], neg_t[N];
long long _hash_array[S];
set<int> _ind[S];
char _match[S];
bool _mark[S], old_hash[S];
vector<char> sigma;
int system_time;
void build_hash_t();
void build_first_hash_s();
bool check();
bool make_match(char);
void move_right(int, int);
void pre_proc();
void add(char, int);
void del(char, int);
set<int> &ind(char);
char &match(char);
bool &mark(char);
long long &char_hash_in_t(char);
long long &hash_array(char);
void cerr_hash(string, bool = true);
int32_t main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  for (char c = 'a'; c <= 'z'; c++) sigma.push_back(c);
  cin >> ns >> nt;
  cin >> s >> t;
  pre_proc();
  t_hash_to_char.reserve(1 << 5);
  t_hash_to_char.max_load_factor(0.25);
  build_hash_t();
  cerr_hash("T:");
  build_first_hash_s();
  cerr_hash("first S:");
  int l = 0, r = nt;
  vector<int> ans;
  while (r <= ns) {
    cerr_hash("\n\nsegment [" + to_string(l) + ',' + to_string(r) + "): ");
    if (check()) {
      ans.push_back(l);
    }
    if (r < ns) move_right(l, r);
    l++;
    r++;
  }
  cout << ans.size() << endl;
  for (int i : ans) cout << i + 1 << ' ';
  cout << endl;
}
void pre_proc() {
  pos_t[0] = 1;
  neg_t[0] = MOD - 1;
  for (int i = 1; i <= ns + 2; i++) {
    pos_t[i] = (pos_t[i - 1] * 2) % MOD;
    neg_t[i] = (pos_t[i - 1] * 2) % MOD;
  }
}
void build_hash_t() {
  for (int i = 0; i < nt; i++) {
    ind(t[i]).insert(i);
    add(t[i], i);
  }
  for (char c : sigma) {
    long long cur_hash = hash_array(c);
    char_hash_in_t(c) = cur_hash;
    assert(ind(c).empty() || t_hashes.find(cur_hash) == t_hashes.end());
    t_hashes.insert(cur_hash);
    if (!ind(c).empty()) t_hash_to_char[cur_hash] = c;
  }
}
void build_first_hash_s() {
  for (char c : sigma) {
    ind(c).clear();
    hash_array(c) = 0;
  }
  for (int i = 0; i < nt; i++) {
    ind(s[i]).insert(i);
    add(s[i], i);
  }
}
bool check() {
  for (char c : sigma) mark(c) = false;
  seg_hashes.clear();
  for (char c : sigma) seg_hashes.insert(hash_array(c));
  if (seg_hashes != t_hashes) return false;
  for (char c : sigma)
    if (!mark(c) && !ind(c).empty())
      if (!make_match(c)) {
        return false;
      }
  return true;
}
bool make_match(char c) {
  match(c) = t_hash_to_char[hash_array(c)];
  if (mark(match(c))) return false;
  mark(match(c)) = true;
  if (hash_array(match(c)) != char_hash_in_t(c)) return false;
  match(match(c)) = c;
  return true;
}
void move_right(int l, int r) {
  cerr_hash("before move " + to_string(l) + ": ", false);
  ind(s[l]).erase(l);
  ind(s[r]).insert(r);
  del(s[l], 0);
  add(s[r], nt);
  cerr_hash("before move1 " + to_string(l) + ": ", false);
  for (char c : sigma)
    hash_array(c) = (hash_array(c) * BASE_MODULAR_INVERSE) % MOD;
  cerr_hash("after move2 " + to_string(l) + ": ", false);
  system_time++;
}
void add(char c, int val) {
  hash_array(c) = (hash_array(c) + pos_t[val]) % MOD;
}
void del(char c, int val) {
  hash_array(c) = (hash_array(c) + neg_t[val]) % MOD;
}
void cerr_hash(string msg, bool tt) {
  tt = true;
  if (tt) return;
  cout << msg << endl;
  for (char c : sigma) {
    if (ind(c).size() == 0) continue;
    cout << c << ": ";
    for (int i : ind(c)) cout << i << "(=" << i - system_time << ") ";
    cout << " -> " << hash_array(c) << endl;
  }
}
long long &hash_array(char c) { return _hash_array[int(c - 'a')]; }
set<int> &ind(char c) { return _ind[int(c - 'a')]; }
char &match(char c) { return _match[int(c - 'a')]; }
bool &mark(char c) { return _mark[int(c - 'a')]; }
long long &char_hash_in_t(char c) { return _char_hash_in_t[int(c - 'a')]; }
