#include <bits/stdc++.h>
using namespace std;

int main() {
    int k, m;
    scanf("%d%d", &k, &m);
    vector<int> bytes;
    int b;
    while (scanf("%d", &b) == 1) bytes.push_back(b);

    int total = bytes.size() * 8;
    vector<int> idle(total);
    for (int i = 0; i < (int)bytes.size(); i++)
        for (int j = 0; j < 8; j++)
            idle[i * 8 + j] = (bytes[i] >> j) & 1;

    struct Seg { int start, len; };
    vector<Seg> segs;
    int i = 0;
    while (i < total) {
        if (idle[i]) {
            int j = i;
            while (j < total && idle[j]) j++;
            segs.push_back({i, j - i});
            i = j;
        } else i++;
    }
    // 环形合并：首尾段相连
    if (segs.size() >= 2 && segs.front().start == 0
        && segs.back().start + segs.back().len == total) {
        segs.back().len += segs.front().len;
        segs.erase(segs.begin());
    }

    int bestFit = -1, bestDist = -1, bestStart = -1;
    for (auto& seg : segs) {
        if (seg.len < k) continue;
        int fit = seg.len - k;
        int s = seg.start;
        int dist = s > m ? s - m : total - m + s;
        if (s == m) dist = total;
        if (bestFit == -1 || fit < bestFit || (fit == bestFit && dist < bestDist)) {
            bestFit = fit;
            bestDist = dist;
            bestStart = s;
        }
    }
    printf("%d\n", bestStart);
    return 0;
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int k = sc.nextInt(), m = sc.nextInt();
        List<Integer> bytes = new ArrayList<>();
        while (sc.hasNextInt()) bytes.add(sc.nextInt());

        int total = bytes.size() * 8;
        int[] idle = new int[total];
        for (int i = 0; i < bytes.size(); i++)
            for (int j = 0; j < 8; j++)
                idle[i * 8 + j] = (bytes.get(i) >> j) & 1;

        List<int[]> segs = new ArrayList<>();
        int i = 0;
        while (i < total) {
            if (idle[i] == 1) {
                int j = i;
                while (j < total && idle[j] == 1) j++;
                segs.add(new int[]{i, j - i});
                i = j;
            } else i++;
        }
        if (segs.size() >= 2 && segs.get(0)[0] == 0
                && segs.get(segs.size() - 1)[0] + segs.get(segs.size() - 1)[1] == total) {
            segs.get(segs.size() - 1)[1] += segs.get(0)[1];
            segs.remove(0);
        }

        int bestFit = -1, bestDist = -1, bestStart = -1;
        for (int[] seg : segs) {
            if (seg[1] < k) continue;
            int fit = seg[1] - k;
            int s = seg[0];
            int dist = s > m ? s - m : total - m + s;
            if (s == m) dist = total;
            if (bestFit == -1 || fit < bestFit || (fit == bestFit && dist < bestDist)) {
                bestFit = fit;
                bestDist = dist;
                bestStart = s;
            }
        }
        System.out.println(bestStart);
    }
}

import sys

def main():
    data = sys.stdin.read().split()
    idx = 0
    k = int(data[idx]); idx += 1
    m = int(data[idx]); idx += 1
    bytes_list = []
    while idx < len(data):
        bytes_list.append(int(data[idx])); idx += 1

    total = len(bytes_list) * 8
    idle = [0] * total
    for i, b in enumerate(bytes_list):
        for j in range(8):
            idle[i * 8 + j] = (b >> j) & 1

    segs = []
    i = 0
    while i < total:
        if idle[i]:
            j = i
            while j < total and idle[j]:
                j += 1
            segs.append([i, j - i])
            i = j
        else:
            i += 1

    if len(segs) >= 2 and segs[0][0] == 0 and segs[-1][0] + segs[-1][1] == total:
        segs[-1][1] += segs[0][1]
        segs.pop(0)

    best_fit = best_dist = best_start = -1
    for start, length in segs:
        if length < k:
            continue
        fit = length - k
        dist = start - m if start > m else total - m + start
        if start == m:
            dist = total
        if best_fit == -1 or fit < best_fit or (fit == best_fit and dist < best_dist):
            best_fit = fit
            best_dist = dist
            best_start = start

    print(best_start)

main()

const readline = require('readline');
const rl = readline.createInterface({ input: process.stdin });
const lines = [];
rl.on('line', line => lines.push(line.trim()));
rl.on('close', () => {
    const data = lines.join(' ').split(/\s+/).map(Number);
    let idx = 0;
    const k = data[idx++], m = data[idx++];
    const bytes = [];
    while (idx < data.length) bytes.push(data[idx++]);

    const total = bytes.length * 8;
    const idle = new Array(total).fill(0);
    for (let i = 0; i < bytes.length; i++)
        for (let j = 0; j < 8; j++)
            idle[i * 8 + j] = (bytes[i] >> j) & 1;

    const segs = [];
    let i = 0;
    while (i < total) {
        if (idle[i]) {
            let j = i;
            while (j < total && idle[j]) j++;
            segs.push([i, j - i]);
            i = j;
        } else i++;
    }
    if (segs.length >= 2 && segs[0][0] === 0
        && segs[segs.length - 1][0] + segs[segs.length - 1][1] === total) {
        segs[segs.length - 1][1] += segs[0][1];
        segs.shift();
    }

    let bestFit = -1, bestDist = -1, bestStart = -1;
    for (const [s, len] of segs) {
        if (len < k) continue;
        const fit = len - k;
        let dist = s > m ? s - m : total - m + s;
        if (s === m) dist = total;
        if (bestFit === -1 || fit < bestFit || (fit === bestFit && dist < bestDist)) {
            bestFit = fit;
            bestDist = dist;
            bestStart = s;
        }
    }
    console.log(bestStart);
});