output_description: If the depth of the snow cover is x meters, print x as an integer.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      a b
attempt: ###############################################################################
  
  from sys import stdout
  from bisect import bisect_left as binl
  from copy import copy, deepcopy
  from collections import defaultdict
  
  
  mod = 1
  
  
  def intin():
      input_tuple = input().split()
      if len(input_tuple) <= 1:
          return int(input_tuple[0])
      return tuple(map(int, input_tuple))
  
  
  def intina():
      return [int(i) for i in input().split()]
  
  
  def intinl(count):
      return [intin() for _ in range(count)]
  
  
  def modadd(x, y):
      global mod
      return (x + y) % mod
  
  
  def modmlt(x, y):
      global mod
      return (x * y) % mod
  
  
  def lcm(x, y):
      while y != 0:
          z = x % y
          x = y
          y = z
      return x
  
  
  def combination(x, y):
      assert x >= y
  
      if y > x // 2:
          y = x - y
  
      ret = 1
  
      for i in range(0, y):
          j = x - i
          i = i + 1
  
          ret = ret * j
          ret = ret // i
  
      return ret
  
  
  def get_divisors(x):
      retlist = []
      for i in range(1, int(x**0.5) + 3):
          if x % i == 0:
              retlist.append(i)
              retlist.append(x // i)
      return retlist
  
  
  def get_factors(x):
      retlist = []
      for i in range(2, int(x**0.5) + 3):
          while x % i == 0:
              retlist.append(i)
              x = x // i
      retlist.append(x)
      return retlist
  
  
  def make_linklist(xylist):
      linklist = {}
      for a, b in xylist:
          linklist.setdefault(a, [])
          linklist.setdefault(b, [])
          linklist[a].append(b)
          linklist[b].append(a)
      return linklist
  
  
  def calc_longest_distance(linklist, v=1):
      distance_list = {}
      distance_count = 0
      distance = 0
      vlist_previous = []
      vlist = [v]
      nodecount = len(linklist)
  
      while distance_count < nodecount:
          vlist_next = []
          for v in vlist:
              distance_list[v] = distance
              distance_count += 1
              vlist_next.extend(linklist[v])
          distance += 1
          vlist_to_del = vlist_previous
          vlist_previous = vlist
          vlist = list(set(vlist_next) - set(vlist_to_del))
  
      max_distance = -1
      max_v = None
      for v, distance in distance_list.items():
          if distance > max_distance:
              max_distance = distance
              max_v = v
  
      return (max_distance, max_v)
  
  
  def calc_tree_diameter(linklist, v=1):
      _, u = calc_longest_distance(linklist, v)
      distance, _ = calc_longest_distance(linklist, u)
      return distance
  
  
  ###############################################################################
  
  
  def main():
      a, b = intin()
  
      sub = b - a
      ans = 0
  
      for i in range(sub):
          ans += i
  
      ans -= a
      print(ans)
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  In some village, there are 999 towers that are
  1,(1+2),(1+2+3),...,(1+2+3+...+999) meters high from west to east, at
  intervals of 1 meter.
  
  It had been snowing for a while before it finally stopped. For some two
  adjacent towers located 1 meter apart, we measured the lengths of the parts of
  those towers that are not covered with snow, and the results are a meters for
  the west tower, and b meters for the east tower.
  
  Assuming that the depth of snow cover and the altitude are the same everywhere
  in the village, find the amount of the snow cover.
  
  Assume also that the depth of the snow cover is always at least 1 meter.
samples: [{"input": "8 13", "output": "2\n    \n\nThe heights of the two towers are 10 meters and 15 meters, respectively. Thus,\nwe can see that the depth of the snow cover is 2 meters.\n\n* * *"}, {"input": "54 65", "output": "1"}]