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

#include <bits/stdc++.h>
#include <math.h>
#include <cmath>
#define fio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
int main()
{
  fio;
  int a,b,c,d;
  cin>>a>>b>>c>>d;
  ll p1,p2,p3,p4;
  p1=a*c;
  p2=a*d;
  p3=b*d;
  p4=b*c;
  ll z=max(p1,p2);
  z=max(z,p3);
  z=max(z,p4);
  cout<<z<<endl;
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:11:3: error: 'll' was not declared in this scope
   11 |   ll p1,p2,p3,p4;
      |   ^~
a.cc:12:3: error: 'p1' was not declared in this scope; did you mean 'y1'?
   12 |   p1=a*c;
      |   ^~
      |   y1
a.cc:13:3: error: 'p2' was not declared in this scope
   13 |   p2=a*d;
      |   ^~
a.cc:14:3: error: 'p3' was not declared in this scope
   14 |   p3=b*d;
      |   ^~
a.cc:15:3: error: 'p4' was not declared in this scope
   15 |   p4=b*c;
      |   ^~
a.cc:16:5: error: expected ';' before 'z'
   16 |   ll z=max(p1,p2);
      |     ^~
      |     ;
a.cc:17:3: error: 'z' was not declared in this scope
   17 |   z=max(z,p3);
      |   ^
Language: C++

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

#define     fast()              ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); 
#define     ll                  long long int
#define     test()              ll t; cin>>t; while(t--) 
#define     lp0(i,begin,end)    for(ll i=begin;i<end;i++)
#define     lp1(i,begin,end)    for(ll i=begin;i<=end;i++)
#define     rlp(i,begin,end)    for(ll i=end;i>=begin;i--)
#define     prec(n)             fixed<<setprecision(n)
#define     initial(a,i)        memset(a,i,sizeof(a))
#define     pb                  push_back
#define     PI                  3.1415926535897932384626433832795
#define     MOD                 1000000007
#define     F                   first
#define     S                   second
#define     all(a)              (a).begin(),(a).end()
#define     BPC(x)              __builtin_popcountll(x)
#define     gcd(a,b)            __gcd(a,b)

ll gcd(ll a,ll b) {if (a==0) return b;return gcd(b%a,a);}

ll power(ll x,ll n)
{
    ll result = 1;
    while (n)
    {
        if (n & 1)
            result = result * x;
        n = n / 2;
        x = x * x;
    }
    return result;
}


// Solution Function
void solution(ll compte)
{
    // cout<<compte<<"\n";

    ll a,b,c,d;
    cin>>a>>b>>c>>d;
    ll p1 = a*c;
    ll p2 =a *d;
    ll p3 = b*c;
    ll p4 = b*d;

    ll ans = max(p1,max(p2,max(p3,p4)));
    cout<<Ans<<"\n";
}

// Driver Function
int main()
{
    ll compte = 1;
    //test()
    //{
        solution(compte);
        compte++;
    //}
    return 0;
}


Compiler output:
a.cc: In function 'void solution(long long int)':
a.cc:51:11: error: 'Ans' was not declared in this scope; did you mean 'ans'?
   51 |     cout<<Ans<<"\n";
      |           ^~~
      |           ans
Language: C++

a,b,c,d=map(int,input().split( ))
mx=-1000000000
mx=max(mx,a*c);
mx=max(mx,a*d);
mx=max(mx,b*c);
mx=max(mx,b*d);
print(mx)

Compiler output:
a.cc:1:1: error: 'a' does not name a type
    1 | a,b,c,d=map(int,input().split( ))
      | ^
a.cc:4:1: error: 'mx' does not name a type
    4 | mx=max(mx,a*d);
      | ^~
a.cc:5:1: error: 'mx' does not name a type
    5 | mx=max(mx,b*c);
      | ^~
a.cc:6:1: error: 'mx' does not name a type
    6 | mx=max(mx,b*d);
      | ^~
a.cc:7:6: error: expected constructor, destructor, or type conversion before '(' token
    7 | print(mx)
      |      ^
Language: Java

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);

		int a=s.nextInt();
      	int b=s.nextInt();
      	int c=s.nextInt();
      	int d=s.nextInt();
      	int p1=a*c;
      	int p2=a*d;
      	int p3=b*c;
      	int p4=b*d;

		int[] a = new int[]{p1,p2,p3,p4};
      	int max;
      	for(int i=0;i<4;i++)
        {
          if(i==0)
          {
            max=a[0];
          }
          else if(a[i]>=max)
          {
            max=a[i];
          }
        }
      	System.out.println(max+"");
	}
}


Compiler output:
Main.java:16: error: variable a is already defined in method main(String[])
		int[] a = new int[]{p1,p2,p3,p4};
		      ^
1 error
Language: C++

#include <bits/stdc++.h>
using namespace std;
 
