#include <bits/stdc++.h>
double lagrange_interpolation(std::vector<double> x, std::vector<double> y, double T) {
    const long long n = x.size() - 1;
    double ret = 0;
    for(int i=0;i<n+1;++i) {
        double t = 1;
        for(int j=0;j<n+1;++j) {
            if(i == j) continue;
            t *= T-x[j];
            t /= x[i]-x[j];
        }
        ret += t * y[i];
    }
    return ret;
}
std::vector<double> lagrange_interpolation(std::vector<double> x, std::vector<double> y) {
    const long long n = x.size() - 1;
    const double eps = 1e-6;
    for(int i=0;i<n+1;++i) {
        double t = 1;
        for(int j=0;j<n+1;++j) {
          if(i != j) t *= x[i]-x[j];
        }
        y[i] /= t;
    }
    long long cur = 0, nxt = 1;
    std::vector<std::vector<double>> dp(2, std::vector<double>(n+2));
    dp[0][0] = -1 * x[0], dp[0][1] = 1;
    for(int i=1;i<n+1;++i) {
        for(int j=0;j<n+2;++j) {
            dp[nxt][j] = dp[cur][j] * -1 * x[i];
            if(j >= 1) dp[nxt][j] += dp[cur][j-1];
        }
        std::swap(nxt, cur);
    }
    std::vector<double> ret(n+1);
    for(int i=0;i<n+1;++i) {
        if(y[i]==0) continue;
        if(abs(x[i]) < eps) {
            for(int j=0;j<n+1;++j) ret[j] += dp[cur][j+1] * y[i];
        } else {
            ret[0] -= dp[cur][0] / x[i] * y[i];
            double pre = -1 * dp[cur][0] / x[i];
            for(int j=1;j<n+1;++j) {
                ret[j] -= (dp[cur][j] - pre) / x[i] * y[i];
                pre = -1 * (dp[cur][j] - pre) / x[i];
            }
        }
    }
    return ret;
}
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
const double eps = 1e-4;
const ll MOD = 1000000007;
const int INF = 1000000000;
const ll LINF = 1ll<<50;
template<typename T>
void printv(const vector<T>& s) {
  for(int i=0;i<(int)(s.size());++i) {
    cout << s[i];
    if(i == (int)(s.size())-1) cout << endl;
    else cout << " ";
  }
}
template<typename T1, typename T2>
ostream& operator<<(ostream &os, const pair<T1, T2> p) {
  os << p.first << ":" << p.second;
  return os;
}
bool operator== (const vector<double> &v1, const vector<double> &v2) {
  if((int)(v1.size()) == (int)(v2.size())) {
    bool res = true;
    for(int i=0;i<(int)(v1.size());++i) {
      res &= abs(v1[i] - v2[i]) < eps;
    }
    return res;
  } else {
    return false;
  }
}
double err (const vector<double> &v1, const vector<double> &v2) {
  double res = 0;
  for(int i=0;i<(int)(v1.size());++i) {
    res += abs(v1[i] - v2[i]);
  }
  return res;
}
void solve(int d) {
  vector<double> x, y;
  for(int i=0;i<d+3;++i) {
    x.push_back(i);
    double tmp; cin >> tmp;
    y.push_back(tmp);
  }
  vector<pair<double, int>> vp;
  for(int i=0;i<d+3;++i) {
    vector<vector<double>> v;
    for(int j=0;j<d+3;++j) {
      if(j == i) continue;
      vector<double> nx, ny;
      for(int k=0;k<d+3;++k) {
        if(k == i || k == j) continue;
        nx.push_back(x[k]);
        ny.push_back(y[k]);
      }
      v.emplace_back(lagrange_interpolation(nx, ny));
    }
    bool ok = true;
    double ma = 0;
    for(int j=0;j<d+2;++j) {
      ma = max(ma, err(v[j], v[(j+1)%(d+2)]));
    }
    vp.push_back({ma, i});
  }
  sort(vp.begin(), vp.end());
  cout << vp[0].second << endl;
}
int main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  cout << fixed << setprecision(10);
  while(1) {
    int d; cin >> d;
    if(d == 0) break;
    solve(d);
  }
}



Measured memory_bytes: 3220