You are given a huge decimal number consisting of $n$ digits. It is guaranteed that this number has no leading zeros. Each digit of this number is either 0 or 1.

You may perform several (possibly zero) operations with this number. During each operation you are allowed to change any digit of your number; you may change 0 to 1 or 1 to 0. It is possible that after some operation you can obtain a number with leading zeroes, but it does not matter for this problem.

You are also given two integers $0 \le y < x < n$. Your task is to calculate the minimum number of operations you should perform to obtain the number that has remainder $10^y$ modulo $10^x$. In other words, the obtained number should have remainder $10^y$ when divided by $10^x$.


-----Input-----

The first line of the input contains three integers $n, x, y$ ($0 \le y < x < n \le 2 \cdot 10^5$) — the length of the number and the integers $x$ and $y$, respectively.

The second line of the input contains one decimal number consisting of $n$ digits, each digit of this number is either 0 or 1. It is guaranteed that the first digit of the number is 1.


-----Output-----

Print one integer — the minimum number of operations you should perform to obtain the number having remainder $10^y$ modulo $10^x$. In other words, the obtained number should have remainder $10^y$ when divided by $10^x$.


-----Examples-----
Input
11 5 2
11010100101

Output
1

Input
11 5 1
11010100101

Output
3



-----Note-----

In the first example the number will be $11010100100$ after performing one operation. It has remainder $100$ modulo $100000$.

In the second example the number will be $11010100010$ after performing three operations. It has remainder $10$ modulo $100000$.

Difficulty: EASY
Tags: Mathematics

Implementation

Starter code:

Solutions:
import sys

class Main:

	def __init__(self):
		self.buff = None
		self.index = 0

	def next(self):
		if self.buff is None or self.index == len(self.buff):
			self.buff = self.next_line()
			self.index = 0
		val = self.buff[self.index]
		self.index += 1
		return val

	def next_line(self):
		return sys.stdin.readline().split()

	def next_ints(self):
		return [int(x) for x in sys.stdin.readline().split()]

	def next_int(self):
		return int(self.next())

	def solve(self):
		(n, x, y) = self.next_ints()
		xx = self.next()
		stp = 0
		for i in range(0, x):
			if i == y:
				if xx[-1 - i] != '1':
					stp += 1
			elif xx[-1 - i] != '0':
				stp += 1
		print(stp)
Main().solve()


(n, x, y) = map(int, input().split())
inp = input()
s = inp[-x:]
a = s.count('1')
if s[-y - 1] == '1':
	print(a - 1)
else:
	print(a + 1)


(d, x, y) = map(int, input().rstrip().split())
n = input()
nlis = list(n)
req = nlis[-x:]
cnt = 0
for i in range(1, len(req) + 1):
	if i == y + 1:
		if nlis[-i] != '1':
			cnt += 1
	elif nlis[-i] != '0':
		cnt += 1
print(cnt)


def inputSeperator(inputStr):
	return list(map(int, inputStr.split(' ')))
temp = inputSeperator(input())
n = temp[0]
x = temp[1]
y = temp[2]
number = list(input())
number = list(map(int, number))
number = number[n - x:n]
if number[x - y - 1] == 1:
	print(sum(number) - 1)
else:
	print(sum(number) + 1)


(n, x, y) = map(int, input().split())
num = list(input())
l = len(num) - 1
x10 = 10 ** x
y10 = 10 ** y
count = 0
ans = 1
while ans % x10 != y10:
	ans = ans * 10
ans_str = list('0' * (x - y - 1) + str(ans))
smalll = len(ans_str) - 1
while smalll > -1:
	if ans_str[smalll] != num[l]:
		count = count + 1
	smalll = smalll - 1
	l = l - 1
print(count)


(n, x, y) = [int(x) for x in input().split()]
a = input()
a = a[n - x - 1:]
cnt = 0
n = len(a)
for i in range(1, len(a)):
	if i == n - y - 1:
		if a[i] == '0':
			cnt += 1
		continue
	if a[i] == '1':
		cnt += 1
print(cnt)


(n, x, y) = map(int, input().split())
s = input()
count = 0
for i in range(n - x, n):
	if s[i] == '1' and i != n - y - 1:
		count += 1
	if s[i] == '0' and i == n - y - 1:
		count += 1
print(count)


(n, x, y) = map(int, input().split())
q = input()
ans = 0
for i in range(n - 1, n - x - 1, -1):
	if i != n - y - 1 and q[i] == '1':
		ans += 1
	if i == n - y - 1 and q[i] == '0':
		ans += 1
print(ans)


(n, x, y) = list(map(int, input().split()))
l = list(map(int, list(input())))
su = 0
for i in range(x):
	if i != y:
		su += l[-i - 1]
	elif l[-i - 1] == 0:
		su += 1
print(su)


(_, x, y) = map(int, input().split())
y = str(10 ** y).zfill(x)
p = input()[-x:]
print(sum((1 for (p1, p2) in zip(y, p) if p1 != p2)))


(n, x, y) = list(map(int, input().split()))
s = input()
val = 10 ** x + 10 ** y
val = str(val)
n1 = len(val)
st = s[n - n1:]
sss = 0
for i in range(1, n1):
	if st[i] != val[i]:
		sss += 1
print(sss)


(n, x, y) = [int(x) for x in input().split()]
num = input()
num = num[n - x - 1:]
count = 0
if num[x - y] != '1':
	count += 1
for i in range(1, x - y):
	if num[i] != '0':
		count += 1
for j in range(x - y + 1, len(num)):
	if num[j] != '0':
		count += 1
print(count)


(n, x, y) = input().split(' ')
num = str(input())
x = -int(x)
y = -int(y) - 1
i = x
c = 0
while i < 0:
	if i != y and num[i] == '1':
		c = c + 1
	elif i == y and num[i] == '0':
		c = c + 1
	i = i + 1
print(c)


(n, x, y) = map(int, input().split())
a = list(map(int, input()))
ans = 0
for i in range(n - 1, n - y - 1, -1):
	if a[i] == 1:
		ans += 1
if a[n - y - 1] == 0:
	ans += 1
for i in range(n - y - 2, n - x - 1, -1):
	if a[i] == 1:
		ans += 1
print(ans)


(n, x, y) = map(int, input().split())
i = input()
end = (x - y - 1) * '0' + '1' + y * '0'
relevant = i[-x:]
total = 0
for (a, b) in zip(end, relevant):
	total += a != b
print(total)


[n, x, y] = list(map(int, input().split()))
a = list(map(int, input()))
op = 0
a = a[n - x:]
s = a[x - y - 1]
if s == 1:
	print(sum(a) - 1)
else:
	print(sum(a) + 1)


(n, x, y) = map(int, input().split())
d = list(map(int, input()))
d = d[::-1]
total = 0
for i in range(x):
	if i == y:
		total += d[i] != 1
	else:
		total += d[i] != 0
print(total)


from sys import stdin

def main():
	(N, X, Y) = map(int, input().split())
	D = input()
	d = D[N - X:]
	y = str(10 ** Y).zfill(X)
	cnt = 0
	for (s1, s2) in zip(d, y):
		if s1 != s2:
			cnt += 1
	print(cnt)
input = lambda : stdin.readline().rstrip()
main()


(n, x, y) = map(int, input().split())
a = list(input())
a.reverse()
cnt = 0
for i in range(x):
	if i == y:
		if a[i] == '0':
			cnt += 1
	elif a[i] == '1':
		cnt += 1
print(cnt)


string = input().split(' ')
num = input()
x = int(string[1])
y = int(string[2])
rem = str(num)[len(num) - x:]
ony = 10 ** y
onx = 10 ** x
a = len(rem) - len(str(ony))
actions = 0
for i in range(a):
	if rem[i] != '0':
		actions += 1
nrem = rem[a:]
if nrem[0] != '1':
	actions += 1
for i in range(len(str(ony)) - 1):
	if nrem[i + 1] != '0':
		actions += 1
print(actions)


(n, x, y) = map(int, input().strip().split())
number = input()
ops = 0
final = '0' * (x - y - 1) + '1' + '0' * y
number = number[-len(final):]
for i in range(len(final)):
	if final[i] != number[i]:
		ops += 1
print(ops)


import math
import bisect
import heapq
from collections import defaultdict

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		(g, x, y) = egcd(b % a, a)
		return (g, y - b // a * x, x)

def mulinv(b, n):
	(g, x, _) = egcd(b, n)
	if g == 1:
		return x % n

def isprime(n):
	for d in range(2, int(math.sqrt(n)) + 1):
		if n % d == 0:
			return False
	return True

def argsort(ls):
	return sorted(range(len(ls)), key=ls.__getitem__)

def f(p=0):
	if p == 1:
		return map(int, input().split())
	elif p == 2:
		return list(map(int, input().split()))
	elif p == 3:
		return list(input())
	else:
		return int(input())
(n, x, y) = f(1)
s = f(3)
count = 0
for i in range(n - x, n):
	if s[i] == '1' and i != n - 1 - y or (s[i] == '0' and i == n - 1 - y):
		count += 1
print(count)


(n, x, y) = map(int, input().split())
s = list(input())
s1 = s[n - x:]
s2 = list(str(pow(10, y)))
s2.reverse()
l = x - y - 1
for i in range(l):
	s2.append('0')
s2.reverse()
c = 0
for i in range(x):
	if s1[i] != s2[i]:
		c += 1
print(c)


(n, x, y) = list(map(int, input().strip().split()))
s = input()
y = n - 1 - y
ans = 0
for i in range(n - 1, n - 1 - x, -1):
	if i == y:
		ans += 1 if s[i] == '0' else 0
	elif s[i] == '1':
		ans += 1
print(ans)


(N, x, y) = list(map(int, input().split()))
n = list(input())
n = n[N - x:]
c = 0
for i in range(0, x - y - 1):
	if n[i] == '1':
		c += 1
if n[x - y - 1] == '0':
	c += 1
for i in range(x - y, x):
	if n[i] == '1':
		c += 1
print(c)


def solution():
	params = input()
	params = params.split(' ')[1:]
	array_to_int(params)
	number = input()
	result = 0
	for i in range(0, params[0]):
		if i == params[1]:
			if number[len(number) - i - 1] != '1':
				result += 1
		elif number[len(number) - 1 - i] != '0':
			result += 1
	print(result)

def array_to_int(array):
	for i in range(len(array)):
		array[i] = int(array[i])
	return array

def join0(array):
	result = ''
	for i in array:
		result += str(i)
	return result
solution()


(n, x, y) = map(int, input().split())
t = input()
count = 0
if t[n - 1 - y] == '0':
	count += 1
else:
	count -= 1
for i in range(x):
	if t[n - 1 - i] == '1':
		count += 1
print(count)


(n, y, x) = map(int, input().split())
st = input()
res = 0
for i in range(len(st) - 1, len(st) - y - 1, -1):
	if i != len(st) - x - 1:
		if st[i] == '1':
			res += 1
	elif st[i] == '0':
		res += 1
print(res)


(n, x, y) = map(int, input().split())
num = input()
cnt = 0
for i in range(-x, 0):
	if num[i] == '1' and i != -y - 1:
		cnt += 1
	elif i == -y - 1 and num[i] == '0':
		cnt += 1
print(cnt)


def main():
	(n, x, y) = map(int, input().split())
	s = input()
	ans = 0
	should = '0' * (x - y - 1) + '1' + '0' * y
	have = s[n - x:n]
	for i in range(len(should)):
		if should[i] != have[i]:
			ans += 1
	print(ans)
main()


q = list(map(int, input().split()))
w = input()
e = 0
for i in range(q[1]):
	if i == q[2]:
		if w[-(i + 1)] == '0':
			e += 1
	elif w[-(i + 1)] == '1':
		e += 1
print(e)


def main():
	from sys import stdin, stdout

	def read():
		return stdin.readline().rstrip('\n')

	def read_array(sep=None, maxsplit=-1):
		return read().split(sep, maxsplit)

	def read_int():
		return int(read())

	def read_int_array(sep=None, maxsplit=-1):
		return [int(a) for a in read_array(sep, maxsplit)]

	def write(*args, **kwargs):
		sep = kwargs.get('sep', ' ')
		end = kwargs.get('end', '\n')
		stdout.write(sep.join((str(a) for a in args)) + end)

	def write_array(array, **kwargs):
		sep = kwargs.get('sep', ' ')
		end = kwargs.get('end', '\n')
		stdout.write(sep.join((str(a) for a in array)) + end)
	(n, x, y) = read_int_array()
	s = read()
	out = 0
	for i in range(x):
		if i != y and s[-1 - i] == '1':
			out += 1
		elif i == y and s[-1 - i] == '0':
			out += 1
	write(out)
main()


(n, x, y) = map(int, input().split())
s = list(map(int, input()))
s = s[len(s) - x:]
ss = [1]
c = 0
while c < y:
	ss.append(0)
	c = c + 1
k = len(s) - len(ss)
d = 0
while d < k:
	ss[0:0] = [0]
	d = d + 1
m = 0
for (i, j) in zip(s, ss):
	if i != j:
		m = m + 1
print(m)


(n, x, y) = map(int, input().split())
s = input()
s = s[n - x:]
y = '0' * (x - (y + 1)) + '{}'.format(10 ** y)
count = 0
for i in range(len(y)):
	if s[i] != y[i]:
		count += 1
print(count)


(n, x, y) = map(int, input().split())
s = list(input())
a = s[-x:]
c = 0
if s[-(y + 1)] != '1':
	c += a.count('1') + 1
else:
	c += a.count('1') - 1
print(c)


from collections import deque
import os
import sys

class InputReader:

	def __init__(self):
		self.IN = open('cf.in') if os.path.exists('cf.in') else sys.stdin
		self.TOKENS = deque()

	def check(self):
		if len(self.TOKENS) == 0:
			self.TOKENS = deque(self.IN.readline().strip('\n').split())

	def s(self):
		self.check()
		return self.TOKENS.popleft()

	def i(self):
		return int(self.s())

	def f(self):
		return float(self.s())
f = InputReader()
(n, x, y) = (f.i(), f.i(), f.i())
z = f.s()
print(z[-x:].count('1') + (1 if z[-y - 1] == '0' else -1))


(n, x, y) = map(int, input().split())
a = list(input())
b = []
for i in range(x):
	b.append(a[n - x + i])
ans1 = b[:x - y - 1]
ans2 = b[x - y - 1:]
c1 = ans1.count('1')
c2 = 0
c3 = 0
for j in range(1, len(ans2)):
	if ans2[j] == '1':
		c2 += 1
if ans2[0] == '0':
	c3 += 1
print(c1 + c2 + c3)


(n, x, y) = list(map(int, input().strip().split(' ')))
s = input()[:n]
count = 0
b = n - y - 1
for i in range(0, x):
	a = n - x + i
	c = s[n - x + i]
	if c == '1':
		if a != b:
			count += 1
	elif a == b:
		count += 1
print(count)


def getN():
	return int(input())

def getList():
	return list(map(int, input().split()))
(n, x, y) = getList()
s = input()
ans = 0
for (i, c) in enumerate(s[::-1][:x]):
	if i == y:
		if c == '0':
			ans += 1
	elif c == '1':
		ans += 1
print(ans)


(n, x, y) = input().split()
a = input()
n = int(n)
x = int(x)
y = int(y)
if y + 1 == n:
	if 10 ** y == int(a):
		print(0)
	else:
		count = 0
		for i in range(1, n):
			if a[i] == '1':
				count = count + 1
		print(count)
else:
	count = 0
	for i in range(n - x, n):
		if i == n - y - 1:
			continue
		if a[i] == '1':
			count = count + 1
	if a[n - y - 1] == '0':
		count = count + 1
	print(count)


import math
from sys import stdin
I = stdin.readline
(n, x, y) = map(int, I().split())
s = I()
s = s[n - x:].rstrip()
ref = '0' * (x - y - 1) + str(10 ** y)
count = 0
for i in range(len(s)):
	if ref[i] != s[i]:
		count += 1
print(count)


(n, x, y) = list(map(int, input().split()))
l = list(input())
s = l[n - x:n]
if s[-y - 1] == '1':
	print(s.count('1') - 1)
else:
	print(s.count('1') + 1)


(n, x, y) = map(int, input().split(' '))
chungus = input()
y_there = chungus[-y - 1] == '1'
ones = len(list(filter(lambda c: c == '1', chungus[-x:])))
print(ones + (-1 if y_there else 1))


s = [int(n) for n in input().split()]
x = [int(n) for n in input()]
x = x[::-1]
l = 0
for n in range(s[2]):
	if x[n] == 1:
		l += 1
		x[n] = 0
if x[s[2]] == 0:
	l += 1
	x[s[2]] = 1
for n in range(s[2] + 1, s[1]):
	if x[n] == 1:
		l += 1
		x[n] = 0
print(l)


(n, x, y) = map(int, input().split())
s = input()
print(s[n - x:n - y - 1].count('1') + s[n - y:].count('1') + (1 if s[n - y - 1] == '0' else 0))


(n, x, y) = map(int, input().split())
s = input()
a = 0
for i in range(n - x, n):
	if i == n - y - 1:
		if s[i] != '1':
			a += 1
	elif s[i] != '0':
		a += 1
print(a)


(n, x, y) = map(int, input().rstrip().split(' '))
num = list(input())
c = 0
for i in range(1, y + 1):
	if num[-1 * i] == '1':
		c += 1
if num[-1 * (y + 1)] == '0':
	c += 1
for j in range(y + 2, x + 1):
	if num[-1 * j] == '1':
		c += 1
print(c)


(n, x, y) = map(int, input().split())
s = input()[-x:]
print(s.count('1') + 2 * (s[-(y + 1)] == '0') - 1)


(n, x, y) = map(int, input().strip().split())
s = list(input())
tobe = ['0' for i in range(x)]
tobe[-y - 1] = '1'
s = s[-x:]
c = 0
for i in range(len(s)):
	if s[i] != tobe[i]:
		c += 1
print(c)


(n, x, y) = map(int, input().split())
A = input()[::-1]
result = 0
for i in range(0, x):
	result += i == y and A[i] != '1' or (i != y and A[i] == '1')
print(result)


(n, x, y) = map(int, input().split())
s = input()
if s[n - y - 1] == '0':
	res = 1
else:
	res = 0
for (i, item) in enumerate(s[n - x:n - y - 1]):
	if item == '1':
		res += 1
for (i, item) in enumerate(s[n - y:n]):
	if item == '1':
		res += 1
print(res)


(n, x, y) = [int(s) for s in input().split()]
s = input()
s = s[::-1]
ans = 0
for i in range(x):
	if i == y:
		ans -= int(s[i]) - 1
	else:
		ans += int(s[i])
print(ans)


(n, x, y) = map(int, input().split())
a = list(reversed(input()))
ops = 0
for i in range(y + 1, x):
	if a[i] == '1':
		ops += 1
if a[y] == '0':
	ops += 1
for i in range(0, y):
	if a[i] == '1':
		ops += 1
print(ops)


(n, x, y) = map(int, input().split())
m = list(input())
a = list(map(int, m))
wl = a[len(a) - x - 1:n]
if wl[0] == 1:
	on = wl.count(1) - 1
else:
	on = wl.count(1)
if wl[x - y] == 1:
	on = on - 1
else:
	on = on + 1
print(on)


(n, x, y) = [int(x) for x in input().split()]
a = list(input())
count = 0
for i in range(len(a) - 1, len(a) - x - 1, -1):
	if y == 0 and a[i] == '0':
		count += 1
	elif a[i] == '1' and y != 0:
		count += 1
	y -= 1
print(count)


(n, x, y) = map(int, input().split())
number = input()
counter = 0
for i in range(n - x, n):
	if number[i] == '1' and i != n - y - 1:
		counter += 1
	elif number[i] == '0' and i == n - y - 1:
		counter += 1
print(counter)


R = lambda : map(int, input().split())
(n, x, y) = R()
(s, c) = (input()[::-1], 0)
print(sum([int(s[i] == '0') ^ (i != y) for i in range(x)]))


(n, x, y) = map(int, input().split())
s = input()[n - x:]
a = '0' * (x - y - 1) + '1' + '0' * y
ans = 0
for i in range(len(s)):
	ans += a[i] != s[i]
print(ans)


(n, y, x) = list(map(int, input().split()))
string = list(input())[::-1]
err = 0
for i in range(x):
	if string[i] != '0':
		err += 1
if string[x] != '1':
	err += 1
for i in range(x + 1, y):
	if string[i] != '0':
		err += 1
print(err)


(n, x, y) = map(int, input().split())
num = input()
temp = str(num)
count = 0
if temp[n - y - 1] == '1':
	pass
else:
	count += 1
for i in range(n - x, n, 1):
	if temp[i] == '0':
		pass
	elif i == n - y - 1:
		pass
	else:
		count += 1
print(count)


(n, x, y) = map(int, input().split())
s = input()
c = s[-x:]
d = x - (y + 1)
z = '1' + '0' * y
res = d * '0' + z
ctr = 0
for i in range(len(res)):
	if res[i] != c[i]:
		ctr += 1
print(ctr)


(n, x, y) = map(int, input().split(' '))
z = list(input())
c = 0
if z[len(z) - y - 1] == '0':
	c += 1
for i in range(len(z) - x, len(z)):
	if i != len(z) - y - 1 and z[i] == '1':
		c += 1
print(c)


(n, x, y) = [int(x) for x in input().split()]
num = str(input())
temp = 10 ** y
cnt = 0
temp = str(temp)
l1 = y + 1
j = 0
for i in range(n - l1, n, 1):
	if num[i] != temp[j]:
		cnt += 1
	j += 1
for i in range(n - x, n - l1, 1):
	if num[i] != '0':
		cnt += 1
print(cnt)


(n, x, y) = map(int, input().split())
num = input()
move = 0
for j in range(n - y, n):
	if num[j] != '0':
		move += 1
if num[n - 1 - y] != '1':
	move += 1
for i in range(n - x, n - 1 - y):
	if num[i] != '0':
		move += 1
print(move)


nxy = input().split()
n = int(nxy[0])
x = int(nxy[1])
y = int(nxy[2])
c = 0
a = list(input())
for i in range(n - 1, n - x - 1, -1):
	if a[i] == '1' and i != n - y - 1:
		c = c + 1
	if a[i] != '1' and i == n - y - 1:
		c = c + 1
print(c)


(n, x, y) = input().split()
(n, x, y) = (int(n), int(x), int(y))
z = input()
c = 0
for i in range(1, x + 1):
	if i == y + 1:
		if z[n - i] != '1':
			c = c + 1
	elif z[n - i] != '0':
		c = c + 1
print(c)


(n, x, y) = map(int, input().split())
a = input()
c = 0
for i in range(n - 1, n - x - 1, -1):
	if a[i] == '1':
		c += 1
if a[n - y - 1] == '0':
	c += 1
else:
	c -= 1
print(c)


import sys
input = sys.stdin.readline
(n, x, y) = map(int, input().split())
s = input()[:-1]
s = s[::-1]
ans = 0
for i in range(x):
	if i != y and s[i] == '1':
		ans += 1
	elif i == y and s[i] == '0':
		ans += 1
print(ans)


(n, x, y) = map(int, input().split())
actual = input()[-x:]
target = ('1' + y * '0').zfill(x)
print(sum((a != b for (a, b) in zip(target, actual))))


ri = lambda : map(int, input().split(' '))
(n, x, y) = ri()
s = input()
ans = 0
for i in range(x):
	if i == y:
		if s[n - i - 1] == '0':
			ans += 1
	elif s[n - i - 1] == '1':
		ans += 1
print(ans)


l = list(map(int, input().split()))
(n, x, y) = (l[0], l[1], l[2])
s = input()
s = s[::-1]
c = 0
for i in range(x):
	if i == y and s[i] == '0':
		c += 1
	elif s[i] == '1' and i != y:
		c += 1
print(c)


def f(l1, l2):
	(n, x, y) = l1
	l2.reverse()
	l2[y] = [1, 0][l2[y]]
	return sum(l2[:x])
l1 = list(map(int, input().split()))
l2 = list(map(int, list(input())))
print(f(l1, l2))


import os
import heapq
import sys, threading
import math
import bisect
import operator
from collections import defaultdict
sys.setrecursionlimit(10 ** 5)
from io import BytesIO, IOBase

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)

