// clang-format off
	#define BADSEED chrono::high_resolution_clock::now().time_since_epoch().count()
	#include <bits/stdc++.h>
	using namespace std;
	using uint = unsigned int;
	#define TM_(...) template <class __VA_ARGS__>
	#define ENABLE(...) TM_(T) static enable_if_t<__VA_ARGS__>
	#define SFINAE(name, ...)                                                  \
		TM_(, class = void) struct name##_s : false_type {};                   \
		TM_(T) struct name##_s<T, decltype(void(__VA_ARGS__))> : true_type {}; \
		TM_(T) constexpr bool name = name##_s<T>::value;
	ostream &operator<<(ostream &os, int8_t c) { return os << static_cast<int>(c); }
	namespace narut {
		TM_(T) using TupSz = tuple_size<decay_t<T>>;
		SFINAE(Iterable, begin(declval<T &>()))
		SFINAE(IsTuple, TupSz<T>{})
		SFINAE(Coutable, cout << declval<T &>())
		SFINAE(Cinable, cin >> declval<T &>())
		TM_(T) constexpr char Spc(T &&) { return (Iterable<T> or IsTuple<T>) ? '\n' : ' '; }
		template <ostream &os, bool Red> struct Writer {
			ENABLE(Coutable<T>) Write(T const &t) { os << t; }
			ENABLE(!Coutable<T> and Iterable<T>) Write(T const &t) {
				auto it = begin(t), e = end(t);
				if (it != e) Write(*it++);
				for (; it != e; Write(*it++)) os << Spc(*it);
			}
			TM_(T, size_t... Is) static void WriteTup(T const &t, index_sequence<Is...>) {
				(void)(int[]){0, ((Is == 0) ? 0 : ((os << ' '), 0), Write(get<Is>(t)), 0)...};
			}
			ENABLE(!Coutable<T> and !Iterable<T> and IsTuple<T>) Write(T const &t) {
				WriteTup(t, make_index_sequence<TupSz<T>::value>{});
			}
			void operator()() const { os << '\n'; }
			TM_(F, class... Ts) void operator()(F const &f, Ts const &... ts) {
				if (Red) os << "\033[0;31m";
				Write(f);
				(void)(int[]){0, (os << ' ', Write(ts), 0)...};
				if (Red)
					os << "\033[0m\n";
				else
					os << '\n';
			}
		};
		struct Cin {
			ENABLE(Cinable<T>) Read(T &t) { cin >> t; }
			ENABLE(!Cinable<T> and Iterable<T>) Read(T &t) {
				for (auto &&x : t) Read(x);
			}
			TM_(T, size_t... Is) static void ReadTup(T &t, index_sequence<Is...>) {
				(void)(int[]){0, (Read(get<Is>(t)), 0)...};
			}
			ENABLE(!Cinable<T> and !Iterable<T> and IsTuple<T>) Read(T &t) {
				ReadTup(t, make_index_sequence<TupSz<T>::value>{});
			}
			TM_(T) void operator()(T &t) const { Read(t); }
			TM_(T) void operator()(T &t, uint n) const { t.resize(n), Read(t); }
			TM_(T) operator T() const {
				T t;
				return Read(t), t;
			}
		};
		struct Big {
			TM_(T) constexpr operator T() const { return static_cast<T>(0x3f3f3f3f3f3f3f3f); }
		};
	} // namespace narut
	narut::Cin Cin;
	narut::Writer<cout, false> Cout;
	narut::Big Big;
	using ll = long long;
	#define FOR(i, j, n) for (int i = static_cast<int>(j); i < static_cast<int>(n); ++i)
	#define ROF(i, j, n) for (int i = static_cast<int>(n) - 1; i >= static_cast<int>(j); --i)
	#ifdef NARUT_LOCAL
	narut::Writer<cerr, true> Cerr;
	#define DBG(...) __VA_ARGS__
	#define Debug(...) Cerr(__VA_ARGS__)
	#else
	#define Debug(...) 0
	#define DBG(...)
	#endif
	#ifndef BADSEED
	#define BADSEED random_device{}()
	#endif

// clang-format on

const int M =2019;

ll L,R;

array<int, M> cnt;

auto Run()
{
	cin>>L>>R;
	
	FOR(i,L,R+1) {
		int j = i % 2019;
		if (cnt[j]==2) break;
		cnt[j]++;
	}

	int mn = (L*R)%2019;

	FOR(i,0,M) if (cnt[i] > 1) mn = min(mn, (i*i)%2019);
	FOR(i,0,M) {
		if (cnt[i]==0)continue;
		FOR(j,i+1,M) {
			if (cnt[j]==0) continue;
			mn = min(mn, (i*j)%2019);
		}
	}	
	
	cout<<mn;
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout << fixed << setprecision(10);
#ifdef NARUT_LOCAL
	cerr << fixed << setprecision(10);
	assert(freopen("./io/test.in", "r", stdin));
	assert(freopen("./io/test.out", "w", stdout));
#endif

	Run();
}


Measured memory_bytes: 256