It was the third month of remote learning, Nastya got sick of staying at dormitory, so she decided to return to her hometown. In order to make her trip more entertaining, one of Nastya's friend presented her an integer array a. 

Several hours after starting her journey home Nastya remembered about the present. To entertain herself she decided to check, are there four different indices x, y, z, w such that a_x + a_y = a_z + a_w.

Her train has already arrived the destination, but she still hasn't found the answer. Can you help her unravel the mystery?

Input

The first line contains the single integer n (4 ≤ n ≤ 200 000) — the size of the array.

The second line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 2.5 ⋅ 10^6).

Output

Print "YES" if there are such four indices, and "NO" otherwise.

If such indices exist, print these indices x, y, z and w (1 ≤ x, y, z, w ≤ n).

If there are multiple answers, print any of them.

Examples

Input


6
2 1 5 2 7 4


Output


YES
2 3 1 6 

Input


5
1 3 1 9 20


Output


NO

Note

In the first example a_2 + a_3 = 1 + 5 = 2 + 4 = a_1 + a_6. Note that there are other answer, for example, 2 3 4 6.

In the second example, we can't choose four indices. The answer 1 2 2 3 is wrong, because indices should be different, despite that a_1 + a_2 = 1 + 3 = 3 + 1 = a_2 + a_3
#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
#include <math.h>
#define ll long long int
#define ld long long double
#define pb push_back
#define pll pair<ll, ll>
#define vi vector<int>
#define vl vector<ll>
#define vvl vector<vector<ll> >
#define vvi vector<vector<int> >
#define vlp vector<pair<ll, ll> >
#define vllp vector<pair<ll, ll>, ll>
#define mll map<ll, ll>
#define rep(i, a) for (ll i = 0; i < a; i++)
#define rep1(i, a) for (ll i = 1; i < a; i++)
#define foi(i, a, b) for (ll i = a; i < b; i++)
#define fod(i, a, b) for (ll i = a; i >= b; i--)
#define mp make_pair
#define fst first
#define sec second
#define ff first.first
#define fs first.second
#define pi pair<int, int>
#define ppi pair<pair<int, int>, int>
#define max3(a, b, c) max(max(a, b), c)
#define min3(a, b, c) min(min(a, b), c)
#define MAX 1e18
#define MOD 1000000007
//#define MOD 998244353
#define INF (ll)1e18
#define s(v) v.size()
#define e(v) v.empty()
//typedef long long ll;
ll c=0;
ll ans=0;
vvl grap(300100);
 
