use std::collections::HashSet;
use std::collections::BTreeMap;
use std::fmt::Display;
use std::ops::Neg;
use std::ops::Div;
use std::ops::Mul;
use std::ops::Add;
use std::ops::{AddAssign, Sub};
use std::cmp::max;
use std::collections::VecDeque;
use std::cmp::min;
use std::collections::BTreeSet;
use std::cmp::Ordering;
use std::fmt::Debug;

fn read_line() -> String {
    let mut buffer = String::new();
    std::io::stdin().read_line(&mut buffer).expect("No Line");
    buffer
}
fn read_lines<T: std::str::FromStr>(count: usize) -> Vec<T> {
    let mut buffer = String::new();
    let mut vec = Vec::with_capacity(count);
    for _ in 0 .. count {
        std::io::stdin().read_line(&mut buffer).expect("No Line");
        vec.push(buffer.trim().parse().ok().expect("Can't Parse"));
        buffer.clear();
    }
    vec
}
fn read_tabulate<R, T: Fn(&str)->R> (count: usize, transformer: T) -> Vec<R> {
    let mut buffer = String::new();
    let mut vec = Vec::with_capacity(count);
    for _ in 0 .. count {
        std::io::stdin().read_line(&mut buffer).expect("No Line");
        vec.push(transformer(buffer.trim()));
        buffer.clear();
    }
    vec
}
fn read_value<T: std::str::FromStr>() -> T {
    read_line().trim().parse().ok().unwrap()
}
fn read_values<T: std::str::FromStr>() -> Vec<T> {
    read_line().trim().split(' ').map(|x| x.parse().ok().expect("Can't Parse")).collect::<Vec<T>>()
}
macro_rules! freeze {
    ($($id:ident), *) => {
        $(let $id = $id;)*
    };
}
macro_rules! read_map {
    ($ident: ident: [$block: block; $size: expr]) => {
        let $ident = (0 .. $size).into_iter().map(|_| $block).collect::<Vec<_>>();
    };
    (mut $ident: ident: [$block: block; $size: expr]) => {
        let mut $ident = (0 .. $size).into_iter().map(|_| $block).collect::<Vec<_>>();
    };
}
macro_rules! read {
    (mut $ident: ident: [$ty:ty]) => {
        let mut $ident = read_values::<$ty>();
    };
    ($ident: ident: [$ty:ty]) => {
        let $ident = read_values::<$ty>();
    };
    (mut $ident: ident: [[$ty:ty]; $size: expr]) => {
        let mut $ident = (0 .. $size).into_iter().map(|_| read_values::<$ty>()).collect::<Vec<_>>();
    };
    ($ident: ident: [[$ty:ty]; $size: expr]) => {
        let $ident = (0 .. $size).into_iter().map(|_| read_values::<$ty>()).collect::<Vec<_>>();
    };
    (mut $ident: ident: [$ty:ty; $size:expr]) => {
        let mut $ident = read_lines::<$ty>($size);
    };
    ($ident: ident: [$ty:ty; $size:expr]) => {
        let $ident = read_lines::<$ty>($size);
    };
    ($ident: ident: [$block: block; $size: expr]) => {
        let $ident = (0 .. $size).into_iter().map(|_| $block).collect::<Vec<_>>();
    };
    (mut $ident: ident: [$block: block; $size: expr]) => {
        let mut $ident = (0 .. $size).into_iter().map(|_| $block).collect::<Vec<_>>();
    };
    ($($token: tt)*) => {
        let mut iter = read_values::<String>().into_iter();
        read_from_iter!(iter; $($token)*);
    };
}
macro_rules! read_from_iter {
    ($iter:expr; mut $ident:ident:$ty:ty, $($rest:tt)*) => {
        let mut $ident = $iter.next().unwrap().parse::<$ty>().expect("Can't Parse");
        read_from_iter!($iter; $($rest)*);
    };
    ($iter:expr; $ident:ident:$ty:ty, $($rest:tt)*) => {
        let $ident = $iter.next().unwrap().parse::<$ty>().expect("Can't Parse");
        read_from_iter!($iter; $($rest)*);
    };
    ($iter:expr; mut $ident:ident:$ty:ty) => {
        let mut $ident = $iter.next().unwrap().parse::<$ty>().expect("Can't Parse");
    };
    ($iter:expr; $ident:ident:$ty:ty) => {
        let $ident = $iter.next().unwrap().parse::<$ty>().expect("Can't Parse");
    };
    ($iter: expr; ) => {};
}
struct KeyValue<K, V> {
    key: K,
    value: V
}
impl <K: PartialOrd, V> PartialEq for KeyValue<K, V> {
    fn eq(&self, other: &Self) -> bool {
        self.key.eq(&other.key)
    }
}
impl <K: PartialOrd, V> Eq for KeyValue<K, V> {}
impl <K: PartialOrd, V> PartialOrd for KeyValue<K, V> {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.key.partial_cmp(&other.key)
    }
}
impl <K: PartialOrd, V> Ord for KeyValue<K, V> {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.key.partial_cmp(&other.key).ok_or("Can't Compare").unwrap()
    }
}
#[derive(Clone, Debug)]
struct Polynomial {
    coefficient: Vec<f64>
}
impl Polynomial {
    fn new(demension: usize) -> Polynomial {
        Polynomial{coefficient: vec![0f64; demension + 1]}
    }
    fn from_points(points: Vec<(f64, f64)>) -> Polynomial {
        let mut result = Polynomial::new(0);
        for i in 0 .. points.len() {
            let (xi, yi) = points[i];
            let mut p = Polynomial{coefficient: vec![1f64]};
            for j in 0 .. points.len() {
                if i == j {continue;}
                let (xj, _) = points[j];
                let poly = Polynomial{coefficient: vec![-xj / (xi - xj), 1f64 / (xi - xj)]};
                p = p.mul(&poly);
            }
            result = result.add(&p.times(yi));
        }
        result
    }
    fn value_at(&self, x: f64) -> f64 {
        let mut result = 0f64;
        let mut x_value = 1f64;
        for c in &self.coefficient {
            result += c * x_value;
            x_value *= x;
        }
        result
    }
    fn add(&self, that: &Polynomial) -> Polynomial {
        let mut coefficients = vec![0f64; max(self.coefficient.len(), that.coefficient.len())];
        for i in 0 .. self.coefficient.len() {
            coefficients[i] += self.coefficient[i];
        }
        for j in 0 .. that.coefficient.len() {
            coefficients[j] += that.coefficient[j];
        }
        Polynomial{coefficient: coefficients}
    }
    fn div(&self, value: f64) -> Polynomial {
        let mut coefficient = self.coefficient.clone();
        for mut c in &mut coefficient {
            *c /= value;
        }
        Polynomial{coefficient: coefficient}
    }
    fn times(&self, value: f64) -> Polynomial {
        let mut coefficient = self.coefficient.clone();
        for mut c in &mut coefficient {
            *c *= value;
        }
        Polynomial{coefficient: coefficient}
    }
    fn mul(&self, that: &Polynomial) -> Polynomial {
        let mut coefficient = vec![0f64; self.coefficient.len() + that.coefficient.len() - 1];
        for i in 0 .. self.coefficient.len() {
            for j in 0 .. that.coefficient.len() {
                coefficient[i + j] += self.coefficient[i] * that.coefficient[j];
            }
        }
        Polynomial{coefficient: coefficient}
    }
}
fn try_make(points: &Vec<(f64, f64)>) -> Option<Polynomial> {
    let mut points = points.clone();
    if let Some((x, y)) = points.pop() {
        let poly = Polynomial::from_points(points);
        if (poly.value_at(x) - y).abs() < 1e-3 {
            Some(poly)
        }else {
            None
        }
    }else {
        panic!();
    }
}
fn find_outlier(points: &Vec<(f64, f64)>) -> usize {
    for susupect in 0 .. points.len() {
        let others = (0 .. points.len()).filter(|x| x != &susupect).map(|i| points[i]).collect::<Vec<_>>();
        if let Some(poly) = try_make(&others) {
            let (x, y) = points[susupect];
            if (poly.value_at(x) - y).abs() >= 0.5 {
                return susupect;
            }
        }
    }
    panic!()
}
fn main() {
    loop {
        read!(d: usize);
        if d == 0 {break;}
        read!(ys: [f64; d + 3]);
        let points = (0usize.. d + 3).map(|i| (i as f64, ys[i])).collect::<Vec<_>>();
        println!("{}", find_outlier(&points));
    }
}



Measured memory_bytes: 5068