#include <bits/stdc++.h>
#ifdef dbg
#define D(...) fprintf(stderr, __VA_ARGS__)
#define DD(...) D(#__VA_ARGS__ " = "), debug_helper::debug(__VA_ARGS__), D("\n")
#include "C:\Users\wsyear\Desktop\OI\templates\debug.hpp"
#else
#define D(...) ((void)0)
#define DD(...) ((void)0)
#endif
#define rep(i, j, k) for (int i = (j); i <= (k); ++i)
#define per(i, j, k) for (int i = (j); i >= (k); --i)
#define SZ(v) int((v).size())
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
#define gc getchar
#define pc putchar
using ll = long long;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;

using namespace std;

template <class T = int> T read() {
  T x = 0; bool f = 0; char ch = gc();
  while (!isdigit(ch)) f = ch == '-', ch = gc();
  while (isdigit(ch)) x = (x << 3) + (x << 1) + (ch ^ 48), ch = gc();
  return f ? -x: x;
}
template <class T> void write(T x) {
  if (x >= 0) { if (x > 9) write(x / 10); pc(x % 10 + 48); }
  else { pc('-'); if (x < -9) write(-x / 10); pc(48 - x % 10); }
}

template <int P>
class mod_int {
	using Z = mod_int;

private:
	static int mo(int x) { return x < 0 ? x + P : x; }

public:
	int x;
	int val() const { return x; }
	mod_int() : x(0) {}
	template <class T>
	mod_int(const T &x_) : x(x_ >= 0 && x_ < P ? static_cast<int>(x_) : mo(static_cast<int>(x_ % P))) {}
	bool operator==(const Z &rhs) const { return x == rhs.x; }
	bool operator!=(const Z &rhs) const { return x != rhs.x; }
	Z operator-() const { return Z(x ? P - x : 0); }
	Z pow(long long k) const {
		Z res = 1, t = *this;
		while (k) {
			if (k & 1) res *= t;
			if (k >>= 1) t *= t;
		}
		return res;
	}
	Z &operator++() {
		x < P - 1 ? ++x : x = 0;
		return *this;
	}
	Z &operator--() {
		x ? --x : x = P - 1;
		return *this;
	}
	Z operator++(int) {
		Z ret = x;
		x < P - 1 ? ++x : x = 0;
		return ret;
	}
	Z operator--(int) {
		Z ret = x;
		x ? --x : x = P - 1;
		return ret;
	}
	Z inv() const { return pow(P - 2); }
	Z &operator+=(const Z &rhs) {
		(x += rhs.x) >= P && (x -= P);
		return *this;
	}
	Z &operator-=(const Z &rhs) {
		(x -= rhs.x) < 0 && (x += P);
		return *this;
	}
	Z &operator*=(const Z &rhs) {
		x = 1ULL * x * rhs.x % P;
		return *this;
	}
	Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
#define setO(T, o)                                 \
	friend T operator o(const Z &lhs, const Z &rhs) {\
		Z res = lhs;                                   \
		return res o## = rhs;                          \
	}
	setO(Z, +) setO(Z, -) setO(Z, *) setO(Z, /)
#undef setO
};
const int P = 998244353;
using Z = mod_int<P>;

const int N = 22;

int n, a[N];
ll dp[1 << N];

int main() {
  n = read();
  rep (i, 0, n - 1) a[n - i] = read();
  rep (i, 0, (1 << n) - 1) dp[i] = 1E18;
  dp[1] = 0;
  rep (mask, 1, (1 << n) - 1) rep (k, 0, n - 1) {
    int m1 = (mask << k) & ((1 << n) - 1), m2 = mask >> (n - k);
    dp[mask | m1 | m2] = min(dp[mask | m1 | m2], dp[mask] + a[k]);
  }
  per (mask, (1 << n) - 1, 1) rep (k, 0, n - 1) if (mask >> k & 1) {
    dp[mask ^ (1 << k)] = min(dp[mask ^ (1 << k)], dp[mask]);
  }
  Z ans = 0;
  rep (mask, 1, (1 << n) - 1) ans += Z(mask) * dp[mask];
  write(ans.val());
}