int main() {
  int a,b,c,d,num1;num2,num3,num4,num5,num6;
  cin >> a >> b >> c >> d;
  num1=a*c;
  num2=a*d;
  num3=b*c;
  num4=b*d;
  if(num1>num2){
      num5=num1;
  }else{
      num5=num2;
  }
  if(num3>num4){
      num6=num3;
  }else{
      num6=num4;
  }
  if(num5>num6){
      cout << num5;
  }else{
      cout << num6;
  }
}

Compiler output:
a.cc: In function 'int main()':
a.cc:5:20: error: 'num2' was not declared in this scope; did you mean 'num1'?
    5 |   int a,b,c,d,num1;num2,num3,num4,num5,num6;
      |                    ^~~~
      |                    num1
a.cc:5:25: error: 'num3' was not declared in this scope; did you mean 'num1'?
    5 |   int a,b,c,d,num1;num2,num3,num4,num5,num6;
      |                         ^~~~
      |                         num1
a.cc:5:30: error: 'num4' was not declared in this scope; did you mean 'num1'?
    5 |   int a,b,c,d,num1;num2,num3,num4,num5,num6;
      |                              ^~~~
      |                              num1
a.cc:5:35: error: 'num5' was not declared in this scope; did you mean 'num1'?
    5 |   int a,b,c,d,num1;num2,num3,num4,num5,num6;
      |                                   ^~~~
      |                                   num1
a.cc:5:40: error: 'num6' was not declared in this scope; did you mean 'num1'?
    5 |   int a,b,c,d,num1;num2,num3,num4,num5,num6;
      |                                        ^~~~
      |                                        num1
Language: C++

#include <algorithm>
#include <array>
#include <atcoder/all>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
using namespace atcoder;

using ll = long long;
using ld = long double;
using mint = modint;
const int INF = 1e9;
const double EPS = 1e-9;
const int MOD = 1e9 + 7;

int main()
{
  long long a;
  scanf("%lld", &a);
  long long b;
  scanf("%lld", &b);
  long long c;
  scanf("%lld", &c);
  long long d;
  scanf("%lld", &d);

  ll ans = max({a * c, a * d, b * c, b * d});
  if ((a < 0 && b > 0) || (c < 0 && d > 0))
    cout << max(ans, 0LL) << endl;
  else
    cout << ans << endl;

  return 0;
}


Compiler output:
a.cc:3:10: fatal error: atcoder/all: No such file or directory
    3 | #include <atcoder/all>
      |          ^~~~~~~~~~~~~
compilation terminated.
Language: C++

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

int main() {
  int a, b, c, d, e, f, g, h, i, j;
  cin >> a >> b >> c >> d;
  e=a*b;
  f=a*c;
  g=a*d;
  h=b*c;
  i=b*d;
  j=c*d;

}
    cout << max(max(max(max(max(max(j, i), h), g), f), e) << endl;

Compiler output:
a.cc:15:5: error: 'cout' does not name a type
   15 |     cout << max(max(max(max(max(max(j, i), h), g), f), e) << endl;
      |     ^~~~
Language: Java

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		long a = sc.nextLong();
		long b = sc.nextLong();
		long c = sc.nextLong();
		long d = sc.nextLong();
		
		long xl = Math.max(a, b);
		long yl = Math.max(c, d);
		
		long xs = Math.min(a, b);
		long ys = Math.min(c, d);
		
		if(xl*yl >= xs*ys) {		
			System.out.println(xl*yl);
		}else {
			System.out.println(xs*ys);
		}
	}
}

Compiler output:
Main.java:3: error: cannot find symbol
		Scanner sc = new Scanner(System.in);
		^
  symbol:   class Scanner
  location: class Main
Main.java:3: error: cannot find symbol
		Scanner sc = new Scanner(System.in);
		                 ^
  symbol:   class Scanner
  location: class Main
2 errors
Language: C++

