#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using u64 = uint_fast64_t; 
using pii =  pair<int, int>;
using pll =  pair<long long, long long>;
#define rep(i, n) for(int i = 0; i < (n); ++i)
#define all(x) (x).begin(),(x).end()
constexpr char ln =  '\n';
////////////////////////////////////////////////////////////////////////////////

using DD = double;
constexpr DD EPS = 1e-3;
inline int sgn(DD a) {return (a < -EPS) ? -1 : (a > EPS) ? 1 : 0;}

template<class T>
struct Matrix {

    int N,M;
    vector<vector<T>> A;

    Matrix() {}
    Matrix(int N, int M, T x = 0) : N(N), M(M), A(N, vector<T>(M, x)) {}

    void init(int n, int m, T x = 0) {A.assign(n, vector<T>(m, x));}
    int size() const {return N;}
    inline vector<T>& operator [] (int i) {return A[i];}

    int GaussJordan(bool is_extended = false) {
        int rank = 0;
        for (int col = 0; col < M; ++col) {
            // 拡大係数行列の場合は最後の列は掃き出ししない
            if (is_extended && col == M-1) break;

            // ピボットを探す
            int pivot = -1;
            T ma = EPS;
            for (int row = rank; row < N; ++row) {
                if (abs(A[row][col]) > ma) {
                    ma = abs(A[row][col]);
                    pivot = row;
                }
            }
            // ピボットがなかったら次の列へ
            if (pivot == -1) continue;

            // まずは行を swap
            swap(A[pivot], A[rank]);

            // ピボットの値を 1 にする
            auto fac = A[rank][col];
            for (int col2 = 0; col2 < M; ++col2) A[rank][col2] /= fac;

            // ピボットのある列の値がすべて 0 になるように掃き出す
            for (int row = 0; row < N; ++row) {
                if (row != rank && sgn(A[row][col])) {
                    auto fac = A[row][col];
                    for (int col2 = 0; col2 < M; ++col2) {
                        A[row][col2] -= A[rank][col2] * fac;
                    }
                }
            }
            ++rank;
        }
        return rank;
    }

    vector<T> linear_equation(const vector<T> &b) {
        // extended
        Matrix<T> C(N, M + 1);
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < M; ++j) C[i][j] = A[i][j];
            C[i][M] = b[i];
        }
        int rank = C.GaussJordan(true);
        
        // check if it has no solution
        vector<T> res;
        for (int row = rank; row < N; ++row) if (sgn(C[row][M])) return res;

        // answer
        res.assign(M, 0);
        for (int i = 0; i < rank; ++i) res[i] = C[i][M];
        return res;
    }
};

////////////////////////////////////////////////////////////////////////////////

void AOJ1328() {
    auto solve=[](int N) {
        vector<DD> d(N+3);
        rep(i,N+3) cin >> d[i];

        vector<vector<DD>> beki(N+3, vector<DD>(N+1,1));
        rep(i,N+3) rep(j,N) beki[i][j+1] = beki[i][j]*i;

        auto calc=[&](const vector<DD> &ans, int x) {
            DD ret = 0;
            DD b = 1;
            rep(i,N+1) {
                ret += ans[i]*b;
                b *= x;
            }
            return ret;
        };
        rep(x,N+3) {
            for (int y = x+1; y < N+3; y++) {
                Matrix<DD> mat(N+1, N+1);
                vector<vector<DD>> A;
                vector<DD> B;
                rep(i,N+3) {
                    if (i==x or i==y) continue;
                    A.emplace_back(beki[i]);
                    B.emplace_back(d[i]);
                }
                rep(i,N+1) rep(j,N+1) mat[i][j] = A[i][j];
                auto ret = mat.linear_equation(B);
                if (!ret.empty()) {
                    DD ansx = calc(ret,x);
                    DD ansy = calc(ret,y);
                    if (!sgn(d[x]-ansx)) {
                        cout << y << ln;
                        return;
                    }
                    if (!sgn(d[y]-ansy)) {
                        cout << x << ln;
                        return;
                    }
                }
            }
        }
    };
    while (1) {
        int n; cin >> n;
        if (!n) break;
        solve(n);
    }
}
int main() {
	ios::sync_with_stdio(false); cin.tie(nullptr);
    AOJ1328();
}


Measured memory_bytes: 3312