#include <iostream>
#include <math.h>
using namespace std;
struct Circle {
   double _x, _y, _r ;
} ;
struct Rectangle {
   double _top_left_x, _top_left_y,
               _bot_right_x, _bot_right_y ;
} ;
struct Node {
   void *_data ;
   struct Node *_left, *_right ;
} ;
struct Gen_arr {
   void * arr[5] ;
   int used ;
};
void insert_reset(Gen_arr&,int&,void*);
typedef int(p2_sort_func)(void*val,void*num);
typedef double(p2_area_func)(void*obj);
typedef void (p2_print_func)(Gen_arr,int);
#define _USE_MATH_DEFINES ;
void read_data_c(Node*&);
void insert_to_tree(void*,Node*&,int(*)(void*,void*));
int cmp_circle_x(void*,void*);
void read_data_r(Node*&root);
double get_area_c(void*circle);
double get_area_r(void*rectangle);
void insert(Gen_arr&,int&,void*);
void find_max(Node*root,Gen_arr&p2_max_arr,p2_area_func p2_a,double&prev,int&used);
void print(p2_print_func ,int,Gen_arr);
void print_c(Gen_arr,int size);
void print_r(Gen_arr,int size);
int main() {
    Node*c_root=NULL,*r_root=NULL;
    int used1=0,used2=0;
    double prev1,prev2;
    Gen_arr a,b;
    read_data_c(c_root);
    read_data_r(r_root);
    find_max(c_root,a,get_area_c,prev1,used1);
    find_max(r_root,b,get_area_r,prev2,used2);
    print(print_c,used1,a);
    print(print_r,used2,b);
    return 0;
}
int cmp_circle_x(void* p2_c,void* p2_n){
    Circle* cr=(Circle*)p2_c;
    Circle* tc=(Circle*)p2_n;
    double x=tc->_x;
    if(cr->_x<x)
        return-1;

    return 1;
}
void print(p2_print_func pr,int size,Gen_arr arr){
     pr(arr,size);
}
int cmp_rec_x(void* p2_r,void *p2_n){
    Rectangle* r=(Rectangle*)p2_r;
    Rectangle* s=(Rectangle*)p2_n;
    if(r->_top_left_x<s->_top_left_x)
        return -1;

    return 1;
}
void read_data_c(Node*&root){
        while(true){
        Circle* circle =new Circle;
        cin>>circle->_x>>circle->_y;
        if(circle->_x==0&&circle->_y==0)
            break;
        else cin>>circle->_r;

        insert_to_tree(circle,root,cmp_circle_x);
       }
}
void read_data_r(Node*&root){
      while(true){
          Rectangle* r=new Rectangle;
          cin>>r->_top_left_x>>r->_top_left_y>>r->_bot_right_x>>r->_bot_right_y;
          if(r->_bot_right_x==0&&r->_bot_right_y==0&&r->_top_left_x==0&&r->_top_left_y==0)
              break;
          insert_to_tree(r,root,cmp_rec_x);
      }
}
void print_c(Gen_arr o,int size){
    for(int i=0;i<size;i++){
        Circle* c=(Circle*)o.arr[i];
        cout<<c->_x<<" "<<c->_y<<" "<<c->_r<<endl;
    }
}

void print_r(Gen_arr o,int size){
    for(int i=0;i<size;i++){
        Rectangle* r=(Rectangle*)o.arr[i];
        cout<<r->_top_left_x<<" "<<r->_top_left_y<<" "<<r->_bot_right_x<<" "<<r->_bot_right_y<<endl;
    }
}
double get_area_c(void*circle){
    Circle* c=(Circle*)circle;
    return M_PI*c->_r*c->_r;
}
double get_area_r(void*rectangle){
    Rectangle* r=(Rectangle*)rectangle;
    return ((abs(r->_top_left_x-r->_bot_right_x))*abs((r->_top_left_y-r->_bot_right_y)));

}
void insert_reset(Gen_arr&arr,int&used,void*data){
    if(used>4)
        return;
    used=1;
    arr.used=used;
    arr.arr[0]=data;

}
void insert(Gen_arr&arr,int&used,void*data){
    if(used>4)
        return;

  arr.arr[used]=data;
  used+=1;
  arr.used=used;
}

void find_max(Node*root,Gen_arr&p2_max_arr,p2_area_func p2_a,double&prev,int&used){
    if(!root)
       return;
        if(p2_a(root->_data)>prev){
        insert_reset(p2_max_arr,used,root->_data);
        prev=p2_a(root->_data);
        }else
        if(p2_a(root->_data)==prev)
        insert(p2_max_arr,used,root->_data);

           find_max(root->_right,p2_max_arr,p2_a,prev,used);
           find_max(root->_left,p2_max_arr,p2_a,prev,used);

}

void insert_to_tree(void* p2_obj,Node*&root,p2_sort_func cmp_sort_x){
    //reached location to populate node
    if(!root)
     {
     root=new Node;
         if(!root)
         exit(-1);

     root->_data=p2_obj;
     root->_left=root->_right=NULL;
     }
    //keep looking.. with recursion..
    else
        if(cmp_sort_x(p2_obj,root->_data)<0)
         insert_to_tree(p2_obj,root->_left,cmp_sort_x);
     else
         insert_to_tree(p2_obj,root->_right,cmp_sort_x);
}