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 heapq import heappush, heappop, heapify
  from collections import deque, defaultdict, Counter
  import itertools
  from functools import *
  from itertools import permutations, combinations, groupby
  import sys
  import bisect
  import string
  import math
  import time
  import random
  
  
  def Golf():
      (*a,) = map(int, open(0))
  
  
  def S_():
      return input()
  
  
  def IS():
      return input().split()
  
  
  def LS():
      return [i for i in input().split()]
  
  
  def I():
      return int(input())
  
  
  def MI():
      return map(int, input().split())
  
  
  def LI():
      return [int(i) for i in input().split()]
  
  
  def LI_():
      return [int(i) - 1 for i in input().split()]
  
  
  def NI(n):
      return [int(input()) for i in range(n)]
  
  
  def NI_(n):
      return [int(input()) - 1 for i in range(n)]
  
  
  def StoI():
      return [ord(i) - 97 for i in input()]
  
  
  def ItoS(nn):
      return chr(nn + 97)
  
  
  def LtoS(ls):
      return "".join([chr(i + 97) for i in ls])
  
  
  def GI(V, E, Directed=False, index=0):
      org_inp = []
      g = [[] for i in range(n)]
      for i in range(E):
          inp = LI()
          org_inp.append(inp)
          if index == 0:
              inp[0] -= 1
              inp[1] -= 1
          if len(inp) == 2:
              a, b = inp
              g[a].append(b)
              if not Directed:
                  g[b].append(a)
          elif len(inp) == 3:
              a, b, c = inp
              aa = (inp[0], inp[2])
              bb = (inp[1], inp[2])
              g[a].append(bb)
              if not Directed:
                  g[b].append(aa)
      return g, org_inp
  
  
  def GGI(h, w, search=None, replacement_of_found=".", mp_def={"#": 1, ".": 0}):
      # h,w,g,sg=GGI(h,w,search=['S','G'],replacement_of_found='.',mp_def={'#':1,'.':0}) # sample usage
      mp = [1] * (w + 2)
      found = {}
      for i in range(h):
          s = input()
          for char in search:
              if char in s:
                  found[char] = (i + 1) * (w + 2) + s.index(char) + 1
                  mp_def[char] = mp_def[replacement_of_found]
          mp += [1] + [mp_def[j] for j in s] + [1]
      mp += [1] * (w + 2)
      return h + 2, w + 2, mp, found
  
  
  def bit_combination(k, n=2):
      rt = []
      for tb in range(n**k):
          s = [tb // (n**bt) % n for bt in range(k)]
          rt += [s]
      return rt
  
  
  def show(*inp, end="\n"):
      if show_flg:
          print(*inp, end=end)
  
  
  YN = ["YES", "NO"]
  
  mo = 10**9 + 7
  inf = float("inf")
  l_alp = string.ascii_lowercase
  u_alp = string.ascii_uppercase
  ts = time.time()
  # sys.setrecursionlimit(10**7)
  input = lambda: sys.stdin.readline().rstrip()
  
  
  def ran_input():
      import random
  
      n = random.randint(4, 16)
      rmin, rmax = 1, 10
      a = [random.randint(rmin, rmax) for _ in range(n)]
      return n, a
  
  
  show_flg = False
  show_flg = True
  
  ans = 0
  
  a, b = LI()
  x = b - a
  ans = x * (x - 1) // 2 - a
  
  print(ans)
  
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"}]