#include<bits/stdc++.h>
using namespace std;
int main()
{
  long long a,b,c,d;
  cin >> a >> b >> c >> d;
  vector<long long>v;
  v.push_back(a*c);
  v.push_back(a*d);
  v.push_back(b*c);
  v.push_back(b*d);
  ans = *max_element(v.begin(),v.end());
  cout << ans << endl;
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:12:3: error: 'ans' was not declared in this scope; did you mean 'abs'?
   12 |   ans = *max_element(v.begin(),v.end());
      |   ^~~
      |   abs
Language: C++

#include<iostream>
using namespace std;
typedef long long ll;
int main () {
  ll a, b, c, d;
  cin >> a >> b >> c >> d;
  cout << max(max(a * c, b * d), max(a * d, b * c) << endl;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:7:52: error: invalid operands of types 'const long long int' and '<unresolved overloaded function type>' to binary 'operator<<'
    7 |   cout << max(max(a * c, b * d), max(a * d, b * c) << endl;
      |                                  ~~~~~~~~~~~~~~~~~~^~~~~~~
Language: C++

#include <bits/stdc++>
using namespace std;
int main(){
	long long a,b,c,d;
	cin>>a>>b>>c>>d;
 	long long ans = a*c , ans1 = a*d, ans2 = b*c,ans3 = d*b;
  	cout<<max(ans,max(ans1,max(ans2,ans3)));
  return 0;
}

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

#include<iostream>
using namespace std;
 
int main(){
	long long a,b,c,d,ans;
    cin>>a>>b>>c>>d;
    ans = max({a*c,a*d,b*c,b*d});
  	cout<<ans;
  	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:7:14: error: no matching function for call to 'max(<brace-enclosed initializer list>)'
    7 |     ans = max({a*c,a*d,b*c,b*d});
      |           ~~~^~~~~~~~~~~~~~~~~~~
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:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   candidate expects 2 arguments, 1 provided
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 1 provided
Language: Java

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);

		int a=s.nextInt();
      	int b=s.nextInt();
      	int c=s.nextInt();
      	int d=s.nextInt();
      	int p1=a*c;
      	int p2=a*d;
      	int p3=b*c;
      	int p4=b*d;

		int a[] = new int[]{p1,p2,p3,p4};
      	int max;
      	for(int i=0;i<4;i++)
        {
          if(i==0)
          {
            max=a[0];
          }
          else if(a[i]>=max)
          {
            max=a[i];
          }
        }
      	System.out.println(max+"");
	}
}

Compiler output:
Main.java:16: error: variable a is already defined in method main(String[])
		int a[] = new int[]{p1,p2,p3,p4};
		    ^
1 error
Language: C++

/*-Produced by Aman Vashistha-*/
#include<bits/stdc++.h>
using namespace std;
#define lli long long int
#define mods 1000000007
#define fio ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)

int main()
{
    fio;
    int a,b,c,d;
    cin>>a>>b>>c>>d;
    signed lli prod=1;
    signed lli x,y;
    if(a>=0 && c>=0) { x=b; y=d; }
    else if(b=<0 && d<=0) {x=a; y=c;}
    else if(a<=0 && b>=0 && c<=0 && d>=0){
      if(abs(a)*abs(c)>b*d) {x=a; y=c;}
      else { x=b; y=d;}
    }
    else if(a<=0 && b>=0 && c>=0){
      x=b;
      y=d;
    }
    else if(a>=0 && c<=0 && d>=0){
      x=b;
      y=d;
    }
    else if(a<=0 && c>=0)
    {
      x=a; y=c;
    }
  prod=x*y;
  cout<<prod;
    return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:16:15: error: expected primary-expression before '<' token
   16 |     else if(b=<0 && d<=0) {x=a; y=c;}
      |               ^
Language: C++

#include<bits/stdc++.h>
using namespace std;
int main()
{
  int a,b,c,d;
  cin>>a>>b>>c>>d;
    cout<<max(b*d,a*c)
    
}

Compiler output:
a.cc: In function 'int main()':
a.cc:7:23: error: expected ';' before '}' token
    7 |     cout<<max(b*d,a*c)
      |                       ^
      |                       ;
    8 | 
    9 | }
      | ~
Language: C++

#include <bits/stdc++.h>
 
int main()
{
  int a, b, c, d, x, y, ans;
  scanf("%i%i%i%i", &a, &b, &c, &d);
  ans = a*c;
  ans = max(ans, a*d);
  ans = max(ans, b*c);
  ans = max(ans, b*d);
  printf("%i\n", ans);
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:8:9: error: 'max' was not declared in this scope; did you mean 'std::max'?
    8 |   ans = max(ans, a*d);
      |         ^~~
      |         std::max
In file included from /usr/include/c++/14/algorithm:61,
                 from /usr/include/x86_64-linux-gnu/c++/14/bits/stdc++.h:51,
                 from a.cc:1:
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: 'std::max' declared here
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
Language: C++

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

int main(){
  
  vectot<int> data(4);
  for(int i=0;i<4;i++){
    cin>>data.at(i);
  }
  int max=data.at(0)*data.at(2);
  int aa;
  for(int i=0;i<2;i++){
    for(int j=2;j<4:j++){
     
      aa=data.at(i)*data.at(j); 
      if(max<aa){
        max=aa;
      }
    }
  }
  
  cout<<max<<endl;
  
}

Compiler output:
a.cc: In function 'int main()':
a.cc:6:3: error: 'vectot' was not declared in this scope
    6 |   vectot<int> data(4);
      |   ^~~~~~
a.cc:6:10: error: expected primary-expression before 'int'
    6 |   vectot<int> data(4);
      |          ^~~
a.cc:8:15: error: overloaded function with no contextual type information
    8 |     cin>>data.at(i);
      |               ^~
a.cc:10:16: error: overloaded function with no contextual type information
   10 |   int max=data.at(0)*data.at(2);
      |                ^~
a.cc:10:27: error: overloaded function with no contextual type information
   10 |   int max=data.at(0)*data.at(2);
      |                           ^~
a.cc:13:17: warning: range-based 'for' loops with initializer only available with '-std=c++20' or '-std=gnu++20' [-Wc++20-extensions]
   13 |     for(int j=2;j<4:j++){
      |                 ^
a.cc:13:20: error: expected ';' before ':' token
   13 |     for(int j=2;j<4:j++){
      |                    ^
      |                    ;
a.cc:20:3: error: expected primary-expression before '}' token
   20 |   }
      |   ^
a.cc:19:6: error: expected ';' before '}' token
   19 |     }
      |      ^
      |      ;
   20 |   }
      |   ~   
a.cc:20:3: error: expected primary-expression before '}' token
   20 |   }
      |   ^
a.cc:19:6: error: expected ')' before '}' token
   19 |     }
      |      ^
      |      )
   20 |   }
      |   ~   
