return;

        return;

    for ( unsigned i = 0; i < Options.autoinscriptions.size(); ++i ) {
	if ( Options.autoinscriptions[i].first.matches(iname) ) {
	    item.inscription += Options.autoinscriptions[i].second;
	}

    for ( unsigned i = 0; i < Options.autoinscriptions.size(); ++i )
    {
        if ( Options.autoinscriptions[i].first.matches(iname) )
        {
            item.inscription += Options.autoinscriptions[i].second;
        }

static bool is_banned(const item_def &item) {
    static char name[ITEMNAME_SIZE];
    item_name(item, DESC_INVENTORY, name, false);

static bool is_denied_autopickup(const item_def &item)
{
    std::string iname = item_name(item, DESC_PLAIN);
    for (unsigned i = 0, size = Options.never_pickup.size(); i < size; ++i)
    {
        if (Options.never_pickup[i].matches(iname))
            return (true);
    }
    return false;
}

    std::string iname = name;
    for (unsigned i = 0; i < Options.banned_objects.size(); ++i) {
        if (Options.banned_objects[i].matches(iname))
            return true;

static bool is_forced_autopickup(const item_def &item)
{
    std::string iname = item_name(item, DESC_PLAIN);
    for (unsigned i = 0, size = Options.always_pickup.size(); i < size; ++i)
    {
        if (Options.always_pickup[i].matches(iname))
            return (true);

    return (strstr(item.inscription.c_str(), "=g") != 0
            || ((item.flags & ISFLAG_THROWN) && Options.pickup_thrown)
            || (((Options.autopickups & (1L << item.base_type))

    if (strstr(item.inscription.c_str(), "=g") != 0)
        return (true);
    if ((item.flags & ISFLAG_THROWN) && Options.pickup_thrown)
        return (true);
    return (((Options.autopickups & (1L << item.base_type))
                 || is_forced_autopickup(item)

                && !is_banned(item)));

                && !is_denied_autopickup(item));

    banned_objects.clear();

    never_pickup.clear();
    always_pickup.clear();

        append_vector(banned_objects, split_string(",", field));

        append_vector(never_pickup, split_string(",", field));
    }
    else if (key == "autopickup_exceptions")
    {
        std::vector<std::string> args = split_string(",", field);
        for (int i = 0, size = args.size(); i < size; ++i)
        {
            const std::string &s = args[i];
            if (s.empty())
                continue;
            if (s[0] == '>')
                never_pickup.push_back( s.substr(1) );
            else if (s[0] == '<')
                always_pickup.push_back( s.substr(1) );
            else
                never_pickup.push_back( s );
        }

	append_vector(note_items, split_string(",", field));

        append_vector(note_items, split_string(",", field));

	std::vector<std::string> thesplit = split_string(":", field);
	autoinscriptions.push_back(
	    std::pair<text_pattern,std::string>(thesplit[0],
						thesplit[1]));

        std::vector<std::string> thesplit = split_string(":", field);
        autoinscriptions.push_back(
            std::pair<text_pattern,std::string>(thesplit[0],
                                                thesplit[1]));

	map_file_name = field;

        map_file_name = field;

    std::vector<text_pattern> banned_objects;  // Objects we'll never pick up

    std::vector<text_pattern> never_pickup;   // Objects we'll never pick up
    std::vector<text_pattern> always_pickup;  // Stuff we always pick up

# White space is stripped from the begining and end of the line, as
# well as imediately before and after the '='. If the option allows multiple
# comma/semicolon-separated terms (such as ban_pickup), all whitespace around
# the separator is also trimmed. All other whitespace is left intact.

# White space is stripped from the begining and end of the line, as well as
# imediately before and after the '='. If the option allows multiple
# comma/semicolon-separated terms (such as autopickup_exceptions), all
# whitespace around the separator is also trimmed. All other whitespace is left
# intact.

# ban_pickup = scrolls? of random uselessness

# autopickup_exceptions = scrolls? of random uselessness

		autopickup, default_autopickup, safe_autopickup,
		autopickup_no_burden, safe_zero_exp, pickup_thrown,
		pickup_dropped, assign_item_slot, ban_pickup, drop_mode,
		pickup_mode, drop_filter;

		autopickup, autopickup_exceptions, default_autopickup,
		safe_autopickup, autopickup_no_burden, safe_zero_exp,
		pickup_thrown, pickup_dropped, assign_item_slot,
		ban_pickup, drop_mode, pickup_mode, drop_filter;

autopickup_exceptions = <pickup-regex, >don't-pickup-regex, ...
        A set of regexes that force matching items to be picked up (if prefixed
        with <), or never picked up (if prefixed with >). Excludes (>) take
        precedence over includes (<), so if the same item is matched by both
        an exclude and an include, it will not be subject to autopickup.
        An example:
          autopickup_exceptions = <(poisoned|curare-tipped) needle
        Forces autopickup to grab all poisoned and curare-tipped needles, even
        if missiles are not set in the "autopickup" option.
        Whitespace between <> and the match expression is significant, so this
        is a mistake:
          autopickup_exceptions = <   ebony casket
        autopickup_exceptions is a superset of ban_pickup (see below). Using
          autopickup_exceptions = >decay, >degeneration
        is the same as using
          ban_pickup = decay, degeneration

        If the regexes are not prefixed with < or >, > is implied. So the option
        setting above can also be written as
          autopickup_exceptions = decay, degeneration
        You can use multiple autopickup_exceptions lines.

        See also autopickup_exceptions, which is a superset of ban_pickup.