// Correttore per "padrun", algoritmo naive quadratico, da non usare in gara :)

#include <iostream>
#include <algorithm>
#include <vector>
#include <cassert>
#include <climits>

using namespace std;

#define MAX_N 10000

int N, M;

class Interval {
public:
  int left, right;
  Interval(int l = 0, int r = 0) : right(r), left(l) {}
  
  struct less_left : public binary_function<const Interval*, const Interval*, bool> {
    bool operator() (const Interval* i1, const Interval* i2) {
      return i1->left < i2->left;
    }
  };
  struct less_right : public binary_function<const Interval*, const Interval*, bool> {
    bool operator() (const Interval* i1, const Interval* i2) {
      return i1->right < i2->right;
    }
  };
};

ostream& operator <<(ostream& os, const Interval& interval) {
  return os << interval.left << " " << interval.right;
}

istream& operator >>(istream& is, Interval& interval) {
  return is >> interval.left >> interval.right;
}


Interval intervals[MAX_N];
Interval dominating[MAX_N];



int main()
{
  cin >> N;

  for (int i = 0; i < N; ++i) {
    cin >> intervals[i];
  }
  cin >> M;
  
  for (int i = 0; i < M; ++i) {
    cin >> dominating[i];
  }
  
  for (int i = 0; i < N; ++i) {
    int coperto = 0;
    for (int j = 0; j < M; ++j) {
      if (intervals[i].right >= dominating[j].left && intervals[i].right <= dominating[j].right) {
	coperto = 1;
	break;
      }
      if (intervals[i].left >= dominating[j].left && intervals[i].left <= dominating[j].right) {
	coperto = 1;
	break;
      }
    }
    if (!coperto) {
      cout << "L'intervallo " << intervals[i] << " non e` coperto!" << endl;
      return 1;
    }
  }
    
  cout << "Tutto apposto" << endl;
  return 0;
}