#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const double eps = 1e-9;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long randint(long long l, long long r) {
  long long out = rng() % (r - l + 1) + l;
  return out >= l ? out : out + r - l + 1;
}
template <typename T>
typename enable_if<!is_integral<T>::value, void>::type read(T& x) {
  cin >> x;
}
long long read() {
  char c;
  long long out = 0, f = 1;
  for (c = getchar(); !isdigit(c) && c != '-'; c = getchar())
    ;
  if (c == '-') {
    f = -1;
    c = getchar();
  }
  for (; isdigit(c); c = getchar()) out = (out << 3) + (out << 1) + c - '0';
  return out * f;
}
template <typename T>
typename enable_if<is_integral<T>::value, T>::type read(T& x) {
  char c;
  T f = 1;
  x = 0;
  for (c = getchar(); !isdigit(c) && c != '-'; c = getchar())
    ;
  if (c == '-') {
    f = -1;
    c = getchar();
  }
  for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
  return x *= f;
}
char read(char& x) {
  for (x = getchar(); isspace(x); x = getchar())
    ;
  return x;
}
double read(double& x) {
  scanf("%lf", &x);
  return x;
}
void read(char* x) { scanf("%s", x); }
template <typename T>
typename enable_if<!is_integral<T>::value, void>::type write(const T& x) {
  cout << x;
}
template <typename T>
typename enable_if<is_integral<T>::value, void>::type write(const T& x) {
  if (x < 0) {
    putchar('-');
    write(-x);
    return;
  }
  if (x > 9) write(x / 10);
  putchar(x % 10 + '0');
}
void write(const char& x) { putchar(x); }
void write(const double& x) { printf("%.10lf", x); }
void write(const char* x) { printf("%s", x); }
template <typename T, typename... Args>
void read(T& x, Args&... args) {
  read(x);
  read(args...);
}
template <typename... Args>
void read(char* x, Args&... args) {
  read(x);
  read(args...);
}
template <
    typename OutputIt,
    typename = typename enable_if<
        is_same<output_iterator_tag,
                typename iterator_traits<OutputIt>::iterator_category>::value ||
        (is_base_of<forward_iterator_tag, typename iterator_traits<OutputIt>::
                                              iterator_category>::value &&
         !is_const<OutputIt>::value)>::type>
void read(OutputIt __first, OutputIt __last) {
  for (; __first != __last; ++__first) read(*__first);
}
template <
    typename InputIt,
    typename = typename enable_if<is_base_of<
        input_iterator_tag,
        typename iterator_traits<InputIt>::iterator_category>::value>::type>
void wts(InputIt __first, InputIt __last) {
  for (; __first != __last; ++__first) {
    write(*__first);
    putchar(' ');
  }
}
template <
    typename InputIt,
    typename = typename enable_if<is_base_of<
        input_iterator_tag,
        typename iterator_traits<InputIt>::iterator_category>::value>::type>
void wtb(InputIt __first, InputIt __last) {
  for (; __first != __last; ++__first) {
    write(*__first);
    putchar('\n');
  }
}
void wts(const char* x) {
  write(x);
  putchar(' ');
}
void wtb(const char* x) {
  write(x);
  putchar('\n');
}
void wte(const char* x) {
  write(x);
  exit(0);
}
template <typename T>
void wts(const T& x) {
  write(x);
  putchar(' ');
}
template <typename T>
void wtb(const T& x) {
  write(x);
  putchar('\n');
}
template <typename T>
void wte(const T& x) {
  write(x);
  exit(0);
}
template <typename... Args>
void wts(const char* x, Args... args) {
  wts(x);
  wts(args...);
}
template <typename... Args>
void wtb(const char* x, Args... args) {
  wts(x);
  wtb(args...);
}
template <typename... Args>
void wte(const char* x, Args... args) {
  wts(x);
  wte(args...);
}
template <typename T, typename... Args>
void wts(const T& x, Args... args) {
  wts(x);
  wts(args...);
}
template <typename T, typename... Args>
void wtb(const T& x, Args... args) {
  wts(x);
  wtb(args...);
}
template <typename T, typename... Args>
void wte(const T& x, Args... args) {
  wts(x);
  wte(args...);
}
template <typename T>
inline bool up(T& x, const T& y) {
  return x < y ? x = y, 1 : 0;
}
template <typename T>
inline bool dn(T& x, const T& y) {
  return y < x ? x = y, 1 : 0;
}
const long long N = 100080;
long long n, c[70], a[N], dis[200][200], g[200][200], ans = INF;
signed main() {
  read(n);
  for (long long i = 1; i <= n; ++i) {
    read(a[i]);
    if (!a[i]) {
      --n;
      --i;
      continue;
    }
    for (long long j = (0), jend = (59); j <= jend; ++j) {
      if ((a[i] >> j) & 1ll) {
        if (++c[j] == 3) wte(3);
      }
    }
  }
  memset(dis, 0x3f, sizeof(dis));
  memset(g, 0x3f, sizeof(g));
  for (long long i = (1), iend = (n); i <= iend; ++i) {
    dis[i][i] = 0;
    for (long long j = (i + 1), jend = (n); j <= jend; ++j)
      if (a[i] & a[j]) {
        dis[i][j] = dis[j][i] = g[i][j] = g[j][i] = 1;
      }
  }
  for (long long k = (1), kend = (n); k <= kend; ++k) {
    for (long long i = (1), iend = (k - 1); i <= iend; ++i)
      for (long long j = (1), jend = (i - 1); j <= jend; ++j)
        if (dis[i][j] < INF && dis[i][k] < INF && dis[k][j] < INF)
          dn(ans, dis[i][j] + g[i][k] + g[k][j]);
    for (long long i = (1), iend = (n); i <= iend; ++i)
      for (long long j = (1), jend = (n); j <= jend; ++j)
        dn(dis[i][j], dis[i][k] + dis[k][j]);
  }
  cout << (ans >= INF ? -1 : ans);
  return 0;
}
