#include <iostream>
#include <vector>
#include <array>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <string>
#include <sstream>
#include <algorithm>
#include <random>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cmath>
#include <cassert>
#include <climits>
#include <bitset>
#include <functional>
#include <iomanip>
#include <random>

#define FOR_LT(i, beg, end) for (int i = (int)(beg); i < (int)(end); i++)
#define FOR_LE(i, beg, end) for (int i = (int)(beg); i <= (int)(end); i++)
#define FOR_DW(i, beg, end) for (int i = (int)(beg); (int)(end) <= i; i--)
#define REP(n)              for (int repeat_index = 0; repeat_index < (int)n; repeat_index++)

using namespace std;
//=============================================================================
// Matrix
//=============================================================================

template <typename T>
struct Matrix {
    Matrix(size_t m, size_t n, T x = 0) : val_(vector<vector<T>>(m, vector<T>(n, x))) {}

    void Init(size_t m, size_t n, T x = 0)
    {
        this->val_.assign(vector<vector<T>>(m, vector<T>(n, x)));
    }

    size_t size() {
        return this->val_.size();
    }

    inline vector<T>& operator [] (int i) { return this->val_[i]; }

    void print() {
        for (auto& v : val_) {
            for (auto& t : v) {
cout << t << " ";
            }
            cout << endl;
        }
    }

    vector<vector<T>> val_;
};

//=============================================================================
// REAL
//=============================================================================
static const double kEPS = 1e-10;

template<class T>
int gauss_jordan(Matrix<T>& A, bool is_extended = false) {
    int m = A.size(), n = A[0].size();

    int rank = 0;
    for (int col = 0; col < n; ++col) {
        if (is_extended && col == n - 1) break;

        int pivot = -1;
        T ma = kEPS;
        for (int row = rank; row < m; ++row) {
            if (abs(A[row][col]) > ma) {
                ma = abs(A[row][col]);
                pivot = row;
            }
        }
        if (pivot == -1) continue;

        swap(A[pivot], A[rank]);
        {
            auto fac = A[rank][col];

            for (int col2 = 0; col2 < n; ++col2) {
                A[rank][col2] /= fac;
            }
        }

        for (int row = 0; row < m; ++row) {
            if (row != rank && abs(A[row][col]) > kEPS) {
                auto fac = A[row][col];
                for (int col2 = 0; col2 < n; ++col2) {
                    A[row][col2] -= A[rank][col2] * fac;
                }
            }
        }

        ++rank;
    }

    return rank;
}


template<class T> vector<T> linear_equation(Matrix<T> A, vector<T> b)
{
    int m = A.size(), n = A[0].size();

    Matrix<T> M(m, n + 1);
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) M[i][j] = A[i][j];
        M[i][n] = b[i];
    }
    int rank = gauss_jordan(M, true);

    vector<T> res;
    for (int row = rank; row < m; ++row) {
        if (abs(M[row][n]) > kEPS) return res;
    }

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

void solve(int d)
{
    vector<double> y(d + 3);
    FOR_LT(i, 0, d + 3) {
        cin >> y[i];
    }

    vector<int> s;
    vector<vector<int>> sc;
    vector<vector<double>> v;
    FOR_LT(i, 0, (1 << (d + 3))) {
        {
            int c = 0;
            FOR_LT(j, 0, (d + 3)) {
                if (i & (1 << j)) c++;
            }
            if (c != d + 1) continue;
        }


        Matrix<double> A(d + 1, d + 1);
        vector<double> b(d + 1);

        int c = 0;
        FOR_LT(j, 0, d + 3) {
            if (i & (1 << j)) {
                FOR_LE(k, 0, d) {
                    A[c][k] = pow(j, k);
                }
                b[c] = y[j];
                c++;
            }
		}

        vector<double> ans = linear_equation(A, b);
        assert(!ans.empty());

        {
            bool is_same = false;
            FOR_LT(j, 0, s.size()) {
                bool is_c_same = true;
                FOR_LT(k, 0, d + 1) {
                    if (abs(v[j][k] - ans[k]) >= 10E-4) {
                        is_c_same = false;
                        break;
                    }
                }
                if (is_c_same) {
                    is_same = true;
                    s[j]++;
                    FOR_LT(k, 0, d + 3) {
                        if (i & (1 << k)) {
                            sc[j][k]++;
                        }
                    }
                    break;
                }
            }
            if (!is_same) {
                s.push_back(1);
                v.push_back(ans);
                vector<int> scc(d + 3);
                FOR_LT(k, 0, d + 3) {
                    if (i & (1 << k)) {
                        scc[k]++;
                    }
                }
                sc.push_back(scc);
            }
        }
	}

    int argmax = -1;
    int maxv = 0;
    FOR_LT(i, 0, s.size()) {
        if (maxv < s[i]) {
            argmax = i;
            maxv = s[i];
        }
    }

    FOR_LT(i, 0, d + 3) {
        if (sc[argmax][i] == 0) {
            cout << i << endl;
            return;
        }
    }
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout << fixed << setprecision(20);

	while (true) {
		int d; cin >> d;
		if (d == 0) break;
		solve(d);
	}

	return 0;
}


Measured memory_bytes: 3344