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

template<typename Key, typename Value>
class Generoi
{
    static const unsigned SWITCH_LIMIT = 3;
    
    typedef std::map<Key, Value>  Map;
    typedef std::pair<Key, Value> Pair;
    typedef std::vector<Pair> Vector;
    unsigned indent;
    std::ostream& o;
public:
    Generoi(const Map& kartta, std::ostream& out): indent(0), o(out)
    {
        Vector values;
        
        for(typename Map::const_iterator
            i = kartta.begin();
            i != kartta.end(); ++i)
        {
            values.push_back(*i);
        }
        
        Recurse(values, 0, values.size());
    }
private:
    void Indent()
    {
        for(unsigned n=0; n<indent; ++n) o << ' ';
    }
    void StartBlock(bool need_angles)
    {
        if(need_angles) { Indent(); o << "{\n"; } indent += 4; 
    }
    void EndBlock(bool need_angles)
    {
        indent -= 4; if(need_angles) { Indent(); o << "}\n"; }
    }
    void CompareEqual(const Key& key)
    {
        Indent();
        o << "if(value == " << key << ") ";
    }
    void CompareLess(const Key& key)
    {
        Indent();
        o << "if(value <= " << key << ")\n";
    }
    void CompareElse()
    {
        Indent(); o << "else\n";
    }
    void Result(const Value& value)
    {
        o << "return \"" << value << "\";\n";
    }
    void EndIf()
    {
    }
    void Recurse(const Vector& values, unsigned min, unsigned max)
    {
        Indent(); o << "/* Recurse(" << min << ", " << max << ") */\n";
        
        if(max-min == 1)
        {
            CompareEqual(values[min].first);
            Result(values[min].second);
            EndIf();
            return;
        }
        if(max - min <= SWITCH_LIMIT)
        {
            Indent(); o << "switch(value)\n";
            StartBlock(true);
            for(unsigned pos=min; pos<max; ++pos)
            {
                Indent(); o << "case " << values[pos].first << ": ";
                Result(values[pos].second);
            }
            EndBlock(true);
            return;
        }
        
        unsigned mid = (min+max) / 2;

        bool handle_this = (max-min <= SWITCH_LIMIT+2);
        
        if(handle_this)
        {
            CompareEqual(values[mid].first);
            Result(values[mid].second);
            EndIf();
        }
        
        unsigned gmin = mid;
        unsigned lmax = gmin;
        if(handle_this) ++gmin;
        bool need_angles;

        CompareLess(values[mid].first);
        need_angles = (lmax-min > SWITCH_LIMIT) || (lmax-min <= 1);
        StartBlock(need_angles); Recurse(values, min, lmax); EndBlock(need_angles);
        
        CompareElse();
        need_angles = (max-gmin > SWITCH_LIMIT) || (max-gmin <= 0);
        StartBlock(need_angles); Recurse(values, gmin, max); EndBlock(need_angles);
        EndIf();
    }
};

#include <string>
int main(int argc, const char *const *argv)
{
    std::map<int, std::string> testi;
    
    testi[0x00C6] = "AElig";
    testi[0x0386] = "Aacgr";
    testi[0x00C1] = "Aacute";
    testi[0x0102] = "Abreve";
    testi[0x00C2] = "Acirc";
    testi[0x0410] = "Acy";
    testi[0x0391] = "Agr";
    testi[0x00C7] = "Ccedil";
    testi[0x0108] = "Ccirc";
    testi[0x0402] = "DJcy";
    testi[0x0112] = "Emacr";
    testi[0x0118] = "Eogon";
    testi[0x0395] = "Epsilon";
    testi[0x0397] = "Eta";
    testi[0x00CB] = "Euml";
    testi[0x0424] = "Fcy";
    testi[0x0403] = "GJcy";
    testi[0x0393] = "Gamma";
    testi[0x011E] = "Gbreve";
    testi[0x0122] = "Gcedil";
    testi[0x011C] = "Gcirc";
    
    Generoi<int, std::string>   (testi, std::cout);
    
    return 0;
}