output_description: Print the minimum possible value of (i \times j) \mbox{ mod } 2019 when i and
  j are chosen under the given condition.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      L R
attempt: # coding: utf-8
  import sys
  
  # import bisect
  # import math
  # import numpy as np
  # from fractions import gcd
  
  """Template"""
  
  
  class IP:
      """
      入力を取得するクラス
      """
  
      def __init__(self):
          self.input = sys.stdin.readline
  
      def I(self):
          """
          1文字の取得に使います
          :return: int
          """
          return int(self.input())
  
      def S(self):
          """
          1文字の取得(str
          :return: str
          """
          return self.input()
  
      def IL(self):
          """
          1行を空白で区切りリストにします(int
          :return: リスト
          """
          return list(map(int, self.input().split()))
  
      def SL(self):
          """
          1行の文字列を空白区切りでリストにします
          :return: リスト
          """
          return list(map(str, self.input().split()))
  
      def ILS(self, n):
          """
          1列丸々取得します(int
          :param n: 行数
          :return: リスト
          """
          return [int(self.input()) for _ in range(n)]
  
      def SLS(self, n):
          """
          1列丸々取得します（str
          :param n: 行数
          :return: リスト
          """
          return [self.input() for _ in range(n)]
  
      def SILS(self, n):
          """
          Some Int LineS
          横に複数、縦にも複数
          :param n: 行数
          :return: list
          """
          return [self.IL() for _ in range(n)]
  
      def SSLS(self, n):
          """
          Some String LineS
          :param n: 行数
          :return: list
          """
          return [self.SL() for _ in range(n)]
  
  
  class Idea:
      def __init__(self):
          pass
  
      def HF(self, p):
          """
          Half enumeration
          半分全列挙です
          pの要素の和の組み合わせを作ります。
          ソート、重複削除行います
          :param p: list : 元となるリスト
          :return: list : 組み合わせられた和のリスト
          """
          return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))
  
      def Bfs2(self, a):
          """
          bit_full_search2
          bit全探索の改良版
          全探索させたら2進数のリストと10進数のリストを返す
          :return: list２つ : １個目 2進数(16桁)  2個目 10進数
          """
          # 参考
          # https://blog.rossywhite.com/2018/08/06/bit-search/
          # https://atcoder.jp/contests/abc105/submissions/4088632
          value = []
          for i in range(1 << len(a)):
              output = []
  
              for j in range(len(a)):
                  if self.bit_o(i, j):
                      """右からj+1番目のiが1かどうか判定"""
                      # output.append(a[j])
                      output.append(a[j])
              value.append([format(i, "b").zfill(16), sum(output)])
  
          value.sort(key=lambda x: x[1])
          bin = [value[k][0] for k in range(len(value))]
          val = [value[k][1] for k in range(len(value))]
          return bin, val
  
      def S(self, s, r=0, m=-1):
          """
          ソート関係行います。色々な設定あります。
          :param s: 元となるリスト
          :param r: reversするかどうか 0=False 1=True
          :param m: （2次元配列）何番目のインデックスのソートなのか
          :return: None
          """
          r = bool(r)
          if m == -1:
              s.sort(reverse=r)
          else:
              s.sort(reverse=r, key=lambda x: x[m])
  
      def bit_n(self, a, b):
          """
          bit探索で使います。0以上のときにTrue出します
          自然数だからn
          :param a: int
          :param b: int
          :return: bool
          """
          return bool((a >> b & 1) > 0)
  
      def bit_o(self, a, b):
          """
          bit探索で使います。1のときにTrue出すよ
          oneで1
          :param a: int
          :param b: int
          :return: bool
          """
          return bool(((a >> b) & 1) == 1)
  
      def ceil(self, x, y):
          """
          Round up
          小数点切り上げ割り算
          :param x: int
          :param y: int
          :return: int
          """
          return -(-x // y)
  
      def ave(self, a):
          """
          平均を求めます
          :param a: list
          :return: int
          """
          return sum(a) / len(a)
  
      def gcd(self, x, y):
          if y == 0:
              return x
          else:
              return self.gcd(y, x % y)
  
      def lcm(self, x, y):
          return (x * y) // self.gcd(x, y)
  
  
  """ここからメインコード"""
  
  
  def main():
      # 1文字に省略
      r, e = range, enumerate
      ip = IP()
      id = Idea()
  
      """この下から書いてね"""
      l, r = ip.IL()
      a = l % 2019
      b = r % 2019
      # print(a, b)
      memo1 = id.ceil(l, 2019) * 2019
      # print(memo1)
      if memo1 <= r:
          if memo1 + 2019 >= 2019:
              print(0)
          else:
              print(2)
      else:
          memo2 = l // 2019 * 2019
          memo3 = id.ceil(r, 2019) * 2019
          #  print(memo2, memo3)
          if l - memo2 <= memo3 - r:
              # print("koko")
              print((l * (l + 1)) % 2019)
          else:
              print((r * (r - 1)) % 2019)
  
  
  main()
  
problem_description: Statement
  
  You are given two non-negative integers L and R. We will choose two integers i
  and j such that L \leq i < j \leq R. Find the minimum possible value of (i
  \times j) \mbox{ mod } 2019.
samples: [{"input": "2020 2040", "output": "2\n    \n\nWhen (i, j) = (2020, 2021), (i \\times j) \\mbox{ mod } 2019 = 2.\n\n* * *"}, {"input": "4 5", "output": "20\n    \n\nWe have only one choice: (i, j) = (4, 5)."}]