#include <bits/stdc++.h>
using namespace std;
using ll = long long;
mt19937 rng(1477);

#define int ll
const int MAXN = 40;
vector<int> g[MAXN];

signed main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0); cin.tie(0);

    int n;
    cin >> n;
    vector<int> b(n);
    for (auto &t : b) cin >> t;

    map<int, int> powtwo;
    for (int i = 0; i < 62; ++i) {
        powtwo[1LL << i] = 0;
    }
    vector<int> a;
    for (auto &t : b) {
        if (powtwo.count(t)) {
            powtwo[t]++;
        }
        else if (t != 0) {
            a.push_back(t);
        }
    }

    for (auto p : powtwo) {
        if (p.second >= 3) {
            cout << 3;
            return 0;
        }
    }

    n = a.size();
    if (n > MAXN) {
        cout << 3;
        return 0;
    }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (i != j && (a[i] & a[j])) {
                g[i].push_back(j);
            }
        }
    }

    int res = 2 * n;
    for (int i = 0; i < n; ++i) {
        vector<int> dist(n, -1);
        dist[i] = 0;
        queue<int> que({i});
        while (!que.empty()) {
            int cur = que.front();
            que.pop();
            for (int to : g[cur]) {
                if (dist[to] == -1) {
                    que.push(to);
                    dist[to] = dist[cur] + 1;
                }
                else if (dist[to] >= dist[cur]) {
                    res = min(res, dist[to] + dist[cur] + 1);
                }
            }
        }
    }
    cout << (res == 2 * n ? -1 : res);
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
mt19937 rng(1477);

#define int ll
const int MAXN = 100;
vector<int> g[MAXN];

signed main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0); cin.tie(0);

    int n;
    cin >> n;
    vector<int> a(n);
    for (auto &t : a) cin >> t;
    if (n > MAXN) {
        cout << 3;
        return 0;
    }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (i != j && (a[i] & a[j])) {
                g[i].push_back(j);
            }
        }
    }

    int res = 2 * n;
    for (int i = 0; i < n; ++i) {
        vector<int> dist(n, -1);
        dist[i] = 0;
        queue<int> que({i});
        while (!que.empty()) {
            int cur = que.front();
            que.pop();
            for (int to : g[cur]) {
                if (dist[to] == -1) {
                    que.push(to);
                    dist[to] = dist[cur] + 1;
                }
                else if (to != i) {
                    res = min(res, dist[to] + dist[cur] + 1);
                }
            }
        }
    }
    cout << (res == 2 * n ? -1 : res);
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
mt19937 rng(1477);

#define int ll
const int MAXN = 228;
vector<int> g[MAXN];

signed main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0); cin.tie(0);

    int n;
    cin >> n;
    vector<int> b(n);
    for (auto &t : b) cin >> t;

    map<int, int> powtwo;
    for (int i = 0; i < 62; ++i) {
        powtwo[1LL << i] = 0;
    }
    vector<int> a;
    for (auto &t : b) {
        if (powtwo.count(t)) {
            powtwo[t]++;
        }
        else if (t != 0) {
            a.push_back(t);
        }
    }

    for (auto p : powtwo) {
        if (p.second >= 3) {
            cout << 3;
            return 0;
        }
    }

    n = a.size();
    if (n > MAXN) {
        cout << 3;
        return 0;
    }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (i != j && (a[i] & a[j])) {
                g[i].push_back(j);
            }
        }
    }

    int res = 2 * n;
    for (int i = 0; i < n; ++i) {
        vector<int> dist(n, -1);
        dist[i] = 0;
        queue<int> que({i});
        while (!que.empty()) {
            int cur = que.front();
            que.pop();
            for (int to : g[cur]) {
                if (dist[to] == -1) {
                    que.push(to);
                    dist[to] = dist[cur] + 1;
                }
                else if (dist[to] >= dist[cur]) {
                    res = min(res, dist[to] + dist[cur] + 1);
                }
            }
        }
    }
    cout << (res == 2 * n ? -1 : res);
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
mt19937 rng(1477);

#define int ll
const int MAXN = 1000;
vector<int> g[MAXN];

signed main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0); cin.tie(0);

    int n;
    cin >> n;
    vector<int> b(n);
    for (auto &t : b) cin >> t;

    map<int, int> powtwo;
    for (int i = 0; i < 62; ++i) {
        powtwo[1LL << i] = 0;
    }
    vector<int> a;
    for (auto &t : b) {
        if (powtwo.count(t)) {
            powtwo[t]++;
        }
        else if (t != 0) {
            a.push_back(t);
        }
    }

    for (auto p : powtwo) {
        if (p.second >= 3) {
            cout << 3;
            return 0;
        }
    }

    n = a.size();
    if (n > MAXN) {
        cout << 3;
        return 0;
    }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (i != j && (a[i] & a[j])) {
                g[i].push_back(j);
            }
        }
    }

    int res = 2 * n;
    for (int i = 0; i < n; ++i) {
        vector<int> dist(n, -1);
        dist[i] = 0;
        queue<int> que({i});
        while (!que.empty()) {
            int cur = que.front();
            que.pop();
            for (int to : g[cur]) {
                if (dist[to] == -1) {
                    que.push(to);
                    dist[to] = dist[cur] + 1;
                }
                else if (dist[to] >= dist[cur]) {
                    res = min(res, dist[to] + dist[cur] + 1);
                }
            }
        }
    }
    cout << (res == 2 * n ? -1 : res);
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
mt19937 rng(1477);

vector<int> g[100];

signed main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0); cin.tie(0);

    int n;
    cin >> n;
    vector<int> a(n);
    for (auto &t : a) cin >> t;
    if (n > 40) {
        cout << 3;
        return 0;
    }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (i != j && (a[i] & a[j])) {
                g[i].push_back(j);
            }
        }
    }

    int res = 2 * n;
    for (int i = 0; i < n; ++i) {
        vector<int> dist(n, -1);
        dist[i] = 0;
        queue<int> que({i});
        while (!que.empty()) {
            int cur = que.front();
            que.pop();
            for (int to : g[cur]) {
                if (dist[to] == -1) {
                    que.push(to);
                    dist[to] = dist[cur] + 1;
                }
                else if (to != i) {
                    res = min(res, dist[to] + dist[cur] + 1);
                }
            }
        }
    }
    cout << (res == 2 * n ? -1 : res);
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
mt19937 rng(1477);

#define int ll
const int MAXN = 130;
vector<int> g[MAXN];

signed main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0); cin.tie(0);

    int n;
    cin >> n;
    vector<int> b(n);
    for (auto &t : b) cin >> t;

    vector<int> a;
    for (auto &t : b) {
        if (t != 0) {
            a.push_back(t);
        }
    }

    n = a.size();
    if (n > MAXN) {
        cout << 3;
        return 0;
    }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (i != j && (a[i] & a[j])) {
                g[i].push_back(j);
            }
        }
    }

    int res = 2 * n;
    for (int i = 0; i < n; ++i) {
        vector<int> dist(n, -1);
        dist[i] = 0;
        queue<int> que({i});
        while (!que.empty()) {
            int cur = que.front();
            que.pop();
            for (int to : g[cur]) {
                if (dist[to] == -1) {
                    que.push(to);
                    dist[to] = dist[cur] + 1;
                }
                else if (dist[to] >= dist[cur]) {
                    res = min(res, dist[to] + dist[cur] + 1);
                }
            }
        }
    }
    cout << (res == 2 * n ? -1 : res);
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
mt19937 rng(1477);

vector<int> g[100];

signed main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0); cin.tie(0);

    int n;
    cin >> n;
    vector<int> a(n);
    for (auto &t : a) cin >> t;
    if (n > 1000) {
        cout << 3;
        return 0;
    }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (i != j && (a[i] & a[j])) {
                g[i].push_back(j);
            }
        }
    }

    int res = 2 * n;
    for (int i = 0; i < n; ++i) {
        vector<int> dist(n, -1);
        dist[i] = 0;
        queue<int> que({i});
        while (!que.empty()) {
            int cur = que.front();
            que.pop();
            for (int to : g[cur]) {
                if (dist[to] == -1) {
                    que.push(to);
                    dist[to] = dist[cur] + 1;
                }
                else if (to != i) {
                    res = min(res, dist[to] + dist[cur] + 1);
                }
            }
        }
    }
    cout << (res == 2 * n ? -1 : res);
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
mt19937 rng(1477);

const int MAXN = 3e3 + 10;

vector<int> g[MAXN];

signed main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0); cin.tie(0);

    int n;
    cin >> n;
    vector<int> a(n);
    for (auto &t : a) cin >> t;
    if (n > MAXN) {
        cout << 3;
        return 0;
    }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (i != j && (a[i] & a[j])) {
                g[i].push_back(j);
            }
        }
    }

    int res = 2 * n;
    for (int i = 0; i < n; ++i) {
        vector<int> dist(n, -1);
        dist[i] = 0;
        queue<int> que({i});
        while (!que.empty()) {
            int cur = que.front();
            que.pop();
            for (int to : g[cur]) {
                if (dist[to] == -1) {
                    que.push(to);
                    dist[to] = dist[cur] + 1;
                }
                else if (to != i) {
                    res = min(res, dist[to] + dist[cur] + 1);
                }
            }
        }
    }
    cout << (res == 2 * n ? -1 : res);
}


#include <bits/stdc++.h>
using namespace std;
using ll = long long;
mt19937 rng(1477);

#define int ll
const int MAXN = 100;
vector<int> g[MAXN];

signed main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
#endif
    ios_base::sync_with_stdio(0); cin.tie(0);

    int n;
    cin >> n;
    vector<int> b(n);
    for (auto &t : b) cin >> t;

    vector<int> a;
    for (auto &t : b) {
        if (t != 0) {
            a.push_back(t);
        }
    }

    n = a.size();
    if (n > MAXN) {
        cout << 3;
        return 0;
    }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (i != j && (a[i] & a[j])) {
                g[i].push_back(j);
            }
        }
    }

    int res = 2 * n;
    for (int i = 0; i < n; ++i) {
        vector<int> dist(n, -1);
        dist[i] = 0;
        queue<int> que({i});
        while (!que.empty()) {
            int cur = que.front();
            que.pop();
            for (int to : g[cur]) {
                if (dist[to] == -1) {
                    que.push(to);
                    dist[to] = dist[cur] + 1;
                }
                else if (dist[to] >= dist[cur]) {
                    res = min(res, dist[to] + dist[cur] + 1);
                }
            }
        }
    }
    cout << (res == 2 * n ? -1 : res);
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
int flag[maxn];
const int ma=755;
int dis[ma][ma],e[ma][ma];
int ans=ma;
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
    }
    sort(a+1,a+n+1);
    ll m=min(n,700);

    for(int i=1; i<=m; i++)
        for(int j=1; j<=m; j++)
            if(i==j)
                e[i][j]=dis[i][j]=0;
            else e[i][j]=dis[i][j]=ma;
    for(int i=1;i<=m;i++)
    {
        for(int j=i+1;j<=m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                dis[i][j]=e[i][j]=1;
                dis[j][i]=e[j][i]=1;
            }
        }
    }

    for(int k=1; k<=m; k++)
    {
        for(int i=1; i<k; i++)
            for(int j=1; j<k; j++)
                if(i!=j)
                    ans=min(ans,dis[i][j]+e[i][k]+e[k][j]);
        for(int i=1; i<=m; i++)
            for(int j=1; j<=m; j++)
                if(dis[i][j]>dis[i][k]+dis[k][j])
                    dis[i][j]=dis[i][k]+dis[k][j];
    }
    if(ans==ma)
        printf("-1");
    else
    cout<<ans;

    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
