We have a long seat of width X centimeters.
There are many people who wants to sit here. A person sitting on the seat will always occupy an interval of length Y centimeters.
We would like to seat as many people as possible, but they are all very shy, and there must be a gap of length at least Z centimeters between two people, and between the end of the seat and a person.
At most how many people can sit on the seat?

-----Constraints-----
 - All input values are integers.
 - 1 \leq X, Y, Z \leq 10^5
 - Y+2Z \leq X

-----Input-----
Input is given from Standard Input in the following format:
X Y Z

-----Output-----
Print the answer.

-----Sample Input-----
13 3 1

-----Sample Output-----
3

There is just enough room for three, as shown below:
Figure

Difficulty: EASY

Solutions:
(X, Y, Z) = map(int, input().split(' '))
ans = (X - Z) // (Y + Z)
print(ans)


(x, y, z) = map(int, input().split())
x -= z
r = x // (y + z)
print(r)


(X, Y, Z) = list(map(int, input().split()))
print((X - Z) // (Z + Y))


def answer(x: int, y: int, z: int) -> int:
	return (x - z) // (y + z)

def main():
	(x, y, z) = map(int, input().split())
	print(answer(x, y, z))

def __starting_point():
	main()
__starting_point()


(X, Y, Z) = map(int, input().split())
new = X - Z
print(new // (Y + Z))


(X, Y, Z) = [int(i) for i in input().split()]
print((X - Z) // (Y + Z))


(X, Y, Z) = [int(x) for x in input().split()]
print((X - Z) // (Y + Z))


(X, Y, Z) = map(int, input().split())
left = X - Z
print(left // (Y + Z))


(x, y, z) = map(int, input().split())
width = y + z
print((x - z) // width)


(x, y, z) = map(int, input().split())
x -= z
ans = x // (y + z)
rem = x % (y + z)
print(ans)


(x, y, z) = map(int, input().split())
n = (x - z) // (z + y)
print(n)


(x, y, z) = map(int, input().split())
isu = x - z
print(isu // (z + y))


(X, Y, Z) = map(int, input().split())
N = (X - Z) // (Y + Z)
print(N)


(X, Y, Z) = map(int, input().split())
a = (X - Z) // (Y + Z)
print(a)


(x, y, z) = map(int, input().split())
answer = (x - z) // (y + z)
print(answer)


(x, y, z) = input().split()
print((int(x) - int(z)) // (int(y) + int(z)))


(x, y, z) = list(map(int, input().split()))
x -= z
y += z
print(x // y)


(X, Y, Z) = [int(s) for s in input().split()]
print((X - Z) // (Z + Y))


(x, y, z) = [int(x) for x in input().split()]
print((x - z) // (y + z))


(X, Y, Z) = map(int, input().split())
print((X - (Y + 2 * Z)) // (Y + Z) + 1)


(space, seat, sp) = map(int, input().split())
print((space - sp) // (seat + sp))


(A, B, C) = map(int, input().split())
print((A - C) // (B + C))


import math
(X, Y, Z) = list(map(int, input().split()))
X -= Z
print(math.floor(X / (Y + Z)))


a = list(map(int, input().split()))
print((a[0] - a[2]) // (a[1] + a[2]))


(X, Y, Z) = map(int, input().split())
h = X - Z
y = Y + Z
print(h // y)


(x, y, z) = map(int, input().split())
x -= y + 2 * z
print(1 + x // (y + z))


(x, y, z) = map(int, input().split())
w = x - z
print(w // (y + z))


(x, y, z) = map(int, input().split())
l = [z]
per = (x - z) // (y + z)
print(per)


(a, b, c) = map(int, input().split())
print((a - b - c * 2) // (b + c) + 1)


(n, a, b) = [int(i) for i in input().split()]
print((n - b) // (a + b))


(a, b, c) = input().split()
a = int(a)
b = int(b)
c = int(c)
print((a - c) // (b + c))


(x, y, z) = map(int, input().split())
a = x - z
b = a // (y + z)
print(b)


import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np
from functools import reduce
rr = lambda : sys.stdin.readline().rstrip()
rs = lambda : sys.stdin.readline().split()
ri = lambda : int(sys.stdin.readline())
rm = lambda : list(map(int, sys.stdin.readline().split()))
rl = lambda : list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10 ** 9 + 7
(a, b, c) = rm()
print((a - c) // (b + c))


(x, y, z) = map(int, input().split())
len = x - z
print(len // (y + z))


(x, y, z) = map(int, input().split())
p = (x - z) // (y + z)
print(p)


(X, Y, Z) = [int(_) for _ in input().split()]
print((X - Z) // (Y + Z))


(a, b, c) = (int(i) for i in input().split())
print((a - c) // (b + c))


(x, y, z) = map(int, input().split())
ret = (x - z) // (y + z)
print(ret)


(x, y, z) = map(int, input().split())
m = x - z
print(m // (y + z))


lst = input().split()
x = int(lst[0])
y = int(lst[1])
z = int(lst[2])
x -= z
print(x // (y + z))


(X, Y, Z) = (int(T) for T in input().split())
print((X - Z) // (Y + Z))


(X, Y, Z) = map(int, input().split())
k = (X - Z) // (Z + Y)
print(k)


(x, y, z) = map(int, input().split())
yz = y + z
x -= z
print(x // yz)


(X, Y, Z) = map(int, input().split())
r = (X - Z) // (Y + Z)
print(r)


(X, Y, Z) = map(int, input().split())
X_ = X - Z
print(X_ // (Y + Z))


(x, y, z) = map(int, input().split())
res = (x - z) // (y + z)
print(res)


(X, Y, Z) = map(int, input().split())
A = X - Z
B = Y + Z
print(A // B)


import sys
sys.setrecursionlimit(10 ** 7)

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

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

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

def LI2():
	return list(map(int, sys.stdin.readline().rstrip()))

def S():
	return sys.stdin.readline().rstrip()

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

def LS2():
	return list(sys.stdin.readline().rstrip())
(X, Y, Z) = MI()
X -= Z
print(X // (Y + Z))


(X, Y, Z) = map(int, input().split())
m = X - Z
print(m // (Y + Z))


(X, Y, Z) = map(int, input().split())
tmp = X - Z
print(tmp // (Y + Z))


(x, y, z) = map(int, input().split())
x -= z
count = x // (y + z)
print(count)


import math
(x, y, z) = map(int, input().split())
print(int(math.floor((x - z) / (y + z))))


(x, y, z) = list(map(int, input().split()))
b = x - z
c = y + z
print(b // c)


(X, Y, Z) = map(int, input().split())
X = X - Z
A = X / (Y + Z) // 1
print(round(A))


(a, s, d) = map(int, input().split())
print((a - d) // (s + d))


(x, y, z) = map(int, input().split())
X = x - z
ans = X // (y + z)
print(ans)


(X, Y, Z) = map(int, input().split())
answer = (X - Z) // (Y + Z)
print(answer)


(a, b, c) = map(int, input().split())
a -= c
n = a // (b + c)
print(n)


(X, Y, Z) = map(int, input().split())
p = X - Z
a = Z + Y
ans = p // a
print(ans)


(x, y, z) = map(int, input().split())
ans = 0
print((x - z) // (y + z))


(X, Y, Z) = map(int, input().split())
l = X - Z
print(l // (Y + Z))


(a, b, c) = map(int, input().split())
a = a - c
print(round(a // (b + c)))


(x, y, z) = map(int, input().split())
c = (x - z) // (y + z)
print(c)


import sys
sys.setrecursionlimit(10 ** 6)
(x, y, z) = list(map(int, input().split()))
print((x - z) // (y + z))


(x, y, z) = map(int, input().split())
tmp = (x - z) // (y + z)
amari = (x - z) % (y + z)
print(tmp)


(a, b, c) = map(int, input().split())
X = a - c
Y = b + c
print(X // Y)