Problem:
 Score : 200 points    Problem Statement 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 1 13 3 1      Sample Output 1 3  There is just enough room for three, as shown below:    Figure        Sample Input 2 12 3 1      Sample Output 2 2       Sample Input 3 100000 1 1      Sample Output 3 49999       Sample Input 4 64146 123 456      Sample Output 4 110       Sample Input 5 64145 123 456      Sample Output 5 109

Solution (Python):

import sys
sys.setrecursionlimit(10**6)

x, y, z = list(map(int, input().split()))

print((x-z)//(y+z))

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

Solution (Python):
x,y,z=map(int,input().split())
tmp=x//(y+z)
if tmp*(y+z)+z>x:
    tmp-=1
print(tmp)

Solution (Python):
def answer(x: int, y: int, z: int) -> int:
    return len(range(y + z * 2, x + 1, y + z))


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


if __name__ == '__main__':
    main()

Solution (Python):
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))


if __name__ == '__main__':
    main()

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

Solution (Python):
X, Y, Z = map(int, input().split())

X -= Z
print(X//(Y+Z))

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

Solution (Python):
x,y,z = map(int,input().split())
for ans in range(1,100000):
    if ans*y+(ans+1)*z <= x < (ans+1)*y+(ans+2)*z:
        print(ans)
        exit()

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

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

Solution (Python):
lst = input().split()
x = int(lst[0])
y = int(lst[1])
z = int(lst[2])

x -= z

print(x // (y + z))

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

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

Solution (Python):
X,Y,Z = list(map(int,input().split()))
out = 0
now = 0
if X>=Y+Z+Z:
    out += 1
    now += Y+Z+Z
    while X>=now+Y+Z:
        now += Y+Z
        out += 1
    print(out)

Solution (Python):

[X,Y,Z] = list(map(int,input().split()))

i=0
while True:
    need= i*Y + (i+1)*Z
    if need>X:
        break
    i+=1

print(i-1)

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

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

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

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

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

Solution (Python):
x, y, z = map(int, input().split())

print(int((x - z) / (y + z)))

Solution (Python):
x, y, z = map(int, input().split())

one_length = y + z
print(int((x-z) / one_length))

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

Solution (Python):
x, y, z = map(int, input().split())

i = 1
while True:
  if (y + z) * i + z > x:
    print(i-1)
    break
  i += 1

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

Solution (Python):

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

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

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

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

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

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

Solution (Python):
x, y, z = map(int, input().split())
for i in range(100000):
    if (i+1)*z + i*y > x:
        print(i-1)
        break

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

Solution (Python):
a,b,c = map(int,input().split())

print((a-c)//(b+c))

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

Solution (Python):
x,y,z = list(map(int, input().split()))
b = x-z
c = y+z

print(b//c)

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

Solution (Python):
def main():
    x, y, z = map(int, input().split())
    x -= y + z * 2
    ans = 0
    if x < 0:
        print(ans)
    while x >= 0:
        ans += 1
        x -= y + z
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    x, y, z = map(int, input().split())
    x -= y + z * 2
    ans = 0
    if x < 0:
        return ans
    while x >= 0:
        ans += 1
        x -= y + z
    print(ans)


if __name__ == '__main__':
    main()

Solution (Python):
def main():
    x, y, z = map(int, input().split())

    for i in range(1, 10 ** 5 + 1):
        if (z + y) * i + z > x:
            print(i - 1)
            exit()


if __name__ == "__main__":
    main()

Solution (Python):
def main():
    x, y, z = map(int, input().split())

    print((x - z) // (y + z))


if __name__ == "__main__":
    main()

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

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

Solution (Python):
a = list(map(int,input().split()))


x = 0
count=0

while a[0]-a[2]>= x:
    x += a[1]
    x += a[2]
    count+=1

print(count-1)

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

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

Solution (Python):

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

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    x, y, z = map(int, readline().split())

    rem = x - z
    ans = 0
    while rem >= (y + z):
        rem -= (y + z)
        ans += 1

    print(ans)


if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
import math
X, Y, Z = map(int, input().split())

X -= Z

print(math.floor(X/(Y+Z)))

Solution (Python):
def main():
    X, Y, Z = map(int, input().split())
    rest = X - Z
    c = 0
    while rest > 0:
        rest = rest - Y - Z
        if rest < 0:
            print(c)
            return
        elif rest == 0:
            print(c+1)
            return
        else:
            c += 1
main()

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

Solution (Python):
x,y,z=map(int,input().split())
n=0
while True:
  if n*y+(n+1)*z>x:
    print(n-1)
    exit()
  n+=1

Solution (Python):
x, y, z = map(int,input().split())

result = 0
while y*result + z*(result+1) <= x:
  result += 1

print(result-1)

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

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

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

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

Solution (Python):
a,b,c=map(int,input().split());print((a-c)//(b+c))

Solution (Python):
x, y, z = map(int, input().split())
x -= z
count = 0
while x >= y + z:
    x -= y + z
    count += 1
print(count)

Solution (Python):
X, Y, Z = (int(x) for x in input().split())

ans = (X-Z)//(Y+Z)
print(ans)

Solution (Python):
x=list(map(int,input().split()))
print((x[0]-x[2])//(x[1]+x[2]))

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

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

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

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

Solution (Python):
x,y,z=map(int,input().split())

ans = 0

for i in range(x):
    
    if y*i+z*(i+1) <= x:
        ans=max(ans, i)
print(ans)

Solution (Python):
x,y,z=map(int,input().split())

print((x-z)//(y+z))

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

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

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

Solution (Python):
x, y, z = [int(i) for i in input().split()]
ans = x // (y + z)
if x - (ans * (y + z)) < z:
    ans -= 1
print(ans)

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

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

Solution (Python):
x, y, z = map(int, input().split())
cnt = 0
while x >= 0:
    x -= z
    if x >= y+z:
        x -= y
        cnt += 1

print(cnt)

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

x, y, z = LI()
ans = (x - z) // (y+z)
print(ans)

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

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

Solution (Python):
X,Y,Z=map(int,input().split())
L=X-Z
ans=0
for i in range(1000000):
    if L >= (Z+Y)*i:
        ans=i
    else:
        break
print(ans)

Solution (Python):
x, y, z = map(int,input().split())

cnt = 1
x -= y + 2*z

while x >= y + z:
    cnt += 1
    x -= y + z
print(cnt)

Solution (Python):
x,y,z=map(int,input().split());print((x-z)//(y+z))

Solution (Python):
x,y,z=map(int,input().split())
n=[i for i in range(z,x-z,y+z)]
if n[-1]+y+z<=x:
  print(len(n))
else:
  print(len(n)-1)

Solution (Python):
x, y, z = map(int, input().split())

x -= z
y += z
print(x // y)

Solution (Python):
x, y, z = map(int, input().split())

print((x - z) // (y + z))

Solution (Python):
import sys
input = sys.stdin.readline



def main():
    x, y, z = [int(i) for i in input().strip().split()]
    x = x - z
    ans = x // (y + z)
    print(ans)

    return


if __name__ == "__main__":
    main()

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

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

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

Solution (Python):
x, y, z = map(int, input().split())

x -= z

print( x // (y+z) )

Solution (Python):
X, Y, Z = map(int,input().split())

X = X - Z

print(X//(Y + Z))

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

print(tmp)

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

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

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

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

Solution (Python):
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: 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))

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

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

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

Solution (Python):











x,y,z = map(int, input().split())

ans = x // (y+z)

if (x % (y+z) < z):
    ans -= 1
print(max(0,ans))

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

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

Solution (Python):
X, Y, Z = list(map(lambda w: int(w), input().split(" ")))
print(int((X-Z)/(Y+Z)))

Solution (Python):
x, y, z = map(int, input().split())

print((x-z)//(y+z))

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

Solution (Python):
X,Y,Z = map(int, input().split())

print((X - Z)//(Y + Z))

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

Solution (Python):

x,y,z = map(int, raw_input().split())
cumul = x / (y + z)
x %= y + z
if x < z:
	cumul -=1
print max(cumul,0)

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
x, y, z = M()
ans= 0
for i in range(1, 50000):
    if y*i + z*(i+1) <= x:
        ans = i
    else:
        break
print(ans)

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

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

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

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

Solution (Python):
x,y,z=map(int,input().split())
print(len(range(z+y,x-z+1,z+y)))

Solution (Python):
x, y, z = list(map(int, input().split()))

print((x - z) // (y + z))

Solution (Python):

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

Solution (Python):

















import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
import numpy as np
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

X, Y, Z = MAP()

if Y + 2 * Z > X:
    print(0)
else:
    print(1 + (X - Y - 2 * Z) // (Y + Z))

Solution (Python):
X,Y,Z=map(int,input().split())

print((X-Z)//(Y+Z))

Solution (Python):
X,Y,Z=map(int,input().split())
s=Z
c=0
while True:
  s+=Y+Z
  if s>X:
    break
  c+=1
print(c)

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    X, Y, Z = map(int, readline().split())

    ans = (X - Z) // (Y + Z)

    print(ans)
    return


if __name__ == '__main__':
    main()

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

Solution (Python):
X,Y,Z = map(int,input().split())
cnt = 0

while (X-Z) >= (Z+Y):
    X -= (Z+Y)
    cnt += 1
print(cnt)

Solution (Python):
x, y, z = map(int,input().split())
x -= z
ans = 0

while x > 0:
    ans += 1
    x -= y
    x -= z
    if x < 0:
        ans -= 1

print(ans)

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

Solution (Python):
x,y,z = map(int, input().split())

ans = 0
t = z + y + z
while t <= x:
  ans += 1
  t += y
  t += z
print(ans)

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

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

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

Solution (Python):
def solve():
    X, Y, Z = map(int, input().split())
    print((X - Z) // (Y + Z))


if __name__ == "__main__":
    solve()

Solution (Python):

x, y, z = map(int, input().split())


ans = x // (y + z)
if x - ans*(y + z) < z:
    ans = max(0, ans-1)
print(ans)

Solution (Python):
import sys
from itertools import accumulate
def input(): return sys.stdin.readline().strip()


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


if __name__ == "__main__":
    main()

Solution (Python):









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

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

Solution (Python):
X,Y,Z=map(int,input().split())
 
for i in range(1,X):
  if (Y+Z)*i+Z > X:
    print(i-1)
    break

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

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

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

Solution (Python):
MM = input().split()
X = int(MM[0])
Y = int(MM[1])
Z = int(MM[2])
x = 0
while True:
  if x*(Y+Z)+Z >X:
    break
  else:
    x +=1
print(x-1)

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

Solution (Python):
x,y,z = map(int, input().split())
cnt=0
if x>=y+2*z:
  cnt+=1
  x -= (y+2*z)
cnt += (x//(y+z))
print(cnt)

Solution (Python):
x, y, z = map(int, input().split())

print((x - z) // (y + z))

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

Solution (Python):
x,y,z=map(int,input().split())
a=x//(y+z)
if x-a*(y+z)>=z:
  print(a)
else:
  print(max(0,a-1))

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

Solution (Python):
s = input().split()
x = int(s[0])
y = int(s[1])
z = int(s[2])

p = x - z

answer = int(p / (y + z))

print(answer)

Solution (Python):
x,y,z=map(int,input().split())
mitumori=x//(y+z)
if x - mitumori*(y+z)>=z:print(mitumori)
else:print(mitumori-1)

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

Solution (Python):
X, Y, Z = map(int, input().split())
ans = X - Z
YZ = Y + Z
print(ans // YZ)

Solution (Python):
X, Y, Z = map(int, input().split())
c = 0
l = Z
while l < X:
    if l + Y + Z <= X:
        l += Y + Z
        c += 1
    else:
        break
print(c)

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

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

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

Solution (Python):
import collections
def main():
    x,y,z=map(int, input().split())
    k = y+z+z
    res = 1
    while((k<x)):
        k+=(z+y)
        if(k>x):
            break
        res+=1
    print(res)

if __name__ == '__main__':
    main()

Solution (Python):
x, y, z = [int(i) for i in input().split(' ')]
x -= z
print(x // (y + z))

Solution (Python):
x,y,z = map(int,input().split())
i = 1
while(y+z*2+(z+y)*i <= x):
    i += 1
print(i)

Solution (Python):
x,y,z=map(int,input().split())
if x%(y+z)>=z :
  print(x//(y+z))
else:
  print(x//(y+z)-1)

Solution (Python):
x, y, z = map(int, input().split())
x -= z
if x >= 0:
   print(x//(y+z))
else:
    print(0)

Solution (Python):
X,Y,Z = map(int,input().split())

def solve(x,y,z):
  cnt = 0
  x -= z
  while True:
    x -= y + z
    if x >= 0:
      cnt += 1
    else:
      return cnt
    
print(solve(X,Y,Z))

Solution (Python):
def resolve():
    x, y, z = map(int, input().split())

    x -= z
    count = 0
    while True:
        x = x-(y+z)
        if x >= 0:
            count += 1
        else:
            break
    print(count)
resolve()

Solution (Python):
a,b,c=map(int,input().split())
n=a//(b+c)
m=a-n*(b+c)
if m//c==1:
    print(n)
else:
    print(n-1)

Solution (Python):
x, y, z = map(int, input().split())

print((x - z) // (y + z))

Solution (Python):
X_all, Y_hito, Z_interval = map(int, input().split())

syou = X_all // (Y_hito + Z_interval)

if (syou * (Y_hito + Z_interval) + Z_interval <= X_all):
    ans = syou
else:
    ans = syou - 1

print(ans)

Solution (Python):
x, y, z = map(int, input().split())
if x < y:
    print(0)
else:
    l = z
    i = 0
    while l + (z+y) <= x:
        l += (z+y)
        i += 1
    print(i)

Solution (Python):
X,Y,Z = map(int,input().split())
ans = X//(Y+Z)
if X%(Y+Z) >= Z:
    print(ans)
else:
    print(ans-1)

Solution (Python):
X,Y,Z = map(int,input().split())
ans = X//(Y+Z)
if X%(Y+Z) >= Z:
    print(ans)
else:
    print(ans-1)

Solution (Python):
import sys
import time
import math
def inpl():
    return list(map(int, input().split()))
st = time.perf_counter()


X, Y, Z = map(int, input().split())
for i in range(1, 1001001001):
	if Y * i + Z * (i+1) > X:
		print(i-1)
		sys.exit()


ed = time.perf_counter()
print('time:', ed-st, file=sys.stderr)

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

Solution (Python):
X,Y,Z = map(int,input().split())

print((X-Z)//(Y+Z))

Solution (Python):
X, Y, Z = map(int, input().split())

print((X-Z)//(Z+Y))

Solution (Python):
x, y, z = map(int, input().split())

x -= 2 * z
print(x // (y + z) + x % (y + z) // y)

Solution (Python):
import sys
input = sys.stdin.readline

x,y,z=list(map(int,input().split()))

print((x-z)//(y+z))

Solution (Python):
X,Y,Z = map(int,input().split())

print((X-Z)//(Y+Z))

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

Solution (Python):
x,y,z = map(int,input().split())

ans = 0

while y * ans + z * (ans+1) <= x:
    ans += 1

print(ans-1)

Solution (Python):
X, Y, Z = map(int, input().split())

print((X - Z) // (Y + Z))

Solution (Python):


X, Y, Z = map(int, input().split())

used_space = Y + (Z * 2)
ans = 0

while True:
    if used_space > X:
        break
    used_space = used_space + Y + Z
    ans += 1

print(ans)

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

Solution (Python):
X, Y, Z = map(int, input().split())
ans = X // (Y+Z)
if X-(Y+Z)*ans >= Z:
    print(ans)
else:
    print(ans-1)

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

Solution (Python):
x, y, z = map(int, input().split())

x -= z

print(x//(y+z))

Solution (Python):
x,y,z = map(int,input().split())

x = x - z
print(int(x/(y+z)))

Solution (Python):










import sys

def input(): return sys.stdin.readline().rstrip()
def iIn(): return int(input())
def iInM(): return map(int, input().split())
def iInM1(): return map(int1, input().split())
def iInLH(): return list(map(int, input().split()))
def iInLH1(): return list(map(int1, input().split()))
def iInLV(n): return [iIn() for _ in range(n)]
def iInLV1(n): return [iIn()-1 for _ in range(n)]
def iInLD(n): return [iInLH() for _ in range(n)]
def iInLD1(n): return [iInLH1() for _ in range(n)]
def sInLH(): return list(input().split())
def sInLV(n): return [input().rstrip('\n') for _ in range(n)]
def sInLD(n): return [sInLH() for _ in range(n)]

def OutH(lst, deli=' '): print(deli.join(map(str, lst)))
def OutV(lst): print('\n'.join(map(str, lst)))

sys.setrecursionlimit(10 ** 6)

int1 = lambda x: int(x) - 1

INF = int(1e9)
MOD = 1000000007
dx = (-1, 0, 1, 0)
dy = (0, -1, 0, 1)


X, Y, Z = iInM()

ans = (X - Z) // (Y + Z)

print(ans)

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

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

Solution (Python):
import math
def main():
  x,y,z = list(map(int,input().split()))
  print(int((x-z)/(y+z)))
main()

Solution (Python):
X,Y,Z=list(map(int,input().split()))
for i in range(100001):
  if X >= i * Y + ( i + 1 ) * Z:
    ans = i
print(ans)

Solution (Python):
x,y,z=map(int,input().split());print((x-z)//(y+z))

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

Solution (Python):
import sys
X,Y,Z = map(int,input().split())

if not (1 <= X <= 10 ** 5 and 1 <= Y <= 10 ** 5 and 1 <= Z <= 10 ** 5):
    sys.exit()

if not (Y + 2*Z <= X):
    sys.exit()

max = 0
for I in range(int(X/(Y+Z))+1):
    if X - (Y * I + Z * (I + 1)) >= 0:
        max = I
print(max)

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

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
INF = 10**9
mod = 10**9+7

X,Y,Z = I()
print((X-Z)//(Y+Z))

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

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

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

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

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

Solution (Python):
x,y,z=map(int,input().split());print((x-z)//(y+z))

Solution (Python):
x, y, z = map(int, input().split())

print((x-z) // (y+z))

Solution (Python):
x, y, z = map(int, input().split())
chair = (x - z) // (y + z)
print(chair)

Solution (Python):
X, Y, Z = map(int, input().split())

sum = 0

for i in range(1,X):
    if sum > X:
        ans = i-2
        break
    if sum == X:
        ans = i-1
        break
    else:
        sum = Y*i+Z*(i+1)

print(ans)

Solution (Python):
x,y,z = map(int,input().split())
p = y + z + z
c = 0

while p <= x:
    c += 1
    p = p + y + z

print(c)

Solution (Python):
x,y,z = list(map(int,input().split()))

x -= z

print(x//(y+z))

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

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

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

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

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

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

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

def main():
    X, Y, Z = mi()
    k = X//(Y+Z)
    r = X%(Y+Z)
    if r < Z:
        print(k-1)
    else:
        print(k)


if __name__ == '__main__':
    main()

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

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

Solution (Python):
if __name__ == '__main__':
    a = [int(i) for i in input().split()]
    a[0]-=a[2]*2
    print((a[0]+a[2])//(a[1]+a[2]))

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

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

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

Solution (Python):
X,Y,Z = map(int,input().split())

for i in range(1,10**5):
    if Y*i + Z*(i+1) > X:
        print(i-1)
        break

Solution (Python):
X,Y,Z=map(int,input().split());print((X-Z)//(Y+Z))

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

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

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

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

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

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

Solution (Python):
X,Y,Z = map(int, input().split())
ans = X//(Y+Z) - 1
if ans*(Y+Z)+(Y+Z+Z) <= X: ans += 1
print(ans)

Solution (Python):



x, y, z = (int(i) for i in input().split())

n = int((x-z)/(y+z))

print(n)

Solution (Python):
x,y,z = map(int, input().split())

X = x - 2*z
n = X//(y+z)

if X - (y+z)*n >= y:
  print(n+1)
else:
  print(n)

Solution (Python):
x,y,z=map(int,input().split())

res=x-z
ans=0
while res>=y+z:
    res-=(y+z)
    ans+=1
print(ans)

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

Solution (Python):
def resolve():
    X, Y, Z = map(int, input().split())
    ans = 0
    while ans*Y+(ans+1)*Z <= X:
        ans += 1
    print(ans-1)
resolve()

Solution (Python):
x,y,z=map(int, input().split());print((x-z)//(y+z))

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

Solution (Python):
def main():
    x,y,z=map(int,input().split())
    x -= z
    print(x//(y+z))
        
if __name__ == "__main__":
    main()

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

Solution (Python):
x, y, z = map(int, input().split())

ans = x // (y+z)
if x < ans * (y+z) + z:
    ans -= 1

print(ans)

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

Solution (Python):
X, Y, Z = map(int, input().split())
ans = 0
X -= Z
for _ in range(X):
    if X < (Y + Z):
        print(ans)
        break
    else:
        ans += 1
        X -= (Y + Z)

Solution (Python):
x,y,z=map(int,input().split())
ans=0
while(1):
    ans+=1
    if ans*y+(ans+1)*z>x:
        print(ans-1)
        exit()

Solution (Python):
z,y,x=map(int,input().split())
z-=x*2+y
count=1
while(1):
  z-=y+x
  if z<0:
    break
  count+=1
print(count)

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

Solution (Python):
x, y, z = map(int, input().split())
ans = x // (y + z)
if x % (y + z) < z:
  ans -= 1
print(ans)

Solution (Python):
x,y,z = map(int, input().split())

print ((x-z) // (y+z ))

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

Solution (Python):
X,Y,Z = map(int,input().split())
count = 0
wide = Z+Y+Z
while X >= wide:
    count+=1
    wide +=Z+Y
print(count)

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

Solution (Python):
x,y,z = map(int,input().split())
ans = 0
for i in range(10**5):
    if i*y + (i+1)*z <= x:
        pass
    else:
        break
print(i-1)

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

Solution (Python):
X, Y, Z = map(int, input().split())
X -= Z
people = 0
while X >= 0:
    X -= (Y + Z)
    if X >= 0:
        people += 1
print(people)

Solution (Python):
def ABC_78_B():
    X,Y,Z = map(int, input().split())
    sum=0
    N=0
    while sum<= X:
        sum = Y*N+Z*(N+1)
        N+=1  
    print(N-2)


if __name__ == '__main__':

    ABC_78_B()

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

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

Solution (Python):
x, y, z = (int(i) for i in input().split())

ans, mod = divmod(x, y+z)
if mod >= z:
    print(ans)
else:
    print(ans-1)

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

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