#include <bits/stdc++.h>

using namespace std;

namespace {

    template<class T> ostream& operator<<(ostream& os, const vector<T>& vs) {
        if (vs.empty()) return os << "[]";
        os << "[" << vs[0];
        for (int i = 1; i < vs.size(); i++) os << " " << vs[i];
        return os << "]";
    }

    typedef long double real;

    const real EPS = 1e-3;
    bool EQ(real a, real b) { return abs(a - b) <= EPS; }

    struct Matrix : public vector< vector<real> > {
        int H, W;
        Matrix(int H, int W) : H(H), W(W) {
            clear(); resize(H, vector<real>(W, 0));
        }
    };

    void eliminate(Matrix& M) {
        // 前進消去
        int H = M.H, W = M.W;
        for (int i = 0; i < H; i++) {
            int p = i;
            for (int j = i; j < H; j++) {
                if (M.at(j).at(i) > M.at(p).at(i)) {
                    p = j;
                }
            }
            if (EQ(M.at(p).at(i), 0)) continue;
            swap(M.at(i), M.at(p));
            real x = M.at(i).at(i);
            for (int j = i; j < W; j++) M.at(i).at(j) /= x;
            for (int k = i + 1; k < H; k++) {
                real y = M.at(k).at(i);
                for (int l = i; l < W; l++) {
                    M.at(k).at(l) -= y * M.at(i).at(l);
                }
            }
        }
        // 後退代入
        for (int i = H - 1; i >= 0; i--) {
            for (int j = i - 1; j >= 0; j--) {
                real x = M.at(j).at(i);
                for (int k = i; k < W; k++) {
                    M.at(j).at(k) -= x * M.at(i).at(k);
                }
            }
        }
    }

    int D;
    vector<real> V;
    bool input() {
        cin >> D;
        if (D == 0) return false;
        V.clear(); V.resize(D + 3);
        for (int i = 0; i < D + 3; i++) cin >> V[i];
        return true;
    }

    bool check(const vector<real>& A, int k, real x) {
        real res = 0;
        for (int i = D; i >= 0; i--) {
            res = res * k + A[i];
        }
        return EQ(res, x);
    }

    void solve() {
        for (int i = 0; i < D + 3; i++) {
            Matrix M(D + 1, D + 2);
            int j = 0; int r = 0;
            while (r < D + 1) {
                if (i == j) {
                    j++;
                    continue;
                }
                M[r][0] = 1;
                for (int k = 1; k < D + 1; k++) {
                    M[r][k] = M[r][k - 1] * j;
                }
                M[r][D + 1] = V[j];
                j++; r++;
            }
            //cout << setprecision(12) << M << endl;
            eliminate(M);
            //cout << M << endl;

            vector<real> A(D + 1);
            for (int k = 0; k < D + 1; k++) {
                A[k] = M[k][D + 1];
            }
            //cout << A << endl;
            for (int k = 0; k < D + 3; k++) {
                if (i == k) continue;
                if (check(A, k, V[k])) {
                    //cout << k << " OK" << endl;
                    continue;
                }
                goto next;
            }
            cout << i << endl;
            return;
next:;
        }
        assert(0);
    }
}

int main() {
    while (input()) solve();
    return 0;
}

Measured memory_bytes: 1264