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

// #define int long long

#define GET_MACRO(a, b, c, d, NAME, ...) NAME
#define REP2(i, n) REP3(i, 0, n)
#define REP3(i, a, b) REP4(i, a, b, 1)
#define REP4(i, a, b, s) for (ll i = (a); i < (ll)(b); i += s)
#define RREP2(i, n) RREP3(i, 0, n)
#define RREP3(i, a, b) for (ll i = (b) - 1; i >= (ll)(a); i--)

#define rep(...) GET_MACRO(__VA_ARGS__, REP4, REP3, REP2)(__VA_ARGS__)
#define rrep(...) GET_MACRO(__VA_ARGS__,, RREP3, RREP2)(__VA_ARGS__)
#define eb emplace_back
#define ef emplace_front
#define pb pop_back
#define pf pop_front
#define all(c) begin(c), end(c)
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
#define popcnt __builtin_popcountll

using uint = unsigned;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;

template<typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;

template<typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;

const int INF = 1e9 + 10;
const ll LLINF = 1e18 + 10;

const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
const int dx8[] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int dy8[] = {0, -1, -1, -1, 0, 1, 1, 1};

template<typename T>
inline T sq(T x){
	return x * x;
}

template<typename T, typename U>
inline bool chmax(T &x, U y){
	if (x >= y) return false;
	x = y;
	return true;
}

template<typename T, typename U>
inline bool chmin(T &x, U y){
	if (x <= y) return false;
	x = y;
	return true;
}

template<typename T>
inline T& sort(T &c){
	sort(all(c));
	return c;
}

template<typename T>
inline T& reverse(T &c){
	reverse(all(c));
	return c;
}

template<typename T>
inline T& unique(T &c){
	sort(all(c));
	c.erase(unique(all(c)), end(c));
	return c;
}

template<typename T>
inline T sorted(const T &c){
	T d = c;
	return sort(d);
}

template<typename T>
inline T reversed(const T &c){
	T d = c;
	return reverse(d);
}

template<typename T>
inline T uniqued(const T &c){
	T d = c;
	return unique(d);
}

template<typename T>
T power(T x, long long r, const T &e = 1){
	T res(e);
	while (r){
		if (r & 1) res = res * x;
		x = x * x;
		r >>= 1;
	}
	return res;
}

inline ll in(){
	ll x;
	scanf("%lld", &x);
	return x;
}
// }}}
// rig matrix {{{
template<typename T>
class RigMatrix {
public:	
	RigMatrix(): h(0), w(0), z(0), e(1), a(){}
	RigMatrix(int h, int w): h(h), w(w), z(0), e(1), a(h, vector<T>(w, z)){}
	RigMatrix(int h, int w, int z, int e): h(h), w(w), z(z), e(e), a(h, vector<T>(w, z)){}
	
	int height() const { return h; }
	int width() const { return w; }
	
	const T& operator()(int r, int c) const {
		assert(0 <= r && r < h);
		assert(0 <= c && c < w);
		return a[r][c];
	}

	T& operator()(int r, int c){
		assert(0 <= r && r < h);
		assert(0 <= c && c < w);
		return a[r][c];
	}

	RigMatrix operator+(const RigMatrix &r) const {
		assert(h == r.h && w == r.w);
		assert(e == r.e && z == r.z);
		RigMatrix res(h, w, z, e);
		for (int i = 0; i < h; i++){
			for (int j = 0; j < w; j++){
				res[i][j] = (*this)(i, j) + r(i, j);
			}
		}
		return res;
	}

	RigMatrix operator*(const RigMatrix &r) const {
		assert(w == r.h);
		assert(z == r.z && e == r.e);
		RigMatrix res(h, r.w, z, e);
		for (int i = 0; i < h; i++){
			for (int j = 0; j < r.w; j++){
				for (int k = 0; k < w; k++){
					res(i, j) = res(i, j) + (*this)(i, k) * r(k, j);
				}
			}
		}
		return res;
	}

	RigMatrix& operator+=(const RigMatrix &r){
		assert(h == r.h && w == r.h);
		for (int i = 0; i < h; i++){
			for (int j = 0; j < w; j++){
				(*this)(i, j) = (*this)(i, j) + r(i, j);
			}
		}
		return *this;
	}

	RigMatrix& operator*=(const RigMatrix &r){
		return *this = *this * r;
	}

	RigMatrix pow(ll x) const {
		RigMatrix A = *this;
		RigMatrix R(h, w, z, e);
		rep(i, h) R(i, i) = e;
		while (x > 0){
			if (x & 1) R *= A;
			A *= A;
			x >>= 1;
		}
		return R;
	}
	
private:
	int z, e;
	int h, w;
	vector<vector<T>> a;
};
// }}}

int conv(string s)
{
	int r = 0;
	rep(i, 3) r = r * 2 + (s[i] == 'o');
	return r;
}

int main()
{
	int n;
	string s, t;
	cin >> s >> n >> t;

	RigMatrix<int> A(8, 8);
	A(0, 0) = 1;
	A(1, 1) = A(1, 2) = 1;
	A(2, 1) = A(2, 4) = 1;
	A(3, 3) = A(3, 5) = 1;
	A(4, 2) = A(4, 4) = 1;
	A(5, 3) = A(5, 6) = 1;
	A(6, 5) = A(6, 6) = 1;
	A(7, 7) = 1;

	RigMatrix<int> B(8, 1);
	B(conv(s), 0) = 1;

	auto C = A.pow(n) * B;
	if (C(conv(t), 0)) cout << "FAILURE\n";
	else cout << "SUCCESS\n";
}