#include <algorithm>
#include <fstream>
#include <cstring>

using namespace std;

const int Nmax = 510, Mod = 3210121;

char A[Nmax], B[Nmax];
int Dp[2][Nmax][Nmax];

int main()
{
    ifstream fin("iv.in");
    fin >> (A + 1) >> (B + 1);
    fin.close();

    int N = strlen(A + 1), M = strlen(B + 1);

    int ans = 0;

    Dp[0][0][0] = 1;
    int sz = (N + M) / 2;
    for (int i = 0, u = 0; i <= sz; ++i, u ^= 1) {
        for (int j = 0; i + j <= sz; ++j) {
            if (i == 0 && j == 0) continue;

            for (int k = 0; k <= i + j && k + i <= N; ++k) {
                int l = i + j - k;
                if (j + l > M) continue;

                Dp[u][j][k] = 0;
                if (i > 0) {
                    if (k > 0 && A[i] == A[N - k + 1]) {
                        Dp[u][j][k] += Dp[u ^ 1][j][k - 1];
                        if (Dp[u][j][k] >= Mod) Dp[u][j][k] -= Mod;
                    }
                    if (l > 0 && A[i] == B[M - l + 1]) {
                        Dp[u][j][k] += Dp[u ^ 1][j][k];
                        if (Dp[u][j][k] >= Mod) Dp[u][j][k] -= Mod;
                    }
                }

                if (j > 0) {
                    if (k > 0 && B[j] == A[N - k + 1]) {
                        Dp[u][j][k] += Dp[u][j - 1][k - 1];
                        if (Dp[u][j][k] >= Mod) Dp[u][j][k] -= Mod;
                    }
                    if (l > 0 && B[j] == B[M - l + 1]) {
                        Dp[u][j][k] += Dp[u][j - 1][k];
                        if (Dp[u][j][k] >= Mod) Dp[u][j][k] -= Mod;
                    }
                }

                if (i + j == sz) {
                    ans += Dp[u][j][k];
                    if (ans >= Mod) ans -= Mod;
                }
            }
        }
    }

    ofstream fout("iv.out");
    fout << ans << '\n';
    fout.close();
}