#include <map>
#include <iostream>
#include <string>
#include <vector>


// Для простых примитивных типов (int, bool, char и т. д.) и plain old data
template<typename T>
void Serialize(T pod, std::ostream &out);

void Serialize(const std::string &str, std::ostream &out);

template<typename T>
void Serialize(const std::vector<T> &data, std::ostream &out);

template<typename T1, typename T2>
void Serialize(const std::map<T1, T2> &data, std::ostream &out);


template<typename T>
void Deserialize(std::istream &in, T &pod);

void Deserialize(std::istream &in, std::string &str);

template<typename T>
void Deserialize(std::istream &in, std::vector<T> &data);

template<typename T1, typename T2>
void Deserialize(std::istream &in, std::map<T1, T2> &data);


template<typename T>
void Serialize(T pod, std::ostream &out) {
    out.write(reinterpret_cast<const char *>(&pod), sizeof(pod));
}

void Serialize(const std::string &str, std::ostream &out) {
    out.write(reinterpret_cast<const char *>(sizeof(str), sizeof(sizeof(str)));
    for (auto el : str) {
        out.write(reinterpret_cast<const char *>(&el), sizeof(el));
    }
}

template<typename T>
void Serialize(const std::vector<T> &data, std::ostream &out) {
    out.write(reinterpret_cast<char *>(sizeof(data), sizeof(sizeof(data)));
    for (auto el: data) {
        out.write(reinterpret_cast<const char *>(&el), sizeof(el));
    }
}

template<typename T1, typename T2>
void Serialize(const std::map<T1, T2> &data, std::ostream &out) {
    out.write(reinterpret_cast<char *>(sizeof(data)), sizeof(sizeof(data)));
    for (auto &el: data){
        Serialize(el.first, out);
        Serialize(el.second, out);
    }
};

template<typename T>
void Deserialize(std::istream &in, T &pod){
    in.read(reinterpret_cast<char*> (&pod), sizeof(T));
}


void Deserialize(std::istream &in, std::string &str){
    size_t sz;
    in.read(reinterpret_cast<char *>(&sz), sizeof(size_t));
    for(size_t i = 0; i != sz; ++i){
        in.read(reinterpret_cast<char *>(&(str[i])), sizeof(char));
    }
}

template<typename T1, typename T2>
void Deserialize(std::istream &in, std::map<T1, T2> &data){
    size_t sz;
    in.read(reinterpret_cast<char *>(&sz), sizeof(size_t));
    for(size_t i = 0; i != sz; ++i){
        T1 first;
        T2 second;
        Deserialize(in, first);
        Deserialize(in, second);
        data[first] = second;
    }
};

template<typename T>
void Deserialize(std::istream &in, std::vector<T> &data){
    size_t sz;
    in.read(reinterpret_cast<char *>(&sz), sizeof(size_t));
    for(size_t i = 0; i != sz; ++i){
        Deserialize(in, data[i]);
    }
}