for (int i = 1; i < (int) s.length(); ++i)

    for (unsigned int i = 1; i < s.length(); ++i)

    int itty = igrd[0][5 + shopidx];
    while ( itty != NON_ITEM )
    {
        result.push_back( itty );
        itty = mitm[itty].link;
    }

    // Shop items are heaped up at this cell.
    const coord_def stack_location(0, 5 + shopidx);
    for (stack_iterator si(stack_location); si; ++si)
        result.push_back(si.link());

        const int gp_value = _shop_get_item_value(mitm[stock[i]], shop.greed,
                                                  id);

        const item_def& item = mitm[stock[i]];
        const int gp_value = _shop_get_item_value(item, shop.greed, id);

            const std::string colprf = menu_colour_item_prefix(mitm[stock[i]]);
            const int col = menu_colour(mitm[stock[i]].name(DESC_NOCAP_A),

            const std::string colprf = menu_colour_item_prefix(item);
            const int col = menu_colour(item.name(DESC_NOCAP_A),

                mitm[stock[i]].name(DESC_NOCAP_A, false, id).substr(0, 56).
                    c_str(),

                item.name(DESC_NOCAP_A, false, id).substr(0, 56).c_str(),

        si.add_item(mitm[stock[i]], gp_value);

        si.add_item(item, gp_value);

        for (unsigned int k = 0; k < stock.size(); k++)

        // Autoinscribe randarts in the shop.
        for (unsigned int i = 0; i < stock.size(); i++)

            if (Options.autoinscribe_randarts
                && is_random_artefact(mitm[stock[k]]))
            {
                mitm[stock[k]].inscription =
                    randart_auto_inscription(mitm[stock[k]]);
            }

            item_def& item = mitm[stock[i]];
            if (Options.autoinscribe_randarts && is_random_artefact(item))
                item.inscription = randart_auto_inscription(item);

                _shop_print("I'm sorry, you don't seem to have enough money.", 1);

                _shop_print("I'm sorry, you don't seem to have enough money.",
                            1);

    // Find shop.
    for (int shoppy = 0; shoppy < MAX_SHOPS; shoppy ++)

    // Check all shops for one at the correct position.
    for (int i = 0; i < MAX_SHOPS; i ++)

        // Find shop index plus a little bit of paranoia.
        if (env.shop[shoppy].pos == where
            && env.shop[shoppy].type != SHOP_UNASSIGNED)
        {
            return (&env.shop[shoppy]);
        }

        shop_struct& shop = env.shop[i];
        // A little bit of paranoia.
        if (shop.pos == where && shop.type != SHOP_UNASSIGNED)
            return (&shop);

        int temp = where.x + where.y % 4;
        sh_name += (temp == 0) ? " Shoppe" :
                   (temp == 1) ? " Boutique" :
                   (temp == 2) ? " Emporium"
                               : " Shop";

        const char* suffixnames[] = {"Shoppe", "Boutique", "Emporium", "Shop"};
        const int temp = where.x + where.y % 4;
        sh_name += ' ';
        sh_name += suffixnames[temp];

            result += (mon.number ==  1) ? "one"   :
                      (mon.number ==  2) ? "two"   :
                      (mon.number ==  3) ? "three" :
                      (mon.number ==  4) ? "four"  :
                      (mon.number ==  5) ? "five"  :
                      (mon.number ==  6) ? "six"   :
                      (mon.number ==  7) ? "seven" :
                      (mon.number ==  8) ? "eight" :
                      (mon.number ==  9) ? "nine"
                                         : "ten";

            const char* cardinals[] = {"one", "two", "three", "four", "five",
                                       "six", "seven", "eight", "nine", "ten"};
            result += cardinals[mon.number - 1];

    ASSERT(NUM_KILLBY ==
           (int) sizeof(kill_method_names) / sizeof(*kill_method_names));

    ASSERT(NUM_KILLBY == ARRAYSZ(kill_method_names));

    ASSERT(NUM_KILLBY ==
           (int) sizeof(kill_method_names) / sizeof(*kill_method_names));

    ASSERT(NUM_KILLBY == ARRAYSZ(kill_method_names));

    int start = 0, end = 1;
    while (start < (int) temp.size())

    unsigned int start = 0, end = 1;
    while (start < temp.size())

        for (end = start + 1; end < (int) temp.size(); ++end)

        for (end = start + 1; end < temp.size(); ++end)

    return static_cast<unsigned long>(props["cards"].get_vector().size());

    return (props["cards"].get_vector().size());

                              card_name(card));

             card_name(card));

        item.plus = static_cast<int>(types[keyin - 'a']);

        item.plus = types[keyin - 'a'];

    int              base   = static_cast<int>(DECK_RARITY_COMMON);
    deck_rarity_type rarity =
        static_cast<deck_rarity_type>(base + rarity_val);

    const deck_rarity_type rarity =
        static_cast<deck_rarity_type>(DECK_RARITY_COMMON + rarity_val);

        std::string path_str = "";

        std::string path_str;

    for (int i = ((int) GOD_NO_GOD) + 1; i < NUM_GODS; i++)

    for (int i = GOD_NO_GOD + 1; i < NUM_GODS; i++)