#include <iostream>
#include <vector>
#include <string>
#include <deque>
#include <list>
#include <tuple>
#include <algorithm>
#include <set>

using namespace std;

uint64_t modValue[200] = {UINT64_MAX};
vector<int> pathOne[200];
int searchPath[200];
vector<uint64_t> all;

bool findFlg = false;

bool findTwo(int path[], int pathCount){
    uint64_t tempValue = 0;
    bool twoFlg = false;

    for(int count = 0; count < pathCount; count++){
        uint64_t value = all[(path[count] - 1)];
        tempValue += (value % 200);
    }
    tempValue = tempValue % 200;
    if(modValue[tempValue] == 1){
        cout << "Yes" << endl;
        cout << pathOne[tempValue].size() << " ";
        for(int count = 0; count < pathOne[tempValue].size(); count++){
            cout << pathOne[tempValue][count] << " ";
        }
        cout << endl;

        cout << pathCount << " ";
        for(int count = 0; count < pathCount; count++){
            cout << path[count] << " ";
        }
        cout << endl;

        twoFlg = true;
    } else {
        modValue[tempValue] = 1;
        for(int count = 0; count < pathCount; count++){
            pathOne[tempValue].push_back(path[count]);
        }
    }

    return twoFlg;
}

void solution(vector<uint64_t> all, int targetNum, int pathCount, int checkIndex) {
    if(pathCount == targetNum){
        if(findTwo(searchPath, pathCount)){
            findFlg = true;
        }
        return;
    }
    if(pathCount + all.size() - checkIndex == targetNum){
        for(int copyIndex = checkIndex; copyIndex < all.size(); copyIndex++){
            searchPath[pathCount] = copyIndex + 1;
            pathCount++;
        }
        if(findTwo(searchPath, pathCount)){
            findFlg = true;
        }
        return;
        
    }
    searchPath[pathCount] = checkIndex + 1;
    solution(all, targetNum, pathCount + 1, checkIndex + 1);
    if(findFlg){
        return;
    }

    solution(all, targetNum, pathCount, checkIndex + 1);
}

int main()
{
    int N;
    cin >> N;

    for(int readCount = 1; readCount <= N; readCount++){
        uint64_t temp;
        cin >> temp;
        all.push_back(temp % 200);
    }

    for(int current = 1; current <= N; current++){
        solution(all, current, 0, 0);
        if(findFlg){
            break;
        }
    }

    if(!findFlg){
        cout << "No" << endl;
    }
}
#include <bits/stdc++.h>
using namespace std;

using ll = long long;
using ull = unsigned long long;
using ld = long double;

#define MOD 1000000007LL

#define rep(i, n) for(ll (i) = 0LL;(i) < (ll)(n);(i)++)
#define rep2(i, s, e) for(ll (i) = (ll)(s);(i) < (ll)(e);(i)++)
#define repi(i, n) for(ll (i) = 0LL;(i) <= (ll)(n);(i)++)
#define repi2(i, s, e) for(ll (i) = (ll)(s);(i) <= (ll)(e);(i)++)
#define per(i, n) for(ll (i) = (ll)(n) - 1LL;(i) >= 0LL;(i)--)
#define per2(i, s, e) for(ll (i) = (ll)(s) - 1LL;(i) >= (ll)(e);(i)--)
#define peri(i, n) for(ll (i) = (ll)(n);(i) >= 0LL;(i)--)
#define peri2(i, s, e) for(ll (i) = (ll)(s);(i) >= (ll)(e);(i)--)
#define iter(i, it) for(auto &(i): (it))

template<typename T, typename U> ostream& operator<<(ostream &s, const pair<T, U> m) {
    cout << "(" << m.first << ", " << m.second << ")";
    return s;
}
template<typename T, typename U> ostream& operator<<(ostream &s, const map<T, U> m) {
    ll c = 0;
    cout << "{ ";
    iter(i, m) cout << i << (c++ == m.size() - 1 ? " " : ", ");
    cout << "}";
    return s;
}
template<typename T> ostream& operator<<(ostream &s, const vector<T> &v) {
    cout << "{ ";
    rep(i, v.size()) cout << v[i] << (i == v.size() - 1 ? " " : ", ");
    cout << "}";
    return s;
}
template<typename T> ostream& operator<<(ostream &s, const list<T> &v) {
    ll c = 0;
    cout << "{ ";
    iter(i, v) cout << i << (c++ == v.size() - 1 ? " " : ", ");
    cout << "}";
    return s;
}

int main(void) {
    ll a, b, c, d;
    cin >> a >> b >> c >> d;
    cout << b - c << endl;
    return 0;
}
