#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cfloat>
#include <complex>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <string.h>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
#define int long long
#define ll long long
#define mod (int)1000000007
#define P pair<int,int>
#define prique(T) priority_queue<T,vector<T>,greater<T>>
#define all(V) V.begin(),V.end()
#ifdef int
constexpr int INF = LLONG_MAX / 10;
#else
constexpr int INF = INT_MAX / 10;
#endif
constexpr double eps = 1e-9;
template <class T, class U>
inline bool chmax(T& lhs, const U& rhs) {
	if (lhs < rhs) {
		lhs = rhs;
		return 1;
	}
	return 0;
}
template <class T, class U>
inline bool chmin(T& lhs, const U& rhs) {
	if (lhs > rhs) {
		lhs = rhs;
		return 1;
	}
	return 0;
}
using namespace std;
inline int gcd(int a, int b) {
	while (b) {
		int c = a;
		a = b; b = c % b;
	}
	return a;
}
inline int lcm(int a, int b) {
	return a / gcd(a, b) * b;
}
bool isprime(int n) {
	if (n == 1)return false;
	for (int i = 2; i * i <= n; i++) {
		if (n % i == 0)return false;
	}
	return true;
}
int mypow(int a, int b) {
	if (!b)return 1;
	if (b & 1)return mypow(a, b - 1) * a;
	int memo = mypow(a, b >> 1);
	return memo * memo;
}
int modpow(int a, int b, int m = mod) {
	if (!b)return 1;
	if (b & 1)return modpow(a, b - 1, m) * a % m;
	int memo = modpow(a, b >> 1, m);
	return memo * memo % m;
}
class modInt {
	int value, modulo;
public:
	modInt() : value(0), modulo(mod) { value = 0; }
	template<typename T>
	modInt(T value = 0, int modulo = mod) : value(value), modulo(modulo) {
		if (value < 0) {
			value = -value;
			value %= modulo;
			value = -value;
			value += modulo;
		}
		this->value = value % modulo;
	}
	inline operator int()const { return value; }
	inline modInt& operator+=(modInt x) {
		value += x.value;
		if (value >= modulo)value -= modulo;
		return *this;
	}
	inline modInt& operator++() {
		if (value == modulo - 1)value = 0;
		else value++;
		return *this;
	}
	inline modInt operator-()const {
		return modInt(0) -= *this;
	}
	inline modInt& operator-=(modInt x) {
		value -= x.value;
		if (value < 0)value += modulo;
		return *this;
	}
	inline modInt& operator--() {
		if (value == 0)value = modulo - 1;
		else value--;
		return *this;
	}
	inline modInt& operator*=(modInt x) {
		value = value * x.value % modulo;
		return *this;
	}
	inline modInt& operator/=(modInt x) {
		return operator*=(x.inv());
	}
	inline modInt inv() {
		return modpow(*this, modulo - 2);
	}
	template<typename T> modInt operator+(T x) { return modInt(*this) += x; }
	template<typename T> modInt& operator+=(T x) { return operator+=(modInt(x, modulo)); }
	template<typename T> modInt operator-(T x) { return modInt(*this) -= x; }
	template<typename T> modInt& operator-=(T x) { return operator-=(modInt(x, modulo)); }
	template<typename T> modInt operator*(T x) { return modInt(*this) *= x; }
	template<typename T> modInt& operator*=(T x) { return operator*=(modInt(x, modulo)); }
	template<typename T> modInt operator/(T x) { return modInt(*this) /= x; }
	template<typename T> modInt& operator/=(T x) { return operator/=(modInt(x, modulo)); }
};
istream& operator>>(istream& ist, modInt& x) {
	int a;
	ist >> a;
	x = a;
	return ist;
}
modInt modpow(modInt a, int b) {
	if (!b)return modInt(1);
	if (b & 1)return modpow(a, b - 1) * a;
	modInt memo = modpow(a, b / 2);
	return memo * memo;
}
class Polynomial {
public:
	vector<modInt> vec;
	Polynomial() {}
	Polynomial(vector<modInt> vec) :vec(vec) {}
	modInt get(modInt x) {
		modInt res = 0;
		rep(i, vec.size()) {
			res += modpow(x, i) * vec[i];
		}
		return res;
	}
	Polynomial integrate() {
		vector<modInt> res = vec;
		res.emplace_back();
		for (int i = (int)res.size() - 2; i >= 0; i--)res[i + 1] = res[i] / (i + 1);
		res[0] = 0;
		return Polynomial(res);
	}
};
class func {
public:
	Polynomial first, second;
	modInt third;
	func() {}
	func(Polynomial first, Polynomial second, modInt third) :first(first), second(second), third(third) {}
	void set(Polynomial first, Polynomial second, modInt third) {
		this->first = first;
		this->second = second;
		this->third = third;
	}
	func* operator+=(const func& f) {
		first.vec.resize(max(first.vec.size(), f.first.vec.size()));
		second.vec.resize(max(second.vec.size(), f.second.vec.size()));
		rep(i, f.first.vec.size())first.vec[i] += f.first.vec[i];
		rep(i, f.second.vec.size())second.vec[i] += f.second.vec[i];
		third += f.third;
		return this;
	}
};
func dintegrate(func f, bool flag) {
	Polynomial p = f.first.integrate(), q = f.second.integrate();
	if (!flag) {
		p.vec[0] = f.third;
		return func(p, q, -f.third);
	}
	else {
		p.vec[0] -= p.get(1);
		rep(i, p.vec.size())p.vec[i] = -p.vec[i];
		q.vec[0] -= q.get(1);
		q.vec[0] += f.third;
		rep(i, q.vec.size())q.vec[i] = -q.vec[i];
		return func(p, q, f.third);
	}
}
int n;
string s;
func dp[1010][2][2][2];
modInt fact[1010], inv[1010];
signed main() {
	cin >> n >> s;
	if (s[0] == 'X')dp[0][0][1][0].set(vector<modInt>(), vector<modInt>(), 1);
	else {
		dp[0][0][0][1].set(vector<modInt>(), vector<modInt>(), 1);
		dp[0][1][1][1].set(vector<modInt>(1, 1), vector<modInt>(), modInt(-1));
	}
	REP(i, n - 1) {
		if (s[i] == 'X') {
			dp[i][0][1][0] += dintegrate(dp[i - 1][1][1][0], 0);
			dp[i][0][1][0] += dintegrate(dp[i - 1][1][1][1], 0);
			dp[i][0][1][0] += dintegrate(dp[i - 1][0][0][1], 1);
			dp[i][0][1][0] += dintegrate(dp[i - 1][0][1][1], 1);
			dp[i][0][1][0] += dintegrate(dp[i - 1][1][0][1], 1);
			dp[i][0][1][0] += dintegrate(dp[i - 1][1][1][1], 1);
		}
		else {
			dp[i][0][0][1] += dintegrate(dp[i - 1][1][1][0], 0);
			dp[i][0][0][1] += dintegrate(dp[i - 1][1][1][1], 0);
			dp[i][1][1][1] += dintegrate(dp[i - 1][0][1][0], 0);
			dp[i][1][1][1] += dintegrate(dp[i - 1][0][1][1], 0);
			dp[i][0][0][1] += dintegrate(dp[i - 1][0][1][0], 1);
			dp[i][0][0][1] += dintegrate(dp[i - 1][0][1][1], 1);
			dp[i][0][0][1] += dintegrate(dp[i - 1][1][1][0], 1);
			dp[i][0][0][1] += dintegrate(dp[i - 1][1][1][1], 1);
		}
	}
	fact[0] = 1;
	REP(i, n)fact[i] = fact[i - 1] * i;
	inv[n] = modInt(1) / fact[n];
	for (int i = n - 1; i >= 0; i--)inv[i] = inv[i + 1] * (i + 1);
	modInt a, b, c;
	Polynomial p;

	p = dp[n - 1][0][1][1].first.integrate();
	a += p.get(1) - p.get(0);
	p = dp[n - 1][0][1][1].second.integrate();
	b += p.get(1) - p.get(0);
	a += dp[n - 1][0][1][1].third;
	b -= dp[n - 1][0][1][1].third;
	p = dp[n - 1][1][1][1].first.integrate();
	a += p.get(1) - p.get(0);
	p = dp[n - 1][1][1][1].second.integrate();
	b += p.get(1) - p.get(0);
	a += dp[n - 1][1][1][1].third;
	b -= dp[n - 1][1][1][1].third;

	rep(i, dp[n - 1][0][1][0].first.vec.size()) {
		a += dp[n - 1][0][1][0].first.vec[i] * fact[i];
		rep(j, i + 1) {
			b -= dp[n - 1][0][1][0].first.vec[i] * fact[i] * inv[j];
		}
	}
	rep(i, dp[n - 1][0][1][0].second.vec.size()) {
		b += dp[n - 1][0][1][0].second.vec[i] * fact[i];
		rep(j, i + 1) {
			c -= dp[n - 1][0][1][0].second.vec[i] * fact[i] * inv[j];
		}
	}
	a += dp[n - 1][0][1][0].third / 2;
	c -= dp[n - 1][0][1][0].third / 2;

	rep(i, dp[n - 1][1][1][0].first.vec.size()) {
		a += dp[n - 1][1][1][0].first.vec[i] * fact[i];
		rep(j, i + 1) {
			b -= dp[n - 1][1][1][0].first.vec[i] * fact[i] * inv[j];
		}
	}
	rep(i, dp[n - 1][1][1][0].second.vec.size()) {
		b += dp[n - 1][1][1][0].second.vec[i] * fact[i];
		rep(j, i + 1) {
			c -= dp[n - 1][1][1][0].second.vec[i] * fact[i] * inv[j];
		}
	}
	a += dp[n - 1][1][1][0].third / 2;
	c -= dp[n - 1][1][1][0].third / 2;

	p = dp[n - 1][0][0][1].first.integrate();
	a += p.get(1) - p.get(0);
	p = dp[n - 1][0][0][1].second.integrate();
	b += p.get(1) - p.get(0);
	a += dp[n - 1][0][0][1].third;
	b -= dp[n - 1][0][0][1].third;

	p = dp[n - 1][1][0][1].first.integrate();
	a += p.get(1) - p.get(0);
	p = dp[n - 1][1][0][1].second.integrate();
	b += p.get(1) - p.get(0);
	a += dp[n - 1][1][0][1].third;
	b -= dp[n - 1][1][0][1].third;

	rep(i, dp[n - 1][0][0][1].first.vec.size()) {
		a -= dp[n - 1][0][0][1].first.vec[i] * fact[i];
		rep(j, i + 1) {
			b += dp[n - 1][0][0][1].first.vec[i] * fact[i] * inv[j];
		}
	}
	rep(i, dp[n - 1][0][0][1].second.vec.size()) {
		b -= dp[n - 1][0][0][1].second.vec[i] * fact[i];
		rep(j, i + 1) {
			c += dp[n - 1][0][0][1].second.vec[i] * fact[i] * inv[j];
		}
	}
	a -= dp[n - 1][0][0][1].third / 2;
	c += dp[n - 1][0][0][1].third / 2;

	rep(i, dp[n - 1][1][0][1].first.vec.size()) {
		a -= dp[n - 1][1][0][1].first.vec[i] * fact[i];
		rep(j, i + 1) {
			b += dp[n - 1][1][0][1].first.vec[i] * fact[i] * inv[j];
		}
	}
	rep(i, dp[n - 1][1][0][1].second.vec.size()) {
		b -= dp[n - 1][1][0][1].second.vec[i] * fact[i];
		rep(j, i + 1) {
			c += dp[n - 1][1][0][1].second.vec[i] * fact[i] * inv[j];
		}
	}
	a -= dp[n - 1][1][0][1].third / 2;
	c += dp[n - 1][1][0][1].third / 2;

	cout << a << " " << b << " " << c << endl;
	return 0;
}