#include <bits/stdc++.h>

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;

const int N = 210;

PII path[N];
int a[N];
int s[N];
bool st[N];

void print(int x, bool flag) {
    stack<int> sta;
    while(x != 0) {
        sta.push(path[x].second);
        x = path[x].first;
    }
    if (!flag)
    cout << sta.size() << ' ';
    else cout << sta.size() + 1 << ' ';
    while (sta.size()) {
        cout << sta.top() << ' ';
        sta.pop();
    }
}
int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; i ++)   cin >> a[i];

    st[0] = 1;
    for (int i = 1; i <= n; i ++) {
        vector<int> v;
        for (int j = 0; j < 200; j ++) {
            if (st[j]) {
                if (s[(a[i] + j) % 200] > 0) {
                    cout << "Yes" << endl;
                    if ((a[i] + j) % 200 == 0) {
                        cout << 1 <<' ';
                        cout << path[(a[i] + j) % 200].second;
                    }
                    else print((a[i] + j) % 200, false);
                    cout << endl;
                    print(j, true);
                    cout << i;
                    return 0;
                }
                s[(a[i] + j) % 200] ++;
                v.push_back((a[i] + j) % 200);
                path[(a[i] + j) % 200] = {j, i};
            }
        }
        for (int i = 0; i < v.size(); i ++) st[v[i]] = 1;
    }
    cout << "No";
    return 0;
}

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

namespace tensor {
	template<typename T, int N, int...args>
	struct static_tensor : std::array<static_tensor<T, args...>, N> {
		static_tensor() : std::array<static_tensor<T, args...>, N>() {}

		void fill(const T &val) {
			for (int i = 0; i < N; i++) {
				(*this)[i].fill(val);
			}
		}
	};

	template<typename T, int N>
	struct static_tensor<T, N> : std::array<T, N> {
		static_tensor() : std::array<T, N>() {}
	};

	template<typename T, int D>
	struct dynamic_tensor : std::vector<dynamic_tensor<T, D - 1>> {
		dynamic_tensor() : std::vector<dynamic_tensor<T, D - 1>>() {}

		template<typename...args>
		dynamic_tensor(size_t n, args...A) : std::vector<dynamic_tensor<T, D - 1>>(n, dynamic_tensor<T, D - 1>(A...)) {}

		dynamic_tensor(const std::initializer_list<dynamic_tensor<T, D - 1>> &list) : std::vector<dynamic_tensor<T, D - 1>>(list) {}

		void fill(const T &val) {
			for (auto it = this->begin(); it != this->end(); it++) {
				it->fill(val);
			}
		}
	};

	template<typename T>
	struct dynamic_tensor<T, 1> : std::vector<T> {
		dynamic_tensor() : std::vector<T>() {}

		dynamic_tensor(size_t n, const T &val = T()) : std::vector<T>(n, val) {}

		dynamic_tensor(const std::initializer_list<T> &list) : std::vector<T>(list) {}

		void fill(const T &val = T()) {
			std::fill(this->begin(), this->end(), val);
		}
	};
}

int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);

	using tensor::dynamic_tensor;

	int n;
	cin >> n;

	vector<int> a(n);
	for (auto &x : a) cin >> x, x %= 200;

	dynamic_tensor<bool, 4> dp(n + 1, 200, 4, 2);
	//dp[pos][diff][mask][f]

	dynamic_tensor<int, 4> move(n + 1, 200, 4, 2);
	dynamic_tensor<tuple<int, int, int>, 4> back_track(n + 1, 200, 4, 2);

	dp[0][0][0][0] = true;
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < 200; j++) {
			for (int mask = 0; mask < 4; mask++) {
				for (int f = 0; f < 2; f++) {
					if (!dp[i][j][mask][f]) {
						continue;
					}
					//pick nothing
					dp[i + 1][j][mask][f] = true;
					move[i + 1][j][mask][f] = 0;
					back_track[i + 1][j][mask][f] = make_tuple(j, mask, f);

					//pick for b
					int new_j = (j + a[i]) % 200;
					dp[i + 1][new_j][mask | 1][1] = true;
					move[i + 1][new_j][mask | 1][1] = 1;
					back_track[i + 1][new_j][mask | 1][1] = make_tuple(j, mask, f);

					//pick for c
					new_j = (j + 200 - a[i]) % 200;
					dp[i + 1][new_j][mask | 2][1] = true;
					move[i + 1][new_j][mask | 2][1] = 2;
					back_track[i + 1][new_j][mask | 2][1] = make_tuple(j, mask, f);

					//pick for both
					dp[i + 1][j][mask | 3][f] = true;
					move[i + 1][j][mask | 3][f] = 3;
					back_track[i + 1][j][mask | 3][f] = make_tuple(j, mask, f);
				}
			}
		}
	}

	if (!dp[n][0][3][1]) {
		cout << "No\n";
		return 0;
	}

	vector<int> b, c;

	for (int i = n, j = 0, mask = 3, f = 1; i > 0; i--) {
		if (move[i][j][mask][f] == 1) {
			b.push_back(i);
		} else if (move[i][j][mask][f] == 2) {
			c.push_back(i);
		} else if (move[i][j][mask][f] == 3) {
			b.push_back(i);
			c.push_back(i);
		}
		tie(j, mask, f) = back_track[i][j][mask][f];
	}

	sort(b.begin(), b.end());
	sort(c.begin(), c.end());

	cout << "Yes\n";
	cout << b.size() << ' '; for (auto &x : b) cout << x << ' '; cout << '\n';
	cout << c.size() << ' '; for (auto &x : c) cout << x << ' '; cout << '\n';
	return 0;
}