#include <bits/stdc++.h>
using namespace std;

using LL = long long;

constexpr int P = 1e9 + 7;
struct Mint {
  int v;
  Mint(int v = 0) : v(v) {v += v >> 31 & P;}
  int val() const {return v;}
  Mint &operator+=(const Mint &b) {
    v += b.v - P, v += v >> 31 & P;
    return *this;
  }
  Mint &operator-=(const Mint &b) {
    v -= b.v, v += v >> 31 & P;
    return *this;
  }
  Mint &operator*=(const Mint &b) {
    v = LL(v) * b.v % P;
    return *this;
  }
  friend Mint operator+(Mint a, const Mint &b) {return a += b;}
  friend Mint operator-(Mint a, const Mint &b) {return a -= b;}
  friend Mint operator*(Mint a, const Mint &b) {return a *= b;}
  friend ostream &operator<<(ostream &os, const Mint &a) {
    return os << a.val();
  }
};

constexpr int N = 1e6 + 5;

int cnt = 1, fa[N], len[N], ed[N];
array<int, 26> ch[N];
vector<int> G[N];
Mint sum[N];

int ins(int p, int c) {
  int cur = ++cnt; len[cur] = len[p] + 1;
  ed[cur] = 1;
  for (; p && !ch[p][c]; p = fa[p]) ch[p][c] = cur;
  if (!p) fa[cur] = 1;
  else {
    int q = ch[p][c];
    if (len[q] == len[p] + 1) fa[cur] = q;
    else {
      int cl = ++cnt;
      ch[cl] = ch[q], fa[cl] = fa[q], len[cl] = len[p] + 1;
      fa[cur] = fa[q] = cl;
      for (; p && ch[p][c] == q; p = fa[p]) ch[p][c] = cl;
    }
  }
  return cur;
}

int main() {
  cin.tie(0)->sync_with_stdio(0);
  string s, t;
  cin >> s >> t;
  int n = s.size();
  int las = 1;
  for (auto c : s) las = ins(las, c - 'a');
  for (int i = 2; i <= cnt; i++) {
    G[fa[i]].emplace_back(i);
  }
  vector<Mint> sf2(n + 2), sf1(n + 2), sf0(n + 2);
  for (int i = n; i >= 1; i--) {
    sf2[i] = sf2[i + 1] + (LL(i) * i % P);
    sf1[i] = sf1[i + 1] + i;
    sf0[i] = sf0[i + 1] + 1;
  }
  vector<Mint> ps2(n + 2), ps1(n + 2), ps0(n + 2);
  for (int i = 0; i <= n; i++) {
    ps2[i + 1] = ps2[i] + sf2[i];
    ps1[i + 1] = ps1[i] + sf1[i];
    ps0[i + 1] = ps0[i] + sf0[i];
  }
  vector q(cnt + 1, vector<tuple<int, int, Mint>>());
  {
    Mint ans;
    int l = 0, cur = 1;
    for (auto c : t) {
      c -= 'a';
      while (cur != 1 && !ch[cur][c]) {
        cur = fa[cur];
        l = len[cur];
      }
      if (ch[cur][c]) {
        cur = ch[cur][c];
        l++;
      }
      if (cur != 1) {
        q[cur].emplace_back(len[fa[cur]] + 1, l, 1);
        sum[fa[cur]] += 1;
      }
    }
    auto dfs = [&](auto self, int u)->void {
      for (auto v : G[u]) {
        self(self, v);
        sum[u] += sum[v];
      }
      if (u != 1) {
        q[u].emplace_back(len[fa[u]] + 1, len[u], sum[u]);
      }
    };
    dfs(dfs, 1);
  }
  vector<Mint> f2(n + 1), f1(n + 1), f0(n + 1);
  Mint ans;
  auto sol = [&](auto self, int u, Mint s2, Mint s1, Mint s0, Mint d)->void {
    for (auto [l, r, val] : q[u]) {
      s2 += (ps2[r + 1] - ps2[l]) * val;
      s1 += (ps1[r + 1] - ps1[l]) * val;
      s0 += (ps0[r + 1] - ps0[l]) * val;
      d += val * (r - l + 1);
    }
    if (ed[u]) {
      f2[len[u]] = s2 - d * sf2[len[u] + 1];
      f1[len[u]] = s1 - d * sf1[len[u] + 1];
      f0[len[u]] = s0 - d * sf0[len[u] + 1];
    }
    for (auto v : G[u]) {
      self(self, v, s2, s1, s0, d);
    }
  };
  sol(sol, 1, 0, 0, 0, 0);
  for (int i = 1; i <= n; i++) {
    f2[i] += f2[i - 1] + 2 * f1[i - 1] + f0[i - 1];
    f1[i] += f1[i - 1] + f0[i - 1];
    f0[i] += f0[i - 1];
    ans += f2[i];
  }
  cout << ans << "\n";
  return 0;
}