#include <cassert>

struct Elem_T
{
    int k;
    unsigned int d;
};

struct Elem_M
{
    int k;
    int c;
};

enum IOState
{
    Norm,
    Abnorm
};

#include <iostream>

// T -----------------------------
class T
{
    std::istream &stream;
    bool l;
    
public:
    T (std::istream &stream_);
    IOState Read(Elem_T &di);
};

T::T(std::istream &stream_):
    stream(stream_),
    l (true)
{
}

IOState T::Read(Elem_T &di)
{
    if (!l)
        return Abnorm;

    l = false;
    stream >> di.k;
    if (!stream.eof ())
    {
        stream >> di.d;
        if (!stream.eof ())
        {
            l = true;
            return Norm;
        }
    }

    return Abnorm;
}

// M -----------------------------
class M
{
    class M0
    {
        std::istream &stream;
        bool l;
    public:
        M0 (std::istream &stream);
        IOState Read (Elem_M &dm0);
    };
    
    M0 m0;
    bool l;

    Elem_M dm0;
    IOState sm0;
    
    int k;
    int c;
    
public:
    M (std::istream &stream);
    IOState Read(Elem_M &sm);
};

M::M0::M0 (std::istream &stream_):
    stream (stream_),
    l (true)
{
}

IOState M::M0::Read(Elem_M &dm0)
{
    if (!l)
        return Abnorm;

    l = false;
    stream >> dm0.k;
    if (!stream.eof ())
    {
        stream >> dm0.c;
        if (!stream.eof ())
        {
            l = true;
            return Norm;
        }
    }

    return Abnorm;
}

M::M (std::istream &stream):
    m0 (stream),
    l (false)
{
    sm0 = m0.Read (dm0);
    if (sm0 == Norm)
    {
        l = true; k = dm0.k; c = 0;

        while (sm0 == Norm && dm0.k == k)
        {
            c += dm0.c;
            sm0 = m0.Read (dm0);
        }
    }    
}

IOState M::Read (Elem_M &dm)
{
    if (!l)
        return Abnorm;

    dm.k = k; dm.c = c;

    l = false;
    if (sm0 == Norm)
    {
        l = true; k = dm0.k; c = 0;
        while (sm0 == Norm && dm0.k == k)
        {
            c += dm0.c;
            sm0 = m0.Read (dm0);
        }
    }    
    
    return Norm;
}


// Main --------------------------
void Process (std::istream &stream_i, std::istream &stream_m, std::ostream &stream_o)
{
    T i (stream_i);
    M m (stream_m);

    Elem_T di;
    IOState si = i.Read (di);

    Elem_M dm;
    IOState sm = m.Read (dm);

    while (si == Norm || sm == Norm)
    {
        if (sm != Norm || si == Norm && di.k < dm.k)
        {
            stream_o << di.k << " " << di.d << std::endl;
            
            si = i.Read (di);
        }
        else if (si == sm && di.k == dm.k)
        {
            assert (di.d + dm.c >= 0);
            
            stream_o << di.k << " " << int (di.d + dm.c) << std::endl;

            si = i.Read (di);
            sm = m.Read (dm);
        }
        else if (si != Norm || sm == Norm && dm.k < di.k)
        {
            assert (dm.c >= 0);

            stream_o << dm.k << " " << int (dm.c) << std::endl;

            sm = m.Read (dm);
        }
    }    
}

// Framework ---------------------
#include <fstream>

int main (int argc, char **argv)
{
    if (argc != 3)
    {
        std::cerr << "Meg kell adnod a nyitóegyenleg és a módosítófájl nevét!" << std::endl;
        return -1;
    }
    
    std::ifstream stream_i (argv[1]);
    if (!stream_i)
    {
        std::cerr << "Fájl megnyitása nem sikerült: " << argv[1] << std::endl;        
        return -1;
    }

    std::ifstream stream_m (argv[2]);
    if (!stream_m)
    {
        std::cerr << "Fájl megnyitása nem sikerült: " << argv[2] << std::endl;        
        return -1;
    }

    Process (stream_i, stream_m, std::cout);
}