description: This is the easy version of the problem. The only difference between the two versions is the constraint on n. You can make hacks only if all versions of the problem are solved.
  
  A forest is an undirected graph without cycles (not necessarily connected).
  
  Mocha and Diana are friends in Zhijiang, both of them have a forest with nodes numbered from 1 to n, and they would like to add edges to their forests such that: 
  
    * After adding edges, both of their graphs are still forests. 
    * They add the same edges. That is, if an edge (u, v) is added to Mocha's forest, then an edge (u, v) is added to Diana's forest, and vice versa. 
  
  
  
  Mocha and Diana want to know the maximum number of edges they can add, and which edges to add.
  
  Input
  
  The first line contains three integers n, m_1 and m_2 (1 ≤ n ≤ 1000, 0 ≤ m_1, m_2 < n) — the number of nodes and the number of initial edges in Mocha's forest and Diana's forest.
  
  Each of the next m_1 lines contains two integers u and v (1 ≤ u, v ≤ n, u ≠ v) — the edges in Mocha's forest.
  
  Each of the next m_2 lines contains two integers u and v (1 ≤ u, v ≤ n, u ≠ v) — the edges in Diana's forest.
  
  Output
  
  The first line contains only one integer h, the maximum number of edges Mocha and Diana can add (in each forest).
  
  Each of the next h lines contains two integers u and v (1 ≤ u, v ≤ n, u ≠ v) — the edge you add each time.
  
  If there are multiple correct answers, you can print any one of them.
  
  Examples
  
  Input
  
  
  3 2 2
  1 2
  2 3
  1 2
  1 3
  
  
  Output
  
  
  0
  
  
  Input
  
  
  5 3 2
  5 4
  2 1
  4 3
  4 3
  1 4
  
  
  Output
  
  
  1
  2 4
  
  
  Input
  
  
  8 1 2
  1 7
  2 6
  1 5
  
  
  Output
  
  
  5
  5 2
  2 3
  3 4
  4 7
  6 8
  
  Note
  
  In the first example, we cannot add any edge.
  
  In the second example, the initial forests are as follows.
  
  <image>
  
  We can add an edge (2, 4).
  
  <image>