int flag[maxn];
const int ma=555;
int dis[ma][ma],e[ma][ma];
int ans=ma;
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
    }
    //sort(a+1,a+n+1,greater<ll>());
    ll m=min(n,500);

    for(int i=1; i<=m; i++)
        for(int j=1; j<=m; j++)
            if(i==j)
                e[i][j]=dis[i][j]=0;
            else e[i][j]=dis[i][j]=ma;
    for(int i=1;i<=m;i++)
    {
        for(int j=i+1;j<=m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                dis[i][j]=e[i][j]=1;
                dis[j][i]=e[j][i]=1;
            }
        }
    }

    for(int k=1; k<=m; k++)
    {
        for(int i=1; i<k; i++)
            for(int j=1; j<k; j++)
                if(i!=j)
                    ans=min(ans,dis[i][j]+e[i][k]+e[k][j]);
        for(int i=1; i<=m; i++)
            for(int j=1; j<=m; j++)
                if(dis[i][j]>dis[i][k]+dis[k][j])
                    dis[i][j]=dis[i][k]+dis[k][j];
    }
    if(ans==ma)
        printf("-1");
    else
    cout<<ans;

    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
vector<int> v[maxn];
int flag[4005];
int ans=maxn;
void dfs(int x,int sd)
{
    flag[x]=sd;
    for(int i=0;i<v[x].size();i++)
    {
        if(!flag[v[x][i]])
        {
            dfs(v[x][i],sd+1);
        }
        else
        {
            if(sd-flag[v[x][i]]+1>=3)
                ans=min(sd-flag[v[x][i]]+1,ans);
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&a[i]);
    }
//    for(int i=0;i<n;i++)
//    {
//        for(int j=i+1;j<n;j++)
//        {
//            if((a[i]&a[j])!=0)
//                printf("%lld  %lld\n",i,j);
//        }
//
//    }
    sort(a,a+n,greater<ll>());
    ll m=min(n,4000);
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                v[i].push_back(j);
                v[j].push_back(i);
            }
        }
    }
    for(int i=0;i<m;i++)
    {
        memset(flag,0,sizeof(flag));
        dfs(i,1);
    }
    if(ans==maxn)
    {
        printf("-1");
    }
    else
    {
        printf("%d\n",ans);
    }
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
int flag[maxn];
const int ma=755;
int dis[ma][ma],e[ma][ma];
int ans=ma;
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
    }
    if(n>=200)
    {
        printf("3");
        return 0;
    }
    int m=n;
    for(int i=1; i<=m; i++)
        for(int j=1; j<=m; j++)
            if(i==j)
                e[i][j]=dis[i][j]=0;
            else e[i][j]=dis[i][j]=ma;
    for(int i=1;i<=m;i++)
    {
        for(int j=i+1;j<=m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                dis[i][j]=e[i][j]=1;
                dis[j][i]=e[j][i]=1;
            }
        }
    }

    for(int k=1; k<=m; k++)
    {
        for(int i=1; i<k; i++)
            for(int j=1; j<k; j++)
                if(i!=j)
                    ans=min(ans,dis[i][j]+e[i][k]+e[k][j]);
        for(int i=1; i<=m; i++)
            for(int j=1; j<=m; j++)
                if(dis[i][j]>dis[i][k]+dis[k][j])
                    dis[i][j]=dis[i][k]+dis[k][j];
    }
    if(ans==ma)
        printf("-1");
    else
    cout<<ans;

    return 0;
}


#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#include<map>
#include<vector>
#include<cmath>
#define lson m<<1,l,mid
#define rson m<<1|1,mid+1,r
#define getmid(m) (tree[m].l+tree[m].r)>>1;
const int maxn=1e5+5;
typedef long long ll;
using namespace std;
pair<int,int>pp;
vector<int>vec[65];
vector<int>G[maxn];
ll a[maxn];
int vis[maxn];
int endd;
int minn=0x3f3f3f3f;
void  dfs(int sta,int dep)
{
    vis[sta]=1;
    if(dep>=minn)
    {
          vis[sta]=0;
          return;
    }
    for(int t=0;t<G[sta].size();t++)
    {
      int u=G[sta][t];
      if(u==endd&&dep>1)
      {
          minn=min(minn,dep+1);
      }
      if(vis[u]==0)
      {
          dfs(u,dep+1);
      }
    }
    vis[sta]=0;
}

int main()
{
    int n;
    cin>>n;
    for(int t=0;t<n;t++)
    {
        scanf("%lld",&a[t]);
    }
    for(int t=0;t<64;t++)
    {
        for(int j=0;j<n;j++)
        {
            if(a[j]&((1ll<<t)))
            {
             vec[t].push_back(j);
            }
        }
    }
    for(int t=0;t<64;t++)
    {
        if(vec[t].size()>=3)
        {
            puts("3");
            return 0;
        }
    }
    for(int t=0;t<64;t++)
    {
        if(vec[t].size()==2)
        {
            int u=vec[t][0];
            int v=vec[t][1];
            G[u].push_back(v);
            G[v].push_back(u);
        }
    }
    for(int t=0;t<n;t++)
    {
        endd=t;
        int op;
        dfs(t,0);
    }
    if(minn==0x3f3f3f3f)
    {
        puts("-1");
    }
    else
    {
    printf("%d\n",minn);
    }
   // system("pause");
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
int flag[maxn];
const int ma=555;
int dis[ma][ma],e[ma][ma];
int ans=ma;
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
    }
    sort(a+1,a+n+1,greater<ll>());
    ll m=min(n,200);

    for(int i=1; i<=m; i++)
        for(int j=1; j<=m; j++)
            if(i==j)
                e[i][j]=dis[i][j]=0;
            else e[i][j]=dis[i][j]=ma;
    for(int i=1;i<=m;i++)
    {
        for(int j=i+1;j<=m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                dis[i][j]=e[i][j]=1;
                dis[j][i]=e[j][i]=1;
            }
        }
    }

    for(int k=1; k<=m; k++)
    {
        for(int i=1; i<k; i++)
            for(int j=1; j<k; j++)
                if(i!=j)
                    ans=min(ans,dis[i][j]+e[i][k]+e[k][j]);
        for(int i=1; i<=m; i++)
            for(int j=1; j<=m; j++)
                if(dis[i][j]>dis[i][k]+dis[k][j])
                    dis[i][j]=dis[i][k]+dis[k][j];
    }
    if(ans==ma)
        printf("-1");
    else
    cout<<ans;

    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
vector<int> v[maxn];
int flag[maxn];
int ans=maxn;
void dfs(int x,int sd)
{
    flag[x]=sd;
    for(int i=0;i<v[x].size();i++)
    {
        if(!flag[v[x][i]])
        {
            dfs(v[x][i],sd+1);
        }
        else
        {
            if(sd-flag[v[x][i]]+1>=3)
                ans=min(sd-flag[v[x][i]]+1,ans);
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&a[i]);
    }
    sort(a,a+n);
    ll m=min(n,500);
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                v[i].push_back(j);
                v[j].push_back(i);
            }
        }
    }
    for(int i=0;i<m;i++)
    {
        if(!flag[i])
        {
            dfs(i,1);
        }
    }
    if(ans==maxn)
    {
        printf("-1");
    }
   else
    {
       printf("%d\n",ans);
    }
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
int flag[maxn];
const int ma=755;
int dis[ma][ma],e[ma][ma];
int ans=ma;
int bit[ma];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
        for(int i=0;i<=62;i++)
        {
            if((a[i]>>i)&1)
                a[i]++;
        }
    }
    for(int i=0;i<64;i++)
    {
        if(a[i]>=3)
        {
            printf("3\n");
            return 0;
        }

    }
    int m=n;
    for(int i=1; i<=m; i++)
        for(int j=1; j<=m; j++)
            if(i==j)
                e[i][j]=dis[i][j]=0;
            else e[i][j]=dis[i][j]=ma;
    for(int i=1;i<=m;i++)
    {
        for(int j=i+1;j<=m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                dis[i][j]=e[i][j]=1;
                dis[j][i]=e[j][i]=1;
            }
        }
    }

    for(int k=1; k<=m; k++)
    {
        for(int i=1; i<k; i++)
            for(int j=1; j<k; j++)
                if(i!=j)
                    ans=min(ans,dis[i][j]+e[i][k]+e[k][j]);
        for(int i=1; i<=m; i++)
            for(int j=1; j<=m; j++)
                if(dis[i][j]>dis[i][k]+dis[k][j])
                    dis[i][j]=dis[i][k]+dis[k][j];
    }
    if(ans==ma)
        printf("-1");
    else
    cout<<ans;

    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
vector<int> v[maxn];
int flag[maxn];
int ans=maxn;
void dfs(int x,int sd)
{
    flag[x]=sd;
    for(int i=0;i<v[x].size();i++)
    {
        if(!flag[v[x][i]])
        {
            dfs(v[x][i],sd+1);
        }
        else
        {
            if(sd-flag[v[x][i]]+1>=3)
                ans=min(sd-flag[v[x][i]]+1,ans);
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&a[i]);
    }
    sort(a,a+n);
    ll m=min(n,4000);
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                v[i].push_back(j);
                v[j].push_back(i);
            }
        }
    }
    for(int i=0;i<m;i++)
    {
        if(!flag[i])
        {
            dfs(i,1);
        }
    }
    if(ans==maxn)
    {
        printf("-1");
    }
   else
    {
       printf("%d\n",ans);
    }
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
int flag[maxn];
const int ma=555;
int dis[ma][ma],e[ma][ma];
int ans=ma;
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
    }
    sort(a+1,a+n+1,greater<ll>());
    ll m=min(n,68);

    for(int i=1; i<=m; i++)
        for(int j=1; j<=m; j++)
            if(i==j)
                e[i][j]=dis[i][j]=0;
            else e[i][j]=dis[i][j]=ma;
    for(int i=1;i<=m;i++)
    {
        for(int j=i+1;j<=m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                dis[i][j]=e[i][j]=1;
                dis[j][i]=e[j][i]=1;
            }
        }
    }

    for(int k=1; k<=m; k++)
    {
        for(int i=1; i<k; i++)
            for(int j=1; j<k; j++)
                if(i!=j)
                    ans=min(ans,dis[i][j]+e[i][k]+e[k][j]);
        for(int i=1; i<=m; i++)
            for(int j=1; j<=m; j++)
                if(dis[i][j]>dis[i][k]+dis[k][j])
                    dis[i][j]=dis[i][k]+dis[k][j];
    }
    if(ans==ma)
        printf("-1");
    else
    cout<<ans;

    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
