#include <bits/stdc++.h>
using namespace std;
namespace {
using Integer = long long;
template <class T, class S>
istream& operator>>(istream& is, pair<T, S>& p) {
  return is >> p.first >> p.second;
}
template <class T>
istream& operator>>(istream& is, vector<T>& vec) {
  for (T& val : vec) is >> val;
  return is;
}
template <class T>
istream& operator,(istream& is, T& val) {
  return is >> val;
}
template <class T, class S>
ostream& operator<<(ostream& os, const pair<T, S>& p) {
  return os << p.first << " " << p.second;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
  for (size_t i = 0; i < vec.size(); i++)
    os << vec[i] << (i == vec.size() - 1 ? "" : " ");
  return os;
}
template <class T>
ostream& operator,(ostream& os, const T& val) {
  return os << " " << val;
}
template <class H>
void print(const H& head) {
  cout << head;
}
template <class H, class... T>
void print(const H& head, const T&... tail) {
  cout << head << " ";
  print(tail...);
}
template <class... T>
void println(const T&... values) {
  print(values...);
  cout << endl;
}
template <class H>
void eprint(const H& head) {
  cerr << head;
}
template <class H, class... T>
void eprint(const H& head, const T&... tail) {
  cerr << head << " ";
  eprint(tail...);
}
template <class... T>
void eprintln(const T&... values) {
  eprint(values...);
  cerr << endl;
}
class range {
  Integer start_, end_, step_;

 public:
  struct range_iterator {
    Integer val, step_;
    range_iterator(Integer v, Integer step) : val(v), step_(step) {}
    Integer operator*() { return val; }
    void operator++() { val += step_; }
    bool operator!=(range_iterator& x) {
      return step_ > 0 ? val < x.val : val > x.val;
    }
  };
  range(Integer len) : start_(0), end_(len), step_(1) {}
  range(Integer start, Integer end) : start_(start), end_(end), step_(1) {}
  range(Integer start, Integer end, Integer step)
      : start_(start), end_(end), step_(step) {}
  range_iterator begin() { return range_iterator(start_, step_); }
  range_iterator end() { return range_iterator(end_, step_); }
};
inline string operator"" _s(const char* str, size_t size) {
  return move(string(str));
}
constexpr Integer my_pow(Integer x, Integer k, Integer z = 1) {
  return k == 0    ? z
         : k == 1  ? z * x
         : (k & 1) ? my_pow(x * x, k >> 1, z * x)
                   : my_pow(x * x, k >> 1, z);
}
constexpr Integer my_pow_mod(Integer x, Integer k, Integer M, Integer z = 1) {
  return k == 0    ? z % M
         : k == 1  ? z * x % M
         : (k & 1) ? my_pow_mod(x * x % M, k >> 1, M, z * x % M)
                   : my_pow_mod(x * x % M, k >> 1, M, z);
}
constexpr unsigned long long operator"" _ten(unsigned long long value) {
  return my_pow(10, value);
}
inline int k_bit(Integer x, int k) { return (x >> k) & 1; }
mt19937 mt(chrono::duration_cast<chrono::nanoseconds>(
               chrono::steady_clock::now().time_since_epoch())
               .count());
template <class T>
string join(const vector<T>& v, const string& sep) {
  stringstream ss;
  for (size_t i = 0; i < v.size(); i++) {
    if (i > 0) ss << sep;
    ss << v[i];
  }
  return ss.str();
}
inline string operator*(string s, int k) {
  string ret;
  while (k) {
    if (k & 1) ret += s;
    s += s;
    k >>= 1;
  }
  return ret;
}
}  // namespace
constexpr long long mod = 9_ten + 7;
template <class T = int>
class SparseTable {
 public:
  SparseTable(int len, T default_value_ = 100000000)
      : col(len), default_value(default_value_) {
    row = 1;
    while ((1 << row) < col) row += 1;
    row++;
    table = vector<vector<T>>(row, vector<T>(col, default_value));
  }
  SparseTable(vector<T>& vec, T default_value_ = 100000000)
      : col(vec.size()), default_value(default_value_) {
    row = 1;
    while ((1 << row) < col) row += 1;
    row++;
    table = vector<vector<T>>(row, vector<T>(col, default_value));
    set(vec);
  }
  void set(vector<T>& vec) {
    assert(col == (int)vec.size());
    values = &vec;
    vector<T>& val = vec;
    iota(table[0].begin(), table[0].end(), 0);
    for (int k = 1; k < row; k++) {
      for (int i = 0; i + (1 << k) - 1 < col; i++) {
        T left = val[table[k - 1][i]];
        T right = val[table[k - 1][i + (1 << (k - 1))]];
        if (left == min<T>(left, right)) {
          table[k][i] = table[k - 1][i];
        } else {
          table[k][i] = table[k - 1][i + (1 << (k - 1))];
        }
      }
    }
  }
  T get(int l, int r) {
    if (l >= r) return default_value;
    vector<T>& val = *values;
    T ret = default_value;
    int k = 0;
    while ((1 << (k + 1)) < (r - l)) k++;
    T left = val[table[k][l]];
    T right = val[table[k][r - (1 << k)]];
    ret = min<T>(left, right);
    return ret;
  }

 private:
  int col;
  int row;
  T default_value;
  vector<T>* values;
  vector<vector<T>> table;
};
int main() {
  int n;
  cin >> n;
  vector<int> a(n);
  cin >> a;
  for (int k = 0; k < 2; k++)
    for (int i = 0; i < n; i++) {
      a.push_back(a[i]);
    }
  a.push_back(-1);
  SparseTable<int> a_min(a, 2000000000);
  vector<int> r(n + n);
  for (int i = 0; i < n + n; i++) {
    long long lb = i;
    long long ub = n + n + n;
    auto check = [&](long long m) {
      int v = a_min.get(i, m + 1);
      return v <= (a[i] - 1) / 2;
    };
    while (ub - lb > 1) {
      long long mid = (lb + ub) / 2;
      bool ng = check(mid);
      (ng ? ub : lb) = mid;
    }
    r[i] = ub;
  }
  vector<int> par(n + n, -1);
  set<pair<int, int>> s;
  for (int i = 0; i < n + n; i++) {
    auto itr = s.begin();
    while (itr != s.end() && itr->first <= a[i]) {
      int j = itr->second;
      if (i - j < n) {
        par[j] = i;
      }
      auto next_itr = next(itr);
      s.erase(itr);
      itr = next_itr;
    }
    s.insert(pair<int, int>(a[i], i));
  }
  vector<int> memo(n + n, -1);
  function<int(int)> dfs = [&](int pos) {
    if (memo[pos] != -1) {
      return memo[pos];
    }
    if (par[pos] == -1) {
      memo[pos] = r[pos];
      return memo[pos];
    }
    return memo[pos] = min(r[pos], dfs(par[pos]));
  };
  for (int i = 0; i < n; i++) {
    dfs(i);
  }
  for (int i = 0; i < n; i++) {
    if (memo[i] == n + n + n) {
      memo[i] = -1;
    } else {
      memo[i] = memo[i] - i;
    }
    if (memo[i] >= n) {
    }
  }
  vector<int> ans(begin(memo), begin(memo) + n);
  println(join(ans, " "));
  return 0;
}
