#include<fstream>
#include<vector>

using namespace std;

#define ALPHABET_SIZE 256

vector<int> RabinKarp (string pattern, string text) {

    vector<int> positions;
    int prime = 101;
    int patternLength = pattern.size();
    int textLength = text.size();
    int patternHash = 0, textHash = 0, index = 0;
    int h = 1;

    for (int i = 1; i < patternLength; i++) {
        h = (h * ALPHABET_SIZE) % prime;
    }

    //hash-ul pattern-ului si primului bloc din text
    for (int i = 0; i < patternLength; i++) {
        patternHash = (ALPHABET_SIZE*patternHash + pattern[i]) % prime;
        textHash = (ALPHABET_SIZE*textHash + text[i]) % prime;
    }

    //parcurg textul si iau blocuri de lungime patternLength
    for (int i = 0; i <= (textLength-patternLength); i++) {
        if (patternHash == textHash) { //daca hash-urile sunt egale, compar
            
            for (index = 0; index < patternLength; index++) {
                if (pattern[index] != text[i + index]) {
                    break;
                }
            }

            if (patternLength == index) {
                positions.push_back(i);
            }
        }

        if (i < (textLength-patternLength)) {
            textHash = (ALPHABET_SIZE*(textHash - text[i]*h) + text[i+patternLength]) % prime;
            if (textHash < 0) {
                textHash += prime;
            }
        }
    }

    return positions;
}


int main() {

    ifstream input;
    ofstream output;
    string pattern, text;
    
    input.open("strmatch.in", ios::in);
    output.open("strmatch.out", ios::out);

    getline(input, pattern);
    getline(input, text);

    vector<int> positions = RabinKarp(pattern, text);

    output << positions.size() << "\n";

    for (int i = 0; i < positions.size(); ++i) {
        if (i == 1000) {
            break;
        }
        output << positions.at(i) << " ";
    }

    input.close();
    output.close();

    return 0;
}