#include <bits/stdc++.h>
#include <omp.h>

using namespace std;

class CFabricData;
class CFabricData0;
class CFabricData1;

time_t t1, t2;

class CComplexVector
{
public:
    CComplexVector() {
        sz = 0;
        arr.resize(0);
    }

    CComplexVector(const vector <pair <int, int> > & mas) {
        sz = mas.size();
        arr.resize(sz);
        for (size_t i = 0; i < sz; ++i) {
            arr[i] = mas[i];
        }
    }

    CComplexVector(const CComplexVector& obj) {
        sz = obj.sz;
        arr.resize(sz);
        for (size_t i = 0; i < sz; ++i) {
            arr[i] = obj.arr[i];
        }
    }

    CComplexVector(int sz_, pair <int, int> comp) {
        sz = sz_;
        arr.resize(sz);
        for (size_t i = 0; i < sz; ++i) {
            arr[i] = comp;
        }
    }

    virtual ~CComplexVector() {
        arr.resize(0);
    }

    static CComplexVector* create (int Type, vector <pair <int, int> > vec, string Filename_, CFabricData** f);

    CComplexVector& operator=( const CComplexVector & obj) {
        if (this == &obj) {
            return *this;
        }
        sz = obj.sz;
        arr.resize(sz);
        for (size_t i = 0; i < sz; ++i)
            arr[i] = obj.arr[i];
        return *this;
    }

    friend ostream & operator << (ostream &out, const CComplexVector & obj) {
        out << obj.sz << endl;
        for (size_t i = 0; i < obj.sz; ++i) {
            out << obj.arr[i].first << ' ' << obj.arr[i].second << endl;
        }
        return out;
    }

    virtual void output (string Filename_) = 0;
    virtual string get_name() = 0;

protected:
    vector <pair <int, int> > arr;
    int sz;
};

class CComplexVector0:public CComplexVector {
public:
    CComplexVector0(const vector <pair <int, int> >&x, string Filename_) : CComplexVector(x), Filename(Filename_) {}
    CComplexVector0(string Filename_) : CComplexVector(), Filename(Filename_) {}
    CComplexVector0(const CComplexVector0& obj) : CComplexVector(obj.arr),  Filename{obj.Filename} {}
    CComplexVector0(int sz_, pair <int, int> comp, string Filename_) : CComplexVector(sz_, comp), Filename(Filename_) {}

    CComplexVector0 operator- (const CComplexVector0 &obj) {
        int new_sz = max(obj.sz, sz);
        vector <pair <int, int> > vec(new_sz);
        for (size_t i = 0; i < new_sz; ++i) {
            if (obj.sz > i && sz > i) {
                vec[i].first = arr[i].first - obj.arr[i].first;
                vec[i].second = arr[i].second - obj.arr[i].second;
            } else if (obj.sz > i) {
                vec[i].first = -obj.arr[i].first;
                vec[i].second = -obj.arr[i].second;
            } else {
                vec[i].first = arr[i].first;
                vec[i].second = arr[i].second;
            }
        }
        CComplexVector0 res(vec, this->Filename);
        return res;
    }

    CComplexVector0 operator+ (const CComplexVector0 &obj) {
        int new_sz = max(obj.sz, sz);
        vector <pair <int, int> > vec(new_sz);
        for (size_t i = 0; i < new_sz; ++i) {
            if (obj.sz > i && sz > i) {
                vec[i].first = obj.arr[i].first + arr[i].first;
                vec[i].second = obj.arr[i].second + arr[i].second;
            } else if (obj.sz > i) {
                vec[i].first = obj.arr[i].first;
                vec[i].second = obj.arr[i].second;
            } else {
                vec[i].first = arr[i].first;
                vec[i].second = arr[i].second;
            }
        }
        CComplexVector0 res(vec, this->Filename);
        return res;
    }

    CComplexVector0& operator+= (const CComplexVector0 &obj) {
        *this = *this + obj;
        return *this;
    }

    CComplexVector0& operator-= (const CComplexVector0 &obj) {
        *this = *this - obj;
        return *this;
    }

    CComplexVector0 operator* (const CComplexVector0 &obj) {
        int new_sz = max(obj.sz, sz);
        vector <pair <int, int> > vec(new_sz);
        #pragma omp parallel for
        for (size_t i = 0; i < min(obj.sz, sz); ++i) {
            pair <int, int> tmp = obj.arr[i];
            vec[i].first = arr[i].first * tmp.first - arr[i].second * tmp.second;
            vec[i].second = arr[i].first * tmp.second + arr[i].second * tmp.first;
        }
        for (size_t i = min(obj.sz, sz); i < max(obj.sz, sz); ++i)
            vec[i] = {0, 0};
        CComplexVector0 res(vec, this->Filename);
        return res;
    }

    CComplexVector0& operator*= (const CComplexVector0 &obj) {
        *this = *this * obj;
        return *this;
    }

    virtual string get_name() {
        return this->Filename;
    }

    virtual void output (string Filename_) {
        ofstream out;
        out.open(Filename_.c_str(), ofstream::out | ofstream::app);
        out << sz << ' ';
        for (size_t i = 0; i < sz; ++i) {
            out << arr[i].first << ' ' << arr[i].second << ' ';
        }
        out.close();
    }

private:
    string Filename;
};


class CComplexVector1:public CComplexVector {
public:
    CComplexVector1(const vector <pair <int, int> >&x, string Filename_) : CComplexVector(x), Filename(Filename_) {}
    CComplexVector1(string Filename_) : CComplexVector(), Filename(Filename_) {}
    CComplexVector1(const CComplexVector1& obj, string Filename_) : CComplexVector(obj), Filename(Filename_) {}
    CComplexVector1(int sz_, pair <int, int> comp, string Filename_) : CComplexVector(sz_, comp), Filename(Filename_) {}