unordered_map< ll,ll>mpp;
bool sortbysec(const pair<int,int> &a, const pair<int,int> &b) { return (a.second < b.second); } 
ll gcd(ll a, ll b)
{
  if (b == 0)
    return a;
  return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
ll fexp(ll a, ll b)
{
  ll ans = 1;
  while (b)
  {
    if (b & 1)
      ans = ans * a % MOD;
    b /= 2;
    a = a * a % MOD;
  }
  return ans;
}
ll inverse(ll a, ll p) { return fexp(a, p - 2); }
// bool sortbysec(const pll &a, const pll &b){return (a.second < b.second);}
ll leng =0;
ll cou=0;
ll modify(ll n)
{
  ll res = n;
  res %= MOD;
  res += MOD;
  res %= MOD;
  return res;
}
ll min(ll a, ll b)
{
  if (a > b)
    return b;
  return a;
}
ll max(ll a, ll b)
{
  if (a < b)
    return b;
  return a;
}
bool isPrime(int x) 
{ 
   if (x == 1)
		return false;
	for (int i = 2; i * i <= x; ++i)
		if (x % i == 0)
			return false;
	return true;
}
void ingraph(vector<vector<ll> > &graph, ll m )
{
  ll x, y,z;
  rep(i, m)
  { 
    cin >> x >> y;
    x--;
    y--;
    graph[x].pb(y);
    graph[y].pb(x);
  }
}
 
map< pair<ll,ll> , ll>mm;
void dfs(vvl &grap,ll node,ll par,vl &xorr,ll xo,vl &v,vl &vis , vl &root,vl & dtree , ll depth){
 
  //if (vis[node]!=0)return;
  //root.pb(node);
  //dtree.pb(depth);
  
  
  for(auto i: grap[node]){
    if(i==par)continue;
      root.pb(node);
    dtree.pb(depth);
    if(vis[i]==0)vis[i]=s(root);
 
      xorr[i]=xo^v[i];
      dfs(grap,i,node,xorr,xo^v[i],v,vis,root, dtree, depth+1);
    }
 
    root.pb(node);
  dtree.pb(depth);
    
   
}
 
vl fact(400001,1);
bool myComparison(const pair<ll,ll> &a,const pair<ll,ll> &b){return a.second<b.second;}
vl primes;
void fill(ll i,ll l , ll r , ll d , vl &v, vl &tree){
  if(l==r){
    tree[i]=v[l-1];
    return;
  }
 
  ll mid =(l+r)/2 ;
  fill(2*i,l ,mid,d+1,v , tree);
  fill(2*i+1,mid+1,r,d+1,v,tree);
 
  tree[i] = max(tree[2*i],tree[2*i+1]);
 
}
 
pair<ll,ll> query( ll ind,vlp &tree , ll  l , ll r , ll ql , ll qr){
  //cout<<"at "<<l<<"---"<<r<<endl;
  if(ql <=l && qr>=r){
   // cout<<"returning"<<l<<"___"<<r<<endl;
    return mp(tree[ind].fst,tree[ind].sec);}
  else if(ql>r || qr<l){return mp(MAX,MAX);}
  ll mid = (l +r)/2;
  //cout<<"branching at"<<mid<<endl;
 // return min(query(2*ind , tree , l ,mid ,ql , qr), query(2*ind+1 , tree ,mid+1 , r , ql , qr));
 auto c = query(2*ind , tree , l ,mid ,ql , qr);
 auto d = query(2*ind+1 , tree ,mid+1 , r , ql , qr);
 
 if(c.fst < d.fst ){
   return mp(c.fst , c.sec);
 }else{
   return mp(d.fst , d.sec);
 }
}
 
void build(vlp &t,vl  &a,vl  &b, int v, int tl, int tr) {
    if (tl == tr) {
      //cout<<v<<"==="<<b[tl]<<endl;
        t[v] = mp(a[tl],b[tl]);
    } else {
        int tm = (tl + tr) / 2;
        build(t,a, b,v*2, tl, tm);
        build(t,a, b, v*2+1, tm+1, tr);
        t[v] = (t[v*2].fst < t[v*2+1].fst)? mp(t[v*2].fst,t[v*2].sec): mp(t[v*2+1].fst,t[v*2+1].sec);
    }
}
void update(vl &t,int v, int tl, int tr, int pos, int new_val) {
    if (tl == tr) {
        t[v] = new_val;
    } else {
        int tm = (tl + tr) / 2;
        if (pos <= tm)
            update(t,v*2, tl, tm, pos, new_val);
        else
            update(t,v*2+1, tm+1, tr, pos, new_val);
        t[v] = max(t[v*2] , t[v*2+1]);
    }
}
int getmax(vl &t,int i){
  if(t[2*i]==0){return i;}
  if(t[2*i]==t[1])
  {return getmax(t,2*i);}
  else{
    return getmax(t,2*i +1);
  }
}
 bool compare(vector<ll> & a, vector<ll> & b){
    return a.size() < b.size(); 
 }

pair<int ,int > m[2*2500001];
int main()
{ 
  ios_base::sync_with_stdio(0); cin.tie(0);
  ll te = 1;
  //cin >> te;
  rep(qqw,te)
  {
    
   ll n;
   cin>>n;

   vl v(n);
   rep(i,n){
     cin>>v[i];
   }

   rep(i,2*2500000 +1 ){
     m[i] = mp(-1,-1);
   }
   int flag=0;
   for(int i=0;i<n-1;i++){
     if(flag)break;
     for(int j=i+1;j<n;j++){
          ll sum = v[i]+v[j];
          if(m[sum]!=mp(-1,-1)){
            if(i+1 != m[sum].fst && j+1 != m[sum].sec && i+1 != m[sum].sec && j+1 != m[sum].fst){
              cout<<"YES"<<endl;
              cout<<i+1<<" "<<j+1<<" "<<m[sum].fst<<" "<<m[sum].sec<<endl;flag=1;
              break;

            }else{continue;}
          }
          m[sum]=mp(i+1,j+1);

     }
   }
if(flag==0)
cout<<"NO"<<endl;
   
  
  }
  return 0;
}