a.cc:13:8: note: to match this '('
   13 |     for(int j=2;j<4:j++){
      |        ^
a.cc:20:3: error: expected primary-expression before '}' token
   20 |   }
      |   ^
Language: C++

#include<cstdio>
#include<algorithm>
using namespace std;
int main()
{
	long long a;
	scanf("%lld",&a);
	long long ans = 0;
	ans = max(a*c,b*d);
	printf("%lld\n",ans);
}

Compiler output:
a.cc: In function 'int main()':
a.cc:9:21: error: 'c' was not declared in this scope
    9 |         ans = max(a*c,b*d);
      |                     ^
a.cc:9:23: error: 'b' was not declared in this scope
    9 |         ans = max(a*c,b*d);
      |                       ^
a.cc:9:25: error: 'd' was not declared in this scope
    9 |         ans = max(a*c,b*d);
      |                         ^
Language: C++

#include<bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp> 
//using namespace boost::multiprecision; 

using namespace std;

//#Rohitpratap311
//#Keep Calm And Stay Happy

typedef long long ll;
typedef long double ld;

bool ifprime(ll n)
{
    if(n==2||n==3) { return true ; }
    for(ll i=2;i<=sqrt(n);i++)
    {
        if(n%i==0) { return false; }
    }
    return true;
}

ll gcd(ll a,ll b)
{
    if(b==0) { return a; }
    return gcd(b,a%b);
}
 