    CComplexVector1 operator- (const CComplexVector1 &obj) {
        int new_sz = max(obj.sz, sz);
        vector <pair <int, int> > vec(new_sz);
        for (size_t i = 0; i < new_sz; ++i) {
            if (obj.sz > i && sz > i) {
                vec[i].first = arr[i].first - obj.arr[i].first;
                vec[i].second = arr[i].second - obj.arr[i].second;
            } else if (obj.sz > i) {
                vec[i].first = -obj.arr[i].first;
                vec[i].second = -obj.arr[i].second;
            } else {
                vec[i].first = arr[i].first;
                vec[i].second = arr[i].second;
            }
        }
        CComplexVector1 res(vec, this->Filename);
        return res;
    }

    CComplexVector1 operator+ (const CComplexVector1 &obj) {
        int new_sz = max(obj.sz, sz);
        vector <pair <int, int> > vec(new_sz);
        for (size_t i = 0; i < new_sz; ++i) {
            if (obj.sz > i && sz > i) {
                vec[i].first = obj.arr[i].first + arr[i].first;
                vec[i].second = obj.arr[i].second + arr[i].second;
            } else if (obj.sz > i) {
                vec[i].first = obj.arr[i].first;
                vec[i].second = obj.arr[i].second;
            } else {
                vec[i].first = arr[i].first;
                vec[i].second = arr[i].second;
            }
        }
        CComplexVector1 res(vec, this->Filename);
        return res;
    }

    CComplexVector1& operator+= (const CComplexVector1 &obj) {
        *this = *this + obj;
        return *this;
    }

    CComplexVector1& operator-= (const CComplexVector1 &obj) {
        *this = *this - obj;
        return *this;
    }

    CComplexVector1 operator* (const CComplexVector1 &obj) {
        int new_sz = max(obj.sz, sz);
        vector <pair <int, int> > vec(new_sz);
        for (size_t i = 0; i < min(obj.sz, sz); ++i) {
            pair <int, int> tmp = obj.arr[i];
            vec[i].first = arr[i].first * tmp.first - arr[i].second * tmp.second;
            vec[i].second = arr[i].first * tmp.second + arr[i].second * tmp.first;
        }
        for (size_t i = min(obj.sz, sz); i < max(obj.sz, sz); ++i)
            vec[i] = {0, 0};
        CComplexVector1 res(vec, this->Filename);
        return res;
    }

    CComplexVector1& operator*= (const CComplexVector1 &obj) {
        *this = *this * obj;
        return *this;
    }

    virtual string get_name() {
        return this->Filename;
    }

    virtual void output(string Filename_) {
        ofstream out;
        out.open(Filename_.c_str(), ofstream::app);
        out << sz << endl;
        for (size_t i = 0; i < sz; ++i) {
            out << arr[i].first << ' ' << arr[i].second << endl;
        }
        out.close();
    }
private:
    string Filename;
};

class CFabricData {
public:
    virtual CComplexVector* create(vector <pair<int, int> > vec, string Filename_) = 0;
};

class CFabricData0:public CFabricData {
public:
    virtual CComplexVector0* create(vector <pair <int, int> > vec, string Filename_) {
        return new CComplexVector0(vec, Filename_);
    }
};

class CFabricData1:public CFabricData {
public:
    virtual CComplexVector1* create(vector <pair <int, int> > vec, string Filename_) {
        return new CComplexVector1(vec, Filename_);
    }
};

CComplexVector* CComplexVector::create(int Type, vector <pair <int, int> > vec, string Filename_, CFabricData** f) {
        CComplexVector* t = f[Type]->create(vec, Filename_);
        return t;
}

int main()
{
    /*
    ifstream in;
    in.open("files.txt");
    int n;
    in >> n;
    vector <CComplexVector0> vec0;
    for (size_t i = 0; i < n; ++i) {
        int type, n;
        string out_file;
        in >> type >> out_file >> n;
        vector <pair <int, int> > tmp(n);
        for (size_t j = 0; j < n; ++j) {
            int x, y;
            in >> x >> y;
            tmp[j].first = x;
            tmp[j].second = y;
        }
        if (type) {
            CComplexVector1 a(tmp, out_file);
        } else {
            CComplexVector0 a(tmp, out_file);
            vec0.push_back(a);
        }
    }
    in.close();
    vec0[0].output(vec0[0].get_name());*/
    CComplexVector** t;
    ifstream in;
    in.open("files.txt");
    int n;
    in >> n;
    t = new CComplexVector*[n];
    CFabricData* f[2] = {new CFabricData0(), new CFabricData1()};
    for (size_t i = 0; i < n; ++i) {
        int type, sz;
        string out_file;
        in >> type >> out_file >> sz;
        vector <pair <int, int> > tmp(sz);
        for (size_t j = 0; j < sz; ++j) {
            int x, y;
            in >> x >> y;
            tmp[j].first = x;
            tmp[j].second = y;
        }
        t[i] = CComplexVector::create(type, tmp, out_file, f);
    }
    for (size_t i = 0; i < n; ++i) {
        t[i]->output(t[i]->get_name());
    }
    CComplexVector0 a(10000, {1, 1}, "x"), b(10000, {1, 1}, "x");
    clock_t begin_time1 = clock();
    CComplexVector0 c = a * b;
    cout << float(clock() - begin_time1)/ CLOCKS_PER_SEC;
    CComplexVector1 a1(10000, {1, 1}, "x"), b1(10000, {1, 1}, "x");
    begin_time1 = clock();
    CComplexVector1 c1 = a1 * b1;
    cout << float(clock() - begin_time1)/ CLOCKS_PER_SEC;
    return 0;
}