criyle/codenet-compile-errors huggingface dataset:
Language: C++

#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include <utility>
#include <cmath>
#include <tuple>
#include <queue>
#include <bitset>
#include <set>
#include <map>
#include <list>

using ll = long long;
using ld = long double;
using namespace std;
const int INF = 1e9+100;
const ll INF64 = 7e18l;
const int mod = 1000000007;
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define ALL(a) (a).begin(), (a).end()
#define FIN ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);


int main(){
    FIN;

    ll l,r;
    cin >> l >> r;
    ll minmum = 1000000;
    for(ll i=0;i<2030;i++){
        for(ll j=l;j<r;j++){
            num = 0;
            for(ll k=l+1;k<=r;k++){
                minmum = min(minmum,(j*k)%2019);
                num++;
                if(num > 2030) break;
            }
        }
    }

    cout << minmum << endl;
    return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:35:13: error: 'num' was not declared in this scope; did you mean 'enum'?
   35 |             num = 0;
      |             ^~~
      |             enum
Language: C++

#include <bits/stdc++.h>
using namespace std;

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout << setprecision(20) << fixed;

  long long L, R;
  cin >> L >> R;

  if (R - L > 2019) {
    cout << 0 << endl;
  } else {
    int min = 999999;
    for (long long i = L; i < R; i++) {
      for (long long j = i + 1; j <= R; j++) {
        if ((i % 2019 * j % 2019) % 2019 < min) {
          min = i % 2019 * (j % 2019) % 2019;
        }
      }
    }
    cout << min << endl;
    z
  }
}

Compiler output:
a.cc: In function 'int main()':
a.cc:24:5: error: 'z' was not declared in this scope
   24 |     z
      |     ^
Language: C++

#include <iostream>

using namespace std;

int main(int argc, char* argv[]) {
  long long L, R;
  cin >> L >> R;

  int ret = 2020;
  for (long long i = L; i - L <= 2019 * 2 && i <= R; ++i) {
    int m = (i * (i + 1)) % 2019;
    ret = min(m, ret);
  }

  cout << ret << endl;

  return 0;
}
(sokushukai) takuma-2@takuma: ~/work/bootcamp/medium
$ vim 50.cpp
(sokushukai) takuma-2@takuma: ~/work/bootcamp/medium
$ cat 50.cpp
#include <iostream>

using namespace std;

int main(int argc, char* argv[]) {
  long long L, R;
  cin >> L >> R;

  long long ret = 2020;
  for (long long i = L; i - L <= 2019 * 2 && i < R; ++i) {
    long long m = (i * (i + 1)) % 2019;
    ret = min(m, ret);
  }

  cout << ret << endl;

  return 0;
}

Compiler output:
a.cc:19:22: error: stray '@' in program
   19 | (sokushukai) takuma-2@takuma: ~/work/bootcamp/medium
      |                      ^
a.cc:21:22: error: stray '@' in program
   21 | (sokushukai) takuma-2@takuma: ~/work/bootcamp/medium
      |                      ^
a.cc:19:14: error: expected constructor, destructor, or type conversion before 'takuma'
   19 | (sokushukai) takuma-2@takuma: ~/work/bootcamp/medium
      |              ^~~~~~
