//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



//#define XERR
#include "main.ih"

int main(int argc, char **argv)
try
{
    xerr("MAIN");

    ifstream in{ argv[1] };

//    Omapbuf buffer(argv[2], ios::in | ios::out);
    IOmapbuf buffer(argv[2], ios::in | ios::out);//, "1K");

//    Omapbuf buffer(argv[2], ios::in | ios::out | ios::app);

//                   ios::in | (fs::exists(argv[2]) ? ios::app : ios::trunc)
//                );  // append to existing file

//    ostream io{ &buffer };
    iostream io{ &buffer };

xerr("START");

//    io << "hello world" << endl;

xerr("MID");

//    io.seekg(0);
//    cout << io.tellg() << '\n';

xerr("END");


//    out.seekp(20);

    string line;

//    getline(io, line);
//    cout << io.good() << ' ' << io.tellg() << '\n';
    
//    cout << line << '\n';


//    out << line << '\n';

//return 0;

        // arg 4: 'l' - write lines, 'w' - raw writes, 'r' (default: rdbuf)
    switch (argc == 4 ? *argv[3] : 'r')
    {
        case 'r':
            io << in.rdbuf();                // block-wise insertion
        break;

        case 'l':        
            while (getline(in, line))           // line-wise insertion
                io << line << '\n';
        break;

        case 'w':
            while (getline(in, line))           // raw writes
            {
                line += '\n';
                io.write(line.c_str(), line.length());
            }
        break;

        default:
            cout << "in out [l(ine), r(rdbuf), w(write)]\n";
        break;
    }

    io.flush();

    io.seekg(0);
    cout << io.rdbuf();

}
catch (exception const &exc)
{
    cerr << exc.what() << '\n';
    return 1;
}



