#include <bits/stdc++.h>
using namespace std;
constexpr long long MOD = 1e9 + 7;
template <typename T>
using pq = priority_queue<T>;
template <typename T>
using pqr = priority_queue<T, vector<T>, greater<T>>;
const long long INF = LLONG_MAX / 2;
using P = pair<long long, long long>;
using vec = vector<long long>;
template <typename T>
using mat = vector<vector<T>>;
template <typename T1, typename T2>
ostream& operator<<(ostream& stream, const pair<T1, T2>& p) {
  return stream << p.first << "," << p.second;
}
template <typename T>
void print(const vector<T> vec) {
  for (long long i = (0); i <= static_cast<long long>(vec.size() - 1 - 1); i++)
    cout << vec[i] << ' ';
  cout << vec[vec.size() - 1] << '\n';
}
template <typename Arg>
void print(const Arg arg) {
  cout << arg << '\n';
}
template <typename Head, typename... Args>
void print(const Head head, const Args... args) {
  cout << head << " ";
  print(args...);
}
template <typename T, typename U>
void init(vector<T>& v, vector<U>& w) {
  for (long long i = (0); i <= static_cast<long long>(v.size() - 1); i++)
    cin >> v[i] >> w[i];
}
template <typename T>
void init(vector<T>& v) {
  for (long long i = (0); i <= static_cast<long long>(v.size() - 1); i++)
    cin >> v[i];
}
template <typename T>
T sum_(vector<T> vec, T init = 0) {
  return std::accumulate((vec).begin(), (vec).end(), T(init));
}
template <typename T>
bool chmax(T& a, const T& b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
bool chmin(T& a, const T& b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
long long index(const T& vec, const typename T::iterator it) {
  return distance(vec.begin(), it);
}
template <typename T = long long>
mat<T> mmat(long long n, long long m = 0) {
  return mat<T>(n, vector<T>(m));
}
template <typename T = long long>
vector<T> ivec(long long n) {
  vector<T> v(n);
  init(v);
  return v;
}
void yn(bool tf) { print(tf ? "Yes" : "No"); }
void YN(bool tf) { print(tf ? "YES" : "NO"); }
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
class mint {
  using ll = long long;
  ll num;

 public:
  mint(ll x = 0) : num(x % MOD) {}
  mint operator+=(const mint& x) noexcept {
    this->num += x.num;
    if (this->num >= MOD) this->num %= MOD;
    return *this;
  }
  mint operator-=(const mint& x) noexcept {
    if (this->num < x.num) this->num += MOD;
    this->num -= x.num;
    return *this;
  }
  mint operator*=(const mint& x) noexcept {
    this->num = (this->num * x.num) % MOD;
    return *this;
  }
  mint operator/=(mint x) noexcept {
    ll exp = MOD - 2;
    while (exp) {
      if (exp % 2) *this *= x;
      x *= x;
      exp /= 2;
    }
    return *this;
  }
  mint operator%=(const mint& x) noexcept {
    this->num %= x.num;
    return *this;
  }
  mint operator+(const mint& x) const noexcept { return mint(*this) += x; }
  mint operator-(const mint& x) const noexcept { return mint(*this) -= x; }
  mint operator*(const mint& x) const noexcept { return mint(*this) *= x; }
  mint operator/(const mint& x) const noexcept { return mint(*this) /= x; }
  mint operator%(const mint& x) const noexcept { return mint(*this) %= x; }
  mint operator&(const mint& x) const noexcept { return this->num & x.num; }
  bool operator==(const mint& x) const noexcept { return this->num == x.num; }
  bool operator!=(const mint& x) const noexcept { return not((*this) == x); }
  explicit operator bool() const noexcept { return this->num != 0; }
  explicit operator long long() const noexcept { return this->num; }
  mint pow(mint _n) {
    mint r = mint(*this);
    mint re = 1;
    long long n = (long long)_n;
    for (; n; n /= 2) {
      if (n & 1) re *= r;
      r *= r;
    }
    return re;
  }
  mint inv() { return this->pow(MOD - 2); }
  friend ostream& operator<<(ostream&, const mint&);
};
ostream& operator<<(ostream& stream, const mint& x) { return stream << x.num; }
signed main() {
  cin.tie(0), cout.tie(0), ios::sync_with_stdio(false);
  string s;
  cin >> s;
  long long n = s.length();
  mat<mint> dp = mmat<mint>(3, n + 1);
  for (long long i = (0); i <= static_cast<long long>(n + 1 - 1); i++) {
    if (i == 0) continue;
    if (i == 1) {
      dp[0][i] = 1;
      dp[1][i] = 1;
      dp[2][i] = 0;
      continue;
    }
    dp[0][i] = dp[0][i - 1] + dp[2][i - 1];
    dp[1][i] = dp[0][i - 1] + dp[2][i - 1];
    dp[2][i] = dp[1][i - 1];
  }
  mint ans = 1;
  long long cntu = 0, cntn = 0;
  for (long long i = (0); i <= static_cast<long long>(n - 1); i++) {
    if (s[i] == 'm' or s[i] == 'w') {
      print(0);
      return 0;
    }
    if (s[i] == 'u') {
      cntu++;
      if (i == n - 1 or s[i + 1] != 'u') {
        cerr << "cntu"
             << " = " << (cntu) << '\n';
        ans *= (dp[0][cntu] + dp[2][cntu]);
        cntu = 0;
      }
    } else if (s[i] == 'n') {
      cntn++;
      if (i == n - 1 or s[i + 1] != 'n') {
        cerr << "cntn"
             << " = " << (cntn) << '\n';
        ans *= (dp[0][cntn] + dp[2][cntn]);
        cntn = 0;
      }
    }
  }
  print(ans);
  return 0;
}

### Prompt

Generate a CPP solution to the following problem:

Constanze is the smartest girl in her village but she has bad eyesight.

One day, she was able to invent an incredible machine! When you pronounce letters, the machine will inscribe them onto a piece of paper. For example, if you pronounce 'c', 'o', 'd', and 'e' in that order, then the machine will inscribe "code" onto the paper. Thanks to this machine, she can finally write messages without using her glasses.

However, her dumb friend Akko decided to play a prank on her. Akko tinkered with the machine so that if you pronounce 'w', it will inscribe "uu" instead of "w", and if you pronounce 'm', it will inscribe "nn" instead of "m"! Since Constanze had bad eyesight, she was not able to realize what Akko did.

The rest of the letters behave the same as before: if you pronounce any letter besides 'w' and 'm', the machine will just inscribe it onto a piece of paper.

The next day, I received a letter in my mailbox. I can't understand it so I think it's either just some gibberish from Akko, or Constanze made it using her machine. But since I know what Akko did, I can just list down all possible strings that Constanze's machine would have turned into the message I got and see if anything makes sense.

But I need to know how much paper I will need, and that's why I'm asking you for help. Tell me the number of strings that Constanze's machine would've turned into the message I got.

But since this number can be quite large, tell me instead its remainder when divided by 10^9+7.

If there are no strings that Constanze's machine would've turned into the message I got, then print 0.

Input

Input consists of a single line containing a string s (1 ≤ |s| ≤ 10^5) — the received message. s contains only lowercase Latin letters.

Output

Print a single integer — the number of strings that Constanze's machine would've turned into the message s, modulo 10^9+7.

Examples

Input


ouuokarinn


Output


4


Input


banana


Output


1


Input


nnn


Output


3


Input


amanda


Output


0

Note

For the first example, the candidate strings are the following: "ouuokarinn", "ouuokarim", "owokarim", and "owokarinn".

For the second example, there is only one: "banana".

For the third example, the candidate strings are the following: "nm", "mn" and "nnn".

For the last example, there are no candidate strings that the machine can turn into "amanda", since the machine won't inscribe 'm'.

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
constexpr long long MOD = 1e9 + 7;
template <typename T>
using pq = priority_queue<T>;
template <typename T>
using pqr = priority_queue<T, vector<T>, greater<T>>;
const long long INF = LLONG_MAX / 2;
using P = pair<long long, long long>;
using vec = vector<long long>;
template <typename T>
using mat = vector<vector<T>>;
template <typename T1, typename T2>
ostream& operator<<(ostream& stream, const pair<T1, T2>& p) {
  return stream << p.first << "," << p.second;
}
template <typename T>
void print(const vector<T> vec) {
  for (long long i = (0); i <= static_cast<long long>(vec.size() - 1 - 1); i++)
    cout << vec[i] << ' ';
  cout << vec[vec.size() - 1] << '\n';
}
template <typename Arg>
void print(const Arg arg) {
  cout << arg << '\n';
}
template <typename Head, typename... Args>
void print(const Head head, const Args... args) {
  cout << head << " ";
  print(args...);
}
template <typename T, typename U>
void init(vector<T>& v, vector<U>& w) {
  for (long long i = (0); i <= static_cast<long long>(v.size() - 1); i++)
    cin >> v[i] >> w[i];
}
template <typename T>
void init(vector<T>& v) {
  for (long long i = (0); i <= static_cast<long long>(v.size() - 1); i++)
    cin >> v[i];
}
template <typename T>
T sum_(vector<T> vec, T init = 0) {
  return std::accumulate((vec).begin(), (vec).end(), T(init));
}
template <typename T>
bool chmax(T& a, const T& b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
bool chmin(T& a, const T& b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
long long index(const T& vec, const typename T::iterator it) {
  return distance(vec.begin(), it);
}
template <typename T = long long>
mat<T> mmat(long long n, long long m = 0) {
  return mat<T>(n, vector<T>(m));
}
template <typename T = long long>
vector<T> ivec(long long n) {
  vector<T> v(n);
  init(v);
  return v;
}
void yn(bool tf) { print(tf ? "Yes" : "No"); }
void YN(bool tf) { print(tf ? "YES" : "NO"); }
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
class mint {
  using ll = long long;
  ll num;

 public:
  mint(ll x = 0) : num(x % MOD) {}
  mint operator+=(const mint& x) noexcept {
    this->num += x.num;
    if (this->num >= MOD) this->num %= MOD;
    return *this;
  }
  mint operator-=(const mint& x) noexcept {
    if (this->num < x.num) this->num += MOD;
    this->num -= x.num;
    return *this;
  }
  mint operator*=(const mint& x) noexcept {
    this->num = (this->num * x.num) % MOD;
    return *this;
  }
  mint operator/=(mint x) noexcept {
    ll exp = MOD - 2;
    while (exp) {
      if (exp % 2) *this *= x;
      x *= x;
      exp /= 2;
    }
    return *this;
  }
  mint operator%=(const mint& x) noexcept {
    this->num %= x.num;
    return *this;
  }
  mint operator+(const mint& x) const noexcept { return mint(*this) += x; }
  mint operator-(const mint& x) const noexcept { return mint(*this) -= x; }
  mint operator*(const mint& x) const noexcept { return mint(*this) *= x; }
  mint operator/(const mint& x) const noexcept { return mint(*this) /= x; }
  mint operator%(const mint& x) const noexcept { return mint(*this) %= x; }
  mint operator&(const mint& x) const noexcept { return this->num & x.num; }
  bool operator==(const mint& x) const noexcept { return this->num == x.num; }
  bool operator!=(const mint& x) const noexcept { return not((*this) == x); }
  explicit operator bool() const noexcept { return this->num != 0; }
  explicit operator long long() const noexcept { return this->num; }
  mint pow(mint _n) {
    mint r = mint(*this);
    mint re = 1;
    long long n = (long long)_n;
    for (; n; n /= 2) {
      if (n & 1) re *= r;
      r *= r;
    }
    return re;
  }
  mint inv() { return this->pow(MOD - 2); }
  friend ostream& operator<<(ostream&, const mint&);
};
ostream& operator<<(ostream& stream, const mint& x) { return stream << x.num; }
signed main() {
  cin.tie(0), cout.tie(0), ios::sync_with_stdio(false);
  string s;
  cin >> s;
  long long n = s.length();
  mat<mint> dp = mmat<mint>(3, n + 1);
  for (long long i = (0); i <= static_cast<long long>(n + 1 - 1); i++) {
    if (i == 0) continue;
    if (i == 1) {
      dp[0][i] = 1;
      dp[1][i] = 1;
      dp[2][i] = 0;
      continue;
    }
    dp[0][i] = dp[0][i - 1] + dp[2][i - 1];
    dp[1][i] = dp[0][i - 1] + dp[2][i - 1];
    dp[2][i] = dp[1][i - 1];
  }
  mint ans = 1;
  long long cntu = 0, cntn = 0;
  for (long long i = (0); i <= static_cast<long long>(n - 1); i++) {
    if (s[i] == 'm' or s[i] == 'w') {
      print(0);
      return 0;
    }
    if (s[i] == 'u') {
      cntu++;
      if (i == n - 1 or s[i + 1] != 'u') {
        cerr << "cntu"
             << " = " << (cntu) << '\n';
        ans *= (dp[0][cntu] + dp[2][cntu]);
        cntu = 0;
      }
    } else if (s[i] == 'n') {
      cntn++;
      if (i == n - 1 or s[i + 1] != 'n') {
        cerr << "cntn"
             << " = " << (cntn) << '\n';
        ans *= (dp[0][cntn] + dp[2][cntn]);
        cntn = 0;
      }
    }
  }
  print(ans);
  return 0;
}

```