a.cc:27:5: error: redefinition of 'int main(int, char**)'
   27 | int main(int argc, char* argv[]) {
      |     ^~~~
a.cc:5:5: note: 'int main(int, char**)' previously defined here
    5 | int main(int argc, char* argv[]) {
      |     ^~~~
Language: C++

#include <bits/stdc++.h>
using namespace std;
 
int main() {
  int a,b;
  cin>>a>>b;
  int c=b-a+1;
  if(c>=2018){
    cout<<0<<endl;
  }
  else if{
  vector<int>vec(b-a+1);
  for(int i=0;i<c;i++){
    vec.at(i)=a;
    vec.at(i)%=2019;
    a++;
  }
  sort(vec.begin(),vec.end());
  int x=vec.at(0);
  int y=vec.at(1);
  cout<<x*y<<endl;
  }
}

Compiler output:
a.cc: In function 'int main()':
a.cc:11:10: error: expected '(' before '{' token
   11 |   else if{
      |          ^
      |          (
Language: C++

#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,n) for(int i=1;i<=n;i++)

int main(){
  int l,r;
  cin>>l>>r;
  int min=2018;
  for(int i=l;i<=r;i++){
    int n=i%2019
      if(min>n) min=n;
  }
  cout<<min<<endl;
      
}

Compiler output:
a.cc: In function 'int main()':
a.cc:12:7: error: expected ',' or ';' before 'if'
   12 |       if(min>n) min=n;
      |       ^~
Language: C++

#include <bits/stdc++.h>
using namespace std;
#define ld long double
#define ll long long
#define pb push_back
#define F first
#define S second
const int mod = 1e9+7, A = 1e5+5;

int main()
{
    ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    int l, r;
    cin >> l >> r;
    int ans = 2019;
    if (l + 2019 <= r)
        return cout << 0, 0;
    for (int i = l; i <= r; i++)
    {
        for (int j = i + 1; j <= r; j++)
            ans = min(ans, (1LL * i * j) % 2019);
    }
    cout << ans;
    return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:21:22: error: no matching function for call to 'min(int&, long long int)'
   21 |             ans = min(ans, (1LL * i * j) % 2019);
      |                   ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:21:22: note:   deduced conflicting types for parameter 'const _Tp' ('int' and 'long long int')
   21 |             ans = min(ans, (1LL * i * j) % 2019);
      |                   ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:21:22: note:   mismatched types 'std::initializer_list<_Tp>' and 'int'
   21 |             ans = min(ans, (1LL * i * j) % 2019);
      |                   ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~
Language: C++

#icnlude <bits/stdc++.h>
#include <algorithm>
using namespace std;
 
int main(){
  long l,r;
  cin>>l>>r;
  int m=1<<10;
  for(int i=l;i<l+2019;i++){
    for(int j=i;j<l+2019;i++){
      m=min(m,(i*j)%2019);
    }
  }
  cout<<m<<endl;
}

Compiler output:
a.cc:1:2: error: invalid preprocessing directive #icnlude; did you mean #include?
    1 | #icnlude <bits/stdc++.h>
      |  ^~~~~~~
      |  include
a.cc: In function 'int main()':
a.cc:7:3: error: 'cin' was not declared in this scope
    7 |   cin>>l>>r;
      |   ^~~
a.cc:3:1: note: 'std::cin' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
    2 | #include <algorithm>
  +++ |+#include <iostream>
    3 | using namespace std;
a.cc:14:3: error: 'cout' was not declared in this scope
   14 |   cout<<m<<endl;
      |   ^~~~
a.cc:14:3: note: 'std::cout' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
a.cc:14:12: error: 'endl' was not declared in this scope
   14 |   cout<<m<<endl;
      |            ^~~~
a.cc:3:1: note: 'std::endl' is defined in header '<ostream>'; this is probably fixable by adding '#include <ostream>'
    2 | #include <algorithm>
  +++ |+#include <ostream>
    3 | using namespace std;
Language: C++

#icnlude <bits/stdc++.h>
#include <algorithm>
using namespace std;
 
int main(){
  long l,r;
  cin<<l<<r;
  long m=1<<30;
  for(int i=l;i<l+2019;i++){
    for(int j=i;j<l+2019;i++){
      m=min(m,(i*j)%2019);
    }
  }
  cout<<m<<endl;
}

Compiler output:
a.cc:1:2: error: invalid preprocessing directive #icnlude; did you mean #include?
    1 | #icnlude <bits/stdc++.h>
      |  ^~~~~~~
      |  include
a.cc: In function 'int main()':
a.cc:7:3: error: 'cin' was not declared in this scope
    7 |   cin<<l<<r;
      |   ^~~
a.cc:3:1: note: 'std::cin' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
    2 | #include <algorithm>
  +++ |+#include <iostream>
    3 | using namespace std;
a.cc:11:12: error: no matching function for call to 'min(long int&, int)'
   11 |       m=min(m,(i*j)%2019);
      |         ~~~^~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from a.cc:2:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:11:12: note:   deduced conflicting types for parameter 'const _Tp' ('long int' and 'int')
   11 |       m=min(m,(i*j)%2019);
      |         ~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:11:12: note:   mismatched types 'std::initializer_list<_Tp>' and 'long int'
   11 |       m=min(m,(i*j)%2019);
      |         ~~~^~~~~~~~~~~~~~
a.cc:14:3: error: 'cout' was not declared in this scope
   14 |   cout<<m<<endl;
      |   ^~~~
a.cc:14:3: note: 'std::cout' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
a.cc:14:12: error: 'endl' was not declared in this scope
   14 |   cout<<m<<endl;
      |            ^~~~
a.cc:3:1: note: 'std::endl' is defined in header '<ostream>'; this is probably fixable by adding '#include <ostream>'
    2 | #include <algorithm>
  +++ |+#include <ostream>
    3 | using namespace std;
Language: C++

#icnlude <bits/stdc++.h>
using namespace std;

int main(){
  long l,r;
  cin<<l<<r;
  long m=1.e30;
  for(int i=l;i<l+2019;i++){
    for(int j=i;j<l+2019;i++){
      m=min(m,(i*j)%2019);
    }
  }
  cout<<m<<endl;
}

Compiler output:
a.cc:1:2: error: invalid preprocessing directive #icnlude; did you mean #include?
    1 | #icnlude <bits/stdc++.h>
      |  ^~~~~~~
      |  include
a.cc: In function 'int main()':
a.cc:6:3: error: 'cin' was not declared in this scope
    6 |   cin<<l<<r;
      |   ^~~
a.cc:1:1: note: 'std::cin' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
  +++ |+#include <iostream>
    1 | #icnlude <bits/stdc++.h>
a.cc:7:10: warning: overflow in conversion from 'double' to 'long int' changes value from '1.0e+30' to '9223372036854775807' [-Woverflow]
    7 |   long m=1.e30;
      |          ^~~~~
a.cc:10:9: error: 'min' was not declared in this scope; did you mean 'main'?
   10 |       m=min(m,(i*j)%2019);
      |         ^~~
      |         main
a.cc:13:3: error: 'cout' was not declared in this scope
   13 |   cout<<m<<endl;
      |   ^~~~
a.cc:13:3: note: 'std::cout' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
a.cc:13:12: error: 'endl' was not declared in this scope
   13 |   cout<<m<<endl;
      |            ^~~~
a.cc:1:1: note: 'std::endl' is defined in header '<ostream>'; this is probably fixable by adding '#include <ostream>'
  +++ |+#include <ostream>
    1 | #icnlude <bits/stdc++.h>
Language: C++

#include<bits/stdc++.h>
using namespace std;
int main(){
  long long L,R;
  cin>>L>>R;
  if(R-L+1<2019){
    vector<long long>S(R-L+1);
    for(i=0;i<R-L+1;i++){
      S.at(i)=L+i;
    }
    sort(S.begin(),S.end());
    cout<<(S.at(0)*S.at(1))%2019;
  }
  else{
    cout<<0<<endl;
  }
}

Compiler output:
a.cc: In function 'int main()':
a.cc:8:9: error: 'i' was not declared in this scope
    8 |     for(i=0;i<R-L+1;i++){
      |         ^
Language: C++

#include<cstdio>
#include<iostream>
using namespace std;
int main(void)
{
    long long l,r,mn=4e18;
    scanf("%lld %lld" ,&l,&r);
    if(l/2019!=r/2019)
    {
        printf("0");
        return 0;
    }
    for(int i=l;i<=r;i++)
        for(int j=i+1;j<=r;j++)
        {
//            mn=min(mn,(i%2019)*(j%2019)%2019);
            mn=min(mn, i*j%2019);
        }
    printf("%d" ,mn);
    return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:17:19: error: no matching function for call to 'min(long long int&, int)'
   17 |             mn=min(mn, i*j%2019);
      |                ~~~^~~~~~~~~~~~~~
In file included from /usr/include/c++/14/string:51,
                 from /usr/include/c++/14/bits/locale_classes.h:40,
                 from /usr/include/c++/14/bits/ios_base.h:41,
                 from /usr/include/c++/14/ios:44,
                 from /usr/include/c++/14/ostream:40,
                 from /usr/include/c++/14/iostream:41,
                 from a.cc:2:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:17:19: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
   17 |             mn=min(mn, i*j%2019);
      |                ~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
Language: C++

#include<bits/stdc++.h>

using namespace std;

int main(void){
    long long l, r;
    cin >> l >> r;
    int minj = 2020;
    for(l; l < r; l++){
        for(int j = r; l < j; j--){
            minj = min(minj, l*j%2019);
            if(minj == 0){
                cout << 0 << endl;
                return 0;
            }
        }
    }
    cout << minj << endl;
    return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:11:23: error: no matching function for call to 'min(int&, long long int)'
   11 |             minj = min(minj, l*j%2019);
      |                    ~~~^~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:11:23: note:   deduced conflicting types for parameter 'const _Tp' ('int' and 'long long int')
   11 |             minj = min(minj, l*j%2019);
      |                    ~~~^~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:11:23: note:   mismatched types 'std::initializer_list<_Tp>' and 'int'
   11 |             minj = min(minj, l*j%2019);
      |                    ~~~^~~~~~~~~~~~~~~~
Language: C++

#include<bits/stdc++.h>
using namespace std;

int main(){
	long long L, R, ans = 2020;
	cin >> L >> R;
	for(long long i = L ; i <= R ; i++){
		if(i%2019 == 0){
			cout << "0" << endl;
			return 0;
		}
	}
	for(long long i = L ; i <= L+2020 ; i++){
		ans = (ans < ((i%2019)*((i+1)%2019))%2019) ans : ((i%2019)*((i+1)%2019))%2019;
	}
	cout << ans << endl;
	
	return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:14:59: error: expected ';' before 'ans'
   14 |                 ans = (ans < ((i%2019)*((i+1)%2019))%2019) ans : ((i%2019)*((i+1)%2019))%2019;
      |                                                           ^~~~
      |                                                           ;
Language: C++

#include<bits/stdc++.h>
using namespace std;

int main(){
	long long L, R, ans = 2020;
	cin >> L >> R;
	
	for(int i = L ; i <= R ; i++)
		ans = min(ans, (i%2019)*((i+1)%2019));
	
	cout << ans << endl;
	
	return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:9:26: error: no matching function for call to 'min(long long int&, int)'
    9 |                 ans = min(ans, (i%2019)*((i+1)%2019));
      |                       ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:9:26: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
    9 |                 ans = min(ans, (i%2019)*((i+1)%2019));
      |                       ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:9:26: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
    9 |                 ans = min(ans, (i%2019)*((i+1)%2019));
      |                       ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
Language: C++

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int INF=0x3fffffff;
const ll MOD=1000000007;
const ll MODD=998244353;
#define rrep(i,n) for(ll i=(ll)(n)-1;i>=0;i--)
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
#define rep(i,n) REP(i,0,n)
template<typename T> bool chmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
template<typename T> bool chmin(T &m, const T q) { if (m > q) {m = q; return true;} else return false; }
  
int main()
{
    ll l, r;
    cin >> l >> r;
    if(r < l+2019){
      if(l%2019 < r%2019){
        cout << min(((l%2019)*((l+1)%2019))%2019, ((r%2019)*((r-1)%2019))%2019)) << "\n";
        return(0);
      }
    }
    cout << 0 << "\n";
}

Compiler output:
a.cc: In function 'int main()':
a.cc:19:80: error: expected ';' before ')' token
   19 |         cout << min(((l%2019)*((l+1)%2019))%2019, ((r%2019)*((r-1)%2019))%2019)) << "\n";
      |                                                                                ^
      |                                                                                ;
Language: C++

#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
typedef long long ll;
 
int main(){
  int l,r;
  cin>>l>>r;
  int ans=2018;
  r=min(r,l+4038);
  for(ll i=l;i<=r;i++){
    for(ll j=i+1;j<=r;j++){
      
      ans=min(ans,i*j%2019);
    }
  }
  cout<<ans<<endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:14:14: error: no matching function for call to 'min(int&, ll)'
   14 |       ans=min(ans,i*j%2019);
      |           ~~~^~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:14:14: note:   deduced conflicting types for parameter 'const _Tp' ('int' and 'll' {aka 'long long int'})
   14 |       ans=min(ans,i*j%2019);
      |           ~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:14:14: note:   mismatched types 'std::initializer_list<_Tp>' and 'int'
   14 |       ans=min(ans,i*j%2019);
      |           ~~~^~~~~~~~~~~~~~
Language: C++

#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
typedef long long ll;
 
int main(){
  int l,r;
  cin>>l>>r;
  int ans=2018;
  r=min(r,l+4038);
  for(ll i=l;i<=r;i++){
    for(ll j=i+1;j<=r;j++){
      ans=min(i*j%2019,ans);
    }
  }
  cout<<ans<<endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:13:14: error: no matching function for call to 'min(ll, int&)'
   13 |       ans=min(i*j%2019,ans);
      |           ~~~^~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:13:14: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
   13 |       ans=min(i*j%2019,ans);
      |           ~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:13:14: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
   13 |       ans=min(i*j%2019,ans);
      |           ~~~^~~~~~~~~~~~~~
Language: C++

#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
typedef long long ll;

int main(){
  int l,r;
  ll ans;
  cin>>l>>r;
  if(r-l+1>=2019){
    cout<<0<<endl;
    return 0;
  }else{
    a=l;
    b=l+1;
    ans=a*b;
    ans%=2019;
  }
  cout<<ans<<endl;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:14:5: error: 'a' was not declared in this scope
   14 |     a=l;
      |     ^
a.cc:15:5: error: 'b' was not declared in this scope
   15 |     b=l+1;
      |     ^
Language: C++

#include<bits/stdc++.h>
using namespace std;
int main(){
    int l,r;
    cin >> l >> r;
    int min=10000000;
    for(int i=l;i<=r&&l+2019;i++){
        (int j=l+1;j<=r&&j<l+2019;j++){
            int now=(i*j)%2019;
            if(min>now)min=now;
        }
    }
    cout << min;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:8:10: error: expected primary-expression before 'int'
    8 |         (int j=l+1;j<=r&&j<l+2019;j++){
      |          ^~~
a.cc:8:10: error: expected ')' before 'int'
    8 |         (int j=l+1;j<=r&&j<l+2019;j++){
      |         ~^~~
      |          )
a.cc:8:20: error: 'j' was not declared in this scope
    8 |         (int j=l+1;j<=r&&j<l+2019;j++){
      |                    ^
Language: C++

#include<bits/stdc++.h>
using namespace std;
int main(){
    int l,r;
    cin >> l >> r;
    int min=10000000;
    for(int i=l;i<=r&&l+2019;i++){
        (int j=i+1;j<=r&&j<l+2019;j++){
            int now=(i*j)%2019;
            if(min>now)min=now;
        }
    }
    cout << min;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:8:10: error: expected primary-expression before 'int'
    8 |         (int j=i+1;j<=r&&j<l+2019;j++){
      |          ^~~
a.cc:8:10: error: expected ')' before 'int'
    8 |         (int j=i+1;j<=r&&j<l+2019;j++){
      |         ~^~~
      |          )
a.cc:8:20: error: 'j' was not declared in this scope
    8 |         (int j=i+1;j<=r&&j<l+2019;j++){
      |                    ^
Language: C++

#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0;i < (n);i++)
using namespace std;
using ll = long long;

int main(){
    ll l,r;
    int ans = 2020;
    cin >> l >> r;
    for(ll i = l;i <= r;i++){
        for(ll j = i+1;j <= r;j++){
            ans = min(ans,i*j%2019);
        }
    }
    cout << ans << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:12:22: error: no matching function for call to 'min(int&, ll)'
   12 |             ans = min(ans,i*j%2019);
      |                   ~~~^~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:12:22: note:   deduced conflicting types for parameter 'const _Tp' ('int' and 'll' {aka 'long long int'})
   12 |             ans = min(ans,i*j%2019);
      |                   ~~~^~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:12:22: note:   mismatched types 'std::initializer_list<_Tp>' and 'int'
   12 |             ans = min(ans,i*j%2019);
      |                   ~~~^~~~~~~~~~~~~~
Language: C++

#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0;i < (n);i++)
using namespace std;
using ll = long long;

int main(){
    ll l,r;
    cin >> l >> r;
    for(ll i = l;i <= r;i++){
        for(ll j = i+1;j <= r;j++){
            ans = min(ans,i*j%2019);
        }
    }
    cout << ans << endl;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:11:13: error: 'ans' was not declared in this scope; did you mean 'abs'?
   11 |             ans = min(ans,i*j%2019);
      |             ^~~
      |             abs
a.cc:14:13: error: 'ans' was not declared in this scope; did you mean 'abs'?
   14 |     cout << ans << endl;
      |             ^~~
      |             abs
Language: C

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
int main(void){
    long sup,inf;
    scanf("%ld %ld",&sup,&inf);
    int min=2019;
    long i,j;
    int mod;
    for(i=sup;i<=inf;i++){
        for(j=sup;j<i;j++){
            mod=(i*j)%2019;
            /*if(mod==1){
                //printf("(%ld,%ld)\n",i,j);
                printf("1");
                return 0;
            }*/
            else if(mod<min){
                min=mod;
            }
        }
    }
    printf("%d",min);
    return 0;
}

Compiler output:
main.c: In function 'main':
main.c:19:13: error: 'else' without a previous 'if'
   19 |             else if(mod<min){
      |             ^~~~
Language: C++

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;

int main(){
    ll L,R;
    cin >> L >> R;
    L%=2019;
    R%=2019;
    int ans-2018;
    if(L>=R) ans=0;
    for(int i=L;i<R;i++){
        for(int j=i+1;j<=R;j++){
            ans = min(ans,i*j%2019);
        }
    }
    cout << ans << endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:11:12: error: expected initializer before '-' token
   11 |     int ans-2018;
      |            ^
a.cc:12:14: error: 'ans' was not declared in this scope; did you mean 'abs'?
   12 |     if(L>=R) ans=0;
      |              ^~~
      |              abs
a.cc:15:13: error: 'ans' was not declared in this scope; did you mean 'abs'?
   15 |             ans = min(ans,i*j%2019);
      |             ^~~
      |             abs
a.cc:18:13: error: 'ans' was not declared in this scope; did you mean 'abs'?
   18 |     cout << ans << endl;
      |             ^~~
      |             abs
Language: C

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <limits.h>

#define max 10

//qsort(str, n, sizeof(int), up_comp);
int up_comp(const void *a, const void *b){return *(int*)a - *(int*)b;}
int down_comp(const void *a, const void *b){return *(int*)b - *(int*)a;}

int main()
{
    long long int l, r, i, j, ans, k, cccon=LLONG_MAX;
    
    scanf("%lld %lld", &l, &r);
    
    for (i=l; i<j; i++) {
        for (j=i+1; j<=r; j++) {
            ans=0;
            ans=(i*j)%2019;
            if (ans!=0) {
                cccon=fmin(ans, con);
            } else {
                break;
            }
        }
    }
    
    printf("%lld", cccon);
    
    return 0;
}


Compiler output:
main.c: In function 'main':
main.c:24:33: error: 'con' undeclared (first use in this function); did you mean 'cos'?
   24 |                 cccon=fmin(ans, con);
      |                                 ^~~
      |                                 cos
main.c:24:33: note: each undeclared identifier is reported only once for each function it appears in
Language: C++

#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
typedef long long ll;
int main()
{
    ll l, r;
    cin >> l >> r;
    if (l <= 2019 && r <= 2019)
    {
        cout << (l % 2019) * (r % 2019) << endl;
    }
    else
    {
        ll i = l % 2019;
        ll j = LLONG_MAX;
        for (ll x = l + 1; x <= r; x++)
        {
            if (x % 2019 < j)
            {
                j = x % 2019;
            }
        }

        cout << i * j << endl;
        return 0;
    }
}


Compiler output:
a.cc: In function 'int main()':
a.cc:17:16: error: 'LLONG_MAX' was not declared in this scope
   17 |         ll j = LLONG_MAX;
      |                ^~~~~~~~~
a.cc:4:1: note: 'LLONG_MAX' is defined in header '<climits>'; this is probably fixable by adding '#include <climits>'
    3 | #include <iostream>
  +++ |+#include <climits>
    4 | using namespace std;
Language: C++

#include <iostream>
using namespace std;

int main() {
  ll l,r; 
  cin >>l>>r;
  if (r-l > 3000){
    cout << 0 << endl;
  else {
    ll res = 2018;
    for (ll i = l; i < r; ++i){
      for (ll j = i+1; j <= r; ++j){
        res = min(res, (i * j) % 2019);
      }
    }
    cout << res << endl;
  }
}

Compiler output:
a.cc: In function 'int main()':
a.cc:5:3: error: 'll' was not declared in this scope
    5 |   ll l,r;
      |   ^~
a.cc:6:9: error: 'l' was not declared in this scope
    6 |   cin >>l>>r;
      |         ^
a.cc:6:12: error: 'r' was not declared in this scope
    6 |   cin >>l>>r;
      |            ^
a.cc:9:3: error: expected '}' before 'else'
    9 |   else {
      |   ^~~~
a.cc:7:18: note: to match this '{'
    7 |   if (r-l > 3000){
      |                  ^
a.cc:10:7: error: expected ';' before 'res'
   10 |     ll res = 2018;
      |       ^~~~
      |       ;
a.cc:11:12: error: expected ';' before 'i'
   11 |     for (ll i = l; i < r; ++i){
      |            ^~
      |            ;
a.cc:11:20: error: 'i' was not declared in this scope
   11 |     for (ll i = l; i < r; ++i){
      |                    ^
a.cc:12:14: error: expected ';' before 'j'
   12 |       for (ll j = i+1; j <= r; ++j){
      |              ^~
      |              ;
a.cc:12:24: error: 'j' was not declared in this scope
   12 |       for (ll j = i+1; j <= r; ++j){
      |                        ^
a.cc:13:9: error: 'res' was not declared in this scope
   13 |         res = min(res, (i * j) % 2019);
      |         ^~~
a.cc:16:13: error: 'res' was not declared in this scope
   16 |     cout << res << endl;
      |             ^~~
Language: C++

#include<bits/stdc++.h>
#define REP(N) for(int i = 0; i < N; i++)
using namespace std;
const int MOD = 2019;
 
int main(){
  long long int L, R; cin >>L >>R;
  long long int ans = 1e9 * 3;
  for(int i = L; i <= R; i++){
    for(int j = i + 1; j <= R; j++){
      ans = min(ans, ((i % MOD) * (j % MOD)) % MOD);
    }
  }
  cout <<ans <<endl;
  return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:11:16: error: no matching function for call to 'min(long long int&, int)'
   11 |       ans = min(ans, ((i % MOD) * (j % MOD)) % MOD);
      |             ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:11:16: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
   11 |       ans = min(ans, ((i % MOD) * (j % MOD)) % MOD);
      |             ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:11:16: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
   11 |       ans = min(ans, ((i % MOD) * (j % MOD)) % MOD);
      |             ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Language: C++

#include <bits/stdc++.h>
using namespace std;
#define QOEINDIEDIS freesteed
#define rep(i,a,n) for (int i=a;i<n;i++)
#define pb push_back
#define fill(x,c) memset(x,c,sizeof(x))
#define fi first
#define se second
#define sz(A) (int)(A.size())
#define all(x) (x).begin(),(x).end()
#define caset int ___T; cin>>___T; for(int cs=1;cs<=___T;cs++)
#define get(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
typedef long long ll;
typedef pair<int,int> PII;
typedef vector<int> VI;
const ll mod=1e9+7;
const int Max = 1e6+10;
ll powmod(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
void solve(){
	ll l,r;
	cin>>l>>r;
	if(r-l+1>=2019){ 
		cout<<0;
		return; 
	} 
	int ans = 1e9;
	for(int i=l;i<=r;i++){
		for(int j=i+1;j<=r;j++){
			ans = min(ans,(1LL*j*i)%2019);
		}
	}
	cout<<ans;
}
int main() {
	ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	//caset{
		solve();
	//}
  	return 0;
}






Compiler output:
a.cc: In function 'void solve()':
a.cc:29:34: error: no matching function for call to 'min(int&, long long int)'
   29 |                         ans = min(ans,(1LL*j*i)%2019);
      |                               ~~~^~~~~~~~~~~~~~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:29:34: note:   deduced conflicting types for parameter 'const _Tp' ('int' and 'long long int')
   29 |                         ans = min(ans,(1LL*j*i)%2019);
      |                               ~~~^~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:29:34: note:   mismatched types 'std::initializer_list<_Tp>' and 'int'
   29 |                         ans = min(ans,(1LL*j*i)%2019);
      |                               ~~~^~~~~~~~~~~~~~~~~~~~
Language: C

#include <stdio.h>

int main()
{
	long long int L, R, ans=2020, tmp i, j;
	
	scanf("%lld %lld", &L, &R);
	
	if(L-R==0) ans=0;
	else {
		for(i=L; i<R; i++){
			for(j=i+1; j<=R; j++){ 
				tmp=(i*j)%2019;
				if(ans>tmp)ans=tmp;
			}
		}
	}
	
	printf("%lld", ans);
				
	
return 0;
}

Compiler output:
main.c: In function 'main':
main.c:5:43: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'i'
    5 |         long long int L, R, ans=2020, tmp i, j;
      |                                           ^
main.c:11:21: error: 'i' undeclared (first use in this function)
   11 |                 for(i=L; i<R; i++){
      |                     ^
main.c:11:21: note: each undeclared identifier is reported only once for each function it appears in
main.c:12:29: error: 'j' undeclared (first use in this function)
   12 |                         for(j=i+1; j<=R; j++){
      |                             ^
main.c:13:33: error: 'tmp' undeclared (first use in this function)
   13 |                                 tmp=(i*j)%2019;
      |                                 ^~~
Language: C++

#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
const ll mod = 2019;

int main() {
  ll l,r;
  ll ans = 3000;
  cin >> l >> r;
  r = min(r, l+3000);
  for(int i = l; i < r; ++i) {
    for(int j = i+1; j <= r; ++j) {
      int x = i*j%mod;
      ans = min(ans, x);
    }
  }
  cout << ans << endl;
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:16:16: error: no matching function for call to 'min(ll&, int&)'
   16 |       ans = min(ans, x);
      |             ~~~^~~~~~~~
In file included from /usr/include/c++/14/algorithm:60,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algobase.h:233:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::min(const _Tp&, const _Tp&)'
  233 |     min(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:233:5: note:   template argument deduction/substitution failed:
a.cc:16:16: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
   16 |       ans = min(ans, x);
      |             ~~~^~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::min(const _Tp&, const _Tp&, _Compare)'
  281 |     min(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:281:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5686:5: note: candidate: 'template<class _Tp> constexpr _Tp std::min(initializer_list<_Tp>)'
 5686 |     min(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5686:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5696:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::min(initializer_list<_Tp>, _Compare)'
 5696 |     min(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5696:5: note:   template argument deduction/substitution failed:
a.cc:16:16: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
   16 |       ans = min(ans, x);
      |             ~~~^~~~~~~~
Language: C++

#include <bits/stdc++.h>
using namespace std ; 
typedef long long ll ;   
 
int main () {
    ll l , r , a , b ,rem = -1 ;
    cin >> l >> r ;
    if ( l / 2019 < r / 2019) cout <<0<< endl ;
    else {
        l % = 2019 ,r % = 2019 ;
        ll i = l , j = r ;
        for ( i = l ; i < r ; i ++) {
            for ( j = i + 1 ; j <= r ; j ++) {
                if ( rem ==- 1 ) rem = ( i * j )% 2019 ;
                rem = min ( rem , ( i * j )% 2019 );
        }
        cout << rem << endl ;
    }
}
}

Compiler output:
a.cc: In function 'int main()':
a.cc:10:13: error: expected primary-expression before '=' token
   10 |         l % = 2019 ,r % = 2019 ;
      |             ^
a.cc:10:25: error: expected primary-expression before '=' token
   10 |         l % = 2019 ,r % = 2019 ;
      |                         ^
Language: C++

#include <bits/stdc ++.h >
using namespace std ; 
typedef long long ll ;   
 
int main () {
    ll l , r , a , b ,rem = -1 ;
    cin >> l >> r ;
    if ( l / 2019 < r / 2019) cout <<0<< endl ;
    else {
        l % = 2019 ,r % = 2019 ;
        ll i = l , j = r ;
        for ( i = l ; i < r ; i ++) {
            for ( j = i + 1 ; j <= r ; j ++) {
                if ( rem ==- 1 ) rem = ( i * j )% 2019 ;
                rem = min ( rem , ( i * j )% 2019 );
        }
        cout << rem << endl ;
    }
}
}

Compiler output:
a.cc:1:10: fatal error: bits/stdc ++.h : No such file or directory
    1 | #include <bits/stdc ++.h >
      |          ^~~~~~~~~~~~~~~~~
compilation terminated.
Language: C++

#include < bits / stdc ++. h >
using namespace std ; 
typedef long long ll ;   
 
int main () {
    ll l , r , a , b ,rem = -1 ;
    cin >> l >> r ;
    if ( l / 2019 < r / 2019) cout <<0<< endl ;
    else {
        l % = 2019 ,r % = 2019 ;
        ll i = l , j = r ;
        for ( i = l ; i < r ; i ++) {
            for ( j = i + 1 ; j <= r ; j ++) {
                if ( rem ==- 1 ) rem = ( i * j )% 2019 ;
                rem = min ( rem , ( i * j )% 2019 );
        }
        cout << rem << endl ;
    }
}
}

Compiler output:
a.cc:1:10: fatal error:  bits / stdc ++. h : No such file or directory
    1 | #include < bits / stdc ++. h >
      |          ^~~~~~~~~~~~~~~~~~~~~
compilation terminated.
Language: C++

#include<bits/stdc++.h>
using namespace std;
typedef  long long ll;

int main(){
    ll l,r,a,b;
    ll rem=-1;
    cin>>l>>r;
    if(l/2019LL<r/2019LL)cout<<0<<endl;
    else{
        l%=2019LL;
        r%=2019LL;
        ll i=l,j=r;
        for( i=l;i<r;i++){
            for( j=i+1;j<=r;j++){
                if(rem==-1)rem=(i*j)%2019;
                rem=min(rem,(i*j)%2019);
        }
        cout<<rem<<endl;
    }
}


Compiler output:
a.cc: In function 'int main()':
a.cc:21:2: error: expected '}' at end of input
   21 | }
      |  ^
a.cc:5:11: note: to match this '{'
    5 | int main(){
      |           ^