vector<int> v[maxn];
int flag[4005];
int ans=maxn;
void dfs(int x,int sd)
{
    flag[x]=sd;
    for(int i=0;i<v[x].size();i++)
    {
        if(!flag[v[x][i]])
        {
            dfs(v[x][i],sd+1);
        }
        else
        {
            if(sd-flag[v[x][i]]+1>=3)
                ans=min(sd-flag[v[x][i]]+1,ans);
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&a[i]);
    }
//    for(int i=0;i<n;i++)
//    {
//        for(int j=i+1;j<n;j++)
//        {
//            if((a[i]&a[j])!=0)
//                printf("%lld  %lld\n",i,j);
//        }
//
//    }
    sort(a,a+n,greater<ll>());
    ll m=min(n,2000);
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                v[i].push_back(j);
                v[j].push_back(i);
            }
        }
    }
    for(int i=0;i<m;i++)
    {
        memset(flag,0,sizeof(flag));
        dfs(i,1);
    }
    if(ans==maxn)
    {
        printf("-1");
    }
    else
    {
        printf("%d\n",ans);
    }
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
vector<int> v[maxn];
int flag[maxn];
int ans=maxn;
void dfs(int x,int sd)
{
    flag[x]=sd;
    for(int i=0;i<v[x].size();i++)
    {
        if(!flag[v[x][i]])
        {
            dfs(v[x][i],sd+1);
        }
        else
        {
            if(sd-flag[v[x][i]]+1>=3)
                ans=min(sd-flag[v[x][i]]+1,ans);
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&a[i]);
    }
    sort(a,a+n);
    ll m=min(n,2000);
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                v[i].push_back(j);
                v[j].push_back(i);
            }
        }
    }
    for(int i=0;i<m;i++)
    {
        if(!flag[i])
        {
            dfs(i,1);
        }
    }
    if(ans==maxn)
    {
        printf("-1");
    }
   else
    {
       printf("%d\n",ans);
    }
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
vector<int> v[maxn];
int flag[maxn];
int ans=maxn;
void dfs(int x,int sd)
{
    flag[x]=sd;
    for(int i=0;i<v[x].size();i++)
    {
        if(!flag[v[x][i]])
        {
            dfs(v[x][i],sd+1);
        }
        else
        {
            if(sd-flag[v[x][i]]+1>=3)
                ans=min(sd-flag[v[x][i]]+1,ans);
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&a[i]);
    }
    sort(a,a+n,greater<ll>());
    ll m=min(n,4000);
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                v[i].push_back(j);
                v[j].push_back(i);
            }
        }
    }
    for(int i=0;i<m;i++)
    {
        if(!flag[i])
        {
            dfs(i,1);
        }
    }
    if(ans==maxn)
    {
        printf("-1");
    }
   else
    {
       printf("%d\n",ans);
    }
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
vector<int> v[maxn];
int flag[maxn];
int ans=maxn;
void dfs(int x,int sd)
{
    flag[x]=sd;
    for(int i=0;i<v[x].size();i++)
    {
        if(!flag[v[x][i]])
        {
            dfs(v[x][i],sd+1);
        }
        else
        {
            if(sd-flag[v[x][i]]+1>=3)
            {
                flag[x]=min(flag[x],flag[v[x][i]]+1);
                ans=min(sd-flag[v[x][i]]+1,ans);
            }

        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&a[i]);
    }
//    for(int i=0;i<n;i++)
//    {
//        for(int j=i+1;j<n;j++)
//        {
//            if((a[i]&a[j])!=0)
//                printf("%lld  %lld\n",i,j);
//        }
//
//    }
    sort(a,a+n,greater<ll>());
    ll m=min(n,4000);
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                v[i].push_back(j);
                v[j].push_back(i);
            }
        }
    }
    for(int i=0;i<m;i++)
    {
        if(!flag[i])
        {
            dfs(i,1);
        }
    }
    if(ans==maxn)
    {
        printf("-1");
    }
    else
    {
        printf("%d\n",ans);
    }
    return 0;
}


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

#define ll long long int
#define N 100010
#define LD long double

int inf = 1e9;
int mod = 1e9 + 7;

vector<int> graph[N];

int MINI = inf;
int target;
bool visited[N] = {false};
void dfs(int cur, int dist) {
    visited[cur] = true;
    for(int u : graph[cur]) {
        if(u == target && dist > 1) {
            MINI = min(MINI, dist + 1);
        }
        if(!visited[u]) {
            dfs(u, dist + 1);
        }
    }
    visited[cur] = false;
}

signed main()
{
    //freopen("IN.txt", "r", stdin);
    //freopen("OUT.txt", "w", stdout);

    int n;
    cin >> n;

    ll A[n];
    for(int i = 0; i < n; i++) {
        cin >> A[i];
    }

    vector<ll> bag[64];
    for(ll i = 0; i < 64; i++) {
        for(int j = 0; j < n; j++) {
            if(A[j] & (1LL << i)) {
                bag[i].push_back(j);
            }
        }
    }

    for(int i = 0; i < 64; i++) {
        if((int)bag[i].size() > 2) {
            cout << "3\n";
            return 0;
        }
    }

    for(int i = 0; i < 64; i++) {
        if((int)bag[i].size() > 1) {
            int u = bag[i][0];
            int v = bag[i][1];
            graph[u].push_back(v);
            graph[v].push_back(u);
        }
    }

    for(int i = 0; i < n; i++) {
        target = i;
        dfs(i, 0);
    }

    if(MINI == inf) {
        cout << "-1\n";
    }
    else {
        cout << MINI << "\n";
    }
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
vector<int> v[maxn];
int flag[maxn];
int ans=maxn;
void dfs(int x,int sd)
{
    flag[x]=sd;
    for(int i=0;i<v[x].size();i++)
    {
        if(!flag[v[x][i]])
        {
            dfs(v[x][i],sd+1);
        }
        else
        {
            if(sd-flag[v[x][i]]+1>=3)
                ans=min(sd-flag[v[x][i]]+1,ans);
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&a[i]);
    }
    sort(a,a+n,greater<ll>());
    ll m=min(n,4000);
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                v[i].push_back(j);
                v[j].push_back(i);
            }
        }
    }
    for(int i=0;i<m;i++)
    {
        if(!flag[i])
        {
            dfs(i,1);
        }
    }
    if(ans==maxn)
    {
        printf("-1");
    }
    else
    {
        printf("%d\n",ans);
    }
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
int flag[maxn];
const int ma=555;
int dis[ma][ma],e[ma][ma];
int ans=ma;
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
    }
    sort(a+1,a+n+1,greater<ll>());
    ll m=min(n,500);

    for(int i=1; i<=m; i++)
        for(int j=1; j<=m; j++)
            if(i==j)
                e[i][j]=dis[i][j]=0;
            else e[i][j]=dis[i][j]=ma;
    for(int i=1;i<=m;i++)
    {
        for(int j=i+1;j<=m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                dis[i][j]=e[i][j]=1;
                dis[j][i]=e[j][i]=1;
            }
        }
    }

    for(int k=1; k<=m; k++)
    {
        for(int i=1; i<k; i++)
            for(int j=1; j<k; j++)
                if(i!=j)
                    ans=min(ans,dis[i][j]+e[i][k]+e[k][j]);
        for(int i=1; i<=m; i++)
            for(int j=1; j<=m; j++)
                if(dis[i][j]>dis[i][k]+dis[k][j])
                    dis[i][j]=dis[i][k]+dis[k][j];
    }
    if(ans==ma)
        printf("-1");
    else
    cout<<ans;

    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
vector<int> v[maxn];
int flag[maxn];
int ans=maxn;
void dfs(int x,int sd)
{
    flag[x]=sd;
    for(int i=0;i<v[x].size();i++)
    {
        if(!flag[v[x][i]])
        {
            dfs(v[x][i],sd+1);
        }
        else
        {
            if(sd-flag[v[x][i]]+1>=3)
                ans=min(sd-flag[v[x][i]]+1,ans);
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&a[i]);
    }
    //sort(a,a+n);
    ll m=min(n,6000);
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                v[i].push_back(j);
                v[j].push_back(i);
            }
        }
    }
    for(int i=0;i<m;i++)
    {
        if(!flag[i])
        {
            dfs(i,1);
        }
    }
    if(ans==maxn)
    {
        printf("-1");
    }
   else
    {
       printf("%d\n",ans);
    }
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
vector<int> v[maxn];
int flag[maxn];
int ans=maxn;
void dfs(int x,int sd)
{
    flag[x]=sd;
    for(int i=0;i<v[x].size();i++)
    {
        if(!flag[v[x][i]])
        {
            dfs(v[x][i],sd+1);
        }
        else
        {
            if(sd-flag[v[x][i]]+1>=3)
            {
                flag[x]=min(flag[x],flag[v[x][i]]+1);
                ans=min(sd-flag[v[x][i]]+1,ans);
            }

        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&a[i]);
    }
    for(int i=0;i<n;i++)
    {
        for(int j=i+1;j<n;j++)
        {
            if((a[i]&a[j])!=0)
                printf("%lld  %lld\n",i,j);
        }

    }
    sort(a,a+n,greater<ll>());
    ll m=min(n,4000);
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                v[i].push_back(j);
                v[j].push_back(i);
            }
        }
    }
    for(int i=0;i<m;i++)
    {
        if(!flag[i])
        {
            dfs(i,1);
        }
    }
    if(ans==maxn)
    {
        printf("-1");
    }
    else
    {
        printf("%d\n",ans);
    }
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
vector<int> v[maxn];
int flag[4005];
int ans=maxn;
void dfs(int x,int sd)
{
    flag[x]=sd;
    for(int i=0;i<v[x].size();i++)
    {
        if(!flag[v[x][i]])
        {
            dfs(v[x][i],sd+1);
        }
        else
        {
            if(sd-flag[v[x][i]]+1>=3)
                ans=min(sd-flag[v[x][i]]+1,ans);
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&a[i]);
    }
//    for(int i=0;i<n;i++)
//    {
//        for(int j=i+1;j<n;j++)
//        {
//            if((a[i]&a[j])!=0)
//                printf("%lld  %lld\n",i,j);
//        }
//
//    }
    sort(a,a+n,greater<ll>());
    ll m=min(n,2000);
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                v[i].push_back(j);
                v[j].push_back(i);
            }
        }
    }
    for(int i=0;i<100;i++)
    {
        memset(flag,0,sizeof(flag));
        dfs(i,1);
    }
    if(ans==maxn)
    {
        printf("-1");
    }
    else
    {
        printf("%d\n",ans);
    }
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
vector<int> v[maxn];
int flag[maxn];
int ans=maxn;
void dfs(int x,int sd)
{
    flag[x]=sd;
    for(int i=0;i<v[x].size();i++)
    {
        if(!flag[v[x][i]])
        {
            dfs(v[x][i],sd+1);
        }
        else
        {
            if(sd-flag[v[x][i]]+1>=3)
                ans=min(sd-flag[v[x][i]]+1,ans);
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&a[i]);
    }
    sort(a,a+n,greater<ll>());
    ll m=min(n,6000);
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                v[i].push_back(j);
                v[j].push_back(i);
            }
        }
    }
    for(int i=0;i<m;i++)
    {
        if(!flag[i])
        {
            dfs(i,1);
        }
    }
    if(ans==maxn)
    {
        printf("-1");
    }
   else
    {
       printf("%d\n",ans);
    }
    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
