#include <iostream>
#include <vector>
#include <cstdio>
#include <string>
#include <cassert>
#include <cmath>

typedef long long i64;

using namespace std;

void relax(int& val, int newval) {
    if (val == -1 || val > newval) {
        val = newval;
    }
}

const int MINS = 24 * 60;
// vector<vector<vector<int> > > d(MINS + 1, vector<vector<int> >(MINS + 1, vector<int>(2, -1)));
int d[MINS][MINS][2];


int main() {
    freopen("input.txt", "r" , stdin);
    freopen("output.txt", "w" , stdout);

    int tests;
    cin >> tests;
    // vector<vector<vector<int> > > d(MINS + 1, vector<vector<int> >(MINS + 1, vector<int>(2, -1)));

    for (int test = 1; test <= tests; test++) {
        cout << "Case #" << test << ": ";

        int n, m;
        cin >> n >> m;

        vector<int> busy[2];
        busy[0].assign(MINS, 0);
        busy[1].assign(MINS, 0);

        for (int i = 0; i < n; i++) {
            int l, c;
            cin >> l >> c;
            for (int j = l; j < l + c; j++) {
                busy[0][j] = true;
            }
        }


        for (int i = 0; i < m; i++) {
            int l, c;
            cin >> l >> c;
            for (int j = l; j < l + c; j++) {
                busy[1][j] = true;
            }
        }


        cout << "ASDASD" << endl;
        d[0][0][0] = 0;
        d[0][0][1] = 0;
        for (int i = 0; i < MINS; i++) {
            for (int j = 0; j <= i; j++) {
                if (d[i][j][0] != -1) {
                    if (!busy[0][i]) {
                        relax(d[i + 1][j + 1][0], d[i][j][0]);
                    }
                    if (!busy[1][i]) {
                        relax(d[i + 1][j][1], d[i][j][0] + 1);
                    }
                }

                if (d[i][j][1] != -1) {
                    if (!busy[0][i]) {
                        relax(d[i + 1][j + 1][0], d[i][j][1] + 1);
                    }
                    if (!busy[1][i]) {
                        relax(d[i + 1][j][1], d[i][j][1]);
                    }
                }
            }
        }

        // cout << min(d[MINS][MINS / 2][0], d[MINS][MINS / 2][1]) << endl;
    }
}