if (you.your_level || stair_direction(feat) == CMD_GO_DOWNSTAIRS)

        if ((you.your_level || stair_direction(feat) == CMD_GO_DOWNSTAIRS)
            && you.where_are_you != BRANCH_VESTIBULE_OF_HELL)

%token <i>      PRELUDE MAIN VALIDATE VETO

%token <i>      PRELUDE MAIN VALIDATE VETO NSUBST

                | nsubst

                ;
nsubst          : NSUBST nsubst_specifiers { }

nsubst_specifiers : nsubst_spec
                  | nsubst_specifiers COMMA nsubst_spec
                  ;
nsubst_spec     : ITEM_INFO
                {
                    lc_map.main.add(
                        yylineno, 
                        make_stringf("nsubst(\"%s\")", 
                            quote_lua_string($1).c_str()));
                }
                ;
                

NSUBST:             { BEGIN(ITEM_LIST); return NSUBST; }

#ifdef DEBUG_DIAGNOSTICS
    mprf(MSGCH_DIAGNOSTICS, "Placing lost one: %s",
         f.mons.name(DESC_PLAIN).c_str());
#endif    

        TT_NSUBST,

    subst_spec() : foo(0), fix(false), frozen_value(0), repl() { }

};
class nsubst_spec : public map_transformer
{
public:
    nsubst_spec(int key, const std::vector<subst_spec> &specs);
    std::string apply_transform(map_lines &map);
    map_transformer *clone() const;
    transform_type type() const { return TT_NSUBST; }
    std::string describe() const;
    
public:
    int key;
    std::vector<subst_spec> specs;

    std::string add_nsubst(const std::string &st);

    void clear_nsubsts();

    void nsubst(nsubst_spec &);

    std::string parse_nsubst_spec(const std::string &s,
                                  subst_spec &spec);
    int apply_nsubst(std::vector<coord_def> &pos,
                     int start, int nsub,
                     subst_spec &spec);

    friend class nsubst_spec;

template <typename V>
void scramble(V &v)
{
    V temp(v);
    v.clear();
    while (!temp.empty())
    {
        int i = random2(temp.size());
        v.push_back(temp[i]);
        temp.erase(temp.begin() + i);
    }
}

                                  int *key,

                                  std::string *key,

                                  std::string *arg)

                                  std::string *arg,
                                  int key_max_len = 1)

    std::string what_to_subst = trimmed_string(s.substr(0, sep));

    *key = trimmed_string(s.substr(0, sep));

    if (what_to_subst.length() != 1)

    if (key->empty() || (int) key->length() > key_max_len)

            what_to_subst.c_str(), s.c_str());

            key->c_str(), s.c_str());

    *key = what_to_subst[0];

    std::string arg;
    int key = 0, sep = 0;

    std::string key, arg;
    int sep = 0;

    transforms.push_back(new map_feat_marker_spec(key, feat));    

    transforms.push_back(new map_feat_marker_spec(key[0], feat));    

    int key = 0;

    std::string key;

    transforms.push_back( new subst_spec( key[0], sep == ':', repl ) );
    return ("");
}

    transforms.push_back( new subst_spec( key, sep == ':', repl ) );