int flag[maxn];
const int ma=555;
int dis[ma][ma],e[ma][ma];
int ans=ma;
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
    }
    sort(a+1,a+n+1,greater<ll>());
    ll m=min(n,138);

    for(int i=1; i<=m; i++)
        for(int j=1; j<=m; j++)
            if(i==j)
                e[i][j]=dis[i][j]=0;
            else e[i][j]=dis[i][j]=ma;
    for(int i=1;i<=m;i++)
    {
        for(int j=i+1;j<=m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                dis[i][j]=e[i][j]=1;
                dis[j][i]=e[j][i]=1;
            }
        }
    }

    for(int k=1; k<=m; k++)
    {
        for(int i=1; i<k; i++)
            for(int j=1; j<k; j++)
                if(i!=j)
                    ans=min(ans,dis[i][j]+e[i][k]+e[k][j]);
        for(int i=1; i<=m; i++)
            for(int j=1; j<=m; j++)
                if(dis[i][j]>dis[i][k]+dis[k][j])
                    dis[i][j]=dis[i][k]+dis[k][j];
    }
    if(ans==ma)
        printf("-1");
    else
    cout<<ans;

    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
int flag[maxn];
const int ma=755;
int dis[ma][ma],e[ma][ma];
int ans=ma;
int bit[ma];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&a[i]);
        for(int j=0;j<=62;j++)
        {
            if((a[i]>>j)&1)
                bit[j]++;
        }
    }
    for(int i=0;i<64;i++)
    {
        if(bit[i]>=3)
        {
            printf("3\n");
            return 0;
        }

    }
    int m=n;
    for(int i=1; i<=m; i++)
        for(int j=1; j<=m; j++)
            if(i==j)
                e[i][j]=dis[i][j]=0;
            else e[i][j]=dis[i][j]=ma;
    for(int i=1;i<=m;i++)
    {
        for(int j=i+1;j<=m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                dis[i][j]=e[i][j]=1;
                dis[j][i]=e[j][i]=1;
            }
        }
    }

    for(int k=1; k<=m; k++)
    {
        for(int i=1; i<k; i++)
            for(int j=1; j<k; j++)
                if(i!=j)
                    ans=min(ans,dis[i][j]+e[i][k]+e[k][j]);
        for(int i=1; i<=m; i++)
            for(int j=1; j<=m; j++)
                if(dis[i][j]>dis[i][k]+dis[k][j])
                    dis[i][j]=dis[i][k]+dis[k][j];
    }
    if(ans==ma)
        printf("-1");
    else
    cout<<ans;

    return 0;
}


#include<bits/stdc++.h>

