This submission is migrated from previous version of oj.uz, which used different machine for grading. This submission may have different result if resubmitted.
#include <bits/stdc++.h>
using namespace std;
#define sz(x) ((int)size(x))
#define all(x) begin(x), end(x)
#define trace(x) cout << #x << ": " << (x) << endl;
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
namespace Ment {
template<typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template<typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template<typename U>
Modular(const U &x) {
value = normalize(x);
}
template<typename U>
static Type normalize(const U &x) {
Type v;
if (-mod() <= x && x < mod()) v = static_cast<Type>(x);
else v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type &operator()() const { return value; }
template<typename U>
explicit operator U() const { return static_cast<U>(value); }
constexpr static Type mod() { return T::value; }
Modular &operator+=(const Modular &other) {
value += other.value - mod();
value += (value >> 31) & mod();
return *this;
}
Modular &operator-=(const Modular &other) {
value -= other.value;
value += (value >> 31) & mod();
return *this;
}
template<typename U>
Modular &operator+=(const U &other) { return *this += Modular(other); }
template<typename U>
Modular &operator-=(const U &other) { return *this -= Modular(other); }
Modular &operator++() { return *this += 1; }
Modular &operator--() { return *this -= 1; }
Modular operator++(int) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(int) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template<typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value, Modular>::type &
operator*=(const Modular &rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x), d, m;
asm(
"divl %4; \n\t"
: "=a" (d), "=d" (m)
: "d" (xh), "a" (xl), "r" (mod())
);
value = m;
#else
value = normalize(static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template<typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value, Modular>::type &
operator*=(const Modular &rhs) {
int64_t q = static_cast<int64_t>(static_cast<long double>(value) * rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template<typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value, Modular>::type &
operator*=(const Modular &rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular &operator/=(const Modular &other) { return *this *= Modular(inverse(other.value, mod())); }
template<typename U>
friend bool operator==(const Modular<U> &lhs, const Modular<U> &rhs);
template<typename U>
friend bool operator<(const Modular<U> &lhs, const Modular<U> &rhs);
template<typename U>
friend std::istream &operator>>(std::istream &stream, Modular<U> &number);
private:
Type value;
};
template<typename T>
bool operator==(const Modular<T> &lhs, const Modular<T> &rhs) { return lhs.value == rhs.value; }
template<typename T, typename U>
bool operator==(const Modular<T> &lhs, U rhs) { return lhs == Modular<T>(rhs); }
template<typename T, typename U>
bool operator==(U lhs, const Modular<T> &rhs) { return Modular<T>(lhs) == rhs; }
template<typename T>
bool operator!=(const Modular<T> &lhs, const Modular<T> &rhs) { return !(lhs == rhs); }
template<typename T, typename U>
bool operator!=(const Modular<T> &lhs, U rhs) { return !(lhs == rhs); }
template<typename T, typename U>
bool operator!=(U lhs, const Modular<T> &rhs) { return !(lhs == rhs); }
template<typename T>
bool operator<(const Modular<T> &lhs, const Modular<T> &rhs) { return lhs.value < rhs.value; }
template<typename T>
Modular<T> operator+(const Modular<T> &lhs, const Modular<T> &rhs) { return Modular<T>(lhs) += rhs; }
template<typename T, typename U>
Modular<T> operator+(const Modular<T> &lhs, U rhs) { return Modular<T>(lhs) += rhs; }
template<typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T> &rhs) { return Modular<T>(lhs) += rhs; }
template<typename T>
Modular<T> operator-(const Modular<T> &lhs, const Modular<T> &rhs) { return Modular<T>(lhs) -= rhs; }
template<typename T, typename U>
Modular<T> operator-(const Modular<T> &lhs, U rhs) { return Modular<T>(lhs) -= rhs; }
template<typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T> &rhs) { return Modular<T>(lhs) -= rhs; }
template<typename T>
Modular<T> operator*(const Modular<T> &lhs, const Modular<T> &rhs) { return Modular<T>(lhs) *= rhs; }
template<typename T, typename U>
Modular<T> operator*(const Modular<T> &lhs, U rhs) { return Modular<T>(lhs) *= rhs; }
template<typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T> &rhs) { return Modular<T>(lhs) *= rhs; }
template<typename T>
Modular<T> operator/(const Modular<T> &lhs, const Modular<T> &rhs) { return Modular<T>(lhs) /= rhs; }
template<typename T, typename U>
Modular<T> operator/(const Modular<T> &lhs, U rhs) { return Modular<T>(lhs) /= rhs; }
template<typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T> &rhs) { return Modular<T>(lhs) /= rhs; }
template<typename T, typename U>
Modular<T> power(const Modular<T> &a, const U &b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template<typename T>
string to_string(const Modular<T> &number) {
return to_string(number());
}
template<typename T>
std::ostream &operator<<(std::ostream &stream, const Modular<T> &number) {
return stream << number();
}
template<typename T>
std::istream &operator>>(std::istream &stream, Modular<T> &number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
constexpr int md = 998244353;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
}
using Ment::Mint;
typedef long long ll;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
int rand(int l, int r) { return (int) ((ll) rnd() % (r - l + 1)) + l; }
const int N = 8, A = 62, L = 11;
const ll infL = 3e18;
int g[N][3] = {{1, 2, 4},
{0, 3, 5},
{0, 3, 6},
{1, 2, 7},
{0, 5, 6},
{1, 4, 7},
{2, 4, 7},
{3, 5, 6}};
int n;
Mint cnt[A][A][L], dp2[A][A][A], dp7[A][A][A], dp1[A][A][A], dp4[A][A][A];
Mint ans = 0;
int len = 0, used[N];
int get(char c) {
if ('a' <= c && c <= 'z') {
return c - 'a';
}
if ('A' <= c && c <= 'Z') {
return (c - 'A') + 26;
}
return (c - '0') + 52;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
vector<string> stt;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
string ss = s;
reverse(all(ss));
stt.push_back(ss);
stt.push_back(s);
}
sort(all(stt));
stt.resize(unique(all(stt)) - begin(stt));
for (string s: stt) {
++cnt[get(s[0])][get(s.back())][sz(s)];
}
for (len = 1; len < L; ++len) {
for (int x0 = 0; x0 < A; ++x0) {
for (int x3 = 0; x3 < A; ++x3) {
for (int x6 = 0; x6 < A; ++x6) {
Mint sum = 0;
for (int x = 0; x < A; ++x) {
sum += cnt[x][x0][len] * cnt[x][x3][len] * cnt[x][x6][len];
}
dp2[x0][x3][x6] = dp7[x0][x3][x6] = dp1[x0][x3][x6] = dp4[x0][x3][x6] = sum;
}
}
}
for (int x0 = 0; x0 < A; ++x0) {
for (int x3 = 0; x3 < A; ++x3) {
for (int x5 = 0; x5 < A; ++x5) {
for (int x6 = 0; x6 < A; ++x6) {
ans = (ans + dp4[x0][x5][x6] * dp7[x3][x5][x6] * dp1[x0][x3][x5] *
dp2[x0][x3][x6]);
}
}
}
}
}
cout << ans;
return 0;
}
Compilation message (stderr)
cubeword.cpp:30:39: warning: bad option '-fwhole-program' to pragma 'optimize' [-Wpragmas]
30 | #pragma GCC optimize("-fwhole-program")
| ^
cubeword.cpp:37:41: warning: bad option '-fstrict-overflow' to pragma 'optimize' [-Wpragmas]
37 | #pragma GCC optimize("-fstrict-overflow")
| ^
cubeword.cpp:39:41: warning: bad option '-fcse-skip-blocks' to pragma 'optimize' [-Wpragmas]
39 | #pragma GCC optimize("-fcse-skip-blocks")
| ^
cubeword.cpp:53:51: warning: bad option '-funsafe-loop-optimizations' to pragma 'optimize' [-Wpragmas]
53 | #pragma GCC optimize("-funsafe-loop-optimizations")
| ^
cubeword.cpp:59:23: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
59 | T inverse(T a, T m) {
| ^
cubeword.cpp:59:23: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:59:23: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:59:23: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:77:27: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
77 | constexpr Modular() : value() {}
| ^
cubeword.cpp:77:27: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:77:27: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:77:27: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:80:27: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
80 | Modular(const U &x) {
| ^
cubeword.cpp:80:27: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:80:27: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:80:27: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:85:41: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
85 | static Type normalize(const U &x) {
| ^
cubeword.cpp:85:41: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:85:41: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:85:41: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:93:34: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
93 | const Type &operator()() const { return value; }
| ^~~~~
cubeword.cpp:93:34: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:93:34: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:93:34: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:96:31: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
96 | explicit operator U() const { return static_cast<U>(value); }
| ^~~~~
cubeword.cpp:96:31: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:96:31: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:96:31: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:98:35: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
98 | constexpr static Type mod() { return T::value; }
| ^
cubeword.cpp:98:35: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:98:35: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:98:35: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:100:49: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
100 | Modular &operator+=(const Modular &other) {
| ^
cubeword.cpp:100:49: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:100:49: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:100:49: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:106:49: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
106 | Modular &operator-=(const Modular &other) {
| ^
cubeword.cpp:106:49: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:106:49: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:106:49: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:113:43: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
113 | Modular &operator+=(const U &other) { return *this += Modular(other); }
| ^
cubeword.cpp:113:43: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:113:43: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:113:43: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:116:43: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
116 | Modular &operator-=(const U &other) { return *this -= Modular(other); }
| ^
cubeword.cpp:116:43: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:116:43: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:116:43: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:118:29: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
118 | Modular &operator++() { return *this += 1; }
| ^
cubeword.cpp:118:29: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:118:29: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:118:29: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:120:29: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
120 | Modular &operator--() { return *this -= 1; }
| ^
cubeword.cpp:120:29: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:120:29: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:120:29: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:122:31: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
122 | Modular operator++(int) {
| ^
cubeword.cpp:122:31: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:122:31: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:122:31: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:128:31: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
128 | Modular operator--(int) {
| ^
cubeword.cpp:128:31: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:128:31: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:128:31: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:134:29: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
134 | Modular operator-() const { return Modular(-value); }
| ^~~~~
cubeword.cpp:134:29: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:134:29: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:134:29: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:138:38: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
138 | operator*=(const Modular &rhs) {
| ^
cubeword.cpp:138:38: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:138:38: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:138:38: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:156:38: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
156 | operator*=(const Modular &rhs) {
| ^
cubeword.cpp:156:38: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:156:38: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:156:38: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:164:38: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
164 | operator*=(const Modular &rhs) {
| ^
cubeword.cpp:164:38: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:164:38: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:164:38: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:169:49: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
169 | Modular &operator/=(const Modular &other) { return *this *= Modular(inverse(other.value, mod())); }
| ^
cubeword.cpp:169:49: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:169:49: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:169:49: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:172:76: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
172 | friend bool operator==(const Modular<U> &lhs, const Modular<U> &rhs);
| ^
cubeword.cpp:172:76: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:172:76: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:172:76: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:175:75: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
175 | friend bool operator<(const Modular<U> &lhs, const Modular<U> &rhs);
| ^
cubeword.cpp:175:75: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:175:75: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:175:75: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:178:81: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
178 | friend std::istream &operator>>(std::istream &stream, Modular<U> &number);
| ^
cubeword.cpp:178:81: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:178:81: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:178:81: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:185:65: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
185 | bool operator==(const Modular<T> &lhs, const Modular<T> &rhs) { return lhs.value == rhs.value; }
| ^
cubeword.cpp:185:65: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:185:65: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:185:65: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:188:49: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
188 | bool operator==(const Modular<T> &lhs, U rhs) { return lhs == Modular<T>(rhs); }
| ^
cubeword.cpp:188:49: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:188:49: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:188:49: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:191:49: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
191 | bool operator==(U lhs, const Modular<T> &rhs) { return Modular<T>(lhs) == rhs; }
| ^
cubeword.cpp:191:49: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:191:49: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:191:49: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:194:65: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
194 | bool operator!=(const Modular<T> &lhs, const Modular<T> &rhs) { return !(lhs == rhs); }
| ^
cubeword.cpp:194:65: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:194:65: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:194:65: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:197:49: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
197 | bool operator!=(const Modular<T> &lhs, U rhs) { return !(lhs == rhs); }
| ^
cubeword.cpp:197:49: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:197:49: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:197:49: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:200:49: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
200 | bool operator!=(U lhs, const Modular<T> &rhs) { return !(lhs == rhs); }
| ^
cubeword.cpp:200:49: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
cubeword.cpp:200:49: warning: bad option '-fcse-skip-blocks' to attribute 'optimize' [-Wattributes]
cubeword.cpp:200:49: warning: bad option '-funsafe-loop-optimizations' to attribute 'optimize' [-Wattributes]
cubeword.cpp:203:64: warning: bad option '-fwhole-program' to attribute 'optimize' [-Wattributes]
203 | bool operator<(const Modular<T> &lhs, const Modular<T> &rhs) { return lhs.value < rhs.value; }
| ^
cubeword.cpp:203:64: warning: bad option '-fstrict-overflow' to attribute 'optimize' [-Wattributes]
/var/local/lib/isola| # | Verdict | Execution time | Memory | Grader output |
|---|
| Fetching results... |
| # | Verdict | Execution time | Memory | Grader output |
|---|
| Fetching results... |
| # | Verdict | Execution time | Memory | Grader output |
|---|
| Fetching results... |
| # | Verdict | Execution time | Memory | Grader output |
|---|
| Fetching results... |
