static bool has_nonsquelched_items( int obj ) {
    while ( obj != NON_ITEM ) {

static int count_nonsquelched_items( int obj ) {
    int result = 0;
    while ( obj != NON_ITEM )
    {

            return true;

            ++result;

    return false;

    return result;

                                    has_nonsquelched_items(obj));

                                    count_nonsquelched_items(obj));

    const int num_nonsquelched = count_nonsquelched_items(o);

    }                           // end of if items_here

    }
    else if (Options.pickup_mode != -1 &&
             num_nonsquelched >= Options.pickup_mode)
    {
        pickup_menu(o);
    }

        const bool hide_squelched = has_nonsquelched_items(o);

	    if ( hide_squelched && invisible_to_player(mitm[o]) ) {

	    if ( num_nonsquelched && invisible_to_player(mitm[o]) ) {

    pickup_mode            = -1;

    }
    else if (key == "pickup_mode")
    {
        if (field.find("multi") != std::string::npos)
            pickup_mode = 0;
        else if (field.find("single") != std::string::npos)
            pickup_mode = -1;
        else
            pickup_mode = read_bool_or_number(field, pickup_mode, "auto:");

    int         pickup_mode;        // -1 for single, 0 for menu,
                                    // X for 'if at least X items present'

pickup_mode = auto:5

		drop_mode, drop_filter;

		drop_mode, pickup_mode, drop_filter;

pickup_mode = (multi | single | auto:X)
        Single is the classical behaviour (and default): when picking up
        items, you are prompted for them one by one. Multi makes a menu
        appear, where you can choose which items to pick up. Note that
        no matter how many items you choose, picking up will always take
        one turn.
        If pickup_mode is auto:X, where X is some number (for example,
        auto:5), then pickup will give a menu if there are at least X
        items on your square, and will prompt one by one otherwise.