Problem: Professor Abacus has just built a new computing engine for making numerical tables. It was designed to calculate the values of a polynomial function in one variable at several points at a time. With the polynomial function f(x) = x2 + 2x + 1, for instance, a possible expected calculation result is 1 (= f(0)), 4 (= f(1)), 9 (= f(2)), 16 (= f(3)), and 25 (= f(4)).

It is a pity, however, the engine seemingly has faulty components and exactly one value among those calculated simultaneously is always wrong. With the same polynomial function as above, it can, for instance, output 1, 4, 12, 16, and 25 instead of 1, 4, 9, 16, and 25.

You are requested to help the professor identify the faulty components. As the first step, you should write a program that scans calculation results of the engine and finds the wrong values.



Input

The input is a sequence of datasets, each representing a calculation result in the following format.

d
v0
v1
...
vd+2


Here, d in the first line is a positive integer that represents the degree of the polynomial, namely, the highest exponent of the variable. For instance, the degree of 4x5 + 3x + 0.5 is five and that of 2.4x + 3.8 is one. d is at most five.

The following d + 3 lines contain the calculation result of f(0), f(1), ... , and f(d + 2) in this order, where f is the polynomial function. Each of the lines contains a decimal fraction between -100.0 and 100.0, exclusive.

You can assume that the wrong value, which is exactly one of f(0), f(1), ... , and f(d+2), has an error greater than 1.0. Since rounding errors are inevitable, the other values may also have errors but they are small and never exceed 10-6.

The end of the input is indicated by a line containing a zero.

Output

For each dataset, output i in a line when vi is wrong.

Example

Input

2
1.0
4.0
12.0
16.0
25.0
1
-30.5893962764
5.76397083962
39.3853798058
74.3727663177
4
42.4715310246
79.5420238202
28.0282396675
-30.3627807522
-49.8363481393
-25.5101480106
7.58575761381
5
-21.9161699038
-48.469304271
-24.3188578417
-2.35085940324
-9.70239202086
-47.2709510623
-93.5066246072
-82.5073836498
0


Output

2
1
1
6

Solution (in CPP):

Solution:
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <climits>
#include <cstring>
#include <cassert>

#define rep(i, m, n) for(int i=int(m);i<int(n);i++)
#define all(c) begin(c),end(c)

template<typename T1, typename T2>
inline void chmin(T1 &a, T2 b) { if (a > b) a = b; }

template<typename T1, typename T2>
inline void chmax(T1 &a, T2 b) { if (a < b) a = b; }

typedef long long int ll;
using ll = long long int;
using ull = long long unsigned int;
using Int = long long int;
using uInt = long long unsigned int;
using Double = long double;
using namespace std;
#define INF (1 << 30) - 1
#define INFl (ll)5e15
#define DEBUG 0
#define dump(x)  cerr << #x << " = " << (x) << endl
#define MOD 1000000007


//edit
const double EPS = 1E-7;
typedef vector<Double> vec;
typedef vector<vec> mat;

//Ax = b を解く。Aは正方行列
// 解がないか、一意でない場合は長さ0の配列を返す
vec gauss_jordan(const mat &A, const vec &b) {
    int n = A.size();
    mat B(n, vec(n + 1));
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++) B[i][j] = A[i][j];
    //行列Aの後ろにbを並べ、同時に処理する。
    for (int i = 0; i < n; i++) B[i][n] = b[i];

    for (int i = 0; i < n; i++) {
        //注目している変数の係数の絶対値が大きい式をi番目に持ってくる
        int pivot = i;
        for (int j = i; j < n; j++) {
            if (abs(B[j][i]) > abs(B[pivot][i])) pivot = j;
        }
        swap(B[i], B[pivot]);

        //解がないか一意でない
        if (abs(B[i][i]) < EPS) return vec();

        //注目している変数の係数を1にする
        for (int j = i + 1; j <= n; j++) B[i][j] /= B[i][i];
        for (int j = 0; j < n; j++) {
            if (i != j) {
                //j番目の式からi番目の変数を削除
                for (int k = i + 1; k <= n; k++) B[j][k] -= B[j][i] * B[i][k];
            }
        }
    }
    vec x(n);
    for (int i = 0; i < n; i++) x[i] = B[i][n];
    return x;
}


class Solve {
public:
    Int n;
    vector<Double> v;

    vector<Double> calc(vector<int> idx) {
        vector<vector<Double>> A(idx.size(), vector<Double>(idx.size()));
        vector<Double> b(idx.size());

        for (int i = 0; i < idx.size(); ++i) {
            for (int j = 0; j < idx.size(); ++j) {
                Double tmp = pow(idx[i], j);
                A[i][j] = tmp;
            }
        }
        for (int i = 0; i < idx.size(); ++i) {
            b[i] = v[idx[i]];
        }

        auto ret = gauss_jordan(A, b);
        return ret;
    }

    bool eq_vec(vector<Double> &v1, vector<Double> &v2) {
        for (int i = 0; i < v1.size(); ++i) {
            if (abs(v1[i] - v2[i]) > 0.1) {
                return false;
            }
        }
        return true;
    }

    bool is_wrong(int p) {
        vector<int> idx1, idx2;
        for (int i = 0; i < v.size(); ++i) {
            if (i != p) {
                idx1.push_back(i);
                idx2.push_back(i);
            }
        }
        idx1.pop_back();
        idx2.erase(idx2.begin());

        auto x1 = calc(idx1);
        auto x2 = calc(idx2);

        bool ret = eq_vec(x1, x2);
        return ret;
    }

    bool solve() {
        cin >> n;
        if (n == 0) return false;
        v.resize(n + 3);
        rep(i, 0, n + 3) cin >> v[i];

        int ans = -1;
        for (int i = 0; i <= n + 2; ++i) {
            if (is_wrong(i)) {
                ans = i;
            }
        }
        cout << ans << endl;

        return true;
    }
};


int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(10);
//    std::ifstream in("input.txt");
//    std::cin.rdbuf(in.rdbuf());

    while (Solve().solve());


    return 0;
}