solution: import java.io.*;
  import java.util.StringTokenizer;
  
  public class MochaDiana {
  
      //Fast Input
      static class FastReader {
          BufferedReader br;
          StringTokenizer st;
  
          public FastReader() {
              br = new BufferedReader(new InputStreamReader(System.in));
          }
  
          String next() {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
  
          int nextInt() {
              return Integer.parseInt(next());
          }
  
          long nextLong() {
              return Long.parseLong(next());
          }
  
          double nextDouble() {
              return Double.parseDouble(next());
          }
  
          String nextLine() {
              String str = "";
              try {
                  str = br.readLine();
              } catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
  
      //Printing an array
      static void print(long[][] a, int r, int c) {
          PrintWriter pw = new PrintWriter(System.out);
          for (int i = 0; i < r; i++) {
              for (int j = 0; j < c; j++) {
                  pw.print(a[i][j] + " ");
              }
              pw.println();
          }
          pw.flush();
      }
  
      //Used to generate random test cases
      //Must be changed according to input format
      static void testCaseGenerator(int t, int lowN, int highN, long lowA, long highA) throws FileNotFoundException {
          File input = new File("C:\\Users\\debar\\OneDrive\\Documents\\input.txt");
          PrintWriter pw = new PrintWriter(input);
          pw.println(t);
          for (int i = 0; i < t; i++) {
              int n = (int) (Math.random() * (highN - lowN)) + lowN;
              pw.println(n);
              for (int j = 0; j < n; j++) {
                  long a = (long) (Math.random() * (highA - lowA)) + lowA;
                  pw.print(a + " ");
              }
              pw.println();
          }
          pw.flush();
      }
  
      //Find factorial of numbers from 1 to n
      //Check the size of factorial array
      static long[] factorial(int n, long mod) {
          long[] factorial = new long[n];
          factorial[0] = 1;
          for (int i = 1; i <= n; i++) {
              factorial[i] = (factorial[i - 1] * i) % mod;
          }
          return factorial;
      }
  
      //Find factorial inverse from 1 to n
      //Check the size of inverse_factorial array
      static long[] factorialInverse(int n, long mod) {
          long[] inverse_factorial = modularInverse(n, mod);
          for (int i = 2; i <= n; i++) {
              inverse_factorial[i] = (inverse_factorial[i] * inverse_factorial[i - 1]) % mod;
          }
          return inverse_factorial;
      }
  
      //Inverse exist when two number are relatively prime
      //Based on Fermat little theorem (a^mod-1)%mod=1 when mod is prime
      //a * a^(mod - 2) % mod = 1
      //a^(mod - 2) % mod =a^-1
      //When mod != prime use Extended euclidean theorem to calculate x and y for equation a*x + mod*y = gcd(a,b)=1
      //(a*x + mod*y = gcd(a,b)=1) % mod = a*x %mod =1
      //https://www.geeksforgeeks.org/find-initial-integral-solution-of-linear-diophantine-equation-if-finite-solution-exists/?ref=rp
      //Used for only one number
      static long modularInverse(long a, long mod) {
          return binaryExponentiation(a, mod - 2, mod);
      }
  
      //Modular inverse for number from 1 to n - 1
      //Time complexity O(n) for n numbers
      //Proof https://cp-algorithms.com/algebra/module-inverse.html
      static long[] modularInverse(int n, long mod) {
          long[] inv = new long[n];
          inv[1] = 1;
          for (int i = 2; i < n; i++) {
              inv[i] = mod - (mod / i) * inv[(int) (mod % i)] % mod;
          }
          return inv;
      }
  
      //GCD calculation of a and b with complexity O(log(Max(a,b))
      static long gcd(long a, long b) {
          long r;
          while (b != 0) {
              r = a % b;
              a = b;
              b = r;
          }
          return a;
      }
  
      //Find prime number upto n with complexity O(n*log(log(n)))
      //Travel through the multiple of prime number and set it to false
      static boolean[] sieveOfEratosthenes(int n) {
  
          boolean[] prime = new boolean[n + 1];
          for (int i = 0; i <= n; i++)
              prime[i] = true;
  
          for (int p = 2; p * p <= n; p++) {
              if (prime[p]) {
                  for (int i = p * p; i <= n; i += p)
                      prime[i] = false;
              }
          }
  
          prime[0] = prime[1] = false;
          return prime;
      }
  
      //Find Prefix sum in O(n)
      static long[] PrefixSum(long[] arr, int n) {
  
          long[] prefixSum = new long[n];
  
          prefixSum[0] = arr[0];
          for (int i = 1; i < n; ++i)
              prefixSum[i] = prefixSum[i - 1] + arr[i];
          return prefixSum;
      }
  
      //Find a^n in O(log n)
      //If n=11 then n in binary is equal to 1011
      //a^n=a^(8+2+1) that is multiply with result when bit is set.
      //https://youtu.be/L-Wzglnm4dM
      static long binaryExponentiation(long a, long n, long mod) {
          long result = 1L;
          n = n % (mod - 1);
          //n = (mod - 1) * floor(n / (mod - 1)) + n % (mod - 1)
          //a^((mod - 1) * floor(n / (mod - 1))) % mod = 1 so a^n % mod =a^(n % (mod - 1)) % mod when mod is prime
          //Using fermat little theorem a^(p-1) % p = 1 when p is prime
          while (n > 0) {
              if ((n & 1) == 1) {
                  result = (result * a) % mod;
              }
              a = (a * a) % mod;
              n /= 2;
          }
          return result;
      }
  
      //Matrix multiplication
      static long[][] matrixMultiply(long[][] a, long[][] b, int row, int col, int mid, long mod) {
          long[][] c = new long[row][col];
          for (int i = 0; i < row; i++) {
              for (int j = 0; j < col; j++) {
                  c[i][j] = 0;
                  for (int k = 0; k < mid; k++) {
                      c[i][j] = (c[i][j] + (a[i][k] * b[k][j]) % mod) % mod;
                  }
              }
          }
          return c;
      }
  
      //Matrix Exponentiation
      static long[][] matrixExponentiation(long[][] a, long n, int size, long mod) {
          if (n == 0) {
              long[][] temp = new long[size][size];
              for (int i = 0; i < size; i++) {
                  temp[i][i] = 1;
              }
              return temp;//Returns identity matrix
          } else {
              long[][] temp = matrixExponentiation(a, n / 2, size, mod);
              if (n % 2 == 0) {
                  return matrixMultiply(temp, temp, size, size, size, mod);
              } else {
                  return matrixMultiply(matrixMultiply(temp, temp, size, size, size, mod), a, size, size, size, mod);
              }
          }
      }
  
      //Solution starts here
      public static void main(String[] args) {
  
          //Input output class reference
          FastReader sc = new FastReader();
          PrintWriter pw = new PrintWriter(System.out);
  
          int n=sc.nextInt();
          int m1= sc.nextInt();
          int m2=sc.nextInt();
          int Mocha[]=new int[n];
          int Diana[]=new int[n];
          int u,v;
  
          for(int j=0;j<n;j++)
          {
              Mocha[j]=j;
              Diana[j]=j;
          }
  
          for(int j=0;j<m1;j++)
          {
              u=sc.nextInt();
              v=sc.nextInt();
              Mocha[find(Mocha,v-1)]=find(Mocha,u-1);
          }
  
          for(int j=0;j<m2;j++)
          {
              u=sc.nextInt();
              v=sc.nextInt();
              Diana[find(Diana,v-1)]=find(Diana,u-1);
          }
  
          int count=0;
          int[][] matrix =new int[n][n];
  
          for(int j=0;j<n;j++)
          {
              for(int k=0;k<n;k++)
              {
                  if((find(Mocha,j)!=find(Mocha,k)) && (find(Diana,j)!=find(Diana,k)))
                  {
                      count++;
                      matrix[j][k]=1;
                      Mocha[find(Mocha,k)]=find(Mocha,j);
                      Diana[find(Diana,k)]=find(Diana,j);
                  }
              }
          }
  
          pw.println(count);
          for(int j=0;j<n;j++)
          {
              for(int k=0;k<n;k++)
              {
                  if(matrix[j][k]==1)
                  {
                      pw.println((j+1)+" "+(k+1));
                  }
              }
          }
          pw.flush();
      }
      public static int find(int[] M, int n)
      {
         if(M[n]==n)
             return n;
         else
         {
             M[n]=find(M,M[n]);
             return M[n];
         }
      }
      //Solution ends here
  }