Language: C++

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<bits/stdc++.h>
#include<cmath>
#include<bitset>
#define ll long long
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define FFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define REP(i,n)  FOR(i,0,n)
#define RREP(i,n)  FFOR(i,0,n)
#define SORT(V) sort((V).begin(),(V).end())
#define REVERSE(V) reverse((V).begin(),(V).end())
#define INF ((1LL<<62)-(1LL<<31))
#define MOD 1000000007
using namespace std;

int main(){
  int N;
  double X=0,Y=0;
  double ans=0;
  cin>>N;
  vector<pair<int,int>> A,B,C,D,E,F,G,H;
  REP(i,N){
    int a,b;
    cin>>a>>b;
    A.push_back(make_pair(a,b));
    B.push_back(make_pair(b,a));
    C.push_back(make_pair(-1*a,b));
    D.push_back(make_pair(a,-1*b));
    E.push_back(make_pair(-1*a,-1*b));
    F.push_back(make_pair(-1*b,a));
    G.push_back(make_pair(b,-1*a));
    H.push_back(make_pair(-1*b,-1*a));
  }
  
  SORT(A);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<A.size(); ++i){
      for(int j=i; j<A.size(); ++j){
          if(X*X+Y*Y<(X+A[j].first)*(X+A[j].first)+(Y+A[j].second)*(Y+A[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=A[i].first;
    Y+=A[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  REVERSE(A);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<A.size(); ++i){
      for(int j=i; j<A.size(); ++j){
          if(X*X+Y*Y<(X+A[j].first)*(X+A[j].first)+(Y+A[j].second)*(Y+A[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=A[i].first;
    Y+=A[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  
  
   SORT(B);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<B.size(); ++i){
      for(int j=i; j<B.size(); ++j){
          if(X*X+Y*Y<(X+B[j].first)*(X+B[j].first)+(Y+B[j].second)*(Y+B[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=B[i].first;
    Y+=B[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  REVERSE(B);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<B.size(); ++i){
      for(int j=i; j<B.size(); ++j){
          if(X*X+Y*Y<(X+B[j].first)*(X+B[j].first)+(Y+B[j].second)*(Y+B[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=B[i].first;
    Y+=B[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  
  
  
   SORT(C);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<C.size(); ++i){
      for(int j=i; j<C.size(); ++j){
          if(X*X+Y*Y<(X+C[j].first)*(X+C[j].first)+(Y+C[j].second)*(Y+C[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=C[i].first;
    Y+=C[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  REVERSE(C);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<C.size(); ++i){
      for(int j=i; j<C.size(); ++j){
          if(X*X+Y*Y<(X+C[j].first)*(X+C[j].first)+(Y+C[j].second)*(Y+C[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=C[i].first;
    Y+=C[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  
  
   SORT(D);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<D.size(); ++i){
      for(int j=i; j<D.size(); ++j){
          if(X*X+Y*Y<(X+D[j].first)*(X+D[j].first)+(Y+D[j].second)*(Y+D[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=D[i].first;
    Y+=D[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  REVERSE(D);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<D.size(); ++i){
      for(int j=i; j<D.size(); ++j){
          if(X*X+Y*Y<(X+D[j].first)*(X+D[j].first)+(Y+D[j].second)*(Y+D[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=D[i].first;
    Y+=D[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  
  
  
   SORT(A);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<A.size(); ++i){
      for(int j=i; j<A.size(); ++j){
          if(X*X+Y*Y<(X+A[j].first)*(X+A[j].first)+(Y+A[j].second)*(Y+A[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=A[i].first;
    Y+=A[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  REVERSE(A);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<A.size(); ++i){
      for(int j=i; j<A.size(); ++j){
          if(X*X+Y*Y<(X+A[j].first)*(X+A[j].first)+(Y+A[j].second)*(Y+A[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=A[i].first;
    Y+=A[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  
  
  
   SORT(A);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<A.size(); ++i){
      for(int j=i; j<A.size(); ++j){
          if(X*X+Y*Y<(X+A[j].first)*(X+A[j].first)+(Y+A[j].second)*(Y+A[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=A[i].first;
    Y+=A[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  REVERSE(A);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<A.size(); ++i){
      for(int j=i; j<A.size(); ++j){
          if(X*X+Y*Y<(X+A[j].first)*(X+A[j].first)+(Y+A[j].second)*(Y+A[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=A[i].first;
    Y+=A[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  
  
   SORT(A);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<A.size(); ++i){
      for(int j=i; j<A.size(); ++j){
          if(X*X+Y*Y<(X+A[j].first)*(X+A[j].first)+(Y+A[j].second)*(Y+A[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=A[i].first;
    Y+=A[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  REVERSE(A);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<A.size(); ++i){
      for(int j=i; j<A.size(); ++j){
          if(X*X+Y*Y<(X+A[j].first)*(X+A[j].first)+(Y+A[j].second)*(Y+A[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=A[i].first;
    Y+=A[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  
  
  
   SORT(A);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<A.size(); ++i){
      for(int j=i; j<A.size(); ++j){
          if(X*X+Y*Y<(X+A[j].first)*(X+A[j].first)+(Y+A[j].second)*(Y+A[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=A[i].first;
    Y+=A[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  REVERSE(A);
  X=0;
  Y=0;
  CAN=true;
  for(int i=0; i<A.size(); ++i){
      for(int j=i; j<A.size(); ++j){
          if(X*X+Y*Y<(X+A[j].first)*(X+A[j].first)+(Y+A[j].second)*(Y+A[j].second)){
            CAN=false;
            i=j;
            break;
          }
      }
      if(CAN) break;
    X+=A[i].first;
    Y+=A[i].second;
    ans=max(ans,X*X+Y*Y);
  }
  
  
  cout<<setprecision(10)<<sqrt(ans)<<endl;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:41:3: error: 'CAN' was not declared in this scope; did you mean 'NAN'?
   41 |   CAN=true;
      |   ^~~
      |   NAN