ll lcm(ll a,ll b)
{
    return (a*b)/gcd(a,b);
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    ll t=1;
    //cin>>t;
    while(t--)
    {
      	ll a,b,c,d;
      	cin>>a>>b>>c>>d;
      	if((b>0)&&(d>0)) cout<<b*d;
      	else if((b<0)&&(d<0)) cout<<a*c;
      	else if(b==0&&d==0)   cout<<b*d;
      	else if(b>0)&&(d<0)   cout<<a*d;
      	else if(b<0)&&(d>0)   cout<<b*c;
    }
    return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:47:23: error: expected identifier before '(' token
   47 |         else if(b>0)&&(d<0)   cout<<a*d;
      |                       ^
a.cc:48:23: error: expected identifier before '(' token
   48 |         else if(b<0)&&(d>0)   cout<<b*c;
      |                       ^
Language: Java

import java.util.*;

class Main{
  public static void main(String[] args){
    Scanner sc=new Scanner(System.in);
    long[] a=new Long[2];
    a[0]=sc.nextLong();
    a[1]=sc.nextLong();
    long[] c=new Long[2];
    c[0]=sc.nextLong();
    c[1]=sc.nextLong();
    long max=0;
    for(int i=0;i<2;i++){
      for(int j=0;j<2;j++){
        if(max<a[i]*c[j])max=a[i]*c[j];
      }
    }
    System.out.println(max);
  }
}

Compiler output:
Main.java:6: error: incompatible types: Long[] cannot be converted to long[]
    long[] a=new Long[2];
             ^
Main.java:9: error: incompatible types: Long[] cannot be converted to long[]
    long[] c=new Long[2];
             ^
2 errors
Language: C++

int main(void){
    long a, b, c, d;
    std::cin >> a >> b >> c >> d;
    std::cout << std::fmax(a * c, std::fmax(a * d, std::fmax(b * c, b *d))) << std::endl;

    return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:3:10: error: 'cin' is not a member of 'std'
    3 |     std::cin >> a >> b >> c >> d;
      |          ^~~
a.cc:1:1: note: 'std::cin' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
  +++ |+#include <iostream>
    1 | int main(void){
a.cc:4:10: error: 'cout' is not a member of 'std'
    4 |     std::cout << std::fmax(a * c, std::fmax(a * d, std::fmax(b * c, b *d))) << std::endl;
      |          ^~~~
a.cc:4:10: note: 'std::cout' is defined in header '<iostream>'; this is probably fixable by adding '#include <iostream>'
a.cc:4:23: error: 'fmax' is not a member of 'std'
    4 |     std::cout << std::fmax(a * c, std::fmax(a * d, std::fmax(b * c, b *d))) << std::endl;
      |                       ^~~~
a.cc:4:40: error: 'fmax' is not a member of 'std'
    4 |     std::cout << std::fmax(a * c, std::fmax(a * d, std::fmax(b * c, b *d))) << std::endl;
      |                                        ^~~~
a.cc:4:57: error: 'fmax' is not a member of 'std'
    4 |     std::cout << std::fmax(a * c, std::fmax(a * d, std::fmax(b * c, b *d))) << std::endl;
      |                                                         ^~~~
a.cc:4:85: error: 'endl' is not a member of 'std'
    4 |     std::cout << std::fmax(a * c, std::fmax(a * d, std::fmax(b * c, b *d))) << std::endl;
      |                                                                                     ^~~~
a.cc:1:1: note: 'std::endl' is defined in header '<ostream>'; this is probably fixable by adding '#include <ostream>'
  +++ |+#include <ostream>
    1 | int main(void){
Language: C++

// #pragma GCC optimize ("O2")
// #pragma GCC target("avx2")
#include "bits/stdc++.h"
	
#define PI 3.141592653589793L
#define FAST ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
// Use for file I/O;
#define FIN string _fname = "convention2"; \
			string _is = _fname + ".in", _os = _fname + ".out"; \
			freopen(_is.c_str(), "r", stdin); \
			freopen(_os.c_str(), "w", stdout);

#define all(x) (x).begin(), (x).end()
#define allr(x) (x).rbegin(), (x).rend()
#define gsize(x) (int)((x).size())

using namespace std;

const char nl = '\n';

typedef long long ll;
typedef long double ld;
typedef unsigned int uint;
typedef unsigned long long ull;
 
const ll inf = 1e9;
const ll inf2 = 1e18 + 99LL;
const ld inf3 = 1e14;
const ll mod = 1e9 + 7;
const ld eps = 1e-6;
 
const int logn = 19, maxn = 2e3+5, maxm = 1e5 + 5;

int main() {
	FAST;
	ll a, b, c, d;
	cin >> a >> b >> c >> d;
	cout << max({b * d, a * c, a * d, c * b, 0});
}

Compiler output:
a.cc: In function 'int main()':
a.cc:38:20: error: no matching function for call to 'max(<brace-enclosed initializer list>)'
   38 |         cout << max({b * d, a * c, a * d, c * b, 0});
      |                 ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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:3:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   candidate expects 2 arguments, 1 provided
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 1 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   template argument deduction/substitution failed:
a.cc:38:20: note:   deduced conflicting types for parameter '_Tp' ('long long int' and 'int')
   38 |         cout << max({b * d, a * c, a * d, c * b, 0});
      |                 ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   candidate expects 2 arguments, 1 provided
Language: C++

#include <bits/stdc++.h>
using namespace std;
int main(){
  int a,b,c,d;
  cin>>a>>b>>c>>d;
  long long prod1 = a*c;
  long long prod2 = b*d;
  long long maxi = max(prod1,prod2);

  if (a*b<=0 || c*d<=0)
    maxi=max(0,maxi);
cout<<maxi<<endl;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:11:13: error: no matching function for call to 'max(int, long long int&)'
   11 |     maxi=max(0,maxi);
      |          ~~~^~~~~~~~
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:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:11:13: note:   deduced conflicting types for parameter 'const _Tp' ('int' and 'long long int')
   11 |     maxi=max(0,maxi);
      |          ~~~^~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303: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:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:11:13: note:   mismatched types 'std::initializer_list<_Tp>' and 'int'
   11 |     maxi=max(0,maxi);
      |          ~~~^~~~~~~~
Language: C++

#include<bits/stdc++.h>

using namespace std;

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0); 
	long long a,b,c,d,p1,p2,p4,p3;
  	cin>>a>>b>>c>>d;'
    p1=a*c;
  	p2=b*d;
	p3=a*d;
  	p4=b*c;
  	if(p1>p2 && p1>p3 && p1>p4)
      cout<<p1;
  	else if(p2>p1 && p2>p3 && p2>p4)
      cout<<p2;
  	else if(p3>p2 && p3>p1 && p3>p4)
      cout<<p3;
  	else if(p4>p2 && p4>p3 && p4>p1)
      cout<<p4;
	return 0;
}

Compiler output:
a.cc:10:25: warning: missing terminating ' character
   10 |         cin>>a>>b>>c>>d;'
      |                         ^
a.cc:10:25: error: missing terminating ' character
Language: C++

#include<iostream>
using namespace std;
#define int long long


int main(){
    int a,b,c,d;
    cin>>a>>b>>c>>d;
    int ans=-1e18;
    ans = max(ans,a*c);
    ans = max(ans,a*d);
    ans = max(ans,b*c);
    ans = max(ans,b*d);
    cout<<ans;
    return 0LL;
}

Compiler output:
cc1plus: error: '::main' must return 'int'
Language: C++

#include <bits/stdc++.h>
#include <algorithm>
using namespace std;
using ll = long long;
int main(){
  int a, b, c, d;
  cin >> a >> b >> c >> d;
  ll ans = max((ll)a*c, (ll)a*d, (ll)b*c, (ll)b*d);
  cout << ans << endl;
  return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:8:15: error: no matching function for call to 'max(ll, ll, ll, ll)'
    8 |   ll ans = max((ll)a*c, (ll)a*d, (ll)b*c, (ll)b*d);
      |            ~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   candidate expects 2 arguments, 4 provided
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 4 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 4 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   candidate expects 2 arguments, 4 provided
Language: C++

#include<iostream>
using namespace std;
int main()
{
	long long a,b,c,d,s,ss,k=0;
	cin>>a>>b>>c>>d;
	if ((a<=0 && 0<=b) || (c<=0 && 0<=d))k=1;
	s=max(a*c,a*d);
	ss=max(b*c,b*d);
	s=max(s,ss);
	if (k==1)s=max(0,s);
	cout<<s;
}
	
	

Compiler output:
a.cc: In function 'int main()':
a.cc:11:23: error: no matching function for call to 'max(int, long long int&)'
   11 |         if (k==1)s=max(0,s);
      |                    ~~~^~~~~
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:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257: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 |         if (k==1)s=max(0,s);
      |                    ~~~^~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
Language: C++

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

#include <ext/pb_ds/assoc_container.hpp> 
#include <ext/pb_ds/tree_policy.hpp> 
using namespace __gnu_pbds; 
  
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update> 

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    long long int a,b,c,d;
    cin>>a>>b>>c>>d;
    long long int ans1=a*c;
    long long int ans2=a*d;
    long long int ans3=b*c;
    long long int ans4=b*d;
    long long int ans=max(max(ans1,ans2),max(ans2,ans3));
    if((a<=0 and 0<=b) or (c<=0 and 0<=d)) cout<<max(ans,0)<<"\n";
    else cout<<ans<<"\n";
	return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:21:53: error: no matching function for call to 'max(long long int&, int)'
   21 |     if((a<=0 and 0<=b) or (c<=0 and 0<=d)) cout<<max(ans,0)<<"\n";
      |                                                  ~~~^~~~~~~
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:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:21:53: note:   deduced conflicting types for parameter 'const _Tp' ('long long int' and 'int')
   21 |     if((a<=0 and 0<=b) or (c<=0 and 0<=d)) cout<<max(ans,0)<<"\n";
      |                                                  ~~~^~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303: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:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:21:53: note:   mismatched types 'std::initializer_list<_Tp>' and 'long long int'
   21 |     if((a<=0 and 0<=b) or (c<=0 and 0<=d)) cout<<max(ans,0)<<"\n";
      |                                                  ~~~^~~~~~~
Language: C++

#include <iostream>
int main(){
  long long a, b, c, d;
  std::cin >> a >> b >> c >> d;
  
  long long ans = a * c;
  ans = ans < a * d ? a * d: ans;
  ans = ans < b * c ? b * c: ans;
  ans = ans < b * c ? b * d: ans;
  
  cout << ans << "\n";
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:11:3: error: 'cout' was not declared in this scope; did you mean 'std::cout'?
   11 |   cout << ans << "\n";
      |   ^~~~
      |   std::cout
In file included from a.cc:1:
/usr/include/c++/14/iostream:63:18: note: 'std::cout' declared here
   63 |   extern ostream cout;          ///< Linked to standard output
      |                  ^~~~
Language: C++

#include <iostream>

using namespace std;

#define ll long long

int main()
{
    ll a,b,c,d;
    cin>>a>>b>>c>>d;
    cout<<max({a*c,a*d,b*c,b*d});

    return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:11:14: error: no matching function for call to 'max(<brace-enclosed initializer list>)'
   11 |     cout<<max({a*c,a*d,b*c,b*d});
      |           ~~~^~~~~~~~~~~~~~~~~~~
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:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   candidate expects 2 arguments, 1 provided
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 1 provided
Language: C++

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

int main() {
  int a, b, c, d, e, f;
  cin >> a >> b >> c >> d;

  if (a>b) {
   e= a;
  }
  else {
    e=b;
  }
  if(c>d) {
    f=c;
  }
  else {
    f=d;
}
    cout << e*f << endl;

Compiler output:
a.cc: In function 'int main()':
a.cc:20:25: error: expected '}' at end of input
   20 |     cout << e*f << endl;
      |                         ^
a.cc:4:12: note: to match this '{'
    4 | int main() {
      |            ^
Language: C++

#include<bits/stdc++.h>
#include <cmath>
#define ll long long
#define mod (long long)(1e9+7)
// #define endl "\n"
using namespace std;
#define ld long double
//unordered_map<_____,_____,custom_hash>
struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};
//done custom_hash

void solve(){
	ll a,b,c,d;
    cin>>a>>b>>c>>d;
    cout<<max(a*c,max(b*d,max(a*d,b*c))<<endl;
}


int main(){
	ll t=1;
	//cin>>t;
	while(t--){
		solve();
	}
}




Compiler output:
a.cc: In function 'void solve()':
a.cc:28:40: error: invalid operands of types 'const long long int' and '<unresolved overloaded function type>' to binary 'operator<<'
   28 |     cout<<max(a*c,max(b*d,max(a*d,b*c))<<endl;
      |                   ~~~~~~~~~~~~~~~~~~~~~^~~~~~
Language: Java

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <unordered_map>

using namespace std;

#define ll long long
#define all(v) v.begin(),v.end()
#define bootstrap ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);


void solve() {
    long a, b, c, d;
    ll n1, n2, n3, n4;
    cin >> a >> b >> c >> d;
    n1 = a * c;
    n2 = a * d;
    n3 = b * c;
    n4 = b * d;
    ll res = max(n1, n2);
    res = max(res, n3);
    res = max(res, n4);
    cout << res;
}

int main() {
    bootstrap;
    solve();
}

Compiler output:
Main.java:1: error: illegal character: '#'
#include <iostream>
^
Main.java:2: error: illegal character: '#'
#include <vector>
^
Main.java:3: error: illegal character: '#'
#include <string>
^
Main.java:4: error: illegal character: '#'
#include <algorithm>
^
Main.java:5: error: illegal character: '#'
#include <unordered_map>
^
Main.java:9: error: illegal character: '#'
#define ll long long
^
Main.java:9: error: class, interface, enum, or record expected
#define ll long long
        ^
Main.java:10: error: illegal character: '#'
#define all(v) v.begin(),v.end()
^
Main.java:11: error: illegal character: '#'
#define bootstrap ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
^
Main.java:17: error: not a statement
    cin >> a >> b >> c >> d;
                       ^
Main.java:25: error: not a statement
    cout << res;
         ^
Main.java:14: error: unnamed classes are a preview feature and are disabled by default.
void solve() {
^
  (use --enable-preview to enable unnamed classes)
Main.java:29: error: not a statement
    bootstrap;
    ^
13 errors
Language: C++

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

ll max(vector<ll> v) {
	return *max_element(v.begin(),v.end());
}

int main() {
  ll a,b,c,d;
  cin>>a>>b>>c>>d;
  
  ll ans=max({a*c,a*d,b*c,b*d});
  cout<<ans<<endl;

Compiler output:
a.cc: In function 'int main()':
a.cc:14:19: error: expected '}' at end of input
   14 |   cout<<ans<<endl;
      |                   ^
a.cc:9:12: note: to match this '{'
    9 | int main() {
      |            ^
Language: C++

#include <iostream>
#include<iomanip>
#include <string>
#include<vector>
#include<algorithm>
#include<utility>
#include<queue>
#include<math.h>
#include<stack>
#include<set>
#include<map>
#include<ctime>
#include<cstdlib>
#define INF long long int(1e18+1)
#define MAX 200001
#define rep(i,n,m) for(int i=n;i<m;i++)

using namespace std;
	
int main() {
	long long a, b, c, d;
	cin >> a >> b >> c >> d;
	long long m = -INF;
	m = max(m, a * c);
	m = max(m, a * d);
	m = max(m, b * c);
	m = max(m, b * d);
	cout << m << endl;

}


Compiler output:
a.cc: In function 'int main()':
a.cc:14:13: error: expected primary-expression before 'long'
   14 | #define INF long long int(1e18+1)
      |             ^~~~
a.cc:23:24: note: in expansion of macro 'INF'
   23 |         long long m = -INF;
      |                        ^~~
Language: C++

#include<iostream>
using namespace std;
int main()
{
	long long a,b,c,d,s,ss;
	cin>>a>>b>>c>>d;
	if ((a<=0 && 0<=b) || (c<=0 && 0<=d))k=1;
	s=max(a*c,a*d);
	ss=max(b*c,b*d);
	s=max(s,ss);
	if (k==1)s=max(0,s);
	cout<<s;
}
	
	

Compiler output:
a.cc: In function 'int main()':
a.cc:7:46: error: 'k' was not declared in this scope
    7 |         if ((a<=0 && 0<=b) || (c<=0 && 0<=d))k=1;
      |                                              ^
a.cc:11:13: error: 'k' was not declared in this scope
   11 |         if (k==1)s=max(0,s);
      |             ^
a.cc:11:23: error: no matching function for call to 'max(int, long long int&)'
   11 |         if (k==1)s=max(0,s);
      |                    ~~~^~~~~
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:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257: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 |         if (k==1)s=max(0,s);
      |                    ~~~^~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
Language: C++

#include <bits/stdc++.h>
#include <algorithm>
using namespace std;
int main(){
  int a, b, c, d;
  cin >> a >> b >> c >> d;
  long long ans = max(a*c, a*d, b*c, b*d);
  cout << ans << endl;
  return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:7:22: error: no matching function for call to 'max(int, int, int, int)'
    7 |   long long ans = max(a*c, a*d, b*c, b*d);
      |                   ~~~^~~~~~~~~~~~~~~~~~~~
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:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   candidate expects 2 arguments, 4 provided
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 4 provided
In file included from /usr/include/c++/14/algorithm:61:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 4 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   candidate expects 2 arguments, 4 provided
Language: C++

#include<bits/stdc++.h>
#define ll long long
int M=1e9+7;
using namespace std;
int main()
{
	int a>>b>>c>>d;
	cin>>a>>b>>c>>d;
	ll max=0;
	max=a*c;
	if(a*d>max)
	max=a*d;
	if(b*c>max)
	max=b*c;
	if(b*d>max)
	max=b*d;
	cout<<max;
	return 0;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:7:14: error: expected initializer before '>>' token
    7 |         int a>>b>>c>>d;
      |              ^~
a.cc:8:14: error: 'a' was not declared in this scope
    8 |         cin>>a>>b>>c>>d;
      |              ^
a.cc:8:17: error: 'b' was not declared in this scope
    8 |         cin>>a>>b>>c>>d;
      |                 ^
a.cc:8:20: error: 'c' was not declared in this scope
    8 |         cin>>a>>b>>c>>d;
      |                    ^
a.cc:8:23: error: 'd' was not declared in this scope
    8 |         cin>>a>>b>>c>>d;
      |                       ^
Language: C++

#include <iostream>
#include <cstdint>
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <algorithm>

int main(void)
{
    int64_t a, b, c, d;

    std::cin >> a >> b >> c >> d;

    int64_t max = -10000000000;

    max = std::max(max, a*c);
    max = std::max(max, a*d);
    max = std::max(max, b*c);
    max = std::max(max, b*d);

    if (a < 0 && b > 0 || c < 0 && d > 0) {
        max = std::max(max, 0);
    }

    std::cout << max << std::endl;

    return 0;
}

Compiler output:
a.cc: In function 'int main()':
a.cc:23:23: error: no matching function for call to 'max(int64_t&, int)'
   23 |         max = std::max(max, 0);
      |               ~~~~~~~~^~~~~~~~
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:1:
/usr/include/c++/14/bits/stl_algobase.h:257:5: note: candidate: 'template<class _Tp> constexpr const _Tp& std::max(const _Tp&, const _Tp&)'
  257 |     max(const _Tp& __a, const _Tp& __b)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:257:5: note:   template argument deduction/substitution failed:
a.cc:23:23: note:   deduced conflicting types for parameter 'const _Tp' ('long int' and 'int')
   23 |         max = std::max(max, 0);
      |               ~~~~~~~~^~~~~~~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note: candidate: 'template<class _Tp, class _Compare> constexpr const _Tp& std::max(const _Tp&, const _Tp&, _Compare)'
  303 |     max(const _Tp& __a, const _Tp& __b, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algobase.h:303:5: note:   candidate expects 3 arguments, 2 provided
In file included from /usr/include/c++/14/algorithm:61,
                 from a.cc:7:
/usr/include/c++/14/bits/stl_algo.h:5706:5: note: candidate: 'template<class _Tp> constexpr _Tp std::max(initializer_list<_Tp>)'
 5706 |     max(initializer_list<_Tp> __l)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5706:5: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/14/bits/stl_algo.h:5716:5: note: candidate: 'template<class _Tp, class _Compare> constexpr _Tp std::max(initializer_list<_Tp>, _Compare)'
 5716 |     max(initializer_list<_Tp> __l, _Compare __comp)
      |     ^~~
/usr/include/c++/14/bits/stl_algo.h:5716:5: note:   template argument deduction/substitution failed:
a.cc:23:23: note:   mismatched types 'std::initializer_list<_Tp>' and 'long int'
   23 |         max = std::max(max, 0);
      |               ~~~~~~~~^~~~~~~~