using namespace std;
typedef long long ll;
const int maxn=1e5+10;
ll a[maxn];
vector<int> v[maxn];
int flag[maxn];
int ans=maxn;
void dfs(int x,int sd)
{
    flag[x]=sd;
    for(int i=0;i<v[x].size();i++)
    {
        if(!flag[v[x][i]])
        {
            dfs(v[x][i],sd+1);
        }
        else
        {
            if(sd-flag[v[x][i]]+1>=3)
                ans=min(sd-flag[v[x][i]]+1,ans);
        }
    }
}
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%lld",&a[i]);
    }
    sort(a,a+n,greater<int>());
    ll m=min(n,6000);
    for(int i=0;i<m;i++)
    {
        for(int j=i+1;j<m;j++)
        {
            if((a[i]&a[j])!=0)
            {
                v[i].push_back(j);
                v[j].push_back(i);
            }
        }
    }
    for(int i=0;i<m;i++)
    {
        if(!flag[i])
        {
            dfs(i,1);
        }
    }
    if(ans==maxn)
    {
        printf("-1");
    }
   else
    {
       printf("%d\n",ans);
    }
    return 0;
}


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<ll> a[100000+100];
vector<ll> b[70*3];
vector<ll> nodee[100000+100];
ll cur[100000+100];
ll ans;
ll vis[200000+100];
struct node {
	ll u,f;
};
ll sum[100000+100];
void bfs(ll u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		ll size = nodee[t.u].size();
		for(ll i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
					vis[tt.u]=1;
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				int tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	ll n;
	ll c;
	cin >> n;
	for(ll i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		ll z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);

			}
			copyy>>=1;
			z++;
		}
	}

	ans=INF;

	memset(vis,0,sizeof(vis));
	memset(cur,0,sizeof(cur));
	for(ll i=1; i<=n; i++) {
		for(ll j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(ll k=0; k<b[a[i][j]].size(); k++) {
				ll cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
//	for(int i=1;i<=n;i++) cout << nodee[i].size() << endl;
	for (ll i = 1; i <= n; ++ i) {
		if (!vis[i]) {
			memset(sum,-1,sizeof(sum));
			bfs(i);
		}
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<int> a[100000+100];
vector<ll> b[70];
vector<int> nodee[100000+100];
int cur[100000+100];
int ans;
int vis[100000+100];
struct node {
	int u,f;
};
int sum[100000+100];
void bfs(int u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		int size = nodee[t.u].size();
		for(int i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
			//	vis[tt.u]=1;
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				int tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	int n;
	ll c;
	cin >> n;
	for(int i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		int z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);
			}
			copyy>>=1;
			z++;
		}
	}
	ans=INF;
//	for(int i=0; i<63; i++) {
//		if(b[i].size()>=3) {
//			printf("3\n");
//			return 0;
//		}
//	}
//	memset(vis,0,sizeof(vis));
	memset(cur,0,sizeof(cur));
	for(int i=1; i<=n; i++) {
		for(int j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(int k=0; k<b[a[i][j]].size(); k++) {
				int cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
	for(int i=1; i<=n; i++) {
		if(nodee[i].size()<2) vis[i]=1;
	}
	memset(sum,-1,sizeof(sum));
	for (int i = 1; i <= n; ++ i) {
		if (!vis[i]) {
			bfs(i);
		}
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<ll> a[200000+100];
vector<ll> b[70];
vector<ll> nodee[200000+100];
ll cur[200000+100];
ll ans;
ll vis[200000+100];
struct node {
	ll u,f;
};
ll sum[200000+100];
void bfs(ll u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		ll size = nodee[t.u].size();
		for(ll i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
					vis[tt.u]=1;
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				int tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	ll n;
	ll c;
	cin >> n;
	for(ll i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		ll z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);

			}
			copyy>>=1;
			z++;
		}
	}

	ans=INF;

	memset(vis,0,sizeof(vis));
	memset(cur,0,sizeof(cur));
	for(ll i=1; i<=n; i++) {
		for(ll j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(ll k=0; k<b[a[i][j]].size(); k++) {
				ll cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
//	for(int i=1;i<=n;i++) cout << nodee[i].size() << endl;
	for (ll i = 1; i <= n; ++ i) {
		if (!vis[i]) {
			memset(sum,-1,sizeof(sum));
			bfs(i);
		}
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<int> a[100000+100];
vector<ll> b[70];
vector<int> nodee[100000+100];
int cur[100000+100];
int ans;
int vis[100000+100];
struct node {
	int u,f;
};
int sum[100000+100];
void bfs(int u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		int size = nodee[t.u].size();
		for(int i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
				//	vis[tt.u]=1;
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				int tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	int n;
	ll c;
	cin >> n;
	for(int i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		int z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);

			}
			copyy>>=1;
			z++;
		}
	}

	ans=INF;
	for(int i=0; i<70; i++) {
		if(b[i].size()>=3) {
			printf("3\n");
			return 0;
		}
	}
	memset(vis,0,sizeof(vis));
	memset(cur,0,sizeof(cur));
	for(int i=1; i<=n; i++) {
		for(int j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(int k=0; k<b[a[i][j]].size(); k++) {
				ll cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
	for (int i = 1; i <= n; ++ i) {
		if (!vis[i]) {
			memset(sum,-1,sizeof(sum));
			bfs(i);
		}
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<int> a[100000+100];
vector<ll> b[70];
vector<int> nodee[100000+100];
int cur[100000+100];
int ans;
int vis[100000+100];
struct node {
	int u,f;
};
int sum[100000+100];
void bfs(int u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		int size = nodee[t.u].size();
		for(int i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
				//	vis[tt.u]=1;
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				int tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	int n;
	ll c;
	cin >> n;
	for(int i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		int z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);

			}
			copyy>>=1;
			z++;
		}
	}

	ans=INF;
	for(int i=0; i<70; i++) {
		if(b[i].size()>=3) {
			printf("3\n");
			return 0;
		}
	}
	memset(vis,0,sizeof(vis));
	memset(cur,0,sizeof(cur));
	for(int i=1; i<=n; i++) {
		for(int j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(int k=0; k<b[a[i][j]].size(); k++) {
				int cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
	for(int i=1; i<=n; i++) {
		if(nodee[i].size()<2) vis[i]=1;
	}

	for (int i = 1; i <= n; ++ i) {
		if (!vis[i]) {
			memset(sum,-1,sizeof(sum));
			bfs(i);
		}
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<int> a[100000+100];
vector<ll> b[70];
vector<int> nodee[100000+100];
int cur[100000+100];
int ans;
int vis[100000+100];
struct node {
	int u,f;
};
int sum[100000+100];
void bfs(int u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		int size = nodee[t.u].size();
		for(int i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
					vis[tt.u]=1;
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				int tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	int n;
	ll c;
	cin >> n;
	for(int i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		int z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);

			}
			copyy>>=1;
			z++;
		}
	}

	ans=INF;

	memset(vis,0,sizeof(vis));
	memset(cur,0,sizeof(cur));
	for(int i=1; i<=n; i++) {
		for(int j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(int k=0; k<b[a[i][j]].size(); k++) {
				ll cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
	for (int i = 1; i <= n; ++ i) {
		if (!vis[i]) {
			memset(sum,-1,sizeof(sum));
			bfs(i);
		}
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<int> a[200000+100];
vector<ll> b[700];
vector<int> nodee[200000+100];
int cur[200000+100];
int ans;
int vis[200000+100];
struct node {
	int u,f;
};
int sum[200000+100];
void bfs(int u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		int size = nodee[t.u].size();
		for(int i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
				vis[tt.u]=1;
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				int tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	int n;
	ll c;
	cin >> n;
	for(int i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		int z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);

			}
			copyy>>=1;
			z++;
		}
	}

	ans=INF;
	for(int i=0; i<70; i++) {
		if(b[i].size()>=3) {
			printf("3\n");
			return 0;
		}
	}
	memset(vis,0,sizeof(vis));
	memset(cur,0,sizeof(cur));
	for(int i=1; i<=n; i++) {
		for(int j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(int k=0; k<b[a[i][j]].size(); k++) {
				int cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
	for (int i = 1; i <= n; ++ i) {
		if (!vis[i]) {
			memset(sum,-1,sizeof(sum));
			bfs(i);
		}
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<int> a[100000+100];
vector<ll> b[70];
vector<int> nodee[100000+100];
int cur[100000+100];
int ans;
int vis[100000+100];
struct node {
	int u,f;
};
int sum[100000+100];
void bfs(int u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		int size = nodee[t.u].size();
		for(int i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
				//	vis[tt.u]=1;
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				int tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	int n;
	ll c;
	cin >> n;
	for(int i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		int z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);

			}
			copyy>>=1;
			z++;
		}
	}

	ans=INF;
	for(int i=0; i<70; i++) {
		if(b[i].size()>=3) {
			printf("3\n");
			return 0;
		}
	}
	memset(vis,0,sizeof(vis));
	memset(cur,0,sizeof(cur));
	for(int i=1; i<=n; i++) {
		for(int j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(int k=0; k<b[a[i][j]].size(); k++) {
				ll cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
	for(int i=1; i<=n; i++) {
		sort(nodee[i].begin(),nodee[i].end());
		nodee[i].resize(unique(nodee[i].begin(),nodee[i].end())-nodee[i].begin());
	}
	for (int i = 1; i <= n; ++ i) {
		if (!vis[i]) {
			memset(sum,-1,sizeof(sum));
			bfs(i);
		}
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}
/*
10
145135569469440 4415327043584 17247502464 72075186223972364 145241087982700608 144115188076380352 52776826568712 72198331527331844 46161896180549632 45071180914229248
*/


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<int> a[100000+100];
vector<ll> b[70];
vector<int> nodee[100000+100];
int cur[100000+100];
int ans;
int vis[100000+100];
struct node {
	int u,f;
};
int sum[100000+100];
void bfs(int u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		int size = nodee[t.u].size();
		for(int i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
			//		vis[tt.u]=1;
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				int tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	int n;
	ll c;
	cin >> n;
	for(int i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		int z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);

			}
			copyy>>=1;
			z++;
		}
	}

	ans=INF;

	memset(vis,0,sizeof(vis));
	memset(cur,0,sizeof(cur));
	for(int i=1; i<=n; i++) {
		for(int j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(int k=0; k<b[a[i][j]].size(); k++) {
				ll cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
	for (int i = 1; i <= n; ++ i) {
		if (!vis[i]) {
			memset(sum,-1,sizeof(sum));
			bfs(i);
		}
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<ll> a[100000+100];
vector<ll> b[70];
vector<ll> nodee[100000+100];
ll cur[100000+100];
ll ans;
ll vis[100000+100];
struct node {
	ll u,f;
};
ll sum[100000+100];
void bfs(ll u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		int size = nodee[t.u].size();
		for(ll i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
				//	vis[tt.u]=1;
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				ll tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	ll n;
	ll c;
	cin >> n;
	for(ll i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		ll z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);

			}
			copyy>>=1;
			z++;
		}
	}

	ans=INF;
	for(ll i=0; i<70; i++) {
		if(b[i].size()>=3) {
			printf("3\n");
			return 0;
		}
	}
	memset(vis,0,sizeof(vis));
	memset(cur,0,sizeof(cur));
	for(ll i=1; i<=n; i++) {
		for(ll j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(ll k=0; k<b[a[i][j]].size(); k++) {
				ll cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
	for (ll i = 1; i <= n; ++ i) {
		if (!vis[i]) {
			memset(sum,-1,sizeof(sum));
			bfs(i);
		}
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<int> a[100000+100];
vector<ll> b[70];
vector<int> nodee[100000+100];
int cur[100000+100];
int ans;
struct node {
	int u,f;
};
int sum[100000+100];
void bfs(int u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		int size = nodee[t.u].size();
		for(int i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				int tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	int n;
	ll c;
	cin >> n;
	for(int i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		int z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);

			}
			copyy>>=1;
			z++;
		}
	}

	ans=INF;

	memset(cur,0,sizeof(cur));
	for(int i=1; i<=n; i++) {
		for(int j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(int k=0; k<b[a[i][j]].size(); k++) {
				ll cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
	for (int i = 1; i <= n; ++ i) {
			memset(sum,-1,sizeof(sum));
			bfs(i);
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<ll> a[100000+100];
vector<ll> b[70*3];
vector<ll> nodee[100000+100];
ll cur[100000+100];
ll ans;
ll vis[100000+100];
struct node {
	ll u,f;
};
ll sum[100000+100];
void bfs(ll u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		ll size = nodee[t.u].size();
		for(ll i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
					vis[tt.u]=1;
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				int tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	ll n;
	ll c;
	cin >> n;
	for(ll i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		ll z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);

			}
			copyy>>=1;
			z++;
		}
	}

	ans=INF;

	memset(vis,0,sizeof(vis));
	memset(cur,0,sizeof(cur));
	for(ll i=1; i<=n; i++) {
		for(ll j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(ll k=0; k<b[a[i][j]].size(); k++) {
				ll cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
//	for(int i=1;i<=n;i++) cout << nodee[i].size() << endl;
	for (ll i = 1; i <= n; ++ i) {
		if (!vis[i]) {
			memset(sum,-1,sizeof(sum));
			bfs(i);
		}
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<int> a[100000+100];
vector<ll> b[70];
vector<int> nodee[100000+100];
int cur[100000+100];
int ans;
int vis[100000+100];
struct node {
	int u,f;
};
int sum[100000+100];
void bfs(int u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		int size = nodee[t.u].size();
		for(int i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
				vis[tt.u]=1;
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				int tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	int n;
	ll c;
	cin >> n;
	for(int i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		int z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);
			}
			copyy>>=1;
			z++;
		}
	}
	ans=INF;
	for(int i=0; i<63; i++) {
		if(b[i].size()>=3) {
			printf("3\n");
			return 0;
		}
	}
	memset(vis,0,sizeof(vis));
	memset(cur,0,sizeof(cur));
	for(int i=1; i<=n; i++) {
		for(int j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(int k=0; k<b[a[i][j]].size(); k++) {
				int cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
	for(int i=1; i<=n; i++) {
		if(nodee[i].size()<2) vis[i]=1;
	}
	memset(sum,-1,sizeof(sum));
	for (int i = 1; i <= n; ++ i) {
		if (!vis[i]) {
			bfs(i);
		}
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<int> a[100000+100];
vector<ll> b[70];
vector<int> nodee[100000+100];
int cur[100000+100];
int ans;
int vis[100000+100];
struct node {
	int u,f;
};
int sum[100000+100];
void bfs(int u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		int size = nodee[t.u].size();
		for(int i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
				//	vis[tt.u]=1;
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				int tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	int n;
	ll c;
	cin >> n;
	for(int i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		int z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);

			}
			copyy>>=1;
			z++;
		}
	}

	ans=INF;
	for(int i=0; i<70; i++) {
		if(b[i].size()>=3) {
			printf("3\n");
			return 0;
		}
	}
	memset(vis,0,sizeof(vis));
	memset(cur,0,sizeof(cur));
	for(int i=1; i<=n; i++) {
		for(int j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(int k=0; k<b[a[i][j]].size(); k++) {
				int cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
	for (int i = 1; i <= n; ++ i) {
		if (!vis[i]) {
			memset(sum,-1,sizeof(sum));
			bfs(i);
		}
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}


#include<cstring>
#include<cstdio>
#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll;
vector<int> a[200000+100];
vector<ll> b[700];
vector<int> nodee[200000+100];
int cur[200000+100];
int ans;
int vis[200000+100];
struct node {
	int u,f;
};
int sum[200000+100];
void bfs(int u0) {
	queue<node> q;
	node t;
	t.f=-1;
	t.u=u0;
	sum[u0] = 0;
	q.push(t);
	while(! q.empty()) {
		t = q.front();
		node tt;
		q.pop();
		int size = nodee[t.u].size();
		for(int i=0; i<size; i++) {
			tt.f = t.u;
			tt.u = nodee[t.u][i];
			if(tt.u == t.f)
				continue;
			if(sum[tt.u] == -1) {
				q.push(tt);
			//	vis[tt.u]=1;
				sum[tt.u] = sum[t.u] + 1;
			} else if(sum[tt.u] + sum[t.u] > 1 ) {
				int tmp = sum[tt.u] + sum[t.u] + 1;
				if(ans > tmp) ans = tmp;
			}
		}
	}
}

int main() {
	int n;
	ll c;
	cin >> n;
	for(int i=1; i<=n; i++) {
		scanf("%lld",&c);
		ll copyy=c;
		int z=0;
		while(copyy) {
			if(copyy&1) {
				b[z].push_back(i);
				a[i].push_back(z);

			}
			copyy>>=1;
			z++;
		}
	}

	ans=INF;
	for(int i=0; i<70; i++) {
		if(b[i].size()>=3) {
			printf("3\n");
			return 0;
		}
	}
	memset(vis,0,sizeof(vis));
	memset(cur,0,sizeof(cur));
	for(int i=1; i<=n; i++) {
		for(int j=0; j<a[i].size(); j++) {
			if(b[a[i][j]].size()==0) continue;
			for(int k=0; k<b[a[i][j]].size(); k++) {
				int cnt=b[a[i][j]][k];
				if(cnt==i) continue;
				nodee[i].push_back(cnt);
			}
		}
	}
	for (int i = 1; i <= n; ++ i) {
		if (!vis[i]) {
			memset(sum,-1,sizeof(sum));
			bfs(i);
		}
	}
	if(ans==INF) cout << "-1" << endl;
	else cout << ans << endl;
}


#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+7;
typedef long long LL;
LL a[maxn];
LL num[maxn][100];
LL bit[100];
vector<int> ve[100];
int mp[500][500];
const int N = 500;
#define INF 0x7ffffff
int dist[N][N];
int m,n,minc;
int min(int x,int y)
{
    if(x<y) return x;
    return y;
}
void floyd()
{
    minc=INF;
    for(int k=1; k<=n; k++)
    {
        for(int i=1; i<=k; i++)
            for(int j=i+1; j<=k; j++)
                minc=min(minc,dist[i][j]+mp[i][k]+mp[k][j]);
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                if(dist[i][j]>dist[i][k]+dist[k][j])
                    dist[i][j]=dist[i][k]+dist[k][j];
    }
}
void init()
{
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
        {
            mp[i][j]=INF;
            dist[i][j]=INF;
        }
}
int main()
{
//    printf("%lld\n",1ll<<61);
    for(int i=0; i<63; i++)
    {
        bit[i]=1ll<<i;
    }
    scanf("%d",&n);
    int ccc=0;
    for(int i=1; i<=n; i++)
    {
        scanf("%lld",&a[i]);
        LL tem = a[i];
        if(a[i]==0)ccc++;
        for(int j=0; j<63; j++)
        {
            if((tem&bit[j])==bit[j])
            {
                ve[j].push_back(i);
            }
        }
    }
    n-=ccc;
    if(n>200)
    {
        puts("3");
        return 0;
    }
    for(int i=0; i<63; i++)
    {
        if(ve[i].size()>=3)
        {
            puts("3");
            return 0;
        }
    }
    init();
    for(int i=0; i<63; i++)
    {
        int len = ve[i].size();
//        for(int j=0; j<len; j++)
//        {
//            printf("%d ",ve[i][j]);
//        }
//        printf("\n");
        for(int j=0; j<len; j++)
        {
            for(int k=0; k<len; k++)
            {
                if(k==j) continue;
                mp[ve[i][j]][ve[i][k]]=1;
                dist[ve[i][j]][ve[i][k]]=1;
            }
        }
    }
//    for(int i=1;i<=n;i++)
//    {
//        for(int j=1;j<=n;j++)
//        {
//            printf("mp[%d][%d] = %d\n",i,j,mp[i][j]);
//        }
//    }

    floyd();
    if(minc<INF)
        printf("%d\n",minc);
    else
    {
        printf("-1");
    }
}


#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+7;
typedef long long LL;
LL a[maxn];
LL bit[100];
vector<int> ve[100];
int mp[500][500];
const int N = 500;
#define INF 0x7ffffff
int m,n;
int min_loop;
int num;
int dist[N][N],pre[N][N];
int path[N];
void dfs(int i,int j)
{
    int k=pre[i][j];
    if(k==0)
    {
        path[num++]=j;
        return;
    }
    dfs(i,k);
    dfs(k,j);
}

void Floyd()
{
    min_loop=INF;
    memset(pre,0,sizeof(pre));
    for(int k=1; k<=n; k++)
    {
        for(int i=1; i<k; i++)
        {
            for(int j=i+1; j<k; j++)
            {
                if(dist[i][j]+mp[i][k]+mp[k][j]<min_loop)
                {
                    min_loop=dist[i][j]+mp[i][k]+mp[k][j];
                    num=0;
                    path[num++]=i;
                    dfs(i,j);
                    path[num++]=k;
                }
            }
        }

        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=n; j++)
            {
                if(dist[i][k]+dist[k][j]<dist[i][j])
                {
                    dist[i][j]=dist[i][k]+dist[k][j];
                    pre[i][j]=k;
                }
            }
        }
    }
}
void init()
{
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<N; j++)
        {
            mp[i][j]=INF;
            dist[i][j]=INF;
        }
        mp[i][i]=dist[i][i]=0;
    }
}
int main()
{
//    printf("%lld\n",1ll<<62);
    for(int i=0; i<63; i++)
    {
        bit[i]=1ll<<i;
    }
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        scanf("%lld",&a[i]);
        LL tem = a[i];
        for(int j=0; j<63; j++)
        {
            if((tem&bit[j])==bit[j])
            {
                ve[j].push_back(i);
            }
        }
    }
    if(n>290)
    {
        puts("3");
        return 0;
    }
    for(int i=0; i<63; i++)
    {
        if(ve[i].size()>=3)
        {
//            printf("%lld\n",1ll<<i);
            puts("3");
            return 0;
        }
    }
    init();
    for(int i=0; i<63; i++)
    {
        int len = ve[i].size();
//        for(int j=0; j<len; j++)
//        {
//            printf("%d ",ve[i][j]);
//        }
//        printf("\n");
        for(int j=0; j<len; j++)
        {
            for(int k=0; k<len; k++)
            {
                if(k==j) continue;
                mp[ve[i][j]][ve[i][k]]=1;
                dist[ve[i][j]][ve[i][k]]=1;
            }
        }
    }
//    for(int i=1;i<=n;i++)
//    {
//        for(int j=1;j<=n;j++)
//        {
//            printf("mp[%d][%d] = %d\n",i,j,mp[i][j]);
//        }
//    }

    Floyd();
    if(min_loop<INF)
        printf("%d\n",min_loop);
    else
    {
        printf("-1\n");
    }
}


#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+7;
typedef long long LL;
LL a[maxn];
LL num[maxn][100];
LL bit[100];
vector<int> ve[100];
int mp[500][500];
const int N = 500;
#define INF 0x7ffffff
int dist[N][N];
int m,n,minc;
int min(int x,int y)
{
    if(x<y) return x;
    return y;
}
void floyd()
{
    minc=INF;
    for(int k=1; k<=n; k++)
    {
        for(int i=1; i<=k; i++)
            for(int j=i+1; j<=k; j++)
                minc=min(minc,dist[i][j]+mp[i][k]+mp[k][j]);
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                if(dist[i][j]>dist[i][k]+dist[k][j])
                    dist[i][j]=dist[i][k]+dist[k][j];
    }
}
void init()
{
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
        {
            mp[i][j]=INF;
            dist[i][j]=INF;
        }
}
int main()
{
//    printf("%lld\n",1ll<<61);
    for(int i=0; i<63; i++)
    {
        bit[i]=1ll<<i;
    }
    scanf("%d",&n);
    int ccc=0;
    for(int i=1; i<=n; i++)
    {
        scanf("%lld",&a[i]);
        LL tem = a[i];
        if(a[i]==0)ccc++;
        for(int j=0; j<63; j++)
        {
            if((tem&bit[j])==bit[j])
            {
                ve[j].push_back(i);
            }
        }
    }
//    n-=ccc;
    if(n-ccc>200)
    {
        puts("3");
        return 0;
    }
    for(int i=0; i<63; i++)
    {
        if(ve[i].size()>=3)
        {
            puts("3");
            return 0;
        }
    }
    init();
    for(int i=0; i<63; i++)
    {
        int len = ve[i].size();
//        for(int j=0; j<len; j++)
//        {
//            printf("%d ",ve[i][j]);
//        }
//        printf("\n");
        for(int j=0; j<len; j++)
        {
            for(int k=0; k<len; k++)
            {
                if(k==j) continue;
                mp[ve[i][j]][ve[i][k]]=1;
                dist[ve[i][j]][ve[i][k]]=1;
            }
        }
    }
//    for(int i=1;i<=n;i++)
//    {
//        for(int j=1;j<=n;j++)
//        {
//            printf("mp[%d][%d] = %d\n",i,j,mp[i][j]);
//        }
//    }

    floyd();
    if(minc<INF)
        printf("%d\n",minc);
    else
    {
        printf("-1");
    }
}


#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+7;
typedef long long LL;
LL a[maxn];
LL bit[100];
vector<int> ve[100];
int mp[500][500];
const int N = 500;
#define INF 0x7ffffff
int m,n;
int min_loop;
int num;
int dist[N][N],pre[N][N];
int path[N];
void dfs(int i,int j)
{
    int k=pre[i][j];
    if(k==0)
    {
        path[num++]=j;
        return;
    }
    dfs(i,k);
    dfs(k,j);
}

void Floyd()
{
    min_loop=INF;
    memset(pre,0,sizeof(pre));
    for(int k=1; k<=n; k++)
    {
        for(int i=1; i<k; i++)
        {
            for(int j=i+1; j<k; j++)
            {
                if(dist[i][j]+mp[i][k]+mp[k][j]<min_loop)
                {
                    min_loop=dist[i][j]+mp[i][k]+mp[k][j];
                    num=0;
                    path[num++]=i;
                    dfs(i,j);
                    path[num++]=k;
                }
            }
        }

        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=n; j++)
            {
                if(dist[i][k]+dist[k][j]<dist[i][j])
                {
                    dist[i][j]=dist[i][k]+dist[k][j];
                    pre[i][j]=k;
                }
            }
        }
    }
}
void init()
{
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<N; j++)
        {
            mp[i][j]=INF;
            dist[i][j]=INF;
        }
        mp[i][i]=dist[i][i]=0;
    }
}
int main()
{
//    printf("%lld\n",1ll<<62);
    for(int i=0; i<63; i++)
    {
        bit[i]=1ll<<(i*1ll);
    }
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        scanf("%lld",&a[i]);
        LL tem = a[i];
        for(int j=0; j<63; j++)
        {
            if((tem&bit[j])==bit[j])
            {
                ve[j].push_back(i);
            }
        }
    }
    if(n>290)
    {
        puts("3");
        return 0;
    }
    for(int i=0; i<63; i++)
    {
        if(ve[i].size()>=3)
        {
//            printf("%lld\n",1ll<<i);
            puts("3");
            return 0;
        }
    }
    init();
    for(int i=0; i<63; i++)
    {
        int len = ve[i].size();
//        for(int j=0; j<len; j++)
//        {
//            printf("%d ",ve[i][j]);
//        }
//        printf("\n");
        for(int j=0; j<len; j++)
        {
            for(int k=0; k<len; k++)
            {
                if(k==j) continue;
                mp[ve[i][j]][ve[i][k]]=1;
                dist[ve[i][j]][ve[i][k]]=1;
            }
        }
    }
//    for(int i=1;i<=n;i++)
//    {
//        for(int j=1;j<=n;j++)
//        {
//            printf("mp[%d][%d] = %d\n",i,j,mp[i][j]);
//        }
//    }

    Floyd();
    if(min_loop<INF)
        printf("%d\n",min_loop);
    else
    {
        printf("-1\n");
    }
}


#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+7;
typedef long long LL;
LL a[maxn];
LL bit[100];
vector<int> ve[100];
int mp[500][500];
const int N = 500;
#define INF 0x7ffffff
int m,n;
int min_loop;
int num;
int dist[N][N],pre[N][N];
int path[N];
void dfs(int i,int j)
{
    int k=pre[i][j];
    if(k==0)
    {
        path[num++]=j;
        return;
    }
    dfs(i,k);
    dfs(k,j);
}

void Floyd()
{
    min_loop=INF;
    memset(pre,0,sizeof(pre));
    for(int k=1; k<=n; k++)
    {
        for(int i=1; i<k; i++)
        {
            for(int j=i+1; j<k; j++)
            {
                if(dist[i][j]+mp[i][k]+mp[k][j]<min_loop)
                {
                    min_loop=dist[i][j]+mp[i][k]+mp[k][j];
                    num=0;
                    path[num++]=i;
                    dfs(i,j);
                    path[num++]=k;
                }
            }
        }

        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=n; j++)
            {
                if(dist[i][k]+dist[k][j]<dist[i][j])
                {
                    dist[i][j]=dist[i][k]+dist[k][j];
                    pre[i][j]=k;
                }
            }
        }
    }
}
void init()
{
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<N; j++)
        {
            mp[i][j]=INF;
            dist[i][j]=INF;
        }
        mp[i][i]=dist[i][i]=0;
    }
}
int main()
{
//    printf("%lld\n",1ll<<62);
    for(int i=0; i<63; i++)
    {
        bit[i]=(1ll<<i)*11l;
    }
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        scanf("%lld",&a[i]);
        LL tem = a[i];
        for(int j=0; j<63; j++)
        {
            if((tem&bit[j])==bit[j])
            {
                ve[j].push_back(i);
            }
        }
    }
    if(n>290)
    {
        puts("3");
        return 0;
    }
    for(int i=0; i<63; i++)
    {
        if(ve[i].size()>=3)
        {
//            printf("%lld\n",1ll<<i);
            puts("3");
            return 0;
        }
    }
    init();
    for(int i=0; i<63; i++)
    {
        int len = ve[i].size();
//        for(int j=0; j<len; j++)
//        {
//            printf("%d ",ve[i][j]);
//        }
//        printf("\n");
        for(int j=0; j<len; j++)
        {
            for(int k=0; k<len; k++)
            {
                if(k==j) continue;
                mp[ve[i][j]][ve[i][k]]=1;
                dist[ve[i][j]][ve[i][k]]=1;
            }
        }
    }
//    for(int i=1;i<=n;i++)
//    {
//        for(int j=1;j<=n;j++)
//        {
//            printf("mp[%d][%d] = %d\n",i,j,mp[i][j]);
//        }
//    }

    Floyd();
    if(min_loop<INF)
        printf("%d\n",min_loop);
    else
    {
        printf("-1\n");
    }
}


#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+7;
typedef long long LL;
LL a[maxn];
LL num[maxn][100];
LL bit[100];
vector<int> ve[100];
int mp[500][500];
const int N = 500;
#define INF 0x7ffffff
int dist[N][N];
int m,n,minc;
int min(int x,int y)
{
    if(x<y) return x;
    return y;
}
void floyd()
{
    minc=INF;
    for(int k=1; k<=n; k++)
    {
        for(int i=1; i<=k; i++)
            for(int j=i+1; j<=k; j++)
                minc=min(minc,dist[i][j]+mp[i][k]+mp[k][j]);
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                if(dist[i][j]>dist[i][k]+dist[k][j])
                    dist[i][j]=dist[i][k]+dist[k][j];
    }
}
void init()
{
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
        {
            mp[i][j]=INF;
            dist[i][j]=INF;
        }
}
int main()
{
//    printf("%lld\n",1ll<<61);
    for(int i=0; i<63; i++)
    {
        bit[i]=1ll<<i;
    }
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        scanf("%lld",&a[i]);
        LL tem = a[i];
        for(int j=0; j<63; j++)
        {
            if((tem&bit[j])==bit[j])
            {
                ve[j].push_back(i);
            }
        }
    }
    if(n>290)
    {
        puts("3");
        return 0;
    }
    for(int i=0; i<63; i++)
    {
        if(ve[i].size()>=3)
        {
//            printf("%lld\n",1ll<<i);
            puts("3");
            return 0;
        }
    }
    init();
    for(int i=0; i<63; i++)
    {
        int len = ve[i].size();
//        for(int j=0; j<len; j++)
//        {
//            printf("%d ",ve[i][j]);
//        }
//        printf("\n");
        for(int j=0; j<len; j++)
        {
            for(int k=0; k<len; k++)
            {
                if(k==j) continue;
                mp[ve[i][j]][ve[i][k]]=1;
                dist[ve[i][j]][ve[i][k]]=1;
            }
        }
    }
//    for(int i=1;i<=n;i++)
//    {
//        for(int j=1;j<=n;j++)
//        {
//            printf("mp[%d][%d] = %d\n",i,j,mp[i][j]);
//        }
//    }

    floyd();
    if(minc<INF)
        printf("%d\n",minc);
    else
    {
        printf("-1\n");
    }
}


#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+7;
typedef long long LL;
LL a[maxn];
LL num[maxn][100];
LL bit[100];
vector<int> ve[100];
int mp[500][500];
const int N = 500;
#define INF 0x7ffffff
int dist[N][N];
int m,n,minc;
int min(int x,int y)
{
    if(x<y) return x;
    return y;
}
void floyd()
{
    minc=INF;
    for(int k=1; k<=n; k++)
    {
        for(int i=1; i<=k; i++)
            for(int j=i+1; j<=k; j++)
                minc=min(minc,dist[i][j]+mp[i][k]+mp[k][j]);
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                if(dist[i][j]>dist[i][k]+dist[k][j])
                    dist[i][j]=dist[i][k]+dist[k][j];
    }
}
void init()
{
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
        {
            mp[i][j]=INF;
            dist[i][j]=INF;
        }
}
int main()
{
//    printf("%lld\n",1ll<<61);
    for(int i=0; i<63; i++)
    {
        bit[i]=1ll<<i;
    }
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        scanf("%lld",&a[i]);
        LL tem = a[i];
        for(int j=0; j<63; j++)
        {
            if((tem&bit[j])==bit[j])
            {
                ve[j].push_back(i);
            }
        }
    }
    if(n>290)
    {
        puts("3");
        return 0;
    }
    for(int i=0; i<63; i++)
    {
        if(ve[i].size()>=3)
        {
//            printf("%lld\n",1ll<<i);
            puts("3");
            return 0;
        }
    }
    init();
    for(int i=0; i<63; i++)
    {
        int len = ve[i].size();
//        for(int j=0; j<len; j++)
//        {
//            printf("%d ",ve[i][j]);
//        }
//        printf("\n");
        for(int j=0; j<len; j++)
        {
            for(int k=0; k<len; k++)
            {
                if(k==j) continue;
                mp[ve[i][j]][ve[i][k]]=1;
                dist[ve[i][j]][ve[i][k]]=1;
            }
        }
    }
//    for(int i=1;i<=n;i++)
//    {
//        for(int j=1;j<=n;j++)
//        {
//            printf("mp[%d][%d] = %d\n",i,j,mp[i][j]);
//        }
//    }

    floyd();
    if(minc<INF)
        printf("%d\n",minc);
    else
    {
        printf("-1");
    }
}


#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+7;
typedef long long LL;
LL a[maxn];
LL bit[100];
vector<int> ve[100];
int mp[500][500];
const int N = 500;
#define INF 0x7ffffff
int m,n;
int min_loop;
int num;
int dist[N][N],pre[N][N];
int path[N];
void dfs(int i,int j)
{
    int k=pre[i][j];
    if(k==0)
    {
        path[num++]=j;
        return;
    }
    dfs(i,k);
    dfs(k,j);
}

void Floyd()
{
    min_loop=INF;
    memset(pre,0,sizeof(pre));
    for(int k=1; k<=n; k++)
    {
        for(int i=1; i<k; i++)
        {
            for(int j=i+1; j<k; j++)
            {
                if(dist[i][j]+mp[i][k]+mp[k][j]<min_loop)
                {
                    min_loop=dist[i][j]+mp[i][k]+mp[k][j];
                    num=0;
                    path[num++]=i;
                    dfs(i,j);
                    path[num++]=k;
                }
            }
        }

        for(int i=1; i<=n; i++)
        {
            for(int j=1; j<=n; j++)
            {
                if(dist[i][k]+dist[k][j]<dist[i][j])
                {
                    dist[i][j]=dist[i][k]+dist[k][j];
                    pre[i][j]=k;
                }
            }
        }
    }
}
void init()
{
    for(int i=0; i<N; i++)
    {
        for(int j=0; j<N; j++)
        {
            mp[i][j]=INF;
            dist[i][j]=INF;
        }
        mp[i][i]=dist[i][i]=0;
    }
}
int main()
{
//    printf("%lld\n",1ll<<62);
    for(int i=0; i<63; i++)
    {
        bit[i]=1ll<<(i*1ll);
    }
    scanf("%d",&n);
    int ccc=1;
    for(int i=1;i<=n;i++)
    {
        LL xx;
        scanf("%lld",&xx);
        if(xx!=0) a[ccc++]=xx;
    }
    n=ccc-1;
    for(int i=1; i<=n; i++)
    {
        LL tem = a[i];
        for(int j=0; j<63; j++)
        {
            if((tem&bit[j])==bit[j])
            {
                ve[j].push_back(i);
            }
        }
    }
    if(n>128)
    {
        puts("3");
        return 0;
    }
    for(int i=0; i<63; i++)
    {
        if(ve[i].size()>=3)
        {
//            printf("%lld\n",1ll<<i);
            puts("3");
            return 0;
        }
    }
    init();
    for(int i=0; i<63; i++)
    {
        int len = ve[i].size();
//        for(int j=0; j<len; j++)
//        {
//            printf("%d ",ve[i][j]);
//        }
//        printf("\n");
        for(int j=0; j<len; j++)
        {
            for(int k=0; k<len; k++)
            {
                if(k==j) continue;
                mp[ve[i][j]][ve[i][k]]=1;
                dist[ve[i][j]][ve[i][k]]=1;
            }
        }
    }
//    for(int i=1;i<=n;i++)
//    {
//        for(int j=1;j<=n;j++)
//        {
//            printf("mp[%d][%d] = %d\n",i,j,mp[i][j]);
//        }
//    }

    Floyd();
    if(min_loop<INF)
        printf("%d\n",min_loop);
    else
    {
        printf("-1\n");
    }
}


#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+7;
typedef long long LL;
LL a[maxn];
LL num[maxn][100];
LL bit[100];
vector<int> ve[100];
int mp[500][500];
const int N = 500;
#define INF 0x7ffffff
int dist[N][N];
int m,n,minc;
int min(int x,int y)
{
    if(x<y) return x;
    return y;
}
void floyd()
{
    minc=INF;
    for(int k=1; k<=n; k++)
    {
        for(int i=1; i<=k; i++)
            for(int j=i+1; j<=k; j++)
                minc=min(minc,dist[i][j]+mp[i][k]+mp[k][j]);
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                if(dist[i][j]>dist[i][k]+dist[k][j])
                    dist[i][j]=dist[i][k]+dist[k][j];
    }
}
void init()
{
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
        {
            mp[i][j]=INF;
            dist[i][j]=INF;
        }
}
int main()
{
//    printf("%lld\n",1ll<<61);
    for(int i=0; i<63; i++)
    {
        bit[i]=1ll<<i;
    }
    scanf("%d",&n);
    int ccc=0;
    for(int i=1; i<=n; i++)
    {
        scanf("%lld",&a[i]);
        LL tem = a[i];
        if(a[i]==0)ccc++;
        for(int j=0; j<63; j++)
        {
            if((tem&bit[j])==bit[j])
            {
                ve[j].push_back(i);
            }
        }
    }
//    n-=ccc;
    if(n-ccc>130)
    {
        puts("3");
        return 0;
    }
    for(int i=0; i<63; i++)
    {
        if(ve[i].size()>=3)
        {
            puts("3");
            return 0;
        }
    }
    init();
    for(int i=0; i<63; i++)
    {
        int len = ve[i].size();
//        for(int j=0; j<len; j++)
//        {
//            printf("%d ",ve[i][j]);
//        }
//        printf("\n");
        for(int j=0; j<len; j++)
        {
            for(int k=0; k<len; k++)
            {
                if(k==j) continue;
                mp[ve[i][j]][ve[i][k]]=1;
                dist[ve[i][j]][ve[i][k]]=1;
            }
        }
    }
//    for(int i=1;i<=n;i++)
//    {
//        for(int j=1;j<=n;j++)
//        {
//            printf("mp[%d][%d] = %d\n",i,j,mp[i][j]);
//        }
//    }

    floyd();
    if(minc<INF)
        printf("%d\n",minc);
    else
    {
        printf("-1");
    }
}


#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+7;
typedef long long LL;
LL a[maxn];
LL num[maxn][100];
LL bit[100];
vector<int> ve[100];
int mp[500][500];
const int N = 500;
#define INF 0x7ffffff
int dist[N][N];
int m,n,minc;
int min(int x,int y)
{
    if(x<y) return x;
    return y;
}
void floyd()
{
    minc=INF;
    for(int k=1; k<=n; k++)
    {
        for(int i=1; i<=k; i++)
            for(int j=i+1; j<=k; j++)
                minc=min(minc,dist[i][j]+mp[i][k]+mp[k][j]);
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                if(dist[i][j]>dist[i][k]+dist[k][j])
                    dist[i][j]=dist[i][k]+dist[k][j];
    }
}
void init()
{
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
        {
            mp[i][j]=INF;
            dist[i][j]=INF;
        }
}
int main()
{
//    printf("%lld\n",1ll<<61);
    for(int i=0; i<63; i++)
    {
        bit[i]=1ll<<i;
    }
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        scanf("%lld",&a[i]);
        LL tem = a[i];
        for(int j=0; j<63; j++)
        {
            if((tem&bit[j])==bit[j])
            {
                ve[j].push_back(i);
            }
        }
    }
    for(int i=0; i<63; i++)
    {
        if(ve[i].size()>=3)
        {
            puts("3");
            return 0;
        }
    }
    init();
    for(int i=0; i<63; i++)
    {
        int len = ve[i].size();
//        for(int j=0; j<len; j++)
//        {
//            printf("%d ",ve[i][j]);
//        }
//        printf("\n");
        for(int j=0; j<len; j++)
        {
            for(int k=0; k<len; k++)
            {
                if(k==j) continue;
                mp[ve[i][j]][ve[i][k]]=1;
                dist[ve[i][j]][ve[i][k]]=1;
            }
        }
    }
//    for(int i=1;i<=n;i++)
//    {
//        for(int j=1;j<=n;j++)
//        {
//            printf("mp[%d][%d] = %d\n",i,j,mp[i][j]);
//        }
//    }

    floyd();
    if(minc<INF)
        printf("%d\n",minc);
    else
    {
        printf("-1");
    }
}


#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+7;
typedef long long LL;
LL a[maxn];
LL num[maxn][100];
LL bit[100];
vector<int> ve[100];
int mp[500][500];
const int N = 500;
#define INF 0x7ffffff
int dist[N][N];
int m,n,minc;
int min(int x,int y)
{
    if(x<y) return x;
    return y;
}
void floyd()
{
    minc=INF;
    for(int k=1; k<=n; k++)
    {
        for(int i=1; i<=k; i++)
            for(int j=i+1; j<=k; j++)
                minc=min(minc,dist[i][j]+mp[i][k]+mp[k][j]);
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                if(dist[i][j]>dist[i][k]+dist[k][j])
                    dist[i][j]=dist[i][k]+dist[k][j];
    }
}
void init()
{
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
        {
            mp[i][j]=INF;
            dist[i][j]=INF;
        }
}
int main()
{
//    printf("%lld\n",1ll<<61);
    for(int i=0; i<63; i++)
    {
        bit[i]=1ll<<i;
    }
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        scanf("%lld",&a[i]);
        LL tem = a[i];
        for(int j=0; j<63; j++)
        {
            if((tem&bit[j])==bit[j])
            {
                ve[j].push_back(i);
            }
        }
    }
    if(n>200)
    {
        puts("3");
        return 0;
    }
    for(int i=0; i<63; i++)
    {
        if(ve[i].size()>=3)
        {
            puts("3");
            return 0;
        }
    }
    init();
    for(int i=0; i<63; i++)
    {
        int len = ve[i].size();
//        for(int j=0; j<len; j++)
//        {
//            printf("%d ",ve[i][j]);
//        }
//        printf("\n");
        for(int j=0; j<len; j++)
        {
            for(int k=0; k<len; k++)
            {
                if(k==j) continue;
                mp[ve[i][j]][ve[i][k]]=1;
                dist[ve[i][j]][ve[i][k]]=1;
            }
        }
    }
//    for(int i=1;i<=n;i++)
//    {
//        for(int j=1;j<=n;j++)
//        {
//            printf("mp[%d][%d] = %d\n",i,j,mp[i][j]);
//        }
//    }

    floyd();
    if(minc<INF)
        printf("%d\n",minc);
    else
    {
        printf("-1");
    }
}


#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+7;
typedef long long LL;
LL a[maxn];
LL bit[100];
vector<int> ve[100];
int mp[500][500];
const int N = 500;
const int INF = 1e9+7;
int dist[N][N];
int m,n,minc;
int min(int x,int y)
{
    if(x<y) return x;
    return y;
}
void floyd()
{
    minc=INF;
    for(int k=1; k<=n; k++)
    {
        for(int i=1; i<=k; i++)
            for(int j=i+1; j<=k; j++)
                minc=min(minc,dist[i][j]+mp[i][k]+mp[k][j]);
        for(int i=1; i<=n; i++)
            for(int j=1; j<=n; j++)
                if(dist[i][j]>dist[i][k]+dist[k][j])
                    dist[i][j]=dist[i][k]+dist[k][j];
    }
}
void init()
{
    for(int i=0; i<N; i++)
        for(int j=0; j<N; j++)
        {
            mp[i][j]=INF;
            dist[i][j]=INF;
        }
}
int main()
{
//    printf("%lld\n",1ll<<62);
    for(int i=0; i<63; i++)
    {
        bit[i]=1ll<<i;
    }
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        scanf("%lld",&a[i]);
        LL tem = a[i];
        for(int j=0; j<63; j++)
        {
            if((tem&bit[j])==bit[j])
            {
                ve[j].push_back(i);
            }
        }
    }
    if(n>290)
    {
        puts("3");
        return 0;
    }
    for(int i=0; i<63; i++)
    {
        if(ve[i].size()>=3)
        {
//            printf("%lld\n",1ll<<i);
            puts("3");
            return 0;
        }
    }
    init();
    for(int i=0; i<63; i++)
    {
        int len = ve[i].size();
//        for(int j=0; j<len; j++)
//        {
//            printf("%d ",ve[i][j]);
//        }
//        printf("\n");
        for(int j=0; j<len; j++)
        {
            for(int k=0; k<len; k++)
            {
                if(k==j) continue;
                mp[ve[i][j]][ve[i][k]]=1;
                dist[ve[i][j]][ve[i][k]]=1;
            }
        }
    }
//    for(int i=1;i<=n;i++)
//    {
//        for(int j=1;j<=n;j++)
//        {
//            printf("mp[%d][%d] = %d\n",i,j,mp[i][j]);
//        }
//    }

    floyd();
    if(minc<INF)
        printf("%d\n",minc);
    else
    {
        printf("-1\n");
    }
}


/*
___mennat khoday ra azz o va jall ke taatash mojebe ghorbat ast o be shokr andarash mazide nemat.
___har nafasi ke foro miravad momedde hayatast o chon bar miayad mofarrahe zat.
___pas dar har nafasi 2 nemat mojod ast o bar har nematy shokry vajeb.

___az dast o zabane ke barayad ?
___kaz ohdeye shokrash be dar ayad !

*/
//ios::sync_with_stdio(false);
#include <bits/stdc++.h>
#define pb push_back
#define adelkhah main
#define left(x) ((x)*2)
#define right(x) (((x)*2)+1)
//#define int long long
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N = 200;
int mark[N];
vector<int> G[N];
int dis[N];
int parent[N];
vector<int> bit[N];
int ans = 100000;
void bfs(int u)
{
    vector<int> v;
    v.pb(u);
    mark[u] = 1;
    dis[u] = 0;
    for(int i = 0; i < v.size(); i++){
        int w = v[i];
        for(int j = 0; j < G[w].size(); j++){
            int ww = G[w][j];
            if(mark[ww] == 1 && parent[w] != ww){
                ans = min(ans,dis[w]+dis[ww]+1);
            }
            if(mark[ww] == 0){
                dis[ww] = 1+dis[w];
                v.pb(ww);
                mark[ww] = 1;
                parent[ww] = w;
            }
        }
    }
}
int32_t adelkhah()
{
    int n; cin >> n; int a[n];int t;
    for(int i = 0; i < n; i++){
        cin >> a[i]; t = a[i];
        for(int j = 0; j < 62; j++){
            if(t&(1<<j)){
                bit[j].pb(i);
            }
        }
    }
    for(int i = 0; i < N; i++){
        if(bit[i].size() > 2){
            return cout << 3,0;
        }
    }
    for(int i = 0; i < n; i++){
        for(int j = i+1; j < n; j++){
            if((a[i]&a[j]) > 0){
                G[i].pb(j); G[j].pb(i);
            }
        }
    }
    bfs(0);
    return cout << ans,0;
}
/**< WRITEN BY ALI ADELKHAH ::: The future Legendary GrandMaster */


/*
___mennat khoday ra azz o va jall ke taatash mojebe ghorbat ast o be shokr andarash mazide nemat.
___har nafasi ke foro miravad momedde hayatast o chon bar miayad mofarrahe zat.
___pas dar har nafasi 2 nemat mojod ast o bar har nematy shokry vajeb.

___az dast o zabane ke barayad ?
___kaz ohdeye shokrash be dar ayad !

*/
//ios::sync_with_stdio(false);
#include <bits/stdc++.h>
#define pb push_back
#define adelkhah main
#define left(x) ((x)*2)
#define right(x) (((x)*2)+1)
#define int long long
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N = 200;
int mark[N];
vector<int> G[N];
int dis[N];
int parent[N];
vector<int> bit[N];
int ans = 100000;
void bfs(int u)
{
    vector<int> v;
    v.pb(u);
    mark[u] = 1;
    dis[u] = 0;
    for(int i = 0; i < v.size(); i++){
        int w = v[i];
        for(int j = 0; j < G[w].size(); j++){
            int ww = G[w][j];
            if(mark[ww] == 1 && parent[w] != ww){
                ans = min(ans,dis[w]+dis[ww]+1);
            }
            if(mark[ww] == 0){
                dis[ww] = 1+dis[w];
                v.pb(ww);
                mark[ww] = 1;
                parent[ww] = w;
            }
        }
    }
}
int32_t adelkhah()
{
    int n; cin >> n; int a[n];int t;
    for(int i = 0; i < n; i++){
        cin >> a[i]; t = a[i];
        for(int j = 0; j < 62; j++){
            int y = (1<<j);
            if(t&y > 0){
                bit[j].pb(i);
            }
        }
    }
    for(int i = 0; i < N; i++){
        if(bit[i].size() > 2){
            return cout << 3,0;
        }
    }
    for(int i = 0; i < n; i++){
        for(int j = i+1; j < n; j++){
            if((a[i]&a[j]) > 0){
                G[i].pb(j); G[j].pb(i);
            }
        }
    }
    bfs(0);
    return cout << (ans==100000?-1:ans),0;
}
/**< WRITEN BY ALI ADELKHAH ::: The future Legendary GrandMaster */


/*
___mennat khoday ra azz o va jall ke taatash mojebe ghorbat ast o be shokr andarash mazide nemat.
___har nafasi ke foro miravad momedde hayatast o chon bar miayad mofarrahe zat.
___pas dar har nafasi 2 nemat mojod ast o bar har nematy shokry vajeb.

___az dast o zabane ke barayad ?
___kaz ohdeye shokrash be dar ayad !

*/
//ios::sync_with_stdio(false);
#include <bits/stdc++.h>
#define pb push_back
#define adelkhah main
#define left(x) ((x)*2)
#define right(x) (((x)*2)+1)
#define int long long
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N = 200;
int mark[N];
vector<int> G[N];
int dis[N];
int parent[N];
vector<int> bit[N];
int ans = 100000;
void bfs(int u)
{
    vector<int> v;
    v.pb(u);
    mark[u] = 1;
    dis[u] = 0;
    for(int i = 0; i < v.size(); i++){
        int w = v[i];
        for(int j = 0; j < G[w].size(); j++){
            int ww = G[w][j];
            if(mark[ww] == 1 && parent[w] != ww){
                ans = min(ans,dis[w]+dis[ww]+1);
            }
            if(mark[ww] == 0){
                dis[ww] = 1+dis[w];
                v.pb(ww);
                mark[ww] = 1;
                parent[ww] = w;
            }
        }
    }
}
int32_t adelkhah()
{
    int n; cin >> n; int a[n];int t;
    for(int i = 0; i < n; i++){
        cin >> a[i]; t = a[i];
        for(int j = 0; j < 62; j++){
            int y = (1<<j);
            if(t&y){
                bit[j].pb(i);
            }
        }
    }
    for(int i = 0; i < N; i++){
        if(bit[i].size() > 2){
            return cout << 3,0;
        }
    }
    for(int i = 0; i < n; i++){
        for(int j = i+1; j < n; j++){
            if((a[i]&a[j]) > 0){
                G[i].pb(j); G[j].pb(i);
            }
        }
    }
    bfs(0);
    return cout << ans,0;
}
/**< WRITEN BY ALI ADELKHAH ::: The future Legendary GrandMaster */