#include <stdio.h>
#include <iostream>

using namespace std;

int move_length[128],most_right_index;

void decideMoveLength(int compressedP[],int length,int most_right){
    int j,calc_right_index;

    for(j = 0; j < 3; j++){
        if(compressedP[length-1-j] == most_right && compressedP[length-2-j] != -1) break;
    }
    most_right_index = length-1-j;

    if(length > 2 && compressedP[length-1] == compressedP[length-2] && compressedP[length-2] != compressedP[length-3]){
        move_length[most_right] = 1;
        calc_right_index = length - 2;
    }else if(length > 2 && compressedP[length-1] == compressedP[length-2] && compressedP[length-2] == compressedP[length-3]){
        move_length[most_right] = 1;
        calc_right_index = length - 3;
    }else{
        calc_right_index = most_right_index;
    }

    for(int i = length-j-2; i >= 0; i--){
        if(i == 0 || (compressedP[i-1] != -1 && compressedP[i] >= 48 && compressedP[i] <= 122)){
            if(move_length[compressedP[i]] == -1){
                move_length[compressedP[i]] = calc_right_index - i;
            }
        }
    }

    for(int i = 0; i < 128; i++){
        if(move_length[i] == -1){
            move_length[i]  = most_right_index+1;
        }
    }
}

void compress(int compressed_array[],char base_array[],int& compressed_length){

    int comp_index = 0,count = 0;
    char ch = base_array[0];
    for(int i = 0; base_array[i] != '\0';){

        if(ch == base_array[i]){
            count++;
            if(base_array[i+1] == '\0'){
                if(count >= 4){
                    compressed_array[comp_index-2] = -1;
                    compressed_array[comp_index-1] = count;
                }else{
                    compressed_array[comp_index++] = ch;
                }
            }else{
                if(count <= 3){
                    compressed_array[comp_index++] = ch;
                }
            }
            i++;
        }else{
            if(count >= 4){
                compressed_array[comp_index-2] = -1;
                compressed_array[comp_index-1] = count;
            }
            count = 0;
            ch = base_array[i];
        }
    }
    compressed_length = comp_index;
}


