There is a fence in front of Polycarpus's home. The fence consists of n planks of the same width which go one after another from left to right. The height of the i-th plank is hi meters, distinct planks can have distinct heights.

<image> Fence for n = 7 and h = [1, 2, 6, 1, 1, 7, 1]

Polycarpus has bought a posh piano and is thinking about how to get it into the house. In order to carry out his plan, he needs to take exactly k consecutive planks from the fence. Higher planks are harder to tear off the fence, so Polycarpus wants to find such k consecutive planks that the sum of their heights is minimal possible.

Write the program that finds the indexes of k consecutive planks with minimal total height. Pay attention, the fence is not around Polycarpus's home, it is in front of home (in other words, the fence isn't cyclic).

Input

The first line of the input contains integers n and k (1 ≤ n ≤ 1.5·105, 1 ≤ k ≤ n) — the number of planks in the fence and the width of the hole for the piano. The second line contains the sequence of integers h1, h2, ..., hn (1 ≤ hi ≤ 100), where hi is the height of the i-th plank of the fence.

Output

Print such integer j that the sum of the heights of planks j, j + 1, ..., j + k - 1 is the minimum possible. If there are multiple such j's, print any of them.

Examples

Input

7 3
1 2 6 1 1 7 1


Output

3

Note

In the sample, your task is to find three consecutive planks with the minimum sum of heights. In the given case three planks with indexes 3, 4 and 5 have the required attribute, their total height is 8.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.StringTokenizer;
import javafx.util.converter.BigIntegerStringConverter;
import java.util.*;

/**
 *
 * @author Ahmad
 */
public class JavaApplication1 {

    public static void main(String[] args) {
        FastReader console = new FastReader();
        int n = console.nextInt();
        int m = console.nextInt();
        int x[] = new int[n];
        for (int i = 0; i < x.length; i++) {
            x[i] = console.nextInt();
        }
        long min = Long.MAX_VALUE;
        long ind = 0;
        int count = 0;
        long sum = 0;
        for (int i = 0; i < n; i++) {
            sum += x[i];
            count++;
            if (count == m) {
                if (sum < min) {
                    ind = i - m + 2;
                    min = sum;
                }
                count--;
                sum -= x[i - m + 1];
            }
        }
        System.out.println(ind);
    }
}

class Graph {

    private int V;
    private LinkedList<Integer> adj[];

    Graph(int v) {
        V = v;
        adj = new LinkedList[v];
        for (int i = 0; i < v; ++i) {
            adj[i] = new LinkedList();
        }
    }

    void addEdge(int v, int w) {
        adj[v].add(w);  // Add w to v's list.
        adj[w].add(v);
    }

    void DFSUtil(int v, boolean visited[]) {
        visited[v] = true;
        //System.out.print(v+" ");
        Iterator<Integer> i = adj[v].listIterator();
        while (i.hasNext()) {
            int n = i.next();
            if (!visited[n]) {
                DFSUtil(n, visited);
            }
        }
    }

    boolean DFS(int v, int f) {
        boolean visited[] = new boolean[V];
        DFSUtil(v, visited);
        boolean m = visited[f];
        return m;
    }

    void BFS(int s) {
        // Mark all the vertices as not visited(By default
        // set as false)
        boolean visited[] = new boolean[V];

        // Create a queue for BFS
        LinkedList<Integer> queue = new LinkedList<Integer>();

        // Mark the current node as visited and enqueue it
        visited[s] = true;
        queue.add(s);

        while (queue.size() != 0) {
            // Dequeue a vertex from queue and print it
            s = queue.poll();
            System.out.print(s + " ");

            // Get all adjacent vertices of the dequeued vertex s
            // If a adjacent has not been visited, then mark it
            // visited and enqueue it
            Iterator<Integer> i = adj[s].listIterator();
            while (i.hasNext()) {
                int n = i.next();
                if (!visited[n]) {
                    visited[n] = true;
                    queue.add(n);
                }
            }
        }
    }
}

class Sorting {

    public static int[] bucketSort(int[] array, int bucketCount) {

        if (bucketCount <= 0) {
            throw new IllegalArgumentException("Invalid bucket count");
        }

        if (array.length <= 1) {
            return array; //trivially sorted
        }

        int high = array[0];

        int low = array[0];

        for (int i = 1; i < array.length; i++) { //find the range of input elements

            if (array[i] > high) {
                high = array[i];
            }

            if (array[i] < low) {
                low = array[i];
            }

        }

        double interval = ((double) (high - low + 1)) / bucketCount; //range of one bucket

        ArrayList<Integer> buckets[] = new ArrayList[bucketCount];

        for (int i = 0; i < bucketCount; i++) { //initialize buckets

            buckets[i] = new ArrayList();

        }

        for (int i = 0; i < array.length; i++) { //partition the input array

            buckets[(int) ((array[i] - low) / interval)].add(array[i]);

        }

        int pointer = 0;

        for (int i = 0; i < buckets.length; i++) {

            Collections.sort(buckets[i]); //mergeSort

            for (int j = 0; j < buckets[i].size(); j++) { //merge the buckets

                array[pointer] = buckets[i].get(j);

                pointer++;

            }

        }

        return array;

    }

}

class FastReader {

    BufferedReader br;
    StringTokenizer st;

    public FastReader() {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    String next() {
        while (st == null || !st.hasMoreElements()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }

    int nextInt() {
        return Integer.parseInt(next());
    }

    long nextLong() {
        return Long.parseLong(next());
    }

    double nextDouble() {
        return Double.parseDouble(next());
    }

    String nextLine() {
        String str = "";
        try {
            str = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str;
    }
}