def power(x, p, m):
	res = 1
	while p:
		if p & 1:
			res = res * x % m
		x = x * x % m
		p >>= 1
	return res

def inar():
	return [int(k) for k in input().split()]

def lcm(num1, num2):
	return num1 * num2 // gcd(num1, num2)

def main():
	t = 1
	for _ in range(t):
		(n, x, y) = inar()
		st = input()
		ans = 0
		for i in range(n - x, n):
			if i == n - y - 1:
				if st[i] != '1':
					ans += 1
			elif st[i] != '0':
				ans += 1
		print(ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


(n, x, y) = map(int, input().split())
s = input()[-x:]
t = '0' * (x - y - 1) + '1' + '0' * y
r = sum((i != j for (i, j) in zip(s, t)))
print(r)


(n, x, y) = map(int, input().split())
s = input()
c = 0
if s[-y - 1] == '0':
	c = c + 1
for i in range(-x, 0):
	if i == -y - 1:
		continue
	if s[i] == '1':
		c = c + 1
print(c)


(n, y, x) = map(int, input().split())
s = list(input()[::-1])
i = 0
c = 0
while i < x:
	if s[i] == '1':
		s[i] = '0'
		c += 1
	i += 1
if s[x] == '0':
	c += 1
	s[x] = '1'
i = x + 1
while i < y:
	if s[i] == '1':
		c += 1
		s[i] = '0'
	i += 1
print(c)


nxy = input().split()
n = int(nxy[0])
x = int(nxy[1])
y = int(nxy[2])
num = input()
cnt = 0
for i in range(n - y, n):
	if num[i] == '1':
		cnt += 1
if num[n - y - 1] == '0':
	cnt += 1
for i in range(n - y - 2, n - x - 1, -1):
	if num[i] == '1':
		cnt += 1
print(cnt)


import math
(n, x, y) = map(int, input().split())
number = str(input())
answer = 0
for i in range(x):
	if i == y:
		if int(number[len(number) - i - 1]) == 0:
			answer += 1
	elif int(number[len(number) - i - 1]) == 1:
		answer += 1
print(answer)


def main():
	(n, x, y) = map(int, input().split())
	s = list(map(int, input()))
	print(sum(s[-x:]) - 2 * s[-y - 1] + 1)
main()


(n, x, y) = map(int, input().split())
s = input()
print(s[-x:].count('1') + (1, -1)[s[-y - 1] == '1'])


from math import *
(a, b, c) = map(int, input().split())
string = input()
s1 = int(string[-b:], 2)
s = list('0' * b)
s[-c - 1] = '1'
s = ''.join(s)
s2 = int(s, 2)
r = bin(s1 ^ s2)
print(r.count('1'))


def remainder(n, x, y, a):
	result = 0
	a = a[::-1]
	for i in range(y + 1, x):
		if a[i] == '1':
			result += 1
	if a[y] == '0':
		result += 1
	for i in range(0, y):
		if a[i] == '1':
			result += 1
	return result
(n, x, y) = [int(item) for item in input().split()]
a = input()
print(remainder(n, x, y, a))


(n, x, y) = map(int, input().split())
z1 = input()
z = []
for i in range(n):
	z.append(int(z1[i]))
res = 0
if y == 0:
	if not z[n - 1]:
		res += 1
	for i in range(y + 1, x):
		if z[n - 1 - i]:
			res += 1
else:
	for i in range(y):
		if z[n - 1 - i]:
			res += 1
	if not z[n - 1 - y]:
		res += 1
	for i in range(y + 1, x):
		if z[n - 1 - i]:
			res += 1
print(res)


(n, x, y) = map(int, input().split())
a = input()
digits = [int(x) for x in str(a)]
result = 0
for i in range(len(digits)):
	idx = len(digits) - 1 - i
	if i >= x:
		break
	if i == y:
		if digits[idx] != 1:
			result += 1
	elif digits[idx] != 0:
		result += 1
print(result)


(n, x, y) = map(int, input().split())
bi = input()
bi = bi[n - x:]
if bi[-y - 1] == '1':
	br = bi.count('1') - 1
else:
	br = 1 + bi.count('1')
print(br)


(n, x, y) = map(int, input().split())
t = list(input())
t.reverse()
s = ''.join(t)
ans = 0
for i in range(x):
	if i == y and s[i] == '0':
		ans += 1
	if i != y and s[i] == '1':
		ans += 1
print(ans)


(n, m, k) = map(int, input().split(' '))
s = str(input())
c = 0
l = []
for i in range(n - m, n):
	if i != n - k - 1:
		l.append(i)
if s[n - k - 1] != '1':
	c = c + 1
for i in range(len(l)):
	if s[l[i]] != '0':
		c += 1
print(c)


mod = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
(n, m, k) = f()
s = si()[::-1]
s = s[:m]
c = 0
for i in range(m):
	if i != k and s[i] != '0':
		c += 1
	if i == k and s[i] != '1':
		c += 1
print(c)


(n, x, y) = map(int, input().split())
s = input()
res = 0
for i in range(y):
	if s[-i - 1] == '1':
		res += 1
for i in range(y + 1, x):
	if s[-i - 1] == '1':
		res += 1
if s[-y - 1] == '0':
	res += 1
print(res)


(a, b, c) = map(int, input().split())
num = input()
s = 0
for i in range(a - b, a):
	if i == a - 1 - c:
		if num[i] == '0':
			s += 1
	elif num[i] == '1':
		s += 1
print(s)


def ostatok(n, x, y, s):
	result = 0
	for i in range(n - x, n):
		if i == n - y - 1:
			result += s[i] != '1'
		else:
			result += s[i] != '0'
	return result
(N, X, Y) = [int(i) for i in input().split()]
t = input()
print(ostatok(N, X, Y, t))


(n, x, y) = list((int(a) for a in input().split()))
a = input()[-x:][::-1]
s = 0
for i in range(len(a)):
	if a[i] != ('1' if i == y else '0'):
		s += 1
print(s)


(n, x, y) = list(map(int, input().split()))
s = input()
s = s[len(s) - x:len(s)]
count = 0
for i in range(0, len(s)):
	if i == len(s) - y - 1:
		if s[i] == '0':
			count += 1
		else:
			continue
	elif s[i] == '0':
		continue
	else:
		count += 1
print(count)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def fact(x):
	if x == 0:
		return 1
	else:
		return x * fact(x - 1)
for t in range(1):
	(n, x, y) = list(map(int, input().split()))
	number = input()
	number = number[:n - x - 1:-1]
	cnt = 0
	for ind in range(len(number)):
		if ind == y:
			if number[ind] == '0':
				cnt += 1
		elif number[ind] == '1':
			cnt += 1
	print(cnt)


from sys import stdin, stdout
from itertools import combinations
from collections import defaultdict, OrderedDict
import math

def listIn():
	return list(map(int, stdin.readline().strip().split()))

def stringListIn():
	return [x for x in stdin.readline().split()]

def intIn():
	return int(stdin.readline())

def stringIn():
	return stdin.readline().strip()
(n, x, y) = listIn()
s = stringIn()
ans = 0
st = '0' * (x - y - 1) + '1' + '0' * y
req_s = s[::-1][:x][::-1]
for i in range(len(st)):
	if req_s[i] is not st[i]:
		ans += 1
print(ans)


(n, xx, y) = map(int, input().split())
d = input()
count = 0
s = [x for x in d]
for x in range(n - 1, n - y - 1, -1):
	if s[x] == '1':
		s[x] = '0'
		count += 1
if s[n - y - 1] == '0':
	s[n - y - 1] = '1'
	count += 1
for x in range(n - y - 1, n - xx - 1, -1):
	if x == n - y - 1:
		continue
	if s[x] == '1':
		s[x] = '0'
		count += 1
print(count)


(a, b, c) = map(int, input().split())
x = input()
w = '0' * (b - c - 1) + '1' + '0' * c
s = x[a - 1 - (b - 1):]
e = 0
for i in range(len(s)):
	if s[i] != w[i]:
		e += 1
print(e)


(n, x, y) = map(int, input().split())
s = input()
print(sum((s[-i] == '1' for i in range(1, x + 1))) + 2 * (s[-y - 1] == '0') - 1)


import math
from collections import defaultdict, Counter, deque

def primeFactor(n):
	if n % 2 == 0:
		return 2
	i = 3
	while i ** 2 <= n:
		if n % i == 0:
			return i
		i += 1
	return n

def main():
	(n, x, y) = map(int, input().split())
	s = input()
	n = str(s)
	n = n[len(s) - x:]
	ny = '0' * max(x - y - 1, 0) + str(10 ** y)
	count = 0
	for i in range(x):
		if n[i] != ny[i]:
			count += 1
	print(count)
t = 1
for _ in range(t):
	main()


(N, X, Y) = map(int, input().split())
S = input()
S = S[-X:]
Y = '1' + '0' * Y
Y = '0' * (len(S) - len(Y)) + Y
print(sum((S[i] != Y[i] for i in range(len(S)))))


from sys import stdin
(n, x, y) = map(int, stdin.readline().split())
s = stdin.readline().rstrip()
a = n - 1 - x
b = n - 1 - y
c = 0
for i in range(a + 1, b):
	if s[i] == '1':
		c += 1
if s[b] == '0':
	c += 1
if y > 0:
	for i in range(b + 1, n):
		if s[i] == '1':
			c += 1
print(c)


t = list(map(int, input().split()))
s = input()
r = int(s)
zero1 = t[2]
zero2 = t[1]
val = -1
count = 0
for i in range(t[2]):
	if s[val] != '0':
		count = count + 1
	val = val - 1
if s[val] != '1':
	count = count + 1
val = 0
for i in range(t[1]):
	val = val - 1
	if i > t[2]:
		if s[val] != '0':
			count = count + 1
print(count)


(n, x, y) = map(int, input().split())
nombre = list(input())
for i in range(n):
	nombre[i] = int(nombre[i])
compteur = 0
for i in range(n - x, n - y - 1):
	if nombre[i] != 0:
		compteur += 1
if nombre[n - y - 1] != 1:
	compteur += 1
for i in range(n - y, n):
	if nombre[i] != 0:
		nombre[i] = 0
		compteur += 1
print(compteur)


def main():
	(n, x, y) = map(int, input().split())
	s = input()
	ans = 0
	for i in range(-1, -x - 1, -1):
		if i == -(y + 1):
			ans += s[i] != '1'
			continue
		ans += s[i] == '1'
	print(int(ans))
	return 0
main()


(n, x, y) = map(int, input().split())
num = input()
a = num[-x:]
b = str(10 ** y)
b = '0' * (len(a) - len(b)) + b
cnt = 0
for (p, q) in zip(a, b):
	if p != q:
		cnt += 1
print(cnt)


(n, x, y) = list(map(int, input().split()))
data = input()
data = data[-x:]
count = 0
for (i, c) in enumerate(data):
	if i == x - y - 1:
		if c == '0':
			count += 1
		continue
	elif c == '1':
		count += 1
print(count)


(n, x, y) = list(map(int, input().split()))
bb = input()
trailing = '0' * (x - y - 1) + str(10 ** y)
cnt = 0
for i in range(x):
	if trailing[i] != bb[n - x + i]:
		cnt += 1
print(cnt)


def main():
	(n, x, y) = map(int, input().split())
	num = input()[::-1]
	ans = 0
	for i in range(x):
		if i != y and num[i] == '1' or (i == y and num[i] == '0'):
			ans += 1
	print(ans)
main()


(n, x, y) = [int(v) for v in input().split()]
valid_part = input()[-x:]
index = x - y - 1
count = 0
for (i, digit) in enumerate(valid_part):
	if digit == '1' and i != index or (digit == '0' and i == index):
		count += 1
print(count)


def inputSeperator(inputStr):
	return list(map(int, inputStr.split(' ')))
temp = inputSeperator(input())
n = temp[0]
x = temp[1]
y = temp[2]
number = input()
operations = 0
number = number[n - x - 1:n]
for i in range(1, len(number)):
	if i == x - y and number[i] == '0':
		operations += 1
	if i != x - y and number[i] == '1':
		operations += 1
print(operations)


length_of_number = 0
exp_of_remainder = 0
exp_of_modulo = 0
number = ''
count = 0

def Input(length_of_number, exp_of_remainder, exp_of_modulo, number):
	arr = list(map(int, input().split()))
	length_of_number = arr[0]
	exp_of_modulo = arr[1]
	exp_of_remainder = arr[2]
	number = str(input())
	return (length_of_number, exp_of_remainder, exp_of_modulo, number)

def Processing(length_of_number, exp_of_remainder, exp_of_modulo, number, count):
	for index in range(length_of_number - exp_of_modulo, length_of_number):
		if index == length_of_number - exp_of_remainder - 1:
			if number[index] != '1':
				count += 1
		elif number[index] != '0':
			count += 1
	return (length_of_number, exp_of_remainder, exp_of_modulo, number, count)

def Output(count):
	print(count)
(length_of_number, exp_of_remainder, exp_of_modulo, number) = Input(length_of_number, exp_of_remainder, exp_of_modulo, number)
(length_of_number, exp_of_remainder, exp_of_modulo, number, count) = Processing(length_of_number, exp_of_remainder, exp_of_modulo, number, count)
Output(count)


(n, x, y) = map(int, input().split())
s = input()
d = 2 ** x
r = 2 ** y
num = int(s, 2)
if num % d == r:
	print(0)
else:
	num = num - num % d
	res = bin(num + r)
	res = res[2:]
	count = 0
	for i in range(len(res)):
		if s[i] != res[i]:
			count += 1
	print(count)


import sys
input = sys.stdin.readline
(n, x, y) = list(map(int, input().split()))
num = input().rstrip()
num = num[::-1]
ans = 0
for i in range(x):
	if i == y:
		if num[i] == '0':
			ans += 1
	elif i < y:
		if num[i] == '1':
			ans += 1
	elif num[i] == '1':
		ans += 1
print(ans)


(n, x, y) = list(map(int, input().split()))
num = input()
ans = 0
for i in range(x):
	if i == y:
		if num[n - 1 - i] != '1':
			ans += 1
	elif num[n - 1 - i] != '0':
		ans += 1
print(ans)


def Input(n, x, y, Str):
	(n, x, y) = list(map(int, input().split()))
	Str = str(input())
	return (n, x, y, Str)

def Processing(n, x, y, Str):
	number_y = '1'
	number_result = ''
	for i in range(y):
		number_y = number_y + '0'
	while len(number_y) != x:
		number_y = '0' + number_y
	count = 0
	index_y = 0
	for index_Str in range(n - x, n):
		if Str[index_Str] != number_y[index_y]:
			count += 1
		index_y += 1
	print(count)
n = 0
x = 0
y = 0
Str = ''
(n, x, y, Str) = Input(n, x, y, Str)
Processing(n, x, y, Str)


import sys
lines = sys.stdin.readlines()
(n, x, y) = map(int, lines[0].split())
num = lines[1]
r = 0
for i in range(n - x, n):
	if i == n - (y + 1):
		r += num[i] != '1'
	else:
		r += num[i] == '1'
print(r)


(n, x, y) = map(int, input().split())
nn = input('')
a = []
cnt = 0
for i in range(n - 1, -1, -1):
	a.append(nn[i])
for i in range(x):
	if a[i] == '1':
		cnt += 1
if a[y] == '1':
	print(cnt - 1)
else:
	print(cnt + 1)


[k, x, y] = list(map(int, input().rstrip().split()))
n = input()[::-1]
count = 0
for i in range(x):
	if n[i] == '1':
		count += 1
if n[y] == '0':
	count += 1
else:
	count = count - 1
print(count)


(n, x, y) = map(int, input().split())
s = input()
s = str(s)[-x:]
q = 0
for i in range(0, len(s)):
	if i == x - y - 1:
		if s[i] == '1':
			q += 0
		else:
			q += 1
	elif s[i] == '0':
		q += 0
	else:
		q += 1
print(q)


(n, x, y) = map(int, input().split(' '))
arr = list(input())
c = 0
remainder = 10 ** y
quotient = 10 ** x
if arr[n - y - 1] == '0':
	arr[n - y - 1] = '1'
	c += 1
for i in range(n - x, n):
	if arr[i] == '1' and i != n - y - 1:
		c += 1
		arr[i] = '0'
print(c)


from sys import stdin
(n, x, y) = map(int, stdin.buffer.readline().decode('ascii').split())
stdin.buffer.read(n - x)
start = stdin.buffer.read(x)
result = sum((b & 1 for b in start))
if start[-y - 1] & 1:
	result -= 1
else:
	result += 1
print(result)


(n, x, y) = input().split()
y = int(y)
n = int(n)
a = input()
cc = 0
for i in range(int(x)):
	if a[n - 1 - i] == '1':
		cc = cc + 1
if a[n - 1 - y] == '0':
	cc = cc + 1
if a[n - 1 - y] == '1':
	cc = cc - 1
print(cc)


(n, x, y) = map(int, input().split())
n = input()
c = 0
p = len(n) - x
le = len(n)
for i in range(p, le):
	if i == le - y - 1:
		if n[i] != '1':
			c += 1
	elif n[i] != '0':
		c += 1
print(c)


(n, x, y) = map(int, input().split())
s = input()
ans = 0
for i in range(n):
	if i != x and i != y and (s[n - 1 - i] == '1'):
		ans += 1
	elif i == y and s[n - 1 - i] == '0':
		ans += 1
	if i == x:
		break
print(ans)


(n, x, y) = map(int, input().split())
n = input()
n = n[::-1]
a = n[:x]
y1 = list(str(pow(10, y)))
x1 = list(str(pow(10, x)))
x1 = x1[::-1]
y1 = y1[::-1]
count = 0
for i in range(0, len(y1)):
	if x1[i] != y1[i]:
		x1[i] = y1[i]
for i in range(0, x):
	if a[i] != x1[i]:
		count = count + 1
print(count)


(n, x, y) = map(int, input().split())
m = list(map(int, input()))
ans = 0
for i in range(1, y + 2):
	if m[-i] != 0 and i != y + 1:
		ans += 1
		m[-i] = 0
	elif m[-i] != 1 and i == y + 1:
		ans += 1
		m[-i] = 1
for i in range(y + 2, x + 1):
	if m[-i] != 0:
		ans += 1
		m[-i] = 0
print(ans)


(n, x, y) = map(int, input().split())
n = list(input())
x = 10 ** x
y = 10 ** y
xs = str(x)
yss = str(y)
temp = '0' * (len(xs) - len(yss) - 1)
ys = temp + yss
i = len(n) - len(ys)
ans = 0
j = 0
while i < len(n):
	if ys[j] != n[i]:
		n[i] = ys[j]
		ans += 1
	i += 1
	j += 1
print(ans)


l = list(map(int, input().split()))
n = 10 ** l[0]
x = 10 ** l[1]
x = str(x)
y = 10 ** l[2]
y = str(y)
num = input()
lx = len(x)
ly = len(y)
lx = lx - 1
count = 0
for i in range(0, ly):
	if y[ly - i - 1] == num[len(num) - i - 1]:
		continue
	else:
		count += 1
for j in range(0, lx - ly):
	if num[len(num) - 1 - ly - j] == '0':
		continue
	else:
		count += 1
print(count)


(n, x, y) = [int(i) for i in input().split()]
number = input()
remainder = str(10 ** y)
i = len(number) - 1
j = len(remainder) - 1
ans = 0
while j >= 0:
	if number[i] != remainder[j]:
		ans += 1
	i -= 1
	j -= 1
while i >= len(number) - x:
	if number[i] == '1':
		ans += 1
	i -= 1
print(ans)


(n, x, y) = map(int, input().split())
a = list(input())
print(a[-x:].count('1') + (-1 if a[-1 - y] == '1' else 1))


(n, x, y) = map(int, input().split())
string = input()
r = 0
for i in range(1, x + 1):
	if (string[-i] == '0') == (i - 1 == y):
		r += 1
print(r)


import sys, os
f = lambda : list(map(int, input().split()))
if 'local' in os.environ:
	sys.stdin = open('./input.txt', 'r')

def solve():
	(n, x, y) = f()
	s = input()
	ans = 0
	for i in range(n - x, n):
		if i < n - y - 1 and s[i] == '1':
			ans += 1
		if i == n - y - 1 and s[i] == '0':
			ans += 1
		if i > n - y - 1 and s[i] == '1':
			ans += 1
	print(ans)
solve()


import math
(n, x, y) = [int(x) for x in input().split()]
num = input()
rem = num[n - x:]
count = 0
for i in range(len(rem)):
	if x - i - 1 == y and rem[i] == '0':
		count += 1
	elif x - i - 1 != y and rem[i] == '1':
		count += 1
print(count)


(n, x, y) = [int(x) for x in input().split()]
number = input()
n = n - 1
min_operations = 0
for i in range(n - x + 1, n - y):
	if number[i] == '1':
		min_operations += 1
if number[n - y] == '0':
	min_operations += 1
for i in range(n - y + 1, n + 1):
	if number[i] == '1':
		min_operations += 1
print(min_operations)


import sys
input = sys.stdin.readline
(n, x, y) = map(int, input().split())
s = input().strip()
ans = 0
for i in range(n - 1, n - y - 1, -1):
	if s[i] == '1':
		ans += 1
if s[n - y - 1] == '0':
	ans += 1
for i in range(n - y - 2, n - x - 1, -1):
	if s[i] == '1':
		ans += 1
print(ans)


f = input().split()
chain = input()
x = int(f[1])
y = int(f[2])
st = []
for i in range(x - y - 1):
	st.append('0')
st.append('1')
for i in range(y):
	st.append('0')
newchain = chain[-1 * x:]
change = 0
for i in range(len(st)):
	if not st[i] == newchain[i]:
		change += 1
print(change)


ind = input()
l = ind.split(' ')
n = int(l[0])
x = int(l[1])
y = int(l[2])
l = input()

def pr(num, count, y):
	print(num, count, y)
count = 0
countx = 0
county = 1
for num in l[::-1]:
	num = int(num)
	if county <= y:
		if num == 1:
			count += 1
	elif county == y + 1:
		if num == 0:
			count += 1
	elif county > y + 1 and county <= x:
		if num == 1:
			count += 1
	else:
		break
	county += 1
print(count)


(n, x, y) = map(int, input().split())
s = list(input())
s.reverse()
tot = 0
for i in range(x):
	if i < y and s[i] == '1':
		tot += 1
	if i == y and s[i] == '0':
		tot += 1
	if i > y and s[i] == '1':
		tot += 1
print(tot)


(n, x, y) = list(map(int, input().split()))
s = input()
s = s[-x:]
res = 0
if s[x - y - 1] == '0':
	res += 1
res += s[:x - y - 1].count('1')
res += s[x - y:].count('1')
print(res)


(q, divide, rem) = map(int, input().split(' '))
n = input()
n = n[-1 * divide:]
ans = 0
for i in range(divide):
	if i == divide - rem - 1:
		if n[i] != '1':
			ans += 1
	elif n[i] != '0':
		ans += 1
print(ans)


(n, x, y) = map(int, input().split())
(c, a) = (0, input())
b = a[n - x:]
d = str(10 ** y)
for z in range(1, y + 2):
	if b[-z] != d[-z]:
		c += 1
c += b[:x - y - 1].count('1')
print(c)


import sys
moves = 0
input = sys.stdin.readlines()
(n, x, y) = map(int, input[0].split(' '))
num = input[1].strip()
if y == 0:
	moves += 0
else:
	ystr = num[-y:len(num)]
	moves += ystr.count('1')
xydelta = num[-x:-y - 1]
moves += xydelta.count('1')
modchar = num[-y - 1]
moves += 0 if modchar == '1' else 1
print(moves)


ii = lambda : int(input())
mi = lambda : map(int, input().split())
li = lambda : list(mi())
si = lambda : input()
(n, x, y) = li()
s = si()
r1 = s[-x:]
r2 = '0' * (x - y - 1) + '1' + '0' * y
print(sum((1 for i in range(x) if r1[i] != r2[i])))


(n, x, y) = input().split()
n = int(n)
x = int(x)
y = int(y)
num = input()
num = num[::-1]
change = 0
for i in range(0, y):
	if num[i] != '0':
		change += 1
if num[y] != '1':
	change += 1
for i in range(y + 1, x):
	if num[i] != '0':
		change += 1
print(change)


(n, x, y) = map(int, input().split())
s = input()
changes = 0
k = -1
for i in range(n - 1, -1, -1):
	k += 1
	if k >= x:
		break
	if k < y:
		if s[i] == '1':
			changes += 1
		continue
	if k == y:
		if s[i] == '0':
			changes += 1
		continue
	if s[i] == '1':
		changes += 1
print(changes)


from sys import stdin
input = stdin.readline
(n, x, m) = list(map(int, input().split()))
s = input()
ans = 0
for i in range(n - x, n):
	if i == n - m - 1:
		ans += int(s[i] != '1')
	else:
		ans += int(s[i] != '0')
print(ans)


nos = list(map(int, input().split()))
n = nos[0]
x = nos[1]
y = nos[2]
s = input()
count = 0
for i in range(n - 1, 0, -1):
	c = s[i]
	if n - i - 1 == x:
		break
	if n - i - 1 == y:
		if c == '0':
			count += 1
	elif c == '1':
		count += 1
print(count)


[n, x, y] = list(map(int, input().split(' ')))
arr = list(map(int, list(input())))
res = 0
for i in range(x):
	pos = n - 1 - i
	if i < x and arr[pos] != 0:
		res = res + 1
if arr[n - 1 - y] != 0:
	res = res - 1
if arr[n - 1 - y] != 1:
	res = res + 1
print(res)


import sys
r = lambda : sys.stdin.readline()
(n, x, y) = map(int, r().split())
answer = 0
end = str(10 ** x + 10 ** y)
nn = input()
nn = nn[-x - 1:]
for i in range(1, x + 1):
	if nn[i] != end[i]:
		answer += 1
print(answer)


from sys import setcheckinterval, stdin
setcheckinterval(1000)
iin = lambda : int(stdin.readline())
lin = lambda : list(map(int, stdin.readline().split()))
(n, x, y) = lin()
a = list(input())
ch = 0
a = a[::-1]
for i in range(x):
	if i == y and a[i] == '0':
		ch += 1
	elif i != y and a[i] == '1':
		ch += 1
print(ch)


import sys
import os
from io import BytesIO, IOBase
from typing import List
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
mod = 10 ** 9 + 7

def lcm(x, y):
	return x * y / gcd(x, y)

def fact(x, mod=mod):
	ans = 1
	for i in range(1, x + 1):
		ans = ans * i % mod
	return ans

def arr2D(n, m, default=0):
	return [[default for j in range(m)] for i in range(n)]

def arr3D(n, m, r, default=0):
	return [[[default for k in range(r)] for j in range(m)] for i in range(n)]

def sortDictV(x):
	return {k: v for (k, v) in sorted(x.items(), key=lambda item: item[1])}

class DSU:

	def __init__(self, length):
		self.length = length
		self.parent = [-1] * self.length

	def getParent(self, node, start):
		if node >= self.length:
			return False
		if self.parent[node] < 0:
			if start != node:
				self.parent[start] = node
			return node
		return self.getParent(self.parent[node], start)

	def union(self, node1, node2):
		parent1 = self.getParent(node1, node1)
		parent2 = self.getParent(node2, node2)
		if parent1 == parent2:
			return False
		elif self.parent[parent1] <= self.parent[parent2]:
			self.parent[parent1] += self.parent[parent2]
			self.parent[parent2] = parent1
		else:
			self.parent[parent2] += self.parent[parent1]
			self.parent[parent1] = parent2
		return True

	def getCount(self, node):
		return -self.parent[self.getParent(node, node)]

def exact(num):
	if abs(num - round(num)) <= 10 ** (-9):
		return round(num)
	return num

def solve(n, x, y, lst):
	ans = 0
	for i in range(n - x, n):
		if i == n - y - 1:
			if lst[i] == '0':
				ans += 1
		elif lst[i] == '1':
			ans += 1
	return ans
(n, x, y) = list(map(int, input().split()))
lst = list(input())
print(solve(n, x, y, lst))


(n, x, y) = map(int, input().split())
d = list(input())
count = 0
for i in range(-x, 0, 1):
	if i == -y - 1:
		if d[i] == '0':
			d[i] = '1'
			count += 1
	elif d[i] == '1':
		d[i] = '0'
		count += 1
print(count)


(n, x, y) = map(int, input().split())
num = list(map(int, input()))
k = 0
l = len(num)
for i in range(l - 1, l - 1 - x, -1):
	if l - i - 1 != y:
		if num[-(l - i)] == 1:
			k += 1
	elif num[-(l - i)] == 0:
		k += 1
print(k)


(n, x, y) = (int(i) for i in input().split())
a = input()
d = a[-x:]
count = 0
if d[-y - 1] == '0':
	count += 1
else:
	count -= 1
count += d.count('1')
print(count)


(n, x, y) = map(int, input().split())
s = str(input())
ans = 0
for i in range(n - 1, n - y - 1, -1):
	if int(s[i]) != 0:
		ans = ans + 1
if int(s[n - y - 1]) == 0:
	ans = ans + 1
for i in range(n - y - 2, n - x - 1, -1):
	if int(s[i]) != 0:
		ans = ans + 1
print(ans)


(a, x, y) = map(int, input().split())
b = list(input())
c = b[a - x:]
d = ['0'] * x
d[-y - 1] = '1'
p = 0
for j in range(x):
	if c[j] != d[j]:
		p += 1
print(p)


(n, x, y) = map(int, input().split())
st = input()
x = n - x
y = n - y - 1
kol = 0
for i in range(x, y):
	if st[i] == '1':
		kol += 1
if st[y] == '0':
	kol += 1
for i in range(y + 1, n):
	if st[i] == '1':
		kol += 1
print(kol)


(n, x, y) = map(int, input().split())
s = input()
t2 = str(10 ** y)
i = 0
j = -1
cnt = 0
while i < x:
	if j + y + 1 >= 0 and s[j] != t2[j]:
		cnt += 1
	elif j + y + 1 >= 0 and s[j] == t2[j]:
		pass
	elif s[j] != '0':
		cnt += 1
	j -= 1
	i += 1
print(cnt)


(n, x, y) = [*map(int, input().split())]
number = input()
number = number[-x:]
if number[-y - 1] == '1':
	print(number.count('1') - 1)
else:
	print(number.count('1') + 1)


(n, x, y) = map(int, input().split())
s = input()
req = '0' * x
req = list(req)
req[y] = '1'
c = 0
j = 0
req = req[::-1]
for i in range(n - x, n):
	if s[i] != req[j]:
		c += 1
	j += 1
print(c)


(n, x, y) = map(int, input().split())
a = input()
count = 0
for i in range(n - x, len(a)):
	if i != n - y - 1:
		if a[i] == '1':
			count += 1
if a[n - y - 1] == '0':
	count += 1
print(count)


import os
import sys

def log(*args, **kwargs):
	if os.environ.get('CODEFR'):
		print(*args, **kwargs)
(n, x, y) = tuple(map(int, input().split()))
s = input()
l = n
ops = 0
for i in range(l - x, l):
	if i == l - y - 1:
		if s[i] == '0':
			ops += 1
		continue
	if s[i] == '1':
		ops += 1
print(ops)


import sys
f = sys.stdin
(n, x, y) = [int(n) for n in f.readline().strip().split()]
str_num = f.readline().strip()[-x:]
target_num = '{}1{}'.format('0' * (x - y - 1), '0' * y)
print(sum((1 if s != t else 0 for (s, t) in zip(str_num, target_num))))


(n, x, y) = map(int, input().split())
number = input()[-x:]
count = sum([digit == '1' for digit in number])
count += 1 if number[-y - 1] == '0' else -1
print(count)


ll = lambda : map(int, input().split())
t = lambda : int(input())
ss = lambda : input()
lx = lambda x: map(int, input().split(x))
yy = lambda : print('YES')
nn = lambda : print('NO')
from math import log10, log2, ceil, factorial as fac, gcd, inf, sqrt, log
from bisect import bisect_right as br, bisect_left as bl
from collections import Counter
mod = 10 ** 9 + 7

def f():
	(n, x, y) = ll()
	s = list(map(int, ss()))
	c = 0
	for i in range(n - x, n):
		if i == n - y - 1:
			c += s[i] != 1
		else:
			c += s[i] != 0
	print(c)
f()


(n, x, y) = list(map(int, input().split()))
num = input()
need = '0' * (x - y - 1) + str(10 ** y)
cnt = 0
for i in range(len(need)):
	if need[-1 - i] != num[-1 - i]:
		cnt += 1
print(cnt)


import sys
import math
import collections
input = sys.stdin.readline
(n, x, y) = (int(i) for i in input().split())
s = input()
c = 0
for i in range(n - 1, n - x - 1, -1):
	if i != n - 1 - y:
		if s[i] == '1':
			c += 1
	elif s[i] == '0':
		c += 1
print(c)


(n, x, y) = list(map(int, input().split()))
arr = list(input())
arr.reverse()
arr = arr[:x]
ans = 0
for i in range(len(arr)):
	if i == y and arr[i] == '0':
		ans += 1
	elif i != y and arr[i] == '1':
		ans += 1
print(ans)


(n, x, y) = [int(n) for n in input().split(' ')]
num = input()
i = 0
moves = 0
while i < x:
	c = num[-(i + 1)]
	correct = c == ('1' if i == y else '0')
	if not correct:
		moves += 1
	i += 1
print(moves)


(n, x, y) = map(int, input().split())
digit = input()
ans = 0
for i in range(len(digit) - 1, len(digit) - 1 - x, -1):
	if i == n - y - 1:
		if digit[i] == '0':
			ans += 1
	elif digit[i] == '1':
		ans += 1
print(ans)


(n, x, y) = map(int, input().split())
n1 = input()
actual = n1[-x:]
c = str(10 ** y)
ans = '0' * (len(actual) - len(c)) + c
cnt = 0
for i in range(len(ans)):
	if ans[i] != actual[i]:
		cnt += 1
print(cnt)


(n, x, y) = list(map(int, input().split()))
a = input()
a = a[-x:]
b = ['0' for i in range(x)]
b[-y - 1] = '1'
b = ''.join(b)
l = 0
for i in range(x):
	if a[i] != b[i]:
		l = l + 1
print(l)


def main():
	(n, x, y) = map(int, input().split())
	number = list(input())
	count = 0
	i = 0
	while i < y:
		if number[-i - 1] != '0':
			count += 1
			number[-i - 1] = '0'
		i += 1
	i += 1
	if number[-y - 1] == '0':
		number[-y - 1] = '1'
		count += 1
	while i < x:
		if number[-i - 1] != '0':
			count += 1
			number[-i - 1] = '0'
		i += 1
	print(count)
main()


(n, x, y) = map(lambda x: int(x), input().split())
number = int(input(), 2)
number = number % 2 ** x
change_count = 0
if number % 2 ** (y + 1) >> y == 1:
	change_count -= 1
else:
	change_count += 1
bla = 1
while number != 0:
	if number & bla == 1:
		change_count += 1
	number = number >> 1
print(change_count)


(ne, x, y) = map(int, input().split())
a = input()
a = a[-x:]
s1 = int(a[-y - 1])
if s1:
	s1 = a.count('1') - 1
else:
	s1 = a.count('1') + 1
print(s1)


(n, x, y) = [int(n) for n in input().strip().split()]
num = input()
value = 0
for i in range(0, x):
	if i == y:
		if not num[n - i - 1] is '1':
			value += 1
	elif not num[n - i - 1] is '0':
		value += 1
print('{}'.format(value))


(n, x, y) = input().split()
s = input().split()
x = int(x)
y = int(y)
l = s[0]
b = l[-(y + 1)]
c = 0
for i in range(-x, 0):
	if i == -(y + 1):
		if b == '0':
			c += 1
	elif l[i] == '1':
		c += 1
print(c)


mass = list(map(int, input().split()))
stri = input()
val = 0
for i in range(mass[1]):
	if stri[i + mass[0] - mass[1]] == '1' and i != mass[1] - mass[2] - 1:
		val += 1
	elif stri[mass[0] - mass[1] + i] == '0' and i == mass[1] - mass[2] - 1:
		val += 1
print(val)


(t, m, l) = map(int, input().split())
n = list(input())
c = 0
k = n[-m:]
for i in range(m):
	if i == m - l - 1 and k[i] != '1':
		c += 1
	elif k[i] == '1' and i != m - l - 1:
		c += 1
print(c)


from sys import stdin

def input():
	return stdin.readline()[:-1]
(n, x, y) = list(map(int, input().split()))
s = input()
ones = s[-1 * x:].count('1') - (s[-1 * y - 1] == '1') + (s[-1 * y - 1] == '0')
print(ones)


u = input().rstrip().split(' ')
x = int(u[1])
y = int(u[2])
p = input().rstrip()
p = list(p)
f = p[len(p) - y - 1:len(p)]
F = p[0:len(p) - y - 1]
F.reverse()
V = x - (y + 1)
F = F[0:V]
D = 0
for i in range(0, len(f)):
	if i == 0:
		if f[i] != '1':
			D += 1
	elif f[i] != '0':
		D += 1
for i in range(0, len(F)):
	if F[i] != '0':
		D += 1
print(D)


(n, x, y) = map(int, input().split())
num = input()
num = num[-x:]
num_1s = sum(map(int, num))
if num_1s == 0:
	print(1)
elif num[-(y + 1)] == '1':
	print(num_1s - 1)
elif num[-(y + 1)] != '1':
	print(num_1s + 1)


def main():
	(n, x, y) = input().split()
	n = int(n)
	y = int(y)
	x = int(x)
	num = input()
	a = num[n - x:n]
	b = ''
	i = 0
	for i in range(x - y - 1):
		b += '0'
	b += '1'
	i = 0
	while i < y:
		b += '0'
		i += 1
	diff = 0
	for i in range(x):
		if a[i] != b[i]:
			diff += 1
	print(diff)
main()


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from collections import deque
from collections import Counter as counter
from itertools import combinations as comb
from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
mod = 1000000007

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def zerolist(n):
	return [0] * n

def nextline():
	out('\n')

def testcase(t):
	for p in range(t):
		solve()

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')

def lcm(a, b):
	return a * b // gcd(a, b)

def power(a, b):
	ans = 1
	while b > 0:
		if b % 2 == 1:
			ans *= a
		a *= a
		b //= 2
	return ans

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def solve():
	(n, x, y) = sep()
	s = list(inp())
	arr = s[n - x:]
	arr = arr[::-1]
	new = []
	for i in range(len(arr)):
		if i == y:
			new.append('1')
		else:
			new.append('0')
	cnt = 0
	for i in range(len(new)):
		if new[i] != arr[i]:
			cnt += 1
	print(cnt)
testcase(1)


(n, x, y) = list(map(int, input().split()))
A = input()[-x:]
B = str(10 ** y).zfill(x)
ANS = 0
for i in range(x):
	if A[i] != B[i]:
		ANS += 1
print(ANS)


(n, x, y) = [int(x) for x in input().split()]
num = input()
n = num[-x:]
req = '1' + '0' * y
ans = 0
req = '0' * (len(n) - len(req)) + req
for (i, j) in zip(n, req):
	if i != j:
		ans += 1
print(ans)


(n, x, y) = map(int, input().split())
s = input()
x = int(x)
y = int(y)
r = 0
for (i, c) in enumerate(s[-x:]):
	if i == x - y - 1:
		if c == '0':
			r += 1
	elif c == '1':
		r += 1
print(r)


a = [int(x) for x in input().split()]
b = str(input())
remain = str(10 ** a[2])
b = b[a[0] - a[1]:]
x = 0
count = 0
while x < len(b):
	if x < len(remain):
		if remain[-1 - x] != b[-1 - x]:
			count += 1
	elif b[-1 - x] == '1':
		count += 1
	x += 1
print(count)


from collections import Counter
(n, x, y) = map(int, input().split())
s = input()
a = Counter(s[-x:]).get('1', 0)
b = s[-y - 1:-y]
if y == 0:
	b = s[-1:]
if b == '1':
	print(a - 1)
else:
	print(a + 1)


(n, x, y) = [int(i) for i in input().split(' ')]
number_str = input()
number_cut = [int(i) for i in number_str[-x:]]
correct_cut = [0] * x
correct_cut[-1 - y] = 1
num_oper = 0
for (i, j) in zip(number_cut, correct_cut):
	if i != j:
		num_oper += 1
print(num_oper)


(n, x, y) = list(map(int, input().split()))
num = input()
num = num[-x:]
new = '1'
for q in range(y):
	new += '0'
hello = ''
for w in range(x - y - 1):
	hello += '0'
hello = hello + new
count = 0
for e in range(len(num)):
	if num[e] != hello[e]:
		count += 1
print(count)


(n, x, y) = list(map(int, input().split(' ')))
m = input()
m = m[-x:]
c = '0' * max(0, x - y - 1) + '1' + '0' * y
ans = 0
for (l1, l2) in zip(m, c):
	if l1 != l2:
		ans += 1
print(ans)


a = list(map(int, input().split()))
s = input()
c = 0
if s[-a[2] - 1] == '1':
	print(s[-a[1]:].count('1') - 1)
else:
	print(s[-a[1]:].count('1') + 1)


(n, x, y) = map(int, input().split())
s = input()
a = s[-x:]
b = a[-y - 1:]
c = a[0:len(a) - len(b)]
k1 = 0
k2 = 0
for i in range(len(c)):
	if c[i] == '1':
		k1 = k1 + 1
e = str(10 ** y)
for i in range(len(b)):
	if b[i] != e[i]:
		k2 = k2 + 1
print(k1 + k2)


(a, b, c) = map(int, input().split())
l = list(map(int, list(input())))
s = 0
for (i, v) in enumerate(l[-1:-b - 1:-1]):
	if bool(int(v)) ^ (i == c):
		s += 1
print(s)


(n, x, y) = map(int, input().split())
c = str(input())
a = [int(d) for d in c]
print((1 if a[n - y - 1] == 0 else 0) + a[n - x:n - y - 1].count(1) + a[n - y:n].count(1))


def main():
	s = [int(x) for x in input().split()]
	n = s[0]
	x = s[1]
	y = s[2]
	s = input()
	count = 0
	s = s[-x:][::-1]
	for i in range(len(s)):
		if i != y and s[i] != '0':
			count += 1
		elif i == y and s[y] == '0':
			count += 1
	print(count)
main()


(n, x, y) = [*map(int, input().split())]
num = input()
rest = num[n - x:]
result = (x - y - 1) * '0' + str(10 ** y)
c = 0
for (a, b) in zip(rest, result):
	if a != b:
		c += 1
print(c)


(n, x, y) = map(int, input().split())
a = input()
s = 0
a = a[n - x - 1:]
ost = a[len(a) - y - 1:]
ch = a[:len(a) - y - 1]
if ost[0] == '0':
	s += 1
s += ost[1:].count('1')
s += ch[1:].count('1')
print(s)


(n, x, y) = map(int, input().split())
a = input()
b = str(10 ** x + 10 ** y)
count = 0
for i in range(x + 1):
	if a[-i] != b[-i]:
		count += 1
print(count)


import sys
counts = [int(i) for i in sys.stdin.readline().rstrip().split(' ')]
ln = counts[0]
ext = counts[1]
nm = counts[2]
lne = list(sys.stdin.readline().rstrip())
sm = 0
for i in range(0, ext):
	if i == nm and lne[len(lne) - 1 - i] == '0' or (i != nm and lne[len(lne) - 1 - i] == '1'):
		sm += 1
print(sm)


import sys
read = sys.stdin.read
readlines = sys.stdin.readlines

def main():
	(n, x, y) = map(int, input().split())
	p = list(map(int, input()))
	xk = n - x - 1
	yk = n - y - 1
	r = 0
	r += sum(p[xk + 1:yk])
	if p[yk] == 0:
		r += 1
	r += sum(p[yk + 1:])
	print(r)
main()


X = list(map(int, input().split()))
N = input()[::-1][:X[1]]
print(N.count('1') - (1 if N[X[-1]] == '1' else -1))


def strtoint(string):
	try:
		integer = int(string)
		return integer
	except ValueError:
		print('Value not integer!')
		exit()

def inttostr(integer):
	try:
		string = str(integer)
		return string
	except ValueError:
		print('Value not string!')
		exit()

def power(base, ex):
	if ex == 1 or ex == 0:
		return 1
	else:
		return base * power(base, ex - 1)

def tochararray(string):
	chars = []
	for char in string:
		chars.append(char)
	return chars

def getdiff(ary1, ary2):
	count = 0
	for i in range(0, len(ary1)):
		if ary1[i] != ary2[i]:
			count += 1
	return count

def getNonZero(ary):
	count = 0
	for i in ary:
		if i != '0':
			count += 1
	return count
inputVal = input('').split(' ')
n = strtoint(inputVal[0])
x = inttostr(pow(10, strtoint(inputVal[1])))
y = inttostr(pow(10, strtoint(inputVal[2])))
num = tochararray(input(''))
temp = []
for i in range(len(num) - len(y), len(num)):
	temp.append(num[i])
results = getdiff(temp, y)
temp.clear()
for i in range(len(num) - len(x) + 1, len(num) - len(y)):
	temp.append(num[i])
results += getNonZero(temp)
print(results)


[n, x, y] = list(map(int, input().split()))
string = input()
lastx = string[n - x:]
required = ''
for i in range(len(lastx)):
	if i == len(lastx) - y - 1:
		required += '1'
	else:
		required += '0'
count = 0
for i in range(len(lastx)):
	if lastx[i] != required[i]:
		count += 1
print(count)


numbers = input().split()
lengthOfNumber = int(numbers[0])
division = int(numbers[1])
remainder = int(numbers[2])
number = input()
i = lengthOfNumber - 1
j = i - remainder
counter = 0
if number[j] == '0':
	counter += 1
while i >= lengthOfNumber - division:
	if i != j:
		if number[i] == '1':
			counter += 1
	i -= 1
print(counter)


(n, x, y) = map(int, input().split())
s = str(input())
if x > len(s):
	x = len(s)
sy = ['0'] * x
sy[x - y - 1] = '1'
cnt = 0
c = 0
for i in range(len(s) - x, len(s)):
	if sy[c] != s[i]:
		cnt += 1
	c += 1
print(cnt)


p = [*map(int, input().split())]
u = input()
u = u[::-1]
s = u[:p[1]]

def f(l):
	e = 0
	for i in range(p[1]):
		if i == p[2]:
			if l[i] == '0':
				e += 1
		if l[i] == '1' and i != p[2]:
			e += 1
	return e
print(f(s))


(u, x, y) = map(int, input().split())
v = input()
c = 0
d = v[-x - 1:]
d = d[::-1]
for i in range(0, len(d) - 1):
	if i == y:
		if d[i] != '1':
			c += 1
	elif d[i] != '0':
		c += 1
print(c)


from __future__ import division, print_function
from sys import stdin, stdout
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
import heapq
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd

def ii():
	return int(input())

def si():
	return str(input())

def mi():
	return map(int, input().split())

def li():
	return list(mi())

def fii():
	return int(stdin.readline())

def fsi():
	return str(stdin.readline())

def fmi():
	return map(int, stdin.readline().split())

def fli():
	return list(fmi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def dfs(v, c):
	if visited[v]:
		if col[v] != c:
			print('-1')
			exit()
		return
	col[v] = c
	visited[v] = 1
	for i in graph[v]:
		dfs(i, c ^ 1)

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)
	print(l)

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
		if y not in d.keys():
			d[y] = [x]
		else:
			d[y].append(x)
	return d

def gr2(n):
	d = {}
	for i in range(n):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans

def primeFactors(n):
	s = set()
	while n % 2 == 0:
		s.add(2)
		n = n // 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			s.add(i)
			n = n // i
	if n > 2:
		s.add(n)
	return s
(n, x, y) = mi()
s = si()
count = 0
if x > y:
	s = list(s[::-1])
	for i in range(x):
		if i == y:
			if s[i] == '0':
				count += 1
		elif s[i] == '1':
			count += 1
print(count)


(n, x, y) = map(int, input().split())
pokemon = input()
x = 10 ** x
y = 10 ** y
z = str(x + y)
ans = 0
for i in range(1, len(z)):
	if pokemon[-i] != z[-i]:
		ans += 1
print(ans)


(n, x, y) = map(int, input().split())
s = list(input())
l1 = x
l2 = y
s = s[::-1]
ans = 0
sk = '0' * y + '1'
for i in range(y + 1):
	if sk[i] != s[i]:
		ans += 1
		s[i] = sk[i]
sk = sk + '0' * (x - y - 1) + '1'
for i in range(x):
	if sk[i] != s[i]:
		ans += 1
print(ans)


(n, x, y) = list(map(int, input().split()))
num = list(map(int, list(input())))
s = 0
for i in range(n - x, n):
	if num[i] and i != n - y - 1:
		s += 1
	elif not num[i] and i == n - y - 1:
		s += 1
print(s)


IN = input().split()
n = int(IN[0])
x = int(IN[1])
y = int(IN[2])
IN = str(input())
S = [0] * n
for i in range(0, n):
	S[i] = int(IN[i])
res = 0
if S[n - y - 1] == 1:
	S[n - y - 1] = 0
else:
	res = 1
for i in range(n - 1, n - x - 1, -1):
	if S[i] == 1:
		res = res + 1
print(res)


class cinn:

	def __init__(self):
		self.x = []

	def cin(self, t=int):
		if len(self.x) == 0:
			a = input()
			self.x = a.split()
			self.x.reverse()
		return self.get(t)

	def get(self, t):
		return t(self.x.pop())

	def clist(self, n, t=int):
		l = [0] * n
		for i in range(n):
			l[i] = self.cin(t)
		return l

	def clist2(self, n, t1=int, t2=int, t3=int, tn=2):
		l = [0] * n
		for i in range(n):
			if tn == 2:
				a1 = self.cin(t1)
				a2 = self.cin(t2)
				l[i] = (a1, a2)
			elif tn == 3:
				a1 = self.cin(t1)
				a2 = self.cin(t2)
				a3 = self.cin(t3)
				l[i] = (a1, a2, a3)
		return l

	def clist3(self, n, t1=int, t2=int, t3=int):
		return self.clist2(self, n, t1, t2, t3, 3)

	def cout(self, i, ans=''):
		if ans == '':
			print('Case #' + str(i + 1) + ':', end=' ')
		else:
			print('Case #' + str(i + 1) + ':', ans)

	def printf(self, thing):
		print(thing, end='')

	def countlist(self, l, s=0, e=None):
		if e == None:
			e = len(l)
		dic = {}
		for el in range(s, e):
			if l[el] not in dic:
				dic[l[el]] = 1
			else:
				dic[l[el]] += 1
		return dic

	def talk(self, x):
		print(x, flush=True)

	def dp1(self, k):
		L = [-1] * k
		return L

	def dp2(self, k, kk):
		L = [-1] * k
		for i in range(k):
			L[i] = [-1] * kk
		return L
c = cinn()
l = c.cin()
d = c.cin()
r = c.cin()
num = c.cin(str)
num = num[::-1]
tot = 0
for i in range(d):
	if i == r:
		if int(num[i]) == 0:
			tot += 1
	elif int(num[i]) == 1:
		tot += 1
print(tot)


import sys
from bisect import bisect_left, bisect_right, insort
from collections import deque, Counter
from math import gcd, sqrt, factorial, ceil, log10, log2, floor
from itertools import permutations
from heapq import heappush, heappop, heapify
inf = float('inf')
mod = 1000000007

def factorial_p(n, p):
	ans = 1
	if n <= p // 2:
		for i in range(1, n + 1):
			ans = ans * i % p
	else:
		for i in range(1, p - n):
			ans = ans * i % p
		ans = pow(ans, p - 2, p)
		if n % 2 == 0:
			ans = p - ans
	return ans

def nCr_p(n, r, p):
	ans = 1
	while n != 0 or r != 0:
		(a, b) = (n % p, r % p)
		if a < b:
			return 0
		ans = ans * factorial_p(a, p) * pow(factorial_p(b, p), p - 2, p) * pow(factorial_p(a - b, p), p - 2, p) % p
		n //= p
		r //= p
	return ans

def prime_sieve(n):
	flag = n % 6 == 2
	sieve = bytearray((n // 3 + flag >> 3) + 1)
	for i in range(1, int(n ** 0.5) // 3 + 1):
		if not sieve[i >> 3] >> (i & 7) & 1:
			k = 3 * i + 1 | 1
			for j in range(k * k // 3, n // 3 + flag, 2 * k):
				sieve[j >> 3] |= 1 << (j & 7)
			for j in range(k * (k - 2 * (i & 1) + 4) // 3, n // 3 + flag, 2 * k):
				sieve[j >> 3] |= 1 << (j & 7)
	return sieve

def prime_list(n):
	res = []
	if n > 1:
		res.append(2)
	if n > 2:
		res.append(3)
	if n > 4:
		sieve = prime_sieve(n + 1)
		res.extend((3 * i + 1 | 1 for i in range(1, (n + 1) // 3 + (n % 6 == 1)) if not sieve[i >> 3] >> (i & 7) & 1))
	return res

def is_prime(n):
	if n < 5 or n & 1 == 0 or n % 3 == 0:
		return 2 <= n <= 3
	s = (n - 1 & 1 - n).bit_length() - 1
	d = n >> s
	for a in [2, 325, 9375, 28178, 450775, 9780504, 1795265022]:
		p = pow(a, d, n)
		if p == 1 or p == n - 1 or a % n == 0:
			continue
		for _ in range(s):
			p = p * p % n
			if p == n - 1:
				break
		else:
			return False
	return True

def all_factors(n):
	(small, large) = ([], [])
	for i in range(1, int(n ** 0.5) + 1, 2 if n & 1 else 1):
		if not n % i:
			small.append(i)
			large.append(n // i)
	if small[-1] == large[-1]:
		large.pop()
	large.reverse()
	small.extend(large)
	return small

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
(n, x, y) = get_ints()
string = input()
string2 = string[n - x:]
count = 0
for i in range(x):
	if x - i - 1 == y:
		if string2[i] != '1':
			count += 1
	elif string2[i] == '1':
		count += 1
print(count)


(n, x, y) = map(int, input().split())
s = input()
m = 0
s = s[n - x:]
if s[x - y - 1] != '1':
	m += 1
for i in range(len(s)):
	if s[i] != '0':
		if i == x - y - 1:
			continue
		else:
			m += 1
print(m)


(n, x, y) = map(int, input().split())
a = input()
cnt = 0
i = y
j = n - 1
while i:
	if a[j] == '1':
		cnt += 1
	j -= 1
	i -= 1
if a[n - y - 1] == '0':
	cnt += 1
t = n - y - 2
k = x - y - 1
while k:
	if a[t] == '1':
		cnt += 1
	k -= 1
	t -= 1
print(cnt)


import math

def fact(n):
	ans = 1
	for i in range(2, n + 1):
		ans *= i
	return ans

def comb(n, c):
	return fact(n) // (fact(n - c) * c)
(n, x, y) = map(int, input().split())
t = str(input())
ans = 0
des = str(10 ** y)
pnt = len(des) - 1
for i in range(n - 1, n - x - 1, -1):
	if t[i] == '0' and i == n - y - 1:
		ans += 1
	elif t[i] == '1' and i != n - y - 1:
		ans += 1
print(ans)


(n, x, y) = map(int, input().split())
a = input()
a = a[::-1]
k1 = 0
for i in range(0, x):
	if a[i] == '1' and i != y:
		k1 += 1
if a[y] == '0':
	k1 += 1
print(k1)


(n, x, y) = map(int, input().split())
s = input()
t = str(pow(10, x) + pow(10, y))
c = 0
j = 1
for i in range(len(s) - len(t) + 1, len(s)):
	if s[i] != t[j]:
		c += 1
	j += 1
print(c)


(n, x, y) = [int(i) for i in input().split()]
s = list(input())
print(s[-x:].count('1') + (-1 if s[-1 - y] == '1' else 1))


(n, x, y) = [int(i) for i in input().split()]
s = input()
cont = 0
for i in range(len(s) - x, len(s)):
	if i != len(s) - y - 1 and s[i] == '1':
		cont += 1
	if i == len(s) - y - 1 and s[i] == '0':
		cont += 1
print(cont)


(n, x, y) = map(int, input().split())
s = input()
s = s[::-1]
a = s[:x + 1]
b = a[:y]
c = a[y + 1:]
p = b.count('1') + c.count('1')
if a[y] != '1':
	p += 1
if a[-1] == '1':
	p -= 1
print(p)


(n, x, y) = map(int, input().split())
t = input()
r = 0
if t[len(t) - y - 1] == '0':
	r = r + 1
for i in range(n - 1, n - x - 1, -1):
	if i == len(t) - y - 1:
		continue
	if t[i] != '0':
		r = r + 1
print(r)


(n, x, y) = map(int, input().split())
s = input()
sy = n - 1 - y
sx = n - 1 - x
ans = 0
for i in range(sx + 1, n):
	if i == sy:
		if s[i] == '0':
			ans += 1
	elif s[i] == '1':
		ans += 1
print(ans)


(n, x, y) = map(int, input().split())
a = input()
if a[-y - 1] == '1':
	print(max(a[-x:].count('1') - 1, 0))
else:
	print(a[-x:].count('1') + 1)


def inp():
	return map(int, input().split())
(n, x, y) = inp()
(s, out) = (input(), 0)
for i in range(1, x + 1):
	if i <= y:
		if s[-i] == '1':
			out += 1
	elif i == y + 1:
		if s[-i] == '0':
			out += 1
	elif s[-i] == '1':
		out += 1
print(out)


import sys
(n, x, y) = map(int, sys.stdin.readline().split())
hugeint = sys.stdin.readline().strip()
wrongs = sum((1 for i in range(0, x) if hugeint[-i - 1] == '1'))
if hugeint[-y - 1] == '1':
	wrongs -= 1
else:
	wrongs += 1
print(wrongs)


(n, x, y) = map(int, input().split())
num = input()
last = '1' + '0' * y
first = num[0:n - x]
mid = '0' * (n - len(first) - len(last))
rnum = first + mid + last
count = 0
for i in range(n):
	if num[i] != rnum[i]:
		count += 1
print(count)


(n, x, y) = [int(x) for x in input().split()]
s = input()
k = s[-1:-x - 1:-1]
t = 0
for i in range(y + 1, x):
	if k[i] == '1':
		t += 1
for i in range(y):
	if k[i] == '1':
		t += 1
if k[y] == '0':
	t += 1
print(t)


(n, x, y) = map(int, input().split())
num = str(input())
num = num[n - x:]
if num[x - y - 1] == '1':
	print(num.count('1') - 1)
else:
	print(num.count('1') + 1)


(a, b, c) = input().split()
temp = 0
num = input()
num = list(num)
num = num[len(num) - int(b):]
numl = len(num)
clen = int(c) + 1
c = 10 ** int(c)
c = [int(x) for x in str(c)]
count = 0
if numl > clen:
	iter = numl - clen
	for i in range(0, iter):
		if num[i] != '0':
			count += 1
	temp = numl - clen
num = num[temp:]
for i in range(0, clen):
	if int(num[i]) != int(c[i]):
		count += 1
print(count)


(n, x, y) = map(int, input().split())
final = str(10 ** x + 10 ** y)[1:]
num = input().strip()[-x:]
cnt = 0
for i in range(len(final)):
	if num[i] != final[i]:
		cnt += 1
print(cnt)


nxy = input()
(n, x, y) = [int(num) for num in nxy.split(' ')]
s = input()
ans = 0
for i in range(n - 1, n - x - 1, -1):
	if i == n - y - 1 and s[i] == '0':
		ans += 1
	elif i != n - y - 1 and s[i] == '1':
		ans += 1
print(ans)


(n, x, y) = map(int, input().split())
s = input()
mod = list(s[n - x:n])
before = mod[0:len(mod) - y - 1]
after = mod[len(mod) - y - 1:len(mod)]
if after[0] == '1':
	print(before.count('1') + after.count('1') - 1)
elif after[0] == '0':
	print(before.count('1') + after.count('1') + 1)


co = 0
(n, c, d) = map(int, input().split())
b = list(input())
for i in range(n - 1, n - c - 1, -1):
	if i == n - d - 1 and b[i] == '0':
		co = co + 1
	if b[i] != '0' and i != n - d - 1:
		co = co + 1
print(co)


(n, x, y) = (int(x) for x in input().split())
a = [int(i) for i in input()]
a.reverse()
res = 0
for i in range(x):
	if i == y:
		if a[y] != 1:
			res += 1
	elif a[i] != 0:
		res += 1
print(res)


(n, x, y) = map(int, input().split())
a = str(input())
a = a[-x:][::-1]
ans = 0
for (i, x) in enumerate(a):
	if i == y:
		d = 1
	else:
		d = 0
	if int(x) != d:
		ans += 1
print(ans)


(n, x, y) = map(int, input().split())
ch = input()
ind = n - x
ost = ch[ind:]
res = 0
y_ost = '0' * (x - y - 1) + '1' + '0' * y
for i in range(x):
	if ost[i] != y_ost[i]:
		res += 1
print(res)


(n, x, y) = map(int, input().split())
a = list(reversed(input()))
ans = 0
for i in range(x):
	if a[i] == '1' and i != y or (i == y and a[i] == '0'):
		ans += 1
print(ans)


import sys
import math
import collections
from pprint import pprint as pp
mod = 1000000007
MAX = 10 ** 10

def vector(size, val=0):
	vec = [val for i in range(size)]
	return vec

def matrix(rowNum, colNum, val=0):
	mat = []
	for i in range(rowNum):
		collumn = [val for j in range(colNum)]
		mat.append(collumn)
	return mat
(n, x, y) = map(int, input().split())
s = input()
temp = s[-x:]
ans = 0
for i in range(x):
	if i == x - y - 1:
		if temp[i] != '1':
			ans += 1
	elif temp[i] == '1':
		ans += 1
print(ans)


(n, x, y) = (int(x) for x in input().split())
n = input()
a = n[-x:]
b = '0' * (x - y - 1) + '1' + y * '0'
ans = 0
for i in range(x):
	if a[i] != b[i]:
		ans += 1
print(ans)


def op_rem_x_y(n, x, y, number):
	count_changes = 0
	for i in range(n - 1, n - x - 1, -1):
		if i >= n - y:
			if number[i] == '1':
				count_changes += 1
		elif i == n - y - 1:
			if number[i] == '0':
				count_changes += 1
		elif number[i] == '1':
			count_changes += 1
	return count_changes

def get_input(flag=0):
	if flag:
		return input()
	return [int(num) for num in input().split()]
(n, x, y) = get_input()
num = get_input(1)
print(op_rem_x_y(n, x, y, num))


(L, Y, X) = map(int, input().split())
B = input()
c = 0
for i in range(Y):
	b = B[L - i - 1]
	if i < X and b == '1':
		c += 1
	if i == X and b == '0':
		c += 1
	if X < i and b == '1':
		c += 1
print(c)


(n, x, y) = map(int, input().split())
a = input()
b = a[n - x:]
kq = 0
for i in range(x - y - 1):
	if b[i] != '0':
		kq += 1
if b[x - y - 1] != '1':
	kq += 1
for i in range(x - y, x):
	if b[i] != '0':
		kq += 1
print(kq)


(n, x, y) = list(map(int, input().split()))
num = str(input())
result = str(10 ** y)
ops = 0
j = n - 1
i = y
while i >= 0:
	if result[i] != num[j]:
		ops += 1
	i -= 1
	j -= 1
while n - j <= x:
	if num[j] != '0':
		ops += 1
	j -= 1
print(ops)


(n, x, y) = map(int, input().split())
l = input()
l = l[len(l) - x - 1:len(l)]
ans = 0
if int(l[len(l) - y - 1]) != 1:
	ans += 1
	ans += l[1:len(l)].count('1')
else:
	ans += l[1:len(l)].count('1') - 1
print(ans)


from math import *
from collections import *
import sys
sys.setrecursionlimit(10 ** 9)
(n, x, y) = map(int, input().split())
a = list(input())
a = a[::-1]
ct = 0
for i in range(y):
	if a[i] == '1':
		ct += 1
if a[y] == '0':
	ct += 1
for i in range(y + 1, x):
	if a[i] == '1':
		ct += 1
print(ct)


(n, x, y) = map(int, str(input()).split())
b = str(input())
op = 0
for i in range(x):
	if i == y:
		if b[-i - 1] == '0':
			op += 1
	elif b[-i - 1] == '1':
		op += 1
print(op)


(n, x, y) = map(int, input().split())
s = input()
res = s[-x:]
(i, out) = (0, 0)
while i < x:
	if i != x - y - 1 and res[i] != '0':
		out += 1
	if i == x - y - 1 and res[i] != '1':
		out += 1
	i += 1
print(out)


(n, x, y) = list(map(int, input().split(' ')))
a = str(input())
b = a[n - x:]
k = len(b)
c = '0' * x
c = c[0:k - y - 1] + '1' + '0' * y
count = 0
for i in range(x):
	if b[i] == c[i]:
		count += 1
print(x - count)


num = [int(z) for z in input().split(' ')]
(n, x, y) = (num[0], num[1], num[2])
nm = input()
cnt = 0
for i in range(n - 1, n - x - 1, -1):
	if i == n - y - 1:
		if nm[i] != '1':
			cnt += 1
	elif nm[i] != '0':
		cnt += 1
print(cnt)


(n, x, y) = [int(i) for i in input().split()]
s = list(input())
s = s[::-1]
ct = 0
for i in range(n):
	idx = i + 1
	if i < y and s[i] == '1':
		s[i] = '0'
		ct += 1
	if i == y and s[i] == '0':
		ct += 1
		s[i] = '1'
	if i > y and i < x and (s[i] == '1'):
		ct += 1
		s[i] = '0'
print(ct)


(n, x, y) = input().split()
(n, x, y) = [int(n), int(x), int(y)]
a = input()
i = n - 1
j = i - y
ans = 0
if a[j] == '0':
	ans += 1
while i >= n - x:
	if i != j:
		if a[i] == '1':
			ans += 1
	i -= 1
print(ans)


l = input().split()
y = int(l.pop())
x = int(l.pop())
n = int(l.pop())
num = input()
num = num[n - x:]
basic = str(10 ** y)
basic = '0' * (x - y - 1) + basic
count = 0
for i in range(x):
	if basic[i] != num[i]:
		count += 1
print(count)


arr = list(map(int, input().strip().split()))
n = arr[0]
y = arr[2]
x = arr[1]
num = input()
ans = 0
for i in range(0, n):
	if n - x - 1 == n - i - 1:
		break
	if n - y - 1 == n - i - 1:
		if num[n - i - 1] == '0':
			ans += 1
		continue
	if num[n - i - 1] == '1':
		ans += 1
print(ans)


a = input().split()
n = int(a[0])
x = int(a[1])
y = int(a[2])
a = list(input())
count = 0
b = a[n - 1 - x:n]
c1 = b.count('1')
if a[n - 1 - x] == '1':
	c1 -= 1
if a[n - 1 - y] == '1':
	c1 -= 1
else:
	c1 += 1
print(c1)


from collections import *
import sys

def ri():
	return int(input())

def rl():
	return list(map(int, input().split()))
(n, x, y) = rl()
num = input()
ans = 0
for i in range(1, y + 1):
	if num[-i] == '1':
		ans += 1
if num[-y - 1] == '0':
	ans += 1
for i in range(y + 2, x + 1):
	if num[-i] == '1':
		ans += 1
print(ans)


(n, x, y) = map(int, input().split(' '))
num = input()
num = num[len(num) - x:]
compare = str(10 ** y)
ans = 0
for i in range(x - (y + 1)):
	if num[i] != '0':
		ans += 1
num = num[len(num) - (y + 1):]
for i in range(y + 1):
	if compare[i] != num[i]:
		ans += 1
print(ans)


def prob_1(ns, x, y):
	L = len(ns)
	count = 0
	for i in range(L):
		if i == x:
			break
		if i < y:
			if ns[L - i - 1] == '1':
				count += 1
		elif i == y:
			if ns[L - i - 1] == '0':
				count += 1
		elif i < x:
			if ns[L - i - 1] == '1':
				count += 1
	return count
l1 = input().split()
(x, y) = (int(l1[1]), int(l1[2]))
n = input().split()[0]
print(prob_1(n, x, y))


(n, x, y) = map(int, input().split())
p = input()
d = 10 ** x + 10 ** y
s = str(d)
e = p[n - x - 1:]
cnt = 0
for i in range(1, x + 1):
	if e[i] != s[i]:
		cnt = cnt + 1
print(cnt)


(n, x, y) = [int(s) for s in input().split(' ')]
s = input()
ans = s[-x:].count('1') - 2 * int(s[-(y + 1)]) + 1
print(ans)


(n, x, y) = map(int, input().split())
yy = '0' * (x - y - 1) + str(10 ** y)
a = input()
r = a[n - x:]
ans = 0
for i in range(x):
	if yy[i] != r[i]:
		ans = ans + 1
print(ans)


(n, x, y) = [int(i) for i in input().strip().split(' ')]
s = input().strip()
changes = 0
i = 0
while i < x:
	if i == y:
		if s[-i - 1] != '1':
			changes += 1
	elif s[-i - 1] == '1':
		changes += 1
	i += 1
print(changes)


(n, x, y) = map(int, input().split())
S = input()
F = ['1'] + ['0'] * x
F[len(F) - y - 1] = '1'
ans = 0
for i in range(len(F) - 1):
	if S[len(S) - 1 - i] != F[len(F) - 1 - i]:
		ans += 1
print(ans)


(n, x, y) = input().split()
n = int(n)
x = int(x)
y = int(y)
s = input()
count1 = 0
for i in range(x):
	if i == y:
		if s[n - i - 1] != '1':
			count1 = count1 + 1
	elif s[n - i - 1] != '0':
		count1 = count1 + 1
print(count1)


n = list(map(int, input().split(' ')))
in_strng = input()
cnt = 0
for k in range(0, n[1]):
	if in_strng[n[0] - n[1] + k] == '1' and n[0] - n[1] + k != n[0] - n[2] - 1:
		cnt += 1
	elif in_strng[n[0] - n[1] + k] == '0' and n[0] - n[1] + k == n[0] - n[2] - 1:
		cnt += 1
print(cnt)


(n, x, y) = map(int, input().split())
k = input()
k = k[::-1]
count = 0
for i in range(x):
	if i == y:
		if k[i] == '1':
			continue
		else:
			count += 1
	elif k[i] == '1':
		count += 1
print(count)


(n, x, y) = list(map(int, input().split()))
a = list(input())
ii = n - 1
ans = 0
i = 0
while ii > 0:
	if n - ii <= y:
		if a[ii] == '1':
			ans += 1
	elif n - ii == y + 1:
		if a[ii] == '0':
			ans += 1
	elif n - ii <= x:
		if a[ii] == '1':
			ans += 1
	else:
		break
	ii -= 1
print(ans)


lista = [int(x) for x in input().split()]
numero = input()
numeroFinal = '0' * (lista[1] - lista[2] - 1) + '1' + lista[2] * '0'
contador = 0
for i in range(lista[0] - lista[1], len(numero)):
	j = i - (lista[0] - lista[1])
	if numeroFinal[j] != numero[i]:
		contador += 1
print(contador)


(n, y, x) = list(map(int, input().split()))
number = input()
number = number[len(number) - y:]
count = 0
j = y - 1
for i in range(x):
	if number[j] != '0':
		count += 1
	j -= 1
if number[j] != '1':
	count += 1
for i in range(y - x - 1):
	if number[i] != '0':
		count += 1
print(count)


(nd, x, y) = input().split()
str = input()
s = str
index = int(nd) - int(x)
X = int(x)
ND = int(nd)
Y = int(y)
k = s[index:]
sa = []
for i in k:
	sa.append(i)
buckets = []
for i in range(0, X):
	if i == X - Y - 1:
		buckets.append(1)
	else:
		buckets.append(0)
ans = 0
for i in range(X - 1, -1, -1):
	if int(sa[i]) != int(buckets[i]):
		ans = ans + 1
print(ans)


(n, x, y) = map(int, input().split())
cnt = 0
ans = 0
s = input()
s1 = ''
s2 = ''
for i in range(n - 1, -1, -1):
	s1 += s[i]
	cnt += 1
	if cnt == x:
		break
for i in range(x):
	if i == y:
		s2 += '1'
	else:
		s2 += '0'
for i in range(x):
	if s1[i] != s2[i]:
		ans += 1
print(ans)


from sys import stdin

def ria(sep=''):
	if sep == '':
		return list(map(int, input().split()))
	else:
		return list(map(int, input().split(sep)))

def rsa(sep=''):
	if sep == '':
		return input().split()
	else:
		return input().split(sep)

def ri():
	return int(input())

def rd():
	return float(input())

def rs():
	return input()
(N, X, Y) = map(int, input().split())
S = rs()
cnt = 0
for i in range(Y):
	if S[N - 1 - i] == '1':
		cnt += 1
if S[N - 1 - Y] == '0':
	cnt += 1
for i in range(Y + 1, X):
	if S[N - 1 - i] == '1':
		cnt += 1
print(cnt)


(N, x, y) = map(int, input().split())
S = input()
reversed = S[::-1]
count = 0
for i in range(x):
	if reversed[i] == '1' and i != y:
		count += 1
	if i == y and reversed[i] == '0':
		count += 1
print(count)


(n, x, y) = map(int, input().split())
num = input()
count = 0
index = n - x
while index < n:
	if index == n - y - 1:
		if num[index] != '1':
			count += 1
	elif num[index] != '0':
		count += 1
	index += 1
print(count)


R = lambda : map(int, input().split())
(n, x, y) = R()
s = input()[-x:]
t = format(10 ** y, f'#0{len(s)}')
print(sum((s[i] != t[i] for i in range(len(s)))))


from math import *
from itertools import *
mod = 998244353
(n, x, y) = map(int, input().split(' '))
t = input()
t = t[::-1]
s = '0' * y
s += '1'
x -= y + 1
s += '0' * x
s += '1'
c = 0
for i in range(len(s) - 1):
	if s[i] != t[i]:
		c += 1
print(c)


(n, x, y) = map(int, input().split())
s = [*map(int, input())]
print(sum(s[-x:]) - 2 * s[-y - 1] + 1)


(a, b, c) = map(int, input().split())
s = str(input())
d = ''.join(reversed(s))
n = a - c
m = n - b
sum = 0
for i in range(0, b, 1):
	if i != c:
		f = '0'
	else:
		f = '1'
	if d[i] != f:
		sum += 1
print(sum)


(n, x, y) = [int(i) for i in input().split()]
seq = input()
rx = x
sr = n - 1
nx = str(pow(10, x) + pow(10, y))
cnt = 0
while rx > 0:
	if seq[sr] != nx[rx]:
		cnt += 1
	rx -= 1
	sr -= 1
print(cnt)


import math
(n, a, b) = map(int, input().split())
s = input()
k = s[-a:]
c = 0
y = '0' * (a - b - 1) + '1' + '0' * b
for i in range(len(k)):
	if y[i] != k[i]:
		c = c + 1
print(int(c))


inp = input().split()
n = int(inp[0])
x = int(inp[1])
y = int(inp[2])
istr = input()
res = istr[-x:]
indx = 0
cnt = 0
for ch in res:
	if indx == x - y - 1:
		if ch == '0':
			cnt += 1
	elif ch == '1':
		cnt += 1
	indx += 1
print(cnt)


(n, x, y) = map(int, input().split())
s = list(input())
s1 = s.copy()
for i in range(-1, -x - 1, -1):
	s1[i] = '0'
s1[-y - 1] = '1'
c = 0
for i in range(len(s)):
	if s[i] != s1[i]:
		c += 1
print(c)


(n, x, y) = map(int, input().split())
number = list(map(int, input()))
print(sum(number[-x:]) - 2 * number[-y - 1] + 1)


(n, x, y) = map(int, input().split())
num = input()[n - x:n]
z = '0' * (x - y - 1) + '1' + '0' * y
cnt = 0
for i in range(len(num)):
	if z[i] != num[i]:
		cnt += 1
print(cnt)


(n, x, y) = map(int, input().split())
a = input()
otv = 0
b = []
for i in range(n - 1, n - x - 1, -1):
	b.append(int(a[i]))
otv += sum(b)
if b[y] == 1:
	otv -= 1
else:
	otv += 1
print(otv)


(_, x, y) = [int(j) for j in input().split()]
s = list([int(k) for k in input()[-x:]])
s[-(y + 1)] = 1 if s[-(y + 1)] is 0 else 0
print(sum(s))


l = list(map(int, input().split()))
n = l[0]
x = l[1]
y = l[2]
s = input()
string = s[::-1]
count = 0
for i in range(y):
	if string[i] == '1':
		count += 1
if string[y] == '0':
	count += 1
for i in range(y + 1, x):
	if string[i] == '1':
		count += 1
print(count)


IN = input
rint = lambda : int(IN())
rmint = lambda : map(int, IN().split())
rlist = lambda : list(rmint())
(n, x, y) = rmint()
t = list(map(int, list(IN())))
t.reverse()
t = t[:x]
t[y] = 1 - t[y]
print(sum(t))


b = list(map(int, input().split(' ')))
a = input()
k = a[len(a) - b[1]:len(a)]
k = list(k)
r = str(10 ** b[2])
r = list(r)
count = 0
while len(k) != 0:
	if r[-1] != k[-1]:
		count += 1
	r.pop()
	k.pop()
	if len(r) == 0:
		r.append('0')
print(count)


(n, x, y) = map(int, input().split(' '))
s = input()
(p, q) = (s[-x:], '1' + '0' * y)
c = 0
q = '0' * (len(p) - len(q)) + q
l = [int(a) ^ int(b) for (a, b) in zip(p, q)]
print(sum(l))


def get_num():
	return int(input())

def print_arr(arr: list):
	for val in arr:
		print(val)

def read_num_list():
	num_str = input()
	return [int(v) for v in num_str.split(' ')]
(n, x, y) = read_num_list()
s = input()
wanted_str = '1' + '0' * y
wanted_str = '0' * (x - y - 1) + wanted_str
s_trunc = s[n - x:]
ans = 0
for (a, b) in zip(s_trunc, wanted_str):
	if a != b:
		ans += 1
print(ans)


(n, x, y) = map(int, input().split())
s = input()
s1 = s[len(s) - x:]
s1 = s1[::-1]
rem = str(10 ** y)
rem = rem[::-1]
count = 0
for i in range(len(rem)):
	if rem[i] != s1[i]:
		count += 1
for i in range(len(rem), len(s1)):
	if s1[i] != '0':
		count += 1
print(count)


(n, x, y) = map(int, input().split())
ns = list(input())
changes = 0
for i in range(x):
	if i == y:
		if ns[n - 1 - i] == '0':
			changes += 1
	elif ns[n - 1 - i] == '1':
		changes += 1
print(changes)


inp = lambda cast=int: list(map(cast, input().split()))
printf = lambda s='', *args, **kwargs: print(str(s).format(*args), flush=True, **kwargs)
(n, x, y) = inp()
(n,) = inp(str)
n = n[-x:]
if n[-y - 1] == '1':
	r = n.count('1') - 1
else:
	r = n.count('1') + 1
print(r)


def go():
	(n, x, y) = map(int, input().split(' '))
	a = input()[::-1]
	b = str(10 ** x + 10 ** y)[::-1]
	total = 0
	for i in range(min(len(a) - 1, len(b) - 1)):
		if a[i] != b[i]:
			total += 1
	return total
print(go())


(n, x, y) = [int(item) for item in input().split()]
s = [int(item) for item in list(input())]
ans = 0
for i in range(x):
	if x - i - 1 == y:
		ans += 1 - s[n - x + i]
	elif s[n - x + i] != 0:
		ans += 1
print(ans)


(n, x, y) = map(int, input().split())
s = input()[::-1]
i = 0
ct = 0
while i < y:
	if s[i] == '1':
		ct += 1
	i += 1
if s[y] == '0':
	ct += 1
i += 1
while i < x:
	if s[i] == '1':
		ct += 1
	i += 1
print(ct)


(n, x, y) = map(int, input().split())
num = input()
last_x_digits = num[-x:]
target_x_digits = '0' * (x - y - 1) + str(10 ** y)
ans = 0
for i in range(x):
	if target_x_digits[i] != last_x_digits[i]:
		ans += 1
print(ans)


M = [int(i) for i in input().split()]
n = M[0]
x = M[1]
y = M[2]
a = input()
b = a[-x:]
res = b.count('1')
if a[-y - 1] == '1':
	res -= 1
else:
	res += 1
print(res)


import sys
import collections
import math
import heapq
from operator import itemgetter

def getint():
	return int(input())

def getints():
	return [int(x) for x in input().split(' ')]
(n, x, y) = getints()
a = input()
result = 0
if a[-y - 1] == '0':
	result += 1
else:
	result -= 1
for i in range(x):
	if a[-1 - i] == '1':
		result += 1
print(str(result))


(n, x, y) = map(int, input().split())
numb = input()
op = (int(numb[n - y - 1]) + 1) % 2
for i in range(n - x, n):
	if numb[i] == '1' and i != n - y - 1:
		op += 1
print(op)


import math
from collections import Counter
(a, b, c) = map(int, input().split())
l = list(input())
count = 0
for i in range(1, b + 1):
	if l[-i] == '1' and i != c + 1:
		count += 1
if l[-c - 1] != '1':
	count += 1
print(count)


def min_kol(s1, s2):
	if len(s1) != len(s2):
		return -1
	c = 0
	for i in range(len(s1)):
		if not (s1[i] in ['0', '1'] or s2[i] in ['0', '1']):
			return -1
		if s1[i] != s2[i]:
			c += 1
	return c
(n, x, y) = map(int, input().split())
s = input()
s1 = '0' * (x - y - 1) + '1' + '0' * y
s2 = s[-x:]
print(min_kol(s1, s2))


entrada = []
entrada = input().split()
n = int(entrada[0])
x = int(entrada[1])
y = int(entrada[2])
dezx = 10 ** x
dezy = 10 ** y
numero = input()
resto = list(numero[-x:])
resto.reverse()
string = list(str(dezy))
count = 1
mudancas = 0
tamanho = len(string)
for k in resto:
	if tamanho >= count:
		if k != string[-count]:
			mudancas = mudancas + 1
	elif k != '0':
		mudancas = mudancas + 1
	count = count + 1
print(mudancas)


(n, x, y) = map(int, input().split())
s = input()
e = s[-x - 1:]
z = 0
if e[-y - 1] == '1':
	z = 0
if e[-y - 1] == '0':
	z = 1
if z == 0:
	ans = z + s[-x:].count('1') - 1
if z != 0:
	ans = z + s[-x:].count('1')
print(ans)


(n, x, y) = map(int, input().split())
m = input()[-x:]
print(sum([1 for i in range(x) if i != y and m[x - i - 1] == '1']) + int(m[-y - 1] == '0'))


(n, x, y) = map(int, input().split())
qw = input()
c = 0
for i in range(n - 1, n - 1 - x, -1):
	if qw[i] == '1' and i != n - y - 1:
		c += 1
if qw[n - y - 1] == '0':
	c += 1
print(c)


(n, x, y) = list(map(int, input().split()))
m = input()
lim1 = n - x
lim2 = n - (y + 1)
change = 0
for i in m[lim1:lim2]:
	if i == '1':
		change += 1
if m[lim2] == '0':
	change += 1
for i in m[lim2 + 1:len(m)]:
	if i == '1':
		change += 1
print(change)


from sys import stdin
(n, x, y) = map(int, stdin.buffer.readline().split())
stdin.buffer.read(n - x)
start = stdin.buffer.read(x)
l = start[-y - 1] & 1
print(sum((b & 1 for b in start)) - (l << 1) + 1)


(length_, x, y) = [int(v) for v in input().split(' ')]
order = input()
count = 0
for i in range(x):
	if i == y:
		if order[length_ - i - 1] == '0':
			count = count + 1
	elif order[length_ - i - 1] == '1':
		count = count + 1
print(count)


(n, x, y) = map(int, input().split())
num = input()
res = 0
for i in range(x):
	if num[-(i + 1)] != ('0' if y != i else '1'):
		res += 1
print(res)


(a, b, c) = map(int, input().split())
new = input()
new = list(new)
n = new[::-1]
cnt4 = 0
for i in range(b):
	if i == c and n[i] == '0':
		cnt4 += 1
	elif i != c and n[i] == '1':
		cnt4 += 1
print(cnt4)


(a, b, c) = [int(z) for z in input().split(' ')]
x = input()
n = len(x)
q = 0
for i in range(b):
	if x[n - 1 - i] == '1' and c != i:
		q += 1
	elif x[n - 1 - i] == '0' and c == i:
		q += 1
print(q)


from sys import stdin

def get_ints():
	return list(map(int, stdin.readline().strip().split()))
(m, y, x) = get_ints()
n = input()[::-1]
ans = 0
for i in range(y):
	if i == x:
		ans += 1 - int(n[i])
	else:
		ans += int(n[i])
print(ans)


(a, b, c) = input('').split()
x = input('')
f = int(a)
g = int(b)
h = int(c)
cnt = 1
ck = 0
np = str(0)
i = int(len(x) - 1)
while i > f - (g + 1):
	if i == f - (h + 1):
		if x[i] == '0':
			ck = ck + 1
	elif x[i] != '0':
		ck += 1
	i -= 1
print(ck)


((n, x, y), number) = (map(int, input().split()), input())
print(number[-x:].count('1') + [1, -1][number[-(y + 1)] == '1'])


def func(number, n, x, y):
	count = 0
	for i in range(n - 1, n - y - 1, -1):
		if number[i] == '1':
			count += 1
	if number[n - y - 1] == '0':
		count += 1
	for i in range(n - y - 2, n - x - 1, -1):
		if number[i] == '1':
			count += 1
	return count
inp = list(map(int, input().split()))
n = inp[0]
x = inp[1]
y = inp[2]
number = input()
print(func(number, n, x, y))


array = list(map(int, input().split()))
string = input()
a = list(string)
n = array[0]
x = array[1]
y = array[2]
j = 0
for i in range(x):
	if i == y:
		if a[n - i - 1] == '0':
			j += 1
	elif a[n - i - 1] == '1':
		j += 1
print(j)


b = input()
c = b.split()
n = int(c[0])
x = int(c[1])
y = int(c[2])
a1 = input()
a2 = a1[n - x:]
a = str(10 ** y)
c = 0
l1 = len(a)
l2 = len(a2)
if l1 < l2:
	a = '0' * (l2 - l1) + a
for i in range(l2):
	if a[i] != a2[i]:
		c += 1
print(c)


(n, x, y) = map(int, input().split())
s = input()
s = list(s[n - x - 1:])
l = 0
s.reverse()
if s[-1] != '1':
	l += 1
for i in range(len(s)):
	if i != y and s[i] == '1':
		l += 1
	elif i == y and s[i] != '1':
		l += 1
print(l - 1)


import math
(d, x, y) = input().split()
d = int(d)
x = int(x)
y = int(y)
n = input()
n1 = n[-(x + 1):]
count = 0
for i in range(1, len(n1) - y - 1):
	if n1[i] == '1':
		count = count + 1
if n1[len(n1) - y - 1] == '0':
	count = count + 1
for i in range(len(n1) - y, len(n1)):
	if n1[i] == '1':
		count = count + 1
print(count)


from math import log2

def diff(s1, s2):
	count = 0
	for i in range(len(s1)):
		if s1[i] != s2[i]:
			count += 1
	return count
(n, x, y) = list(map(int, input().split()))
s = input()
numdigits = x
if numdigits < len(s):
	s = s[n - numdigits:]
news = str(10 ** y)
if len(news) <= len(s):
	news = '0' * (len(s) - len(news)) + news
	print(diff(s, news))
else:
	s = '0' * (len(news) - len(s)) + s
	print(diff(s, news))


p = [*map(int, input().split())]
u = input()
u = u[::-1]
o1 = u[:p[2]].count('1')
o2 = u[p[2] + 1:p[1]].count('1')
print(1 - int(u[p[2]]) + o1 + o2)


l = input().split()
n = int(l[0])
x = int(l[1])
y = int(l[2])
num = input()
count = 0
for i in range(n - 1, n - x - 1, -1):
	if i == n - 1 - y:
		if num[i] == '0':
			count += 1
	elif num[i] == '1':
		count += 1
print(count)


def main():
	(n, x, y) = map(int, input().split())
	string = input()[::-1]
	ans = string[:y].count('1') + (string[y] == '0')
	ans += string[y + 1:x].count('1')
	print(ans)
main()


(w, p, z) = input('').split()
n = int(w)
x = int(p)
y = int(z)
k = input('')
a = []
c = 0
for item in k:
	a.append(int(item))
for i in range(x):
	if i == x - y - 1:
		if a[n - x + i] == 0:
			a[n - x + i] = 1
			c += 1
	elif a[n - x + i] == 1:
		a[n - x + i] = 0
		c += 1
	else:
		pass
print(c)


while True:
	try:
		(n, x, y) = map(int, input().split())
		num = input()
		z = n - y - 1
		z1 = n - x - 1
		contr = 0
		for i in range(z1, n, 1):
			if i == z:
				if num[i] == '0':
					contr += 1
			elif num[i] == '1' and i != z1:
				contr += 1
		print(contr)
	except EOFError:
		break


(n, x, y) = input().split()
(n, x, y) = (int(n), int(x), int(y))
b = input()
b = b[len(b) - x:]
ans = 0
for i in b:
	if i is '1':
		ans += 1
if b[len(b) - y - 1] is '1':
	ans -= 1
else:
	ans += 1
print(ans)


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
ALPHA = 'abcdefghijklmnopqrstuvwxyz'
M = 10 ** 1119 + 7
EPS = 1e-06

def Ceil(a, b):
	return a // b + int(a % b > 0)

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
(n, x, y) = value()
given = [int(i) for i in input()]
s = given[:]
s[-x:] = [0] * x
s[-y - 1] = 1
ans = 0
for i in range(n):
	ans += s[i] != given[i]
print(ans)


(n, x, y) = map(int, input().split())
s = input()
s = list(s)
s = s[::-1]
i = 1
op = 0
for i in range(y):
	if s[i] == '1':
		op += 1
		s[i] = '0'
if s[y] == '0':
	s[y] = '1'
	op += 1
for i in range(y + 1, x):
	if s[i] == '1':
		op += 1
		s[i] = '0'
s = s[::-1]
print(op)


(n, x, y) = [int(a) for a in input().split()]
num = input()
num = num[-x:]
half1 = num[:x - y - 1]
mid = num[-(y + 1)]
half2 = num[-y:]
if not y:
	half2 = ''
print(half1.count('1') + mid.count('0') + half2.count('1'))


(x, y, z) = map(int, input().split())
s = input()
t = s[-y:].count('1')
if s[-z - 1] == '1':
	print(t - 1)
else:
	print(t + 1)


(n, x, y) = [int(i) for i in input().split()]
dvd = input()
new = dvd[-x:]
rem = str(10 ** y)
rem = '0' * (len(new) - len(rem)) + rem
ct = 0
for (p, q) in zip(new, rem):
	if p != q:
		ct += 1
print(ct)


(n, x, y) = map(int, input().split())
c = 0
k = str(input())
for i in range(-x, 0):
	if i == -y - 1:
		if k[i] == '0':
			c += 1
	elif k[i] == '1':
		c += 1
print(c)


(n, x, y) = [int(x) for x in input().split()]
a = [int(x) for x in list(input())]
counter = 0
for i in range(n - x, n):
	if i == n - y - 1:
		if a[i] == 0:
			counter += 1
	elif a[i] == 1:
		counter += 1
print(counter)


inputs = list(map(int, input().split()))
n = inputs[0]
x = inputs[1]
y = inputs[2]
num_string = input()
counter = 0
checker = 0
for c in reversed(num_string):
	if checker == y:
		if c == '0':
			counter += 1
		checker += 1
		continue
	if checker >= x:
		break
	if c == '1':
		counter += 1
	checker += 1
print(counter)


(n, x, y) = map(int, input().split())
s = input()
our = s[n - x:n]
idol = '0' * (x - y - 1) + str(10 ** y)
k = 0
for i in range(len(idol)):
	if idol[i] != our[i]:
		k += 1
print(k)


(n, y, x) = map(int, input().split())
l = str(input())
count = 0
p = 0
for i in range(0, n):
	if p == y:
		break
	elif p == x:
		if l[n - i - 1] != '1':
			count += 1
	elif p == x + 1:
		if l[n - i - 1] != '0':
			count += 1
	elif l[n - i - 1] != '0':
		count += 1
	p += 1
print(count)


def sint():
	return int(input())

def sints():
	return map(int, input().split())

def sara():
	return list(map(int, input().split()))

def sstr():
	s = input()
	return list(s[:len(s)])

def main():
	(n, x, y) = sints()
	s = input()
	cnt = 0
	for i in range(n - 1, n - x - 1, -1):
		if i != n - y - 1 and s[i] == '1':
			cnt += 1
		elif i == n - y - 1 and s[i] == '0':
			cnt += 1
	print(cnt)
main()


(n, x, y) = input().split()
x = int(x)
y = '0' * (x - int(y) - 1) + '1' + '0' * int(y)
s = input()[-x:]
print(sum(map(lambda i, j: 1 if i != j else 0, s, y)))


(n, x, y) = map(int, input().split())
p = input()
k = p[n - x:]
count = 0
h = 0
for j in range(len(k) - 1, -1, -1):
	if h == y:
		if k[j] != '1':
			count += 1
	elif k[j] == '1':
		count += 1
	h += 1
print(count)


(z, b, c) = map(int, input().split())
a = input()
temp1 = a[len(a) - b:]
temp1 = [int(x) for x in temp1]
temp2 = [0 for i in range(b)]
temp2[b - 1 - c] = 1
count = 0
for i in range(b):
	if temp1[i] != temp2[i]:
		count += 1
print(count)


(n, x, y) = map(int, input().split())
p = input()
l = str(10 ** x + 10 ** y)
c = 0
for k in range(x):
	if p[len(p) - 1 - k] != l[len(l) - 1 - k]:
		c += 1
print(c)


def convY(y, k):
	for i in range(k - len(y)):
		y = '0' + y
	return y
(n, x, y) = [int(i) for i in input().split()]
num = input()
y10 = str(10 ** y)
operation = 0
yNew = convY(y10, x)
rem = num[n - x:]
for i in range(x):
	if rem[i] != yNew[i]:
		operation += 1
print(operation)


(n, x, y) = map(int, input().split())
st = input()
ar = st[n - x:]
count = 0
for ch in ar:
	if ch == '1':
		count += 1
if st[-y - 1] == '1':
	print(count - 1)
else:
	print(count + 1)


(n, x, y) = map(int, input().split())
snum = input()
ntail = snum[-x:]
target = ['0'] * x
target[-(y + 1)] = '1'
res = 0
for i in range(x):
	if ntail[i] != target[i]:
		res += 1
print(res)


(n, x, y) = map(int, input().split())
s = input()
num = '1' + '0' * y
num1 = '0' * x
temp = s
temp = temp[0:n - len(num1)] + num1
temp = temp[0:n - len(num)] + num
ans = 0
for i in range(n):
	if temp[i] != s[i]:
		ans += 1
print(ans)


m = input()
st = input()
x = m.split()
q = 0
for i in range(0, int(x[1])):
	if i == int(x[2]):
		if st[int(x[0]) - i - 1] == '0':
			q += 1
	elif st[int(x[0]) - i - 1] == '1':
		q += 1
print(q)


(n, a, b) = map(int, input().split())
s = input()
z = '1' + '0' * b
ans = 0
for i in range(n - a, n - b - 1):
	if s[i] == '1':
		ans += 1
idx = n - b - 1
res = s[n - b - 1:]
for i in range(len(z)):
	if res[i] != z[i]:
		ans += 1
print(ans)


import math
from collections import defaultdict
import sys

def main():
	(n, x, y) = map(int, input().split())
	a = input()
	res = 0
	for i in range(1, x + 1):
		pos = n - i
		if i == y + 1:
			if a[pos] == '0':
				res += 1
		elif a[pos] == '1':
			res += 1
	print(res)
main()


a = list(map(int, input().split()))
b = input()
p1 = a[1]
p2 = a[2]
c = b[::-1][:p1 + 1]
d = c[::-1]
score = 0
k = [int(ele) for ele in d]
for j in range(len(k)):
	if j != len(k) - p2 - 1 and j != 0:
		if k[j] == 1:
			k[j] = 0
			score += 1
	elif j == len(k) - p2 - 1:
		if k[j] == 0:
			k[j] = 1
			score += 1
print(score)


(n, x, y) = map(int, input().split())
num = input().strip()
num = num[n - x:]
count = 0
for z in range(len(num)):
	if num[z] == '1':
		count += 1
if num[x - y - 1] == '1':
	count -= 1
else:
	count += 1
print(count)


(n, x, y) = list(map(int, input().split()))
s = input()
s1 = ['0'] * x
s1[-(y + 1)] = '1'
count = 0
for (a, b) in zip(s[-x:], s1):
	if a != b:
		count += 1
print(count)


def fastio():
	import sys
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
(n, x, y) = I()
s = input()
k = ['0'] * 300000
k[-x - 1] = '1'
k[-y - 1] = '1'
ans = 0
for i in range(x):
	ans += k[-i - 1] != s[-i - 1]
print(ans)


numbers = list(map(int, input().split()))
(n, x, y) = (numbers[0], numbers[1], numbers[2])
digits = list(input())
c = 0
for i in range(x):
	if 1 + i != y + 1:
		if digits[-i - 1] != '0':
			digits[-1 - i] = '0'
			c = c + 1
	elif digits[-y - 1] != '1':
		digits[-1 - y] = '1'
		c = c + 1
print(c)


(n, x, y) = map(int, input().split())
a = input()
arr = list(map(int, a))
arr = arr[n - x:n]
count = 0
for a in range(x):
	if a == x - y - 1:
		if arr[a] == 0:
			count += 1
	elif arr[a] == 1:
		count += 1
print(count)


(n, y, x) = input().split()
n = int(n)
x = int(x)
y = int(y)
inp = input()
sum = 0
for i in range(1, x + 1):
	if inp[-i] == '1':
		sum = sum + 1
if inp[-1 * (x + 1)] == '0':
	sum = sum + 1
for j in range(x + 2, y + 1):
	if inp[-j] == '1':
		sum = sum + 1
print(sum)


(a, b, c) = map(int, input().split())
n = list(input())
r = 0
if n[a - b - 1] == '1':
	n[a - b - 1] = '2'
if n[-1 - c] == '1':
	n[-1 - c] = '2'
else:
	r += 1
x = n[a - b - 1:].count('1')
print(x + r)


(n, x, y) = map(int, input().split())
t = input()
g = t[n - x:n - y - 1]
p = t[n - y - 1]
h = t[n - y:]
(a, b, c) = (g.count('1'), h.count('1'), p.count('0'))
print(a + b + c)


(n, x, y) = [int(x) for x in input().split(' ')]
number = input()[::-1]
print(number[0:x].count('1') + (1 if number[y] == '0' else -1))


f = [int(a) for a in input().rstrip().split()]
toCheck = input().rstrip()
count = 0
for i in range(len(toCheck) - 1, len(toCheck) - f[1] - 1, -1):
	if i != len(toCheck) - f[2] - 1 and toCheck[i] == '1':
		count += 1
	elif i == len(toCheck) - f[2] - 1 and toCheck[i] == '0':
		count += 1
print(count)


(n, x, y) = map(int, input().split())
a = input()
k = 0
for i in range(n - y, n):
	if a[i] == '1':
		k += 1
for i in range(n - x, n - y - 1):
	if a[i] == '1':
		k += 1
if a[n - y - 1] == '0':
	k += 1
print(k)


(n, x, y) = [int(x) for x in input().split(' ')]
number = input()
count = 0
for i in range(1, y + 1):
	if number[-i] == '1':
		count += 1
if number[-(y + 1)] == '0':
	count += 1
for i in range(y + 2, x + 1):
	if number[-i] == '1':
		count += 1
print(count)


lst = [int(i) for i in input().split()]
n = lst[0]
x = lst[1]
y = lst[2]
str = '0' * (x - y - 1) + '1' + '0' * y
str1 = input()[n - x:n]
s = 0
for i in range(x):
	if str[i] != str1[i]:
		s += 1
print(s)


line = input().split(' ')
n = int(line[0])
x = int(line[1])
y = int(line[2])
num = input()
num = num[-x:]
v = 10 ** y
v = '0' * (len(num) - len(str(v))) + str(v)
count = 0
for i in range(len(num)):
	if num[i] != v[i]:
		count += 1
print(count)


(n, x, y) = map(int, input().strip().split())
s = input().strip()
a = s[-x:]
b = str(10 ** y).rjust(len(a), '0')
total = 0
for (i, j) in zip(a, b):
	if i != j:
		total += 1
print(total)


(n, x, y) = input().split()
d = input()
x = int(x)
y = int(y)
a = int(pow(10, x) + pow(10, y))
m = str(a)
l = len(d)
j = len(m) - 1
i = l - 1
ans = 0
while j > 0:
	if m[j] != d[i]:
		ans += 1
	i -= 1
	j -= 1
print(ans)


(n, x, y) = list(map(int, input().split()))
binary = input()
ans = 0
for i in range(1, 1 + x):
	if binary[-1 * i] != '0':
		ans += 1
if binary[-1 * (y + 1)] == '1':
	ans -= 1
else:
	ans += 1
print(ans)


(n, x, y) = map(int, input().split())
p = 0
s = input()[-x:]
k = '0' * (x - y - 1) + str(10 ** y)
if k == s:
	print(0)
else:
	for i in range(len(k)):
		if k[i] != s[i]:
			p += 1
	print(p)


(n, x, y) = map(int, input().split())
s = str(input())
s = list(s)
s.reverse()
ans = 0
for i in range(x):
	if s[i] == '1':
		if i != y:
			ans += 1
		else:
			continue
	elif i != y:
		continue
	else:
		ans += 1
print(ans)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from math import gcd, ceil

def pre(s):
	n = len(s)
	pi = [0] * n
	for i in range(1, n):
		j = pi[i - 1]
		while j and s[i] != s[j]:
			j = pi[j - 1]
		if s[i] == s[j]:
			j += 1
		pi[i] = j
	return pi

def prod(a):
	ans = 1
	for each in a:
		ans = ans * each
	return ans

def lcm(a, b):
	return a * b // gcd(a, b)

def binary(x, length=16):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y
for _ in range(int(input()) if not True else 1):
	(n, x, y) = map(int, input().split())
	s = input()
	ans = 0
	for i in range(n - 1, n - x - 1, -1):
		if i == n - y - 1:
			if s[i] == '1':
				continue
			ans += 1
			continue
		if s[i] != '0':
			ans += 1
	print(ans)


(n, x, y) = [int(i) for i in input().split()]
s = input()
k = str(10 ** x + 10 ** y)
c = 0
for i in range(x + 1):
	if s[-i] != k[-i]:
		c += 1
print(c)


(n, x, y) = map(int, input().split())
str = input()
num = str[n - x - 1:]
a = list(num[::-1])
c = 0
for i in range(x):
	if i == y:
		if a[i] == '0':
			c += 1
	elif a[i] == '1':
		c += 1
print(c)


import sys
sys.setrecursionlimit(10 ** 5 + 1)
inf = int(10 ** 20)
max_val = inf
min_val = -inf
RW = lambda : sys.stdin.readline().strip()
RI = lambda : int(RW())
RMI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
RWI = lambda : [x for x in sys.stdin.readline().strip().split()]
(lens, x, y) = RMI()
ins = RW()
remainder = ins[-x:]
ans = 0
for i in range(x):
	ans += int(remainder[-1 - i]) ^ (i == y)
print(ans)


import sys
import math
import bisect

def main():
	(n, x, y) = map(int, input().split())
	A = list((int(a) for a in list(input())))
	A.reverse()
	ans = 0
	for i in range(x):
		if i == y:
			if A[i] == 0:
				ans += 1
		elif A[i] == 1:
			ans += 1
	print(ans)
main()


ip = list(map(int, input().split()))
n = ip[0]
x = ip[1]
y = ip[2]
no = str(input())
result = 0
for i in range(x):
	index = len(no) - 1 - i
	if i == y:
		if no[index] == '0':
			result += 1
	elif no[index] == '1':
		result += 1
print(result)


(n, x, y) = map(int, input().split())
num = input()
ans = 0
for _ in range(len(num)):
	if _ >= len(num) - x:
		if num[_] == '1':
			ans = ans + 1
if num[len(num) - y - 1] == '1':
	ans = ans - 1
else:
	ans = ans + 1
print(ans)


(n, x, y) = map(int, input().split())
numb = list(input())
numb.reverse()
ans = 0
for i in range(x):
	if i == y or i == x:
		if numb[i] == '0':
			ans += 1
	elif numb[i] == '1':
		ans += 1
print(ans)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def main():
	(n, x, y) = LI()
	s = S()[::-1]
	r = 0
	for i in range(x):
		if i == y:
			if s[i] == '0':
				r += 1
		elif s[i] == '1':
			r += 1
	return r
print(main())


(N, X, Y) = map(int, input().split())
S = input()
cnt = 0
for i in range(0, X):
	d = '0'
	if i == Y:
		d = '1'
	if S[-1 - i] != d:
		cnt += 1
print(cnt)


(n, x, y) = map(int, input().split())
s = input()
arr = [int(c) for c in s]
arr.reverse()
ans = 0
for i in range(x):
	if i != y:
		if arr[i] == 1:
			ans += 1
	if i == y and arr[i] == 0:
		ans += 1
print(ans)


from bisect import bisect_right as br
from bisect import bisect_left as bl
from collections import *
from itertools import *
import functools
import sys
from math import *
from decimal import *
from copy import *
getcontext().prec = 30
MAX = sys.maxsize
MAXN = 10 ** 5 + 10
MOD = 10 ** 9 + 7

def isprime(n):
	n = abs(int(n))
	if n < 2:
		return False
	if n == 2:
		return True
	if not n & 1:
		return False
	for x in range(3, int(n ** 0.5) + 1, 2):
		if n % x == 0:
			return False
	return True

def mhd(a, b, x, y):
	return abs(a - x) + abs(b - y)

def numIN(x=' '):
	return map(int, sys.stdin.readline().strip().split(x))

def charIN(x=' '):
	return sys.stdin.readline().strip().split(x)

def arrIN():
	return list(numIN())

def dis(x, y):
	a = y[0] - x[0]
	b = x[1] - y[1]
	return (a * a + b * b) ** 0.5

def lgcd(a):
	g = a[0]
	for i in range(1, len(a)):
		g = math.gcd(g, a[i])
	return g

def ms(a):
	msf = -MAX
	meh = 0
	st = en = be = 0
	for i in range(len(a)):
		meh += a[i]
		if msf < meh:
			msf = meh
			st = be
			en = i
		if meh < 0:
			meh = 0
			be = i + 1
	return (msf, st, en)

def res(ans, t):
	print('Case #{}: {} {}'.format(t, ans[0], ans[1]))
(n, x, y) = numIN()
s = input()
temp = ['0'] * x
temp[x - y - 1] = '1'
temp = temp[::-1]
s = s[::-1]
cnt = 0
for i in range(len(temp)):
	if temp[i] != s[i]:
		cnt += 1
print(cnt)


(rnum, vnum, mnum) = map(int, input().split())
num = input()
temp = 0
compStr = ''
for i in range(0, vnum):
	compStr = '0'
	if i == mnum:
		compStr = '1'
	if num[-1 - i] != compStr:
		temp = temp + 1
print(temp)


import sys

def main():
	(n, x, y) = map(int, sys.stdin.readline().split())
	nc = input()
	out = 0
	f = -1
	for i in range(y):
		num = int(nc[f])
		f -= 1
		if num == 1:
			out += 1
	num = int(nc[f])
	f -= 1
	if num == 0:
		out += 1
	for i in range(x - y - 1):
		num = int(nc[f])
		f -= 1
		if num == 1:
			out += 1
	sys.stdout.write(str(out))
main()


(n, x, y) = map(int, input().split())
s = input()
check1 = s[-x:]
check2 = '0' * (x - y - 1) + '1' + '0' * y
ans = 0
for i in range(x):
	if check1[i] != check2[i]:
		ans += 1
print(ans)


(N, X, Y) = input().split()
n = input()
ans = 0
n = n[-int(X):]
n = n[::-1]
for (idx, num) in enumerate(n):
	num = int(num)
	if idx != int(Y) and num != 0:
		ans += 1
	elif idx == int(Y) and num != 1:
		ans += 1
print(ans)


(n, x, y) = [int(i) for i in filter(None, input().split())]
number = input()
counter = 0
has_ones = False
for i in range(n - x):
	if number[i] == '1':
		has_ones = True
if not has_ones:
	counter += 1
for i in range(n - x, n):
	if number[i] == '1' and i != n - y - 1:
		counter += 1
	if number[i] == '0' and i == n - y - 1:
		counter += 1
print(counter)


(n, x, y) = map(int, input().strip().split(' '))
s = input()
s = s[n - x:]
t = x - y - 1
c = 0
s1 = '0' * t + '1' + '0' * y
for i in range(len(s)):
	if s[i] != s1[i]:
		c += 1
print(c)


(n, x, y) = [int(i) for i in input().split()]
num = input()
ret = 0
for i in range(-x, 0):
	if i == -1 - y:
		ret += 1 - int(num[i])
	else:
		ret += int(num[i])
print(ret)


(n, x, y) = map(int, input().split())
l = input()
ct = 0
for i in range(y):
	if l[n - 1 - i] != '0':
		ct += 1
if l[n - y - 1] != '1':
	ct += 1
for i in l[n - x:n - y - 1]:
	if i != '0':
		ct += 1
print(ct)


def fun(n, x, y, num: str):
	s = list(num)
	s.reverse()
	ans = 0
	for i in range(0, x + 1):
		if i <= y:
			if i == y:
				ans += s[i] == '0'
			else:
				ans += s[i] == '1'
		elif i < x:
			ans += s[i] == '1'
	return ans
(n, x, y) = map(int, input().split())
num = input()
print(fun(n, x, y, num))


from sys import stdin, setrecursionlimit
from bisect import bisect_right
setrecursionlimit(15000)

def get_gdict(arr):
	gdict = dict()
	for i in range(len(arr)):
		if arr[i] in gdict:
			gdict[arr[i]] += 1
		else:
			gdict[arr[i]] = 1
	return gdict

def initial_check(barr, garr):
	for i in garr:
		if i < barr[-1]:
			return False
	return True
(n, x, y) = list(map(int, stdin.readline().split()))
string = list(stdin.readline().strip())
count = 0
for i in range(n - 1, n - y - 1, -1):
	if string[i] == '1':
		string[i] = '0'
		count += 1
if string[n - y - 1] == '0':
	string[n - y - 1] = '1'
	count += 1
for i in range(n - y - 2, max(-1, n - x - 1), -1):
	if string[i] == '1':
		string[i] = 0
		count += 1
print(count)


from sys import stdin

def read_lines(sep=' ', input_type=None):
	_lines = stdin.readlines()
	cast = input_type is not None
	lines = []
	for line in _lines:
		line = line[:-1].split(sep)
		if cast:
			line = [input_type(x) for x in line]
		lines.append(line)
	return lines
import collections
lines = read_lines(input_type=None)
(n, x, y) = [int(z) for z in lines[0]]
num = lines[1][0]
num = num[-x:]
counter = 0
for v in num:
	if v != '0':
		counter += 1
if num[-y - 1] == '0':
	counter += 1
else:
	counter -= 1
print(counter)


(n, x, y) = input().split()
number = input()
n = int(n)
x = int(x)
y = int(y)
last_digit = 10 ** x + 10 ** y
s = str(last_digit)[1:]
ns = number[-x:]
count = 0
for i in range(x):
	if ns[i] != s[i]:
		count += 1
print(count)


import math
nxy = list(input().rstrip().split(' '))
z = input()
n = nxy[0]
x = nxy[1]
y = nxy[2]
k = int(x)
j = int(y)
i1 = z[-k:]
tmp = 10 ** k + 10 ** j
i2 = str(tmp)[1:]
count = 0
for i in range(len(i1)):
	if i1[i] != i2[i]:
		count += 1
print(count)


(n, x, y) = input().split()
n = int(n)
x = int(x)
num = input()
num_rem = num[len(num) - x:]
ctr = 0
new_y = ''
y = str(10 ** int(y))
for i in range(len(num_rem) - len(y)):
	new_y += '0'
new_y += y
for i in range(len(new_y)):
	if new_y[i] != num_rem[i]:
		ctr += 1
print(ctr)


(n, x, y) = map(int, input().split())
S = input()
S = S[::-1]
t = 0
for k in range(y):
	if S[k] == '1':
		t += 1
if S[y] == '0':
	t += 1
u = 0
for k in range(y + 1, x):
	if S[k] == '1':
		u += 1
print(u + t)


(n, x, y) = map(int, input().split())
a = input().strip()[-x:]
res = ('1' + '0' * y).zfill(x)
ans = 0
for i in range(len(a)):
	if a[i] != res[i]:
		ans += 1
print(ans)


(l, x, y) = input().split(' ')
l = int(l)
x = int(x)
y = int(y)
p = 0
n = input()
text = list(n[l - x:])
pattern = []
for i in range(x):
	pattern.append('0')
pattern[x - y - 1] = '1'
for i in range(x):
	if text[i] != pattern[i]:
		p = p + 1
print(p)


(n, x, y) = list(map(int, input().split()))
l = input()
wyn = 0
for i in range(n):
	j = n - 1 - i
	if i == x:
		break
	if i < y:
		if l[j] == '1':
			wyn += 1
	if i == y:
		if l[j] == '0':
			wyn += 1
	if i > y:
		if l[j] == '1':
			wyn += 1
print(wyn)


(n, x, y) = map(int, input().strip().split())
l = list(map(int, input().strip()))
ct = 0
for i in range(-x, 0):
	if l[i] == 1 and i != -y - 1:
		ct += 1
	elif i == -y - 1 and l[i] == 0:
		ct += 1
print(ct)


(n, x, y) = [int(s) for s in input().split()]
x = n - x
y = n - y
array = [int(s) for s in input()]
print(sum(array[x:y - 1]) + sum(array[y:]) + int(array[y - 1] == 0))


(n, x, y) = map(int, input().split())
s = input()
t = s[-x:]
a = '0' * abs(x - y - 1) + str(10 ** y)
ans = 0
for i in range(len(a)):
	if t[i] != a[i]:
		ans += 1
print(ans)


n = input().split()
m = input()
l = m[::-1]
p = l[:int(n[1])]
s = [0] * int(n[1])
s[int(n[2])] = 1
c = 0
for i in range(int(n[1])):
	if int(p[i]) != s[i]:
		c += 1
print(c)


(a, b, c) = map(int, input().split())
d = input()
e = d[::-1]
f = e[:b].count('1')
if e[c] == '1':
	print(f - 1)
else:
	print(f + 1)


from sys import stdin, stdout
import math, sys, heapq
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import bisect as bi

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

	def I():
		return int(input())

	def In():
		return map(int, input().split())
else:

	def I():
		return int(stdin.readline())

	def In():
		return map(int, stdin.readline().split())

def dict(a):
	d = {}
	for x in a:
		if d.get(x, -1) != -1:
			d[x] += 1
		else:
			d[x] = 1
	return d

def find_gt(a, x):
	i = bi.bisect_right(a, x)
	if i != len(a):
		return i
	else:
		return -1

def main():
	try:
		(n, x, y) = In()
		l = list(input())
		ans = 0
		for x in range(n - x, n, 1):
			if x < n - y - 1:
				if l[x] == '1':
					ans += 1
			elif x == n - y - 1:
				if l[x] == '0':
					ans += 1
			elif l[x] == '1':
				ans += 1
		print(ans)
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(1):
	main()


(n, x, y) = [int(x) for x in input().split()]
number = input().split()[0]
count = 0
for i in range(x):
	j = n - 1 - i
	if i == x:
		if number[j] == '0':
			count = count + 1
	if i == y:
		if number[j] == '0':
			count = count + 1
	elif number[j] == '1':
		count = count + 1
print(str(count))


(n, x, y) = map(int, input().split())
number = input()[n - x:]
s = '0' * (x - y - 1) + '1' + '0' * y
ans = 0
for i in range(x):
	ans += s[i] != number[i]
print(ans)


(n, x, y) = map(int, input().split())
a = input()
count = 0
for ai in a[-x:]:
	if ai == '1':
		count += 1
if a[-y - 1] == '0':
	count += 1
else:
	count -= 1
print(count)


(n, x, y) = [int(i) for i in input().split()]
c = input()
ans = 0
if c[n - 1 - y] == '0':
	ans += 1
for i in range(n - 1, n - 1 - x, -1):
	if i != n - 1 - y and c[i] == '1':
		ans += 1
print(ans)


def solve():
	(n, x, y) = map(int, input().split())
	s = input()[::-1]
	ans = 0
	for i in range(n):
		if i >= x:
			break
		elif i < y:
			ans += s[i] == '1'
		elif i == y:
			ans += s[i] == '0'
		elif i > y:
			ans += s[i] == '1'
	print(ans)
	return

def main():
	t = 1
	for i in range(t):
		solve()
	return
main()


(n, x, y) = map(int, input().split())
s = str(input())
ss = s[::-1]
ss = ss[:x]
num = ss.count('1')
if ss[y] == '0':
	num += 1
else:
	num -= 1
print(num)


(n, x, y) = input().split()
n = int(n)
x = int(x)
y = int(y)
s = input()
temp = (x - y - 1) * '0' + '1' + y * '0'
s = s[-x:]
c = 0
for i in range(0, len(s)):
	if temp[i] != s[i]:
		c += 1
print(c)


(n, x, y) = map(int, input().split())
s = input()
a = s[-x:]
b = str(10 ** y)
for i in range(len(a) - len(b)):
	b = '0' + b
cnt = 0
for i in range(x):
	if int(a[i]) ^ int(b[i]):
		cnt += 1
print(cnt)


(n, x, y) = map(int, input().split())
(s, p) = ([e for e in input()[-x:]], ['0' for i in range(x)])
(p[-y - 1], ans) = ('1', 0)
for i in range(x):
	ans += s[i] != p[i]
print(ans)


(n, x, y) = [int(k) for k in input().split()]
s = input()[::-1]
r = str(10 ** y)[::-1]
cnt = 0
for k in range(y + 1):
	if s[k] != r[k]:
		cnt += 1
for k in range(y + 1, x):
	if s[k] != '0':
		cnt += 1
print(cnt)


(n, x, y) = map(int, input().split())
num = input()
count = 0
for i in range(n - x, n - 1 - y):
	if num[i] == '1':
		count += 1
if num[n - 1 - y] == '0':
	count += 1
for i in range(n - y, n):
	if num[i] == '1':
		count += 1
print(count)


def A():
	first_line = input().split()
	n = int(first_line[0])
	x = int(first_line[1])
	y = int(first_line[2])
	line = input()
	correct_line = '1' + (x - y - 1) * '0' + '1' + y * '0'
	result = 0
	for i in range(len(correct_line)):
		if line[len(line) - i - 1] != correct_line[len(correct_line) - i - 1]:
			if i != len(correct_line) - 1:
				result += 1
	print(result)

def C():
	n = int(input())
	line = input()
	result_count = 0
	result_line = ''
	i = 0
	while True:
		if i == len(line) - 1:
			result_count += 1
			break
		if i >= len(line):
			break
		if line[i] != line[i + 1]:
			result_line += line[i] + line[i + 1]
			i += 2
		else:
			i += 1
			result_count += 1
	print(result_count)
	print(result_line)
A()


(n, x, y) = map(int, input().split())
s = input()
s1 = '1' + '0' * y
s2 = '1' + '0' * (x - y - 1)
ss = '0' * (n - x - 1) + s2 + s1
c = 0
for i in range(n - x, n):
	if s[i] != ss[i]:
		c += 1
print(c)


from math import sqrt, ceil, floor, gcd, factorial
from sys import stdin, stdout
from heapq import heapify, heappush, heappop
import string
import bisect

def solve():
	(n, x, y) = map(int, stdin.readline().split())
	b = list(stdin.readline())
	a = [i for i in b if i == '0' or i == '1']
	ans = 0
	if a[n - y - 1] != '1':
		ans += 1
	for i in range(x):
		if a[n - i - 1] != '0' and i != y:
			ans += 1
	print(ans)
solve()


(n, x, y) = [int(x) for x in input().split()]
num = input()
nx = num[-x:]
c = 0
ny = '1' + '0' * y
mul = '0' * (len(nx) - len(ny))
ny = mul + ny
for (i, j) in zip(nx, ny):
	if i != j:
		c += 1
print(c)


(n, x, y) = [int(x) for x in input().split()]
number = [int(x) for x in input()]
number.reverse()
res = 0
for i in range(y):
	if number[i] == 1:
		res += 1
if number[y] == 0:
	res += 1
for i in range(y + 1, x):
	if number[i] == 1:
		res += 1
print(res)


arr = input().split()
n = int(arr[0])
x = int(arr[1])
y = int(arr[2])
string = input()
count = 0
for i in range(n - x, n):
	if i == n - 1 - y:
		if string[i] == '0':
			count += 1
	elif string[i] == '1':
		count += 1
print(count)


line = [int(x) for x in input().split()]
(n, x, y) = (line[0], line[1], line[2])
s = input()
s = s[len(s) - x:]
pp = s.count('1')
print(pp - 1 if s[len(s) - y - 1] == '1' else pp + 1)


(n, x, y) = map(int, input().split())
m = input()
lim1 = n - x
lim2 = n - (y + 1)
change = 0
for i in range(lim1, n):
	if i == lim2:
		if m[i] == '0':
			change += 1
	elif m[i] == '1':
		change += 1
print(change)


(n, x, y) = input().split()
a = list(map(int, input()))
n = int(n)
x = int(x)
y = int(y)
i = n - x
count = 0
while i <= n - y - 2:
	if a[i] == 1:
		count += 1
	i += 1
if a[n - y - 1] == 0:
	count += 1
j = n - y
while j <= n - 1:
	if a[j] == 1:
		count += 1
	j += 1
print(count)


l = [*map(int, input().split())]
s = input()
yy = s[l[0] - l[1]:]
c = 0
for i in range(l[1]):
	if yy[i] == '1':
		c += 1
if yy[-(l[2] + 1)] == '1':
	c -= 1
else:
	c += 1
print(c)


a = [int(x) for x in input().split()]
b = str(input())
count = 0
for x in range(1, a[1] + 1):
	if x == a[2] + 1:
		if b[-x] == '0':
			count += 1
	elif b[-x] == '1':
		count += 1
print(count)


(n, x, y) = [int(i) for i in input().split(' ')]
l = input()
out = 0
for i in range(x):
	c = l[len(l) - i - 1]
	if i == y:
		if c == '0':
			out += 1
	elif c == '1':
		out += 1
print(out)


(n, x, y) = map(int, input().strip().split())
string = input().strip()
ctr = 0
ans = 0
for i in range(n - 1, -1, -1):
	if ctr >= x:
		break
	if ctr == y:
		if string[i] == '0':
			ans += 1
	elif string[i] == '1':
		ans += 1
	ctr += 1
print(ans)


(n, x, y) = map(int, input().split())
num = list(str(input()))
l = num[-x:]
l2 = str(10 ** y)
if len(l2) < len(l):
	l2 = '0' * (len(l) - len(l2)) + l2
l2 = list(l2)
result = 0
for i in range(len(l)):
	if l[i] != l2[i]:
		result += 1
print(result)


import sys
from itertools import accumulate

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
(N, x, y) = MAP()
S = input()
tgt = '0' * x
tgt = list(tgt[::-1])
tgt[y] = '1'
S = S[::-1]
ans = 0
for i in range(x):
	if S[i] != tgt[i]:
		ans += 1
if not S[x:].count('1'):
	ans += 1
print(ans)


from sys import stdin, stdout
stdin.readline

def mp():
	return list(map(int, stdin.readline().strip().split()))

def it():
	return int(stdin.readline().strip())
from math import ceil
from collections import defaultdict as dd
from collections import Counter as C
(n, x, y) = mp()
l = list(input())
ans = 0
for i in range(n - x, n):
	if l[i] == '1' and i != n - y - 1:
		ans += 1
	elif l[i] == '0' and i == n - y - 1:
		ans += 1
print(ans)


def make(l, n, m):
	count = 0
	for i in range(len(l) - 1, len(l) - 1 - n, -1):
		if i == len(l) - 1 - m:
			if l[i] == '1':
				pass
			else:
				count += 1
		elif l[i] == '1':
			count += 1
	return count
m = list(map(int, input().strip().split()))
l = list(input())
print(make(l, m[1], m[2]))


(n, x, y) = [int(x) for x in input().split(' ')]
num = list(input())
total = 0
for i in range(1, x + 1):
	pos = -1 * i
	if i != y + 1 and num[pos] == '1':
		total += 1
	elif i == y + 1 and num[pos] == '0':
		total += 1
if num[-1 * x - 1] == 0:
	total += 1
print(total)


(n, x, y) = map(int, input().split())
s = input()[-x:]
need = ''.join(['0'] * (x - y - 1) + ['1'] + ['0'] * y)
c = 0
for i in range(len(s)):
	if s[i] != need[i]:
		c += 1
print(c)


count = 0
(n, x, y) = input().split()
n = int(n)
x = int(x)
y = int(y)
tenPowX = str(pow(10, x))
tenPowY = str(pow(10, y))
num = input()
new_num = num[n - x:]
for i in range(0, len(new_num) - 1 - y):
	if new_num[i] != '0':
		count += 1
new_num = num[n - y - 1:]
for i in range(0, y + 1):
	if new_num[i] != tenPowY[i]:
		count += 1
print(count)


(n, x, y) = map(int, input().split())
s = str(input())
c = int(s, 2)
rem = c % 2 ** x
xor = rem ^ 2 ** y
binary = bin(xor)
setBits = [ones for ones in binary[2:] if ones == '1']
print(len(setBits))


gi = lambda : list(map(int, input().strip().split()))
(n, x, y) = gi()
s = input()
n = list(s[-x:])
ans = 0
if n[-y - 1] == '0':
	ans += 1
else:
	n[-y - 1] = '0'
ans += ''.join(n).count('1')
print(ans)


import sys, collections
(n, x, y) = map(int, sys.stdin.readline().split())
s = list(map(int, sys.stdin.readline().rstrip()))
s = s[::-1]
temp = []
for i in range(x):
	temp.append(s[i])
cnt = 0
for i in range(y):
	if temp[i] == 1:
		cnt += 1
if temp[y] == 0:
	cnt += 1
for i in range(y + 1, len(temp)):
	if temp[i] == 1:
		cnt += 1
print(cnt)


(N, X, Y) = map(int, input().split())
S = input()
ans = 0
for i in range(N - X, N):
	s = S[i]
	if i == N - Y - 1 and s == '0':
		ans += 1
	elif i != N - Y - 1 and s == '1':
		ans += 1
print(ans)


(n, x, y) = list(map(int, input().split()))
number = input()
number_digits = []
for i in number:
	number_digits.append(i)
val1 = 10 ** x
val2 = 10 ** y
val = str(val1 + val2)
count = 0
j = len(val) - 1
i = n - 1
while j >= 0:
	if j == 0 and number[i] == '0':
		count = count
	elif number[i] != val[j]:
		count += 1
	i -= 1
	j -= 1
print(count)


(x, y) = list(map(int, input().split()[1:]))
numb = list(input()[-x:])
if numb[-y - 1] == '1':
	opers = 0
	numb[-y - 1] = '0'
else:
	opers = 1
for i in numb:
	if i == '1':
		opers += 1
print(opers)


(n, x, y) = list(map(int, input().split()))
l = list(input())
cnt = 0
for i in range(n - 1, n - x - 1, -1):
	if l[i] == '1' and n - y - 1 != i:
		cnt += 1
	if n - y - 1 == i and l[i] == '0':
		cnt += 1
print(cnt)


(n, x, y) = map(int, input().split())
n = list(input())
rem = [i for i in n[len(n) - x:]]
req = ['0' for i in range(len(rem))]
req[len(rem) - 1 - y] = '1'
count = 0
for i in range(len(rem)):
	if rem[i] != req[i]:
		count += 1
print(count)


(n, x, y) = map(int, input().split())
a = input()
b = ''
for i in range(n):
	b += a[n - 1 - i]
count = 0
for j in range(x):
	if j == y:
		if b[j] == '0':
			count += 1
	elif b[j] == '1':
		count += 1
print(count)