int main(){
    int T_comp_index,P_comp_index,comp_P_length,comp_T_length,tmp;

    for(int i = 0; i < 128; i++) move_length[i] = -1;

    char* T = new char[1000001];
    int* compressedT = new int[1000001];

    char P[10001];
    int compressedP[10001];

    scanf("%s",T);
    scanf("%s",P);

    compress(compressedT,T,comp_T_length);
    compress(compressedP,P,comp_P_length);

    int* total_count = new int[comp_T_length];
    int sum = 0;
    for(int i = 0; i < comp_T_length; i++){
        if((i > 0 && compressedT[i-1] != -1 && compressedT[i] != -1) || i == 0){
            total_count[i] = sum;
            sum++;
        }else if(i > 0 && compressedT[i-1] == -1){
            sum += (compressedT[i] - 2);
            total_count[i] = sum;
            sum++;
        }
    }

    bool multFLG = false,leftsuceedFLG = false,rightsucceedFLG = false;
    int most_left  = compressedP[0],most_right = compressedP[0];
    for(int i = 1; i < comp_P_length; i++){
        if(compressedP[i-1] != -1 && compressedP[i] != -1){
            most_right = compressedP[i];
            if(compressedP[i] != most_left){
                multFLG = true;
            }
        }
    }


    if(comp_P_length > 2 && compressedP[comp_P_length-2] == -1){
        rightsucceedFLG = true;
    }

    if(comp_P_length > 1 && compressedP[1] == -1) leftsuceedFLG = true;

    decideMoveLength(compressedP,comp_P_length,most_right);


    if(multFLG){

        for(T_comp_index = 0; T_comp_index < comp_T_length && compressedT[T_comp_index] != most_right;T_comp_index++);

        if(T_comp_index == comp_T_length)return 0;

        int outputFLG;

        while(T_comp_index < comp_T_length){
            tmp = T_comp_index;
            P_comp_index = comp_P_length-1;
            outputFLG = 0;
            while(P_comp_index >= 0){

                if(tmp == T_comp_index){
                    if(rightsucceedFLG){
                        if((tmp < comp_T_length - 2) && (compressedT[tmp+1] == -1) && (compressedT[tmp+2] >= compressedP[comp_P_length-1])){
                            tmp -= 1;
                            P_comp_index -= 3;
                        }else{
                            break;
                        }
                    }else{
                        if((tmp < comp_T_length - 2) && (compressedT[tmp+1] == -1)){
                            if(compressedP[P_comp_index] != compressedP[P_comp_index-1]){
                                tmp--;
                                P_comp_index--;
                            }else if((compressedP[P_comp_index] == compressedP[P_comp_index-1]) && (compressedP[P_comp_index-1] != compressedP[P_comp_index-2])){
                                tmp--;
                                P_comp_index -= 2;
                            }else{
                                tmp--;
                                P_comp_index -= 3;
                            }
                        }else{
                            tmp--;
                            P_comp_index--;
                        }
                    }
                }else if(leftsuceedFLG && P_comp_index == 2){
                    if((tmp > 1) && (compressedT[tmp-1] == -1) && (compressedT[tmp] >= compressedP[P_comp_index])){
                        tmp -= 3;
                        P_comp_index -= 3;
                        outputFLG = 2;
                    }else{
                        break;
                    }
                }else if((leftsuceedFLG == false) && (P_comp_index == 2) && (compressedP[2] == compressedP[1]) && (compressedP[1] == compressedP[0])){

                    if((tmp >= 2) && (compressedT[tmp-1] == -1) && (compressedT[tmp-2] == compressedP[0])){

                        tmp -= 3;
                        P_comp_index -= 3;
                        outputFLG = 3;
                    }else if(compressedP[P_comp_index] == compressedT[tmp] && tmp > 1 && compressedT[tmp] == compressedT[tmp-1] && compressedT[tmp-1] == compressedT[tmp-2]){
                        tmp -= 3;
                        P_comp_index -= 3;

                    }else{
                        break;
                    }

                }else if((leftsuceedFLG == false) && (P_comp_index == 1) && (compressedP[1] == compressedP[0])){

                    if((tmp >= 2) && (compressedT[tmp-1] == -1) && (compressedT[tmp-2] == compressedP[0])){
                        tmp -= 3;
                        P_comp_index -= 2;
                        outputFLG = 3;
                    }else if((compressedP[P_comp_index] == compressedT[tmp]) && (tmp > 0)  && (compressedT[tmp-1] != -1) && (compressedT[tmp-2] != -1) && (compressedT[tmp] == compressedT[tmp-1])){
                        tmp -= 2;
                        P_comp_index -= 2;
                    }else{
                        break;
                    }

                }else if((leftsuceedFLG == false) && (P_comp_index == 0) && (tmp >= 2) && (compressedT[tmp-1] == -1)
                        && (compressedT[tmp-2] == compressedP[P_comp_index])){
                    tmp -= 3;
                    P_comp_index--;
                    outputFLG = 3;
                }else{
                    if(compressedP[P_comp_index] == compressedT[tmp]){
                        tmp -= 1;
                        P_comp_index--;
                    }else{
                        break;
                    }
                }
            }



            if(P_comp_index == -1){
                switch(outputFLG){
                case 0:
                    printf("%d\n",total_count[tmp+1]);
                    break;
                case 2:
                    printf("%d\n",total_count[tmp+1] + compressedT[tmp+3] - compressedP[2]);
                    break;
                case 3:
                    if(compressedP[0] != compressedP[1]){
                        printf("%d\n",total_count[tmp+1] +compressedT[tmp+3]-1);
                    }else if(compressedP[0] == compressedP[1] && compressedP[0] != compressedP[2]){
                        printf("%d\n",total_count[tmp+1] +compressedT[tmp+3]-2);
                    }else{
                        printf("%d\n",total_count[tmp+1] +compressedT[tmp+3]-3);
                    }
                    break;
                }
            }


            T_comp_index += move_length[compressedT[T_comp_index]];


            while(true){

                if(T_comp_index >= comp_T_length){
                    break;
                }
                else if(compressedT[T_comp_index-1] != -1 && compressedT[T_comp_index] == most_right){
                    break;
                }
                else{
                    if(compressedT[T_comp_index] == -1){
                        T_comp_index += 2;
                    }else if(compressedT[T_comp_index-1] == -1){
                        T_comp_index += 1;
                    }else{
                        T_comp_index += move_length[compressedT[T_comp_index]];
                    }
                }
            }
        }

    }else{
        int div = 0;
        if(rightsucceedFLG){
            for(int i = 0; i < comp_T_length;){
                if(compressedT[i] == most_right && i <  comp_T_length-2 && compressedT[i+1] == -1
                        &&compressedT[i+2] >= compressedP[comp_P_length-1]){
                    int t_s = compressedT[i+2];
                    int p_s = compressedP[comp_P_length-1];
                    for(int k = 0; p_s + k <= t_s; k++){
                        printf("%d\n",total_count[i]+k);
                    }
                }
                for(div = 1; i+div < comp_T_length;div++){
                    if(compressedT[i+div] == most_right && i+div <  comp_T_length-2 && compressedT[i+div+2] >= compressedP[comp_P_length-1]){
                        break;
                    }
                }
                i += div;
            }
        }else{
            for(int i = 0; i < comp_T_length;){
                if(compressedT[i] == most_right && i <  comp_T_length-2 && compressedT[i+1] == -1 &&
                        compressedT[i+2] >= comp_P_length){
                    int t_s = compressedT[i+2];
                    int p_s = comp_P_length;
                    for(int k = 0; p_s + k <= t_s; k++){
                        printf("%d\n",total_count[i]+k);
                    }
                }else if(compressedT[i] == most_right){
                    if(comp_P_length == 1){
                        printf("%d\n",total_count[i]);
                    }else if(comp_P_length == 2 && i < comp_T_length-1 && compressedT[i+1] == most_right){
                        printf("%d\n",total_count[i]);
                    }else if(comp_P_length == 3 && i < comp_T_length-2 && compressedT[i+1] == most_right
                            && compressedT[i+2] == most_right){
                        printf("%d\n",total_count[i]);
                    }
                }

                for(div = 1; i+div < comp_T_length;div++){
                    if(compressedT[i+div] == most_right && i+div <  comp_T_length-2 && compressedT[i+div+2] >= comp_P_length){
                        break;
                    }else if(compressedT[i+div] == most_right){
                        break;
                    }
                }
                i += div;
            }
        }
    }

    return 0;
}

Measured memory_bytes: 9996