std::string map_lines::parse_nsubst_spec(const std::string &s,
                                         subst_spec &spec)
{
    std::string key, arg;
    int sep;
    std::string err = split_key_item(s, &key, &sep, &arg);
    if (!err.empty())
        return err;
    const int keyval = key == "*"? -1 : atoi(key.c_str());
    if (!keyval)
        return make_stringf("Illegal spec: %s", s.c_str());
    
    glyph_replacements_t repl;
    err = parse_glyph_replacements(arg, repl);
    if (!err.empty())
        return (err);
    spec = subst_spec(keyval, sep == ':', repl);
    return ("");
}
std::string map_lines::add_nsubst(const std::string &s)
{
    std::vector<subst_spec> substs;
    int sep;
    std::string key, arg;
    std::string err = split_key_item(s, &key, &sep, &arg);
    if (!err.empty())
        return (err);
    
    std::vector<std::string> segs = split_string("/", arg);
    for (int i = 0, size = segs.size(); i < size; ++i)
    {
        std::string &ns = segs[i];
        if (ns.find('=') == std::string::npos
            && ns.find(':') == std::string::npos)
        {
            if (i < size - 1)
                ns = "1=" + ns;
            else
                ns = "*=" + ns;
        }
        subst_spec spec;
        err = parse_nsubst_spec(ns, spec);
        if (!err.empty())
            return (make_stringf("Bad NSUBST spec: %s (%s)",
                                 s.c_str(), err.c_str()));
        substs.push_back(spec);
    }

    transforms.push_back( new nsubst_spec(key[0], substs) );

void map_lines::clear_nsubsts()
{
    clear_transforms(map_transformer::TT_NSUBST);
}

}
void map_lines::nsubst(nsubst_spec &spec)
{
    std::vector<coord_def> positions;
    for (int y = 0, ysize = lines.size(); y < ysize; ++y)
    {
        std::string::size_type pos = 0;
        while ((pos = lines[y].find(spec.key, pos)) != std::string::npos)
            positions.push_back(coord_def(pos++, y));
    }
    scramble(positions);
    int pcount = 0;
    const int psize = positions.size();
    for (int i = 0, size = spec.specs.size(); i < size && pcount < psize; ++i)
    {
        const int nsubsts = spec.specs[i].key();
        pcount += apply_nsubst(positions, pcount, nsubsts, spec.specs[i]);
    }
}
int map_lines::apply_nsubst(std::vector<coord_def> &pos,
                             int start, int nsub,
                             subst_spec &spec)
{
    if (nsub == -1)
        nsub = pos.size();
    const int end = std::min(start + nsub, (int) pos.size());
    int substituted = 0;
    for (int i = start; i < end; ++i)
    {
        const int val = spec.value();
        const coord_def &c = pos[i];
        lines[c.y][c.x] = val;
        ++substituted;
    }
    return (substituted);

    int key = 0;

    std::string arg;

    std::string key, arg;

    keyed_mapspec &km = keyspecs[key];
    km.key_glyph = key;

    keyed_mapspec &km = keyspecs[key[0]];
    km.key_glyph = key[0];

// nsubst_spec
nsubst_spec::nsubst_spec(int _key, const std::vector<subst_spec> &_specs)
    : key(_key), specs(_specs)
{
}
std::string nsubst_spec::apply_transform(map_lines &map)
{
    map.nsubst(*this);
    return ("");
}
map_transformer *nsubst_spec::clone() const
{
    return new nsubst_spec(key, specs);
}
std::string nsubst_spec::describe() const
{
    return ("");
}
//////////////////////////////////////////////////////////////////////////

static int dgn_subst(lua_State *ls)

static int dgn_map_add_transform(
    lua_State *ls,
    std::string (map_lines::*add)(const std::string &s),
    void (map_lines::*erase)())

    if (lua_gettop(ls) == 1)
        return dlua_stringtable(ls, map->get_subst_strings());

            map->map.clear_substs();

            (map->map.*erase)();

            std::string err = map->map.add_subst(luaL_checkstring(ls, i));

            std::string err = (map->map.*add)(luaL_checkstring(ls, i));

}
static int dgn_subst(lua_State *ls)
{
    return dgn_map_add_transform(ls, &map_lines::add_subst,
                                 &map_lines::clear_substs);
}
static int dgn_nsubst(lua_State *ls)
{
    return dgn_map_add_transform(ls, &map_lines::add_nsubst,
                                 &map_lines::clear_nsubsts);

    { "nsubst", dgn_nsubst },

syn keyword desSubstDec SUBST: contained
syn keyword desNsubstDec NSUBST: contained
syn keyword desShuffleDec SHUFFLE: contained

syn region desShuffle start=/^SHUFFLE:\s*/ end=/$/ contains=desShuffleDec,desMapFrag keepend

syn region desNsubst start=/^NSUBST:\s*/ end=/$/ contains=desNsubstDec,desSubstArg,desSubstSep,@desMapElements keepend

syn keyword desSubstDec SUBST: contained
syn keyword desShuffleDec SHUFFLE: contained

syn region desShuffle start=/^SHUFFLE:\s*/ end=/$/ contains=desShuffleDec,desMapFrag keepend

hi link desNsubstDec  Statement

NSUBST:  ? = 3:w / *:l
         NSUBST is similar to SUBST, replacing placeholders with
         replacements values. Unlike SUBST, however, it allows you to
         replace different instances of the same placeholder with
         completely different substitutions. For instance:

         ? = 3:w / *:l
         replaces three occurrences (randomly selected) of ? with w
         and all others with l.
         
         You can use complex SUBST specifications:
         ? = 3= w .:15 A / *: =+CF
         This is equivalent to SUBST: ? = w .:15 A for three ? and
         SUBST: ? : =+CF for all the others.
         You use any number of NSUBST specifiers:
         ? = wW / l / A / 1234
         Each specifier is preceded by the number of symbols to apply
         it to, followed by : or = (: to use one substitution for all
         occurrences, = to randomly pick for each occurrence). If you
         omit the initial N: or N=, then 1= is assumed, except for the
         last spec where *= is assumed.