# Function Index

## Description

This lists all functions that appear in the SFO 1e libraries, with the exception of the automatically-generated functions in sfo_autofunc.tph. (These functions have names like ARE_read_area_script and ITM_number_chargesGT; they are generated automatically for each field in an IE file type.)

- Function Index
- Main menu

## Public Functions

action_append_strref(input:s, arguments:s)=(output:s) action (lib_text)

action_reinclude_this action_macro (lib_macro)
action_reinclude_this(input:s)=() action (lib_tools)

add_animation_entry(minimum:i, animation:s, ini:s, location:s, locbase:s, locabs:s)=() action (lib_general)

add_elements_to_list(number_to_add:i, list:s, elements:s)=(list:s) patch (lib_list)
add_elements_to_list(number_to_add:i, list:s, elements:s)=(list:s) action (lib_list)

add_entry(at_end:i, arguments:s, this, is, a, patch, filename:s, file_ext:s, type:s)=(value//:s, always:s, 1:s) patch (lib_patch)

add_entry_child(sec_index:i, arguments:s, check:s, checkGT:s, checkLT:s, match:s, entry_type:s, parent_type:s, match_parameter:s, filename:s, file_ext:s, at_end:s="0", insert_point:s="0", number_to_add:s="1", it's, still, a, ,, as, it, might, be, functional)=() patch (lib_patch)

add_entry_inline(at_end:i, arguments:s, this, is, a, hash, file_ext:s, filename:s, type:s)=(value//:s, always:s, 1:s) patch (lib_patch)

add_entry_notchild(arguments:s, check:s, checkGT:s, checkLT:s, match:s, match_parameter:s, filename:s, file_ext:s, entry_type:s, at_end:s="0", insert_point:s="0", number_to_add:s="1", it's, still, a, ,, as, it, might, be, functional)=() patch (lib_patch)

add_items_to_store(tv:i, store:s, items:s, item:s, location:s)=() action (lib_sto)

add_silent_sectype(sectype:s)=(sectype_value:s) action (lib_general)

add_spell_to_ids(to_try:i, level:i="-1", type:i, typename:s="unspecified", filename:s, idsname:s, file_loc:s)=(newname:s, newcode:s, to_try_next:s) action (lib_spl)

add_to_statdesc(start_row:i=190, string:s="-1", bam:s="****")=(stat_num:s) action (lib_general)

add_to_statdesc_helper(start_row:i, rowcount:i)=(stat_num:s, row:s) patch (lib_general)

add_to_tlk(string:s)=(strref:s) action (lib_text)

add_wed_door(name:s, tiles:s)=() patch (lib_wed)

allocate_proficiencies(level:i="-1", onhandprof:i, offhandprof:i, rangedprof:i, style:i, class:s, kit:s)=() patch (lib_genai)

alphanumeric_advance(arguments:s)=(value:s) action (lib_internal)

append_numbered_row(arguments:s)=(value:s) patch (lib_table)

append_string(input:s, arguments:s)=(output:s) patch (lib_text)

append_string_nospace(input:s, arguments:s)=(output:s) patch (lib_text)

append_strref(input:s, arguments:s)=(output:s) patch (lib_text)

append_to_tlk_entry(tlk_entry:i=~-1~, new_first:i, arguments:s, separator:s=" ")=() action (lib_text)

append_to_vertices(x:i, y:i, vertices:s)=(vertices:s) patch (lib_wed)

apply_function_to_tlk_entry(tlk_entry:i=~-1~, arguments:s)=() action (lib_text)

apply_patches(offset_secondary:i, really_no_default:i, entry_index:i, parent_index:i, stop_after_match:i, offset_base:i, edits:s, arguments:s, file_ext:s, filename:s, is_conditional:s="no", a, bit, of, a, misnomer., We, really, mean:, is, it, being, called, by, one, of, patch_entry, etc., (If, so,, we, ignore, match, etc, commands))=(value//:s, 1:s, if:s, any:s, patch:s, is:s, made,:s, 0:s, otherwise:s) patch (lib_patch)

apply_patches_inline(offset_secondary:i, offset_base:i, really_no_default:i, entry_index:i, editstring:s, arguments:s, file_ext:s, filename:s)=(value:s) patch (lib_patch)

apply_standard_function(offset_secondary:i, entry_index:i, offset_base:i, func:s, arguments:s="null", filename:s, file_ext:s)=() patch (lib_evaluate)

apply_to_strrefs(arguments:s, filename:s, file_ext:s)=() patch (lib_general)

apply_to_strrefs_2da(arguments:s)=() patch (lib_general)

apply_to_strrefs_opcode_helper(file_ext:s)=(opcode_loc:s) patch (lib_general)

apply_to_strrefs_script(arguments:s)=() patch (lib_general)

ARE_actor_baseline()=() patch (lib_are)

ARE_actor_defaults(arguments:s)=() patch (lib_are)

ARE_actor_orientation(arguments:s)=() patch (lib_are)

ARE_actor_out_of_bounds()=(value:s) patch (lib_are)

ARE_actor_present_always(arguments:s)=() patch (lib_are)

ARE_actor_x_coord(arguments:s)=() patch (lib_are)

ARE_actor_y_coord(arguments:s)=() patch (lib_are)

ARE_add_container_fj(loc_x:i="-1", loc_y:i="-1", launch_x:i="-1", launch_y:i="-1", type:s, name:s, vertices:s)=() patch (lib_are)

ARE_add_pile(arguments:s)=() patch (lib_are)

ARE_add_trigger_fj(activation_x:i="-1", activation_y:i="-1", launch_x:i="-1", launch_y:i="-1", type:s, name:s, script:s, vertices:s)=() patch (lib_are)

ARE_adjust_actor_xloc(arguments:s)=() patch (lib_are)

ARE_adjust_actor_yloc(arguments:s)=() patch (lib_are)

ARE_container_out_of_bounds()=(value:s) patch (lib_are)

ARE_door_out_of_bounds()=(value:s) patch (lib_are)

ARE_edit_restspawn(arguments:s)=() patch (lib_are)

ARE_generic_out_of_bounds()=(value:s) patch (lib_are)

ARE_mapnote_out_of_bounds()=(value:s) patch (lib_are)

ARE_match_script(arguments:s)=(value:s) patch (lib_are)

ARE_move_script_to_bottom(arguments:s)=() patch (lib_are)

ARE_reset_edge_flags(arguments:s)=() patch (lib_are)

ARE_say_mapnote_text(arguments:s)=() patch (lib_are)

ARE_say_trigger_info(arguments:s)=() patch (lib_are)

ARE_slide_door()=() patch (lib_are)

ARE_slide_trigger()=() patch (lib_are)

ARE_swap_items(arguments:s)=() patch (lib_are)

ARE_swap_scripts(arguments:s)=() patch (lib_are)

ARE_trigger_out_of_bounds()=(value:s) patch (lib_are)

ARE_trigger_says(arguments:s)=() patch (lib_are)

ARE_wipe_rest_block(arguments:s)=() patch (lib_are)

ARE_wipe_spawns()=() patch (lib_are)

armor_type(item:s)=(type:s, success:s) action (lib_itm)

assess_main_state_do_commands(dialog_main_state:i, dialog_main:s)=(needs_passback:s, do_list:s) patch (lib_interject)

build_flag_data_field_editors(lookup_table:s, function_prefix:s, offset_base:s, secondary:s)=() action (lib_internal)

build_IDS_data_field_editors(lookup_table:s, function_prefix:s, offset_base:s, secondary:s="no")=() action (lib_internal)

build_instant_spell(spell_ID:s)=(newcode:s, spellcode:s, fullname:s) action (lib_spl)

build_kit_spell_enforcer(force_rebuild:i, collect_apply:i, kit:s)=() action (lib_kit)

build_prebuff_spell(conceal:i, spell_ID:s)=(newcode:s, fullname:s) action (lib_spl)

build_simple_data_field_editors(lookup_table:s, function_prefix:s, offset_base:s, secondary:s="no")=() action (lib_internal)

build_wed(width:i, height:i, tis:s, wed:s)=() action (lib_wed)

check_adder(to_check:s, value:s, suffix:s)=(to_check:s) patch (lib_iterate)

check_component(label:s, mod:s="MOD_FOLDER")=(value:s) action (lib_tools)
check_component(label:s, mod:s)=(value:s) patch (lib_tools)

check_ini(ini:s)=(value:s) patch (lib_tools)
check_ini(ini:s)=(value:s) action (lib_tools)

check_label(label:s)=(value:s) action (lib_tools)
check_label(label:s)=(value:s) patch (lib_tools)

check_standard_function(offset_secondary:i, func_or_string:i, entry_index:i, offset_base:i="", func:s, arguments:s, parameter:s, filename:s, file_ext:s)=(value:s) patch (lib_evaluate)

check_wed_for_multiples()=(value:s) patch (lib_wed)

CLAB_add_ability(level:i=1, spell:s, type:s)=(string:s) patch (lib_kit)

CLAB_remove_ability(level:i=1, spell:s)=(string:s) patch (lib_kit)

CLAB_write(max_level:i, clab:s)=() action (lib_kit)

clip_polygon_block(x:i, xlen:i, y:i, ylen:i, polygons_in:s, vertices_in:s)=(polygons_out:s, vertices_out:s) patch (lib_wed)

clone_area(allow_missing:i, silent:i, area:s, edits:s, editstring:s)=() action (lib_are)

clone_column(dont_complain:i, clone_from:s, clone_to:s, file:s, add_before:s, add_after:s)=() action (lib_table)

clone_creature(allow_missing:i, tv:i, silent:i, creature:s, edits:s, editstring:s)=() action (lib_cre)

clone_effect(allow_missing:i, silent:i, effect:s, edits:s, editstring:s)=() action (lib_eff)

clone_entry(arguments:s, this, is, a, hash, file_ext:s, filename:s, type:s)=(value//:s, always:s, 1:s) patch (lib_patch)

clone_entry_child(sec_index:i, arguments:s, check:s, clone_above:s=0, clone_at_top:s=0, clone_at_bottom:s=0, only_once:s=0, checkGT:s, checkLT:s, match:s, entry_type:s, parent_type:s, filename:s, file_ext:s, number_to_add:s="1", it's, still, a, ,, as, it, might, be, functional)=() patch (lib_patch)

clone_entry_inline(arguments:s, this, is, a, hash, file_ext:s, filename:s, type:s)=(value//:s, always:s, 1:s) patch (lib_patch)

clone_entry_notchild(clone_above:s=0, clone_at_top:s=0, clone_at_bottom:s=0, only_once:s=0, arguments:s, check:s, checkGT:s, checkLT:s, match:s, filename:s, file_ext:s, entry_type:s, number_to_add:s="1", it's, still, a, ,, as, it, might, be, functional)=() patch (lib_patch)

clone_extend(inline:i, arguments:s, top:s="yes", location:s, locbase:s)=() action (lib_general)

clone_item(silent:i, allow_missing:i, tv:i, item:s, edits:s, editstring:s)=() action (lib_itm)

clone_pro(allow_missing:i, pro:s, edits:s, editstring:s)=(pro_num:s) action (lib_pro)

clone_row(dont_complain:i, clone_from:s, clone_to:s, file:s)=() action (lib_table)

clone_script(script:s)=() action (lib_general)

clone_spell(allow_missing:i, silent:i, spell:s, edits:s, editstring:s)=() action (lib_spl)

clone_store(allow_missing:i, tv:i, silent:i, store:s, edits:s, editstring:s)=() action (lib_sto)

clone_template(allow_missing:i, silent:i, tv:i, file_list:s, file_ext:s, edits:s, editstring:s)=() action (lib_internal)

clone_vef(vef:s, edits:s, editstring:s, allow_missing:s="no")=() action (lib_vef)

clone_vvc(allow_missing:i, silent:i, vvc:s, edits:s, editstring:s)=() action (lib_vvc)

clone_worldmap(worldmap:s, edits:s, editstring:s)=() action (lib_wmp)

collect_spell_icons(location:s, locbase:s, locabs:s, spell:s, resref:s)=() action (lib_spl)

color(red:i, green:i, blue:i)=(color:s) action (lib_tools)
color(red:i, green:i, blue:i)=(color:s) patch (lib_tools)

compile_all(location:s, locbase:s, locabs:s)=() action (lib_dlg)

compile_rename(file:s, files:s, location:s, locbase:s)=() action (lib_general)

compile_ssl_output(script:s)=() action (lib_general)

COMPILE_SSL_TO_BCS(script:s, location:s, variables:s, rename_to:s, inline:s, booleans:s)=() action (lib_general)

compile_ssl_to_bcs_core(skip_bcs:i, script:s, variables:s, booleans:s, location:s, locbase:s, locabs:s, rename_to:s, inline:s)=() action (lib_general)

compile_with_ict_handling(dialog:s)=() action (lib_interject)

compress_bam(dl:i, was_compressed:i)=() patch (lib_bam)

consolidate_table(in:s, out:s, locabs:s="weidu_external/workspace", location:s, locbase:s)=() action (lib_tools)

copy_column_contents(copy_from:s, copy_to:s, file:s)=() action (lib_table)

copy_item_effects_to_spell(item:s, spell:s)=() action (lib_itm)

copy_item_to_spell(abil_ind:i, item:s, spell:s)=() action (lib_itm)

count_files(file_ext:s, tv:s="no")=(value:s) action (lib_general)

count_hundreds(counter:i, hundreds:i, task:s="files analysed")=(counter:s, hundreds:s) patch (lib_tools)
count_hundreds(counter:i, hundreds:i, task:s="files analysed")=(counter:s, hundreds:s) action (lib_tools)

count_list(list:s)=(value:s) patch (lib_list)

count_wallgroups()=(value:s) patch (lib_wed)

CRE_ac(arguments:s)=() patch (lib_cre)

CRE_add_all_priest_spells()=() patch (lib_cre)

CRE_add_items(replace:i, arguments:s)=() patch (lib_cre)

CRE_add_known_spells(arguments:s)=() patch (lib_cre)

CRE_add_proficiencies(arguments:s)=() patch (lib_cre)

CRE_add_spells(arguments:s)=() patch (lib_cre)

CRE_build()=() patch (lib_cre)

CRE_bump_down(loc:ix248)=(value:s) patch (lib_cre)

CRE_bump_up(loc:ix248)=(value:s) patch (lib_cre)

CRE_check_if_moron()=(value:s) patch (lib_cre)

CRE_colors(arguments:s)=() patch (lib_cre)

CRE_deduplicate_items()=() patch (lib_cre)

CRE_delete_opcodes(arguments:s)=() patch (lib_cre)

CRE_enforce_animation(arguments:s)=() patch (lib_cre)

CRE_enforce_class(arguments:s)=() patch (lib_cre)

CRE_enforce_hp(arguments:s)=() patch (lib_cre)

CRE_enforce_kit_spells_hardcoded(level:i=1, full_delete:i, kit:s)=() patch (lib_kit)

CRE_enforce_proficiencies()=() patch (lib_genai)

CRE_enforce_saves(arguments:s)=() patch (lib_cre)

CRE_enforce_script_order(arguments:s)=() patch (lib_cre)

CRE_enforce_thac0(arguments:s)=() patch (lib_cre)

CRE_enforce_xp()=() patch (lib_cre)

CRE_find_highest_spell_level(arguments:s=mage)=(value:s) patch (lib_cre)

CRE_first_gap_above(loc:ix248)=(value:s) patch (lib_cre)

CRE_first_gap_below(loc:ix248)=(value:s) patch (lib_cre)

CRE_gender(arguments:s)=() patch (lib_cre)

CRE_has_spell(arguments:s)=(value:s) patch (lib_cre)

CRE_hitpoints(arguments:s)=() patch (lib_cre)

CRE_hitpointsGT(arguments:s)=() patch (lib_cre)

CRE_immunity(arguments:s)=() patch (lib_cre)

CRE_immunity_to_animation(arguments:s)=() patch (lib_cre)

CRE_immunity_to_icon(arguments:s)=() patch (lib_cre)

CRE_immunity_to_opcode(arguments:s)=() patch (lib_cre)

CRE_immunity_to_spell(spellname:s, spellcode:s, arguments:s)=() patch (lib_cre)

CRE_immunity_to_string(arguments:s)=() patch (lib_cre)

CRE_insert_script(arguments:s)=(new_loc:s) patch (lib_cre)

CRE_insert_script_above(arguments:s)=() patch (lib_cre)

CRE_insert_script_below(arguments:s)=() patch (lib_cre)

CRE_insert_script_high(arguments:s)=() patch (lib_cre)

CRE_insert_script_low(arguments:s)=() patch (lib_cre)

CRE_insert_script_second(arguments:s)=() patch (lib_cre)

CRE_invert_scripts(arguments:s)=() patch (lib_cre)

CRE_is_chaotic()=(value:s) patch (lib_cre)

CRE_is_dead()=(value:s) patch (lib_cre)

CRE_is_evil()=(value:s) patch (lib_cre)

CRE_is_geneutral()=(value:s) patch (lib_cre)

CRE_is_good()=(value:s) patch (lib_cre)

CRE_is_innocent()=(value:s) patch (lib_cre)

CRE_is_lawful()=(value:s) patch (lib_cre)

CRE_is_lcneutral()=(value:s) patch (lib_cre)

CRE_is_PC()=(value:s) patch (lib_cre)

CRE_is_thief()=(value:s) patch (lib_cre)

CRE_is_warrior(class:s=UNKNOWN)=(value:s) patch (lib_cre)

CRE_kit(arguments:s)=() patch (lib_cre)

CRE_level_all(arguments:s)=() patch (lib_cre)

CRE_level_by_class(arguments:s)=() patch (lib_cre)

CRE_locate_script(script:s)=(value:s) patch (lib_cre)

CRE_log_me(arguments:s)=() patch (lib_cre)

CRE_make_casting_innate(arguments:s)=() patch (lib_cre)

CRE_make_casting_instant(arguments:s)=() patch (lib_cre)

CRE_make_chaotic()=(value:s) patch (lib_cre)

CRE_make_evil()=(value:s) patch (lib_cre)

CRE_make_geneutral()=(value:s) patch (lib_cre)

CRE_make_good()=(value:s) patch (lib_cre)

CRE_make_lawful()=(value:s) patch (lib_cre)

CRE_make_lcneutral()=(value:s) patch (lib_cre)

CRE_match_script(arguments:s)=(value:s) patch (lib_cre)

CRE_movement(arguments:s)=() patch (lib_cre)

CRE_original_class(arguments:s)=() patch (lib_cre)

CRE_postbuild()=() patch (lib_cre)

CRE_read_item_in_slot(arguments:s)=(value:s) patch (lib_cre)

CRE_read_original_class()=(value:s) patch (lib_cre)

CRE_read_proficiency(arguments:s)=(value:s) patch (lib_cre)

CRE_remove_items(arguments:s)=() patch (lib_cre)

CRE_remove_spell(arguments:s)=() patch (lib_cre)

CRE_remove_spell_of_type(skip_hidden:i, known_only:i, arguments:s)=() patch (lib_cre)

CRE_remove_spells(arguments:s)=() patch (lib_cre)

CRE_replace_items(arguments:s)=() patch (lib_cre)

CRE_saves(arguments:s)=() patch (lib_cre)

CRE_say_both_names(arguments:s)=() patch (lib_cre)

CRE_say_name(arguments:s)=() patch (lib_cre)

CRE_say_sounds(arguments:s)=() patch (lib_cre)

CRE_say_sounds_literal(arguments:s)=() patch (lib_cre)

CRE_say_unidentified_name(arguments:s)=() patch (lib_cre)

CRE_set_both_names(arguments:s)=() patch (lib_cre)

CRE_set_name(arguments:s)=() patch (lib_cre)

CRE_set_proficiencies(arguments:s)=() patch (lib_cre)

CRE_set_unidentified_name(arguments:s)=() patch (lib_cre)

CRE_steal_colors_from(arguments:s)=() patch (lib_cre)

CRE_steal_sounds_from(arguments:s)=() patch (lib_cre)

CRE_strip_script(arguments:s)=() patch (lib_cre)

CRE_swap_items(arguments:s)=() patch (lib_cre)

CRE_swap_script(arguments:s)=() patch (lib_cre)

CRE_wipe_proficiencies(arguments:s)=() patch (lib_cre)

crop_are_file(x:i, y:i, xlen:i, ylen:i, area:s)=() action (lib_wed)

crop_area(x:i, xlen:i, y:i, ylen:i, area_old:s, area_new:s)=() action (lib_wed)

crop_doors(x:i, y:i, xlen:i, ylen:i)=() patch (lib_wed)

crop_polygons(x:i, xlen:i, y:i, ylen:i)=() patch (lib_wed)

deabbreviate_spellname(input:s)=(spellname:s) patch (lib_spl)
deabbreviate_spellname(input:s)=(spellname:s) action (lib_spl)

decomment_code()=() patch (lib_interject)

decompose_CSV(input:s)=(argument_0:s, argument_1:s, argument_2:s, argument_3:s, argument_4:s, argument_5:s, argument_6:s, argument_7:s, argument_8:s, argument_9:s) action (lib_internal)

decompress_bam()=(was_compressed:s, dl:s) patch (lib_bam)

deduplicate_vertices(vertices:s)=(vertices:s) patch (lib_wed)

definalise_hidespl()=() action (lib_spl)

define_make_patch()=() patch (lib_internal)

define_push()=() patch (lib_internal)

delete_action_if(trig_in:s, act_in:s, arguments:s)=(trig_out:s, act_out:s) patch (lib_bcs)

delete_at_index(index:i, number_to_delete:i=1, entry_type:s)=(value:s) patch (lib_patch)

delete_cycle_data(dl:i)=(dl:s) patch (lib_bam)

delete_entry(arguments:s, filename:s, file_ext:s, type:s)=(value//:s, always:s, 1:s) patch (lib_patch)

delete_entry_child(sec_index:i, arguments:s, entry_type:s, parent_type:s, filename:s, file_ext:s)=() patch (lib_patch)

delete_entry_notchild(arguments:s, filename:s, file_ext:s, entry_type:s)=() patch (lib_patch)

delete_polygons(area:s, polygons:s)=() action (lib_wed)

delete_table_column(colnum:i="-1", column:s)=() patch (lib_table)
delete_table_column(colnum:i="-1", column:s, file:s)=() action (lib_table)

delete_table_row(lookup_column:i, row:s)=() patch (lib_table)
delete_table_row(lookup_column:i, row:s, file:s)=() action (lib_table)

delete_trigger_if(trig_in:s, act_in:s, arguments:s)=(trig_out:s, act_out:s) patch (lib_bcs)

delete_wallgroups()=() patch (lib_wed)

divide_round_up(numerator:i, denominator:i)=(value:s) patch (lib_wed)

duplicate_area(area_old:s, area_new:s)=() action (lib_wed)

edit_all_areas(edits:s, editstring:s)=() action (lib_are)

edit_all_creatures(edits:s, editstring:s)=() action (lib_cre)

edit_all_items(edits:s, editstring:s)=() action (lib_itm)

edit_all_kits(at_top_hla:i, skip_trueclass:i, editstring:s, edits:s, parent_class:s, filter:s)=() action (lib_kit)

edit_all_scripts(editstring:s)=() action (lib_bcs)

edit_all_spells(edits:s, editstring:s)=() action (lib_spl)

edit_all_stores(edits:s, editstring:s)=() action (lib_sto)

edit_area(allow_missing:i, silent:i, area:s, edits:s, editstring:s)=() action (lib_are)

edit_clab(editstring:s, edits:s, kit:s)=() action (lib_kit)

edit_clab_mc(kit_id:i, kit:s, parent_class:s, editstring:s)=() action (lib_kit)

edit_compiled_dialog(allow_missing:i, dialog:s, edits:s, editstring:s)=() action (lib_dlg)

edit_creature(allow_missing:i, tv:i, silent:i, creature:s, file:s, edits:s, editstring:s, location:s, locbase:s, locabs:s)=() action (lib_cre)

edit_effect(allow_missing:i, silent:i, effect:s, edits:s, editstring:s)=() action (lib_eff)

edit_item(silent:i, allow_missing:i, tv:i, item:s, edits:s, editstring:s, location:s, locbase:s, locabs:s)=() action (lib_itm)

edit_kit(skip_lua:i, skip_clab:i, at_top_hla:i, editstring:s, edits:s, kit:s)=() action (lib_kit)

edit_kit_parser(command:s, arguments:s)=() action (lib_kit)

edit_lua(at_top:i, kit:s, lua:s, editstring:s)=() action (lib_kit)

edit_pro(allow_missing:i, pro:s, edits:s, editstring:s, location:s, locabs:s, locbase:s)=() action (lib_pro)

edit_race(editstring:s, edits:s, race:s)=() action (lib_kit)

edit_race_parser(command:s, arguments:s, race:s)=() action (lib_kit)

edit_sanity_check(edits:s, editstring:s, task:s="the current task")=() action (lib_tools)
edit_sanity_check(edits:s, editstring:s, task:s="the current task")=() patch (lib_tools)

edit_script(script:s, editstring:s)=() action (lib_bcs)

edit_spell(tv:i, this, doesn't, get, used,, but, it, avoids, a, function, mismatch, in, edit_whatever, allow_missing:i, stop_after_match:i, silent:i, spell:s, edits:s, editstring:s, location:s, locbase:s, locabs:s)=(value:s) action (lib_spl)

edit_store(allow_missing:i, tv:i, silent:i, store:s, edits:s, editstring:s, external_file:s)=() action (lib_sto)

edit_template(silent:i, SFO_RESERVED_object_index:i, allow_missing:i, stop_after_match:i, tv:i, file_list:s, file_ext:s, edits:s, editstring:s, external_file:s, location:s, locbase:s, locabs:s)=(value//:s, 1:s, if:s, any:s, successful:s, edit:s, is:s, made:s) action (lib_internal)

edit_vef(allow_missing:i, vef:s, edits:s, editstring:s, external_file:s)=() action (lib_vef)

edit_vvc(allow_missing:i, silent:i, vvc:s, edits:s, editstring:s)=() action (lib_vvc)

edit_whatever(tv:i, allow_missing:i, files:s, file:s, edits:s, editstring:s, location:s, locbase:s, locabs:s)=() action (lib_general)

edit_worldmap(worldmap:s, edits:s, editstring:s)=() action (lib_wmp)

EFF_build()=() patch (lib_eff)

element_in_list(element:s, list:s)=(value:s) patch (lib_list)
element_in_list(element:s, list:s)=(value:s) action (lib_list)

ensure_hex(pad_length:i, in:s)=(out:s) patch (lib_tools)
ensure_hex(pad_length:i, in:s)=(out:s) action (lib_tools)

evaluate_condition(offset_secondary:i, offset_base:i, match:s="1", match_parameter:s, check:s, checkGT:s, checkLT:s, filename:s, file_ext:s)=(value:s) patch (lib_patch)

evaluate_container(offset_base:i, offset_secondary:i, entry_index:i, arguments:s, list:s, elt:s, filename:s, file_ext:s)=(value:s) patch (lib_evaluate)

evaluate_expression(offset_base:i, offset_secondary:i, entry_index:i, integer:i, boolean:i, list_type:i, subterm:i, arguments:s, expression:s, filename:s, file_ext:s)=(value:s) patch (lib_evaluate)
evaluate_expression(entry_index:i, offset_secondary:i, arguments:s, expression:s, offset_base:s=0)=(value:s) action (lib_evaluate)

extend(tv:i, allow_missing:i, file:s, files:s, script:s, top:s, bottom:s, location:s, locbase:s, locabs:s, inline:s="no", ssl:s="no", variables:s)=() action (lib_general)

extend_area_script(area:s, top:s, bottom:s, location:s, variables:s, inline:s="no", ssl:s="no")=() action (lib_are)

externalise_item_ability(abil_ind:i, item:s, spell:s)=() action (lib_itm)

extract_bounded_part(left_bound:s, right_bound:s, string:s)=(left:s, middle:s, right:s) patch (lib_evaluate)

extract_cycle_data()=(cycle_data:s, lookup_data:s, cycle_num:s) patch (lib_bam)

extract_from_tra(relativise_tra_in:i, force_ref:i="-1", language_list:s="ENGLISH", tra_in:s, tra_in_loc:s, tra_out:s, tra_out_loc:s, tra_entries:s)=() action (lib_text)

fail_unless_boolean(expression:s, value:s)=() patch (lib_evaluate)

fail_unless_int(expression:s, value:s)=() patch (lib_evaluate)

fail_unless_list(expression:s, value:s)=() patch (lib_evaluate)

find_clab(kit:s)=(clab:s) action (lib_kit)

find_clab_levels()=(max_level:s) patch (lib_kit)

find_crossing_points(x1:i, x2:i, y1:i, y2:i, xmin:i, xmax:i, ymin:i, ymax:i)=(xcross1:s, ycross1:s, xcross2:s, ycross2:s) patch (lib_wed)

find_free_clab(to_try:i=1, prefix:s)=(clab:s) action (lib_kit)

find_next_unused_clab(try_next:i=1, clone:i, parent_class:s)=(clab:s) action (lib_kit)

find_next_unused_lua(try_next:i=1, clone:i, parent_class:s)=(lua:s) action (lib_kit)

find_parenthesis_range(left:s="{", right:s="}", index:s=0)=(start:s, end:s) patch (lib_tools)

find_quadrant(x:i, xmin:i, xmax:i, y:i, ymin:i, ymax:i)=(quadrant:s) patch (lib_wed)

find_spare_kit_ids(to_start:ix4029)=(idsnum:s) action (lib_kit)

find_spell_ids_slot(to_try:i, type:i=3, level:i, idsname:s)=(slot:s, to_try_next:s) action (lib_spl)

find_spell_level(level:i="-1", filename:s, file_loc:s)=(level:s) action (lib_spl)

find_spell_type(type:i, idsname:s, filename:s, file_loc:s, typename:s="unspecified")=(type:s) action (lib_spl)

find_unique_filename(to_try:i, prefix:s="dw_", extension:s)=(filename:s) action (lib_tools)

find_unused_wrap_name(to_try:i=1, wrap_prefix:s)=(wrap:s) action (lib_kit)

flip_area(area:s, file_loc:s, script_array:s)=() action (lib_wed)

flip_bounding_box(width_total:i, offset:i, layout:i)=() patch (lib_wed)

flip_orientation(offset:i)=() patch (lib_wed)

flip_tile(height:i, width:i, tile_number:i)=(new_number:s) patch (lib_wed)

flip_vertex(width_total:i, offset:i, is_searchmap:i)=() patch (lib_wed)

generate_interjection(line_count_here:i, passback_state_number:i="-1", needs_passback:i, global_passback_say:i="-1", condition:s, dialog_main:s, stack:s, stack_base:s)=(stack:s, passback_state_number:s) patch (lib_interject)

get_area_script(area:s)=(script:s) action (lib_are)

get_available_mos_index(current:i)=(value:s) action (lib_bam)

get_data_fj(vertices:s)=(bb_top:s, bb_bottom:s, bb_left:s, bb_right:s, x_est:s, y_est:s, vertex_string:s) patch (lib_are)

get_directory(location:s, locbase:s, locabs:s)=(directory:s) patch (lib_tools)
get_directory(location:s, locbase:s, locabs:s)=(directory:s) action (lib_tools)

get_field_value(loc:i, length:i)=(value:s) patch (lib_tools)

get_label_loc()=(location:s) action (lib_tools)

get_max_profs(level:i, proficiency:i, class:s, kit:s)=(max:s) patch (lib_genai)

get_num_profs(level:i, class:s)=(num_profs:s) patch (lib_genai)

get_offset_array patch_macro (lib_macro)

get_or_add_to_IDS(minimum:i=1, maximum:i=99999, to_add:s, idsfile:s)=(idsnum:s) action (lib_tools)
get_or_add_to_IDS(minimum:i=1, maximum:i=99999, to_add:s, idsfile:s)=(idsnum:s) patch (lib_tools)

get_parent_class(kit:s)=(class_id:s, parent_class:s, true_class:s) action (lib_kit)

get_polygons(xmin:i, xmax:i, ymin:i, ymax:i, wed:s, output_file:s)=() action (lib_wed)

get_spellcode(input:s)=(value:s) patch (lib_spl)
get_spellcode(input:s)=(value:s) action (lib_spl)

get_table_column_coordinate(column:s)=(colnum:s) patch (lib_table)

get_table_row_coordinate(lookup_column:i, row:s)=(rownum:s) patch (lib_table)

get_vertex(ind:i, vertices:s)=(x:s, y:s) patch (lib_wed)

handle_charsets_immutably(force_tra_rebuild:i, tra_base:s=lang, base_language:s=english, iconv_path:s)=(scs_tra_loc:s) action (lib_tools)

handle_ict_blocks()=() patch (lib_interject)

has_major_scope(list:s, operator:s)=(value:s, left:s, right:s) patch (lib_evaluate)

hex_digit(digit:i)=(out:s) patch (lib_tools)

hexify(in:i, pad_length:i, out:s)=(out:s) patch (lib_tools)
hexify(in:i, pad_length:i)=(out:s) action (lib_tools)

identify_weapon(weaponfile:s)=(twohanded:s, type:s, proftype:s, enchantment:s, enchantment_ranged:s, damagetype:s) patch (lib_genai)

identify_weapon_patch()=(twohanded:s, type:s, proftype:s, enchantment:s, enchantment_ranged:s, damagetype:s) patch (lib_genai)

identify_weapon_preferences(filename:s)=(onhandprof:s, offhandprof:s, rangedprof:s, style:s, skip_me:s, has_ranged:s, damagetype:s, enchantment:s, no_weapon:s) patch (lib_genai)

idscode_to_spell(idscode:i)=(resref:s) action (lib_spl)
idscode_to_spell(idscode:i)=(resref:s) patch (lib_spl)

implement_line_if()=() patch (lib_general)

include(file:s, files:s, location:s, locbase:s, locabs:s)=() action (lib_tools)

increment_lookup_indices(offset_base:i, increment:i, entry_type:s, secondary_type:s)=() patch (lib_patch)

increment_number_entries(arguments:i, file_ext:s, entry_type:s)=() patch (lib_general)

increment_offset(arguments:i, file_ext:s, entry_type:s)=() patch (lib_general)

increment_secondary_data(offset_base:i, ind_to_write:i, index:i=99999, number:i=99999, entry_type:s, secondary_type:s)=() patch (lib_patch)

insert_after_response(act_in:s, to_insert:s)=(act_out:s) patch (lib_bcs)

insert_area(arguments:s)=() patch (lib_wmp)

insert_copies_at_index(index:i, index_of_copy:i="-1", blank:i, num_to_copy:i, num_of_copies:i, entry_type:s)=(value:s) patch (lib_patch)

insert_cycle_data(cycle_num:i, dl:i, cycle_data:s, lookup_data:s)=(dl:s) patch (lib_bam)

insert_polygon_block(polygons:s, vertices:s)=() patch (lib_wed)

install(overwrite:i=1, file:s, files:s, location:s, locbase:s, inline:s="no", postfix:s)=() action (lib_general)

install_area(allow_missing:i, silent:i, area:s, edits:s, editstring:s, location:s, locbase:s, locabs:s)=() action (lib_are)

install_creature(allow_missing:i, tv:i, silent:i, creature:s, edits:s, editstring:s, location:s, locbase:s)=() action (lib_cre)

install_effect(effect:s, edits:s, editstring:s, location:s, locbase:s, locabs:s)=() action (lib_eff)

install_item(silent:i, allow_missing:i, tv:i, item:s, edits:s, editstring:s, location:s, locbase:s)=() action (lib_itm)

install_kit_in_table(kit_id:s, table:s)=() action (lib_kit)

install_spell(allow_missing:i, silent:i, spell:s, edits:s, idsname:s, editstring:s, destination:s="override", location:s, locbase:s, locabs:s)=(newname:s) action (lib_spl)

install_store(allow_missing:i, tv:i, silent:i, store:s, edits:s, editstring:s, external_file:s, location:s, locbase:s)=() action (lib_sto)

install_template(allow_missing:i, tv:i, silent:i, file_list:s, file_ext:s, edits:s, editstring:s, external_file:s, location:s, locbase:s, locabs:s, destination:s="override")=() action (lib_internal)

install_v2_bam(lowest_mos_index:i, bam_name:s, bam_loc:s, pvrz_loc:s)=() action (lib_bam)

install_v2_mos(lowest_mos_index:i, mos_name:s, mos_loc:s, pvrz_loc:s)=() action (lib_mos)

install_vef(allow_missing:i, vef:s, edits:s, editstring:s, external_file:s, location:s, locbase:s)=() action (lib_vef)

install_vvc(allow_missing:i, silent:i, vvc:s, edits:s, editstring:s, external_file:s, location:s, locbase:s)=() action (lib_vvc)

internal_push_random(list:s, to_add:s)=(list:s) patch (lib_internal)

invert_list(list:s)=(list:s) patch (lib_list)
invert_list(list:s)=(list:s) action (lib_list)

invert_string(block_size:i, string:s)=(string:s) patch (lib_wed)
invert_string(block_size:i, string:s)=(string:s) action (lib_wed)

invert_vertex_sequence_order(initial_vertex_offset:i, initial_vertex_index:i, vertex_number:i, width_total:i, is_searchmap:i)=() patch (lib_wed)

item_useability_string(tra_ref:i)=(desc:s) patch (lib_itm)

iter_2da(to_check:s, entry:s)=(to_check:s) patch (lib_iterate)

iter_are(to_check:s)=(to_check:s) patch (lib_iterate)

iter_bcs(to_check:s)=(to_check:s) patch (lib_iterate)

iter_cre(to_check:s)=(to_check:s) patch (lib_iterate)

iter_dlg(to_check:s)=(to_check:s) patch (lib_iterate)

iter_eff(to_check:s, immunity_func:s)=(to_check:s) patch (lib_iterate)

iter_fam(to_check:s)=(to_check:s) patch (lib_iterate)

iter_ini(to_check:s)=(to_check:s) patch (lib_iterate)

iter_item_random(item:s, to_check:s)=(to_check:s) patch (lib_iterate)

iter_itm(to_check:s, immunity_func:s)=(to_check:s) patch (lib_iterate)

iter_opcode(opcode:i, param2:i, to_check:s, resref:s, source:s, source_ext:s, immunity_func:s)=(to_check:s) patch (lib_iterate)

iter_opcode_monsum(param2:i, to_check:s, 2dalist:s)=(to_check:s) patch (lib_iterate)

iter_pro(to_check:s)=(to_check:s) patch (lib_iterate)

iter_resource(include_spells:i, skip_payload_on_ignore:i, to_check:s, func:s, ignore_func:s, immunity_func:s)=(output:s) action (lib_iterate)

iter_script(to_check:s)=(to_check:s) patch (lib_iterate)

iter_sda(to_check:s)=(to_check:s) patch (lib_iterate)

iter_spl(to_check:s, immunity_func:s)=(to_check:s) patch (lib_iterate)

iter_sto(to_check:s)=(to_check:s) patch (lib_iterate)

iter_vvc(to_check:s)=(to_check:s) patch (lib_iterate)

iter_wish(to_check:s)=(to_check:s) patch (lib_iterate)

iter_wmp(to_check:s)=(to_check:s) patch (lib_iterate)

iterfunc_missing_file(resref:s, ext:s, parent:s, output:s)=(output:s) action (lib_iterate)

ITM_append_description(arguments:s)=() patch (lib_itm)

ITM_append_description_newline(arguments:s)=() patch (lib_itm)

ITM_build()=() patch (lib_itm)

ITM_delete_opcodes(arguments:s)=() patch (lib_itm)

ITM_identified_name()=(value:s) patch (lib_itm)

ITM_immunity_to_opcode(arguments:s)=() patch (lib_itm)

ITM_immunity_to_spell(spellname:s, spellcode:s, arguments:s)=() patch (lib_itm)

ITM_is_stackable()=(value:s) patch (lib_itm)

ITM_log_me(arguments:s)=() patch (lib_itm)

ITM_postbuild()=() patch (lib_itm)

ITM_say_both_descriptions(arguments:s)=() patch (lib_itm)

ITM_say_both_names(arguments:s)=() patch (lib_itm)

ITM_say_description(arguments:s)=() patch (lib_itm)

ITM_say_name(arguments:s)=() patch (lib_itm)

ITM_say_unidentified_description(arguments:s)=() patch (lib_itm)

ITM_say_unidentified_name(arguments:s)=() patch (lib_itm)

ITM_set_both_descriptions(arguments:s)=() patch (lib_itm)

ITM_set_both_names(arguments:s)=() patch (lib_itm)

ITM_set_description(arguments:s)=() patch (lib_itm)

ITM_set_name(arguments:s)=() patch (lib_itm)

ITM_set_name_evaluate(arguments:s)=() patch (lib_itm)

ITM_set_unidentified_description(arguments:s)=() patch (lib_itm)

ITM_set_unidentified_name(arguments:s)=() patch (lib_itm)

ITM_substitute_description(arguments:s)=() patch (lib_itm)

join(list1:s, list2:s)=(list:s) patch (lib_list)
join(list1:s, list2:s)=(list:s) action (lib_list)

key_value_sanity_check(is_key:i=1, arguments:s)=() patch (lib_tools)
key_value_sanity_check(is_key:i=1, arguments:s)=() action (lib_tools)

kit_hardcode()=() patch (lib_kit)

kit_name_to_lower(mixed_string:s)=(lower_string:s) action (lib_kit)

kit_race_mage(entry:s, kit:s)=() action (lib_kit)

kit_race_notrueclass(entry:s, kit:s)=() action (lib_kit)

kit_race_trueclass(entry:s, kit:s)=() action (lib_kit)

kit_softcode patch_macro (lib_cre)

kit_spell_exclude_func(spell:s)=(value:s) patch (lib_kit)

l_r_crossing_point(x1:i, x2:i, y1:i, y2:i, bdy:i)=(xcross:s, ycross:s) patch (lib_wed)

legal_byte(input:i)=(output:s) patch (lib_bam)

length_of_frame_lookup_table()=(lookup_num:s) patch (lib_bam)

length_of_list(list:s)=(value:s) patch (lib_list)
length_of_list(list:s)=(value:s) action (lib_list)

level_at_xp(xp:i, num_classes:i=1, class:s)=(level:s) action (lib_general)

level_at_xp_cap(class:s, parent_class:s)=(level:s) action (lib_general)

level_at_xp_core(min_level:i=1, xp:i, rownum:i, colcount:i=40)=(level:s) patch (lib_general)

level_based_blocks(arguments:s, filename:s, file_ext:s)=() patch (lib_spl)

list_files(location:s, locbase:s, locabs:s, postfix:s)=(list:s) action (lib_tools)

list_wizard_spells()=() action (lib_spl)

log_resource_name(arguments:s="SFOlog")=() patch (lib_general)

log_scroll()=() patch (lib_macro)

log_scroll_main patch_macro (lib_macro)

log_this(file:s, input:s, repeat:s="yes", locabs:s="weidu_external/data/dw_talents", location:s, locbase:s)=() action (lib_tools)
log_this(file:s, input:s, repeat:s="yes", locabs:s="weidu_external/data/dw_talents", location:s, locbase:s)=() patch (lib_tools)

make_aura(spell:s, payload:s, effect:s)=() action (lib_spl)

make_casting_effect(target:i=2, effect:s, spell:s)=() action (lib_eff)

make_clabs_unique()=() action (lib_kit)

make_creature(creature:s, edits:s, editstring:s)=() action (lib_cre)

make_dualclass_legal(original_class:s, final_class:s, creature:s)=() action (lib_cre)

make_effect(effect:s, edits:s, editstring:s)=() action (lib_eff)

make_innate_repeating_spell(cooldown:i, overwrite:i, allow_missing:i, desc_strref_cd:i=100404, the, string, to, be, appended, to, the, description,, with, 99999, replaced, by, the, actual, repeat, time., Default, value, is, from, SCS, shared.tra, desc_strref_atwill:i=100405, this, string, says, 'use, at, will', and, gets, appended, instead, if, cooldown:i, arguments:s)=() action (lib_spl)

make_item(item:s, edits:s, editstring:s)=() action (lib_itm)

make_kit(editstring:s, edits:s, kit:s, parent_class:s, race:s=all)=(idsnum:s) action (lib_kit)

make_kit_selectable(human:i, dwarf:i, elf:i, half_elf:i, halfling:i, gnome:i, halforc:i, all_races:i=1, kit:s, class:s)=() action (lib_kit)

make_kit_selectable_core(kit:s, file:s)=() action (lib_kit)

make_label(label:s)=() action (lib_tools)

make_luas_unique()=() action (lib_kit)

make_luas_unique_helper(min:i=1, prefix:s)=(lua_new:s) action (lib_kit)

make_passback(global_passback_say:i="-1", dialog_main:s, stack_base:s)=(passback_state_number:s) action (lib_interject)

make_pro(pro:s, edits:s, editstring:s)=(pro_num:s) action (lib_pro)

make_scroll_of_spell(price:i="-1", resref:s, scrollname:s, scrollicon:s, name_func:s, spell_loc:s, price_func:s="standard_scroll_price")=(scrollname:s) action (lib_spl)

make_spell(level:i=1, type:i, spell:s, idsname:s, edits:s, editstring:s)=(newname:s) action (lib_spl)

make_store(store:s, edits:s, editstring:s)=() action (lib_sto)

make_template(file_list:s, file_ext:s, edits:s, editstring:s, build_before:s, build_after:s)=() action (lib_internal)

make_vef(type:s, vef:s, edits:s, editstring:s)=() action (lib_vef)

make_vvc(vvc:s, edits:s, editstring:s)=() action (lib_vvc)

make_worldmap(worldmap:s, edits:s, editstring:s)=() action (lib_wmp)

merge_scripts(top:s, bottom:s, script:s)=() action (lib_general)

order_wall_vertices(vertices:s)=(vertices:s) patch (lib_wed)

pad_to_four(arguments:i)=(value:s) action (lib_bam)

parse_ict_command()=() patch (lib_interject)

parse_ict_line(line:s)=(dialog:s, condition:s, say:s, do:s, success:s) patch (lib_interject)

patch_colors(suppress_warning:i, condition:s, action:s, bam:s)=() action (lib_bam)
patch_colors(condition:s, action:s)=() patch (lib_bam)

patch_entry(stop_after_match:i, arguments:s, this, is, a, patch, filename:s, file_ext:s, type:s)=(value//:s, 1:s, if:s, any:s, patching:s, occurs:s) patch (lib_patch)

patch_entry_child(sec_index:i, stop_after_match:i, arguments:s, check:s, checkGT:s, checkLT:s, match:s, match_parameter:s, entry_type:s, parent_type:s, filename:s, file_ext:s)=(value:s) patch (lib_patch)

patch_entry_inline(stop_after_match:i, arguments:s, file_ext:s, filename:s, type:s)=(value:s) patch (lib_patch)

patch_entry_notchild(stop_after_match:i, arguments:s, check:s, checkGT:s, checkLT:s, match:s, match_parameter:s, filename:s, file_ext:s, entry_type:s)=(value:s) patch (lib_patch)

patch_reinclude_this patch_macro (lib_macro)
patch_reinclude_this(input:s)=() patch (lib_tools)

patch_text_entry(loc:i, function:s, arguments:s)=() patch (lib_text)

point_in_bounds(x:i, xmin:i, xmax:i, y:i, ymin:i, ymax:i)=(in_bounds:s, x_in_bounds:s, y_in_bounds:s) patch (lib_wed)
point_in_bounds(x:i, xmin:i, xmax:i, y:i, ymin:i, ymax:i)=(in_bounds:s, x_in_bounds:s, y_in_bounds:s) action (lib_wed)

polish_parser(depth:i=1, left:s, right:s)=(left:s, right:s) patch (lib_evaluate)
polish_parser(depth:i=1, left:s, right:s)=(left:s, right:s) action (lib_evaluate)

prepend_string(input:s, arguments:s)=(output:s) patch (lib_text)

prettify_clab_entry(entry:s)=(entry_new:s) action (lib_kit)

PRO_add_aoe()=() patch (lib_pro)

PRO_add_explosion_vvc(arguments:s)=() patch (lib_pro)

PRO_aoe_radius(arguments:s)=() patch (lib_pro)

PRO_build_area()=() patch (lib_pro)

PRO_build_before()=() patch (lib_pro)

PRO_is_area()=() patch (lib_pro)

PRO_postbuild()=() patch (lib_pro)

PRO_spark_color(arguments:s)=() patch (lib_pro)

PRO_target(arguments:s)=() patch (lib_pro)

process_arrow(input:s)=(key:s, value:s) patch (lib_internal)

process_baf(no_repeats:i, editstring:s, filename:s, until:s, after:s)=() patch (lib_bcs)

process_baf_block_inserter(rowcount:i, trig_in:s, act_in:s)=(rowcount:s) patch (lib_bcs)

process_integer_list(list:s, function:s)=() patch (lib_internal)

process_list_of_arrows(filename:s, input:s, instruction:s)=() patch (lib_internal)

process_main_state_transitions(needs_passback:i, dialog_main_state:i, dialog_main:s)=(stack_base:s) patch (lib_interject)

process_pair(input:s)=(key:s, value:s) patch (lib_internal)

process_string_list(list:s, function:s, field:s="arguments")=() patch (lib_internal)

process_table(cumulative:i, inline:i, table:s, location:s, locbase:s, locabs:s, function:s, ext_args:s)=(value:s) action (lib_tools)

push(head:s="SFO_unspecified", tail:s="SFO_unspecified")=(list:s) patch (lib_list)
push(head:s="SFO_unspecified", tail:s="SFO_unspecified")=(list:s) action (lib_list)

QUICK_ADD_SPELL(as_known:i, ~spellname~:s)=() patch (lib_cre)

quicksort(list:s)=(list:s) action (lib_tools)
quicksort(list:s)=(list:s) patch (lib_tools)

quicksort_numerical(list:s)=(list:s) action (lib_tools)

read_armor_bonus_vs_type()=(slashing:s, piercing:s, crushing:s, missile:s) patch (lib_itm)

read_color(offset:i)=(red:s, green:s, blue:s) patch (lib_bam)

read_file_into_array(file:s, location:s, locbase:s, locabs:s, inline:s="no")=(file_length:s, file_contents:a) action (lib_general)

read_in_2da(lookup_column:i, data_column:i=1, first_row:i, file:s)=(array_data:a) action (lib_tools)

read_in_2da_row patch_macro (lib_macro)

read_in_assoc_array(file:s, location:s, locbase:s, locabs:s, force_case:s)=(list:s, array:a) action (lib_list)
read_in_assoc_array(file:s, location:s, locbase:s, locabs:s)=(list:s, array:a) patch (lib_list)
read_in_assoc_array action_macro (lib_macro)

read_in_clab_spelldata action_macro (lib_macro)

read_in_genai_item_data action_macro (lib_genai)

read_in_hidespl action_macro (lib_macro)

read_in_hit_point_levels action_macro (lib_macro)

read_in_item_slots action_macro (lib_macro)

read_in_item_types action_macro (lib_macro)

read_in_list(col:i, existing:i, first_row:i, file:s, location:s, locbase:s, locabs:s, force_case:s)=(list:s, array:a) dimorphic (lib_list)

read_in_list_core(col:i, first_row:i, force_case:s)=(list:s, array:a) patch (lib_list)

read_in_NPC_dialogs action_macro (lib_macro)

read_in_offsets action_macro (lib_macro)

read_in_PCs action_macro (lib_macro)

read_in_proficiencies action_macro (lib_macro)

read_in_proficiency_progression action_macro (lib_macro)

read_in_saving_throws action_macro (lib_macro)

read_in_spellcodes action_macro (lib_macro)

read_in_spells_in_use action_macro (lib_macro)

read_in_stats action_macro (lib_macro)

read_in_thac0 action_macro (lib_macro)

read_in_variables action_macro (lib_macro)

read_rest_of_line(row:i, col:i, colmin:i)=(list:s) patch (lib_tools)

read_table_entry(lookup_column:i, dont_complain:i, rownum:i="-1", colnum:i="-1", row:s, column:s)=(value:s, rownum:s, colnum:s) patch (lib_table)
read_table_entry(lookup_column:i, dont_complain:i, rownum:i="-1", colnum:i="-1", file:s, row:s, column:s)=(value:s, colnum:s, rownum:s) action (lib_table)

read_table_entry_external(lookup_column:i, dont_complain:i, rownum:i="-1", colnum:i="-1", file:s, row:s, column:s, location:s, locbase:s, locabs:s)=(value:s) action (lib_table)

read_variable_array()=(array_data:a) patch (lib_tools)

realign_vertices(x:i, y:i)=() patch (lib_wed)

realign_wall_polygon_bbs(x:i, y:i)=() patch (lib_wed)

rebuild_wall_groups()=() patch (lib_wed)

rectangle_overlap(xmin_1:i, xmax_1:i, ymin_1:i, ymax_1:i, xmin_2:i, xmax_2:i, ymin_2:i, ymax_2:i)=(overlap:s) patch (lib_wed)

recurse_through_files(base_dir:s, allowed_ext:s, function:s, arguments:s)=() action (lib_tools)

regexp_template(tv:i, file_ext:s, edits:s, editstring:s, glob:s="yes")=() action (lib_internal)

reinclude_this(input:s)=() action (lib_tools)
reinclude_this(input:s)=() patch (lib_tools)

remap_search_map_colors(map:s, reference:s, map_out:s)=() action (lib_wed)

remap_this_tile(x:i, xlen:i, y:i, ylen:i, height:i, width:i, tile_number:i)=(value:s) patch (lib_wed)

remove_tiles(x:i, y:i, xlen:i, ylen:i)=() patch (lib_wed)

renumber_rows(start_at:i=1)=() patch (lib_table)

resolve_lua(kit:s)=(lua:s) action (lib_kit)

resolve_parent_class(kit:s)=(parent_class:s, multiclassed:s, true_class:s) action (lib_kit)

resolve_projectile(projectile:s)=(value:s) action (lib_pro)

resolve_splprot_entry(stat:i, value:i, relation_number:i, relation:s)=(value:s) action (lib_general)

return_first_entry(list:s, separator:s=" ")=(list:s, entry:s) patch (lib_list)
return_first_entry(list:s, separator:s=" ")=(list:s, entry:s) action (lib_list)

return_first_letter(input:s)=(firstletter:s, rest:s) patch (lib_tools)
return_first_letter(input:s)=(firstletter:s, rest:s) action (lib_tools)

return_first_pair(list:s, arrow:s=":s=>")=(list:s, key:s, value:s) patch (lib_list)
return_first_pair(list:s)=(key:s, value:s, list:s) action (lib_list)

return_first_secondary_index(entry_type:s, secondary_type:s)=(value:s) patch (lib_patch)

return_function_and_argument(input:s)=(function:s, argument:s) patch (lib_tools)

return_lowest_secondary_index(offset_base:i, entry_type:s, secondary_type:s)=(value:s) patch (lib_patch)

return_number_entries(file_ext:s, entry_type:s)=(value:s) patch (lib_general)

return_offset(offset_num:i, file_ext:s, entry_type:s)=(value:s, offset_loc:s) patch (lib_general)

return_random_entry(list:s)=(entry:s) patch (lib_list)
return_random_entry(list:s)=(entry:s) action (lib_list)

return_secondary_data(offset_base:i, ind_to_, return:i, entry_type:s, secondary_type:s)=(index:s, number:s) patch (lib_patch)

return_secondary_entry_count(offset_base:i, entry_type:s, secondary_type:s)=(value:s) patch (lib_patch)

return_spell_baseline()=(list:s) action (lib_iterate)

return_spellname(resref:s)=(spellname:s) action (lib_spl)
return_spellname(resref:s)=(spellname:s) patch (lib_spl)

reverse_long(input:i)=(output:s) patch (lib_tools)
reverse_long(input:i)=(output:s) action (lib_tools)

run(file:s, files:s, location:s, locbase:s, locabs:s, version:s, tra:s)=() action (lib_tools)

scroll_of_spell_data_collection patch_macro (lib_spl)

search_map_truncate(x:i, y:i, xlen:i, ylen:i, type:s)=() patch (lib_wed)

searchmap_slide_x(arguments:s=0)=(value:s) patch (lib_are)

searchmap_slide_y(arguments:s=0)=(value:s) patch (lib_are)

set_field_value(loc:i, length:i, value:i, arguments:i)=() patch (lib_tools)

set_lookup_indices_of_type(offset_base:i, index:i, entry_type:s, secondary_type:s)=() patch (lib_patch)

set_string(input:s, arguments:s, list, of, oldstring:s=>, newstring)=(output:s) patch (lib_text)

SFO_read_ini_file action_macro (lib_macro)

slide_x(arguments:s=0)=(value:s) patch (lib_are)

slide_y(arguments:s=0)=(value:s) patch (lib_are)

sort_array_by_function(array:s, function:s)=(sorted_array:a) action (lib_tools)

sort_ids(ids:s)=() action (lib_general)

speed_debug(var:i=4, string:s="Unspecified debug check")=() action (lib_tools)

spell_is_unusable(resref:s, kit:s)=(value:s) action (lib_spl)

spell_to_idscode(resref:s)=(idscode:s) action (lib_spl)
spell_to_idscode(resref:s)=(idscode:s) patch (lib_spl)

spell_use_script_check(type:i, script:s, log:s="spells_unused.txt", filename:s)=() patch (lib_cre)

spell_use_script_check_batch(type:i, prefix:s)=() action (lib_cre)

SPL_add_basic_ability(arguments:s)=() patch (lib_spl)

SPL_append_description(arguments:s)=() patch (lib_spl)

SPL_append_description_newline(arguments:s)=() patch (lib_spl)

SPL_build()=() patch (lib_spl)

SPL_delete_opcodes(arguments:s)=() patch (lib_spl)

SPL_description()=(value:s) patch (lib_spl)

SPL_duration_if_variable(arguments:s)=() patch (lib_spl)

SPL_enforce_school(arguments:s)=() patch (lib_spl)

SPL_enforce_school_bg2(arguments:s)=() patch (lib_spl)

SPL_enforce_school_iwd(arguments:s)=() patch (lib_spl)

SPL_name()=(value:s) patch (lib_spl)

SPL_postbuild()=() patch (lib_spl)

SPL_read_ability_true_level()=(value:s) patch (lib_spl)

SPL_read_school()=(value:s) patch (lib_spl)

SPL_read_spell_type()=(value:s) patch (lib_spl)

SPL_say_description(arguments:s)=() patch (lib_spl)

SPL_say_description_strref(arguments:s)=() patch (lib_spl)

SPL_say_name(arguments:s)=() patch (lib_spl)

SPL_school(arguments:s)=() patch (lib_spl)

SPL_set_description(arguments:s)=() patch (lib_spl)

SPL_set_name(arguments:s)=() patch (lib_spl)

SPL_spell_type(arguments:s)=() patch (lib_spl)

SPL_substitute_description(arguments:s)=() patch (lib_spl)

SPL_substitute_description_exact(arguments:s)=() patch (lib_spl)

SPL_substitute_description_exact_strref(arguments:s)=() patch (lib_spl)

SPL_substitute_description_strref(arguments:s)=() patch (lib_spl)

split_from_left(string:s, splitter:s)=(left:s, right:s) patch (lib_list)
split_from_left(string:s, splitter:s)=(left:s, right:s) action (lib_list)

split_from_right(string:s, splitter:s)=(left:s, right:s) patch (lib_list)
split_from_right(string:s, splitter:s)=(left:s, right:s) action (lib_list)

ssl_ee_to_vanilla()=() patch (install_sfo)

ssl_hotkey_swap()=() patch (install_sfo)

ssl_to_baf(script:s, location:s, locbase:s, locabs:s, variables:s, inline:s, rename_to:s, booleans:s)=() action (lib_general)

ssl_to_bcs(script:s, location:s, locbase:s, locabs:s, variables:s, booleans:s, rename_to:s, inline:s)=() action (lib_general)

standard_scroll_price(arguments:s)=(value:s) action (lib_spl)

standardize_kit(arguments:s)=(value:s) action (lib_kit)

standardize_race(arguments:s)=(value:s) action (lib_kit)

STO_read_store_type()=(value:s) patch (lib_sto)

STO_remove_items(arguments:s)=() patch (lib_sto)

STO_say_drink(arguments:s)=() patch (lib_sto)

STO_say_name(arguments:s)=() patch (lib_sto)

STO_set_drink(arguments:s)=() patch (lib_sto)

STO_set_name(arguments:s)=() patch (lib_sto)

STO_store_type(arguments:s=0)=() patch (lib_sto)

STO_will_buy(arguments:s)=() patch (lib_sto)

STO_will_not_buy(arguments:s)=() patch (lib_sto)

stretch_point(x:i, y:i, x_0:i, y_0:i, numerator:i=1, denominator:i=1)=(x:s, y:s) patch (lib_wed)

strip_quotes_from_string(string:s)=(string:s) patch (lib_tools)

strip_spaces_from_string(string:s)=(string:s) patch (lib_tools)
strip_spaces_from_string(string:s)=(string:s) action (lib_tools)

substitute_string(exact:i, input:s, arguments:s, list, of, oldstring:s=>, newstring)=(output:s) patch (lib_text)
substitute_string(exact:i, input:s, arguments:s)=(output:s) action (lib_text)

substitute_tlk_entry(tlk_entry:i=~-1~, exact:i, arguments:s)=() action (lib_text)
substitute_tlk_entry(tlk_entry:i="-1", exact:i, arguments:s)=() patch (lib_text)

swap_are_cre_script(area:s, creature:s, script:s)=() action (lib_are)

swap_searchmap_code(old:i, new:i, map:s)=() action (lib_wed)
swap_searchmap_code(old:i, new:i)=() patch (lib_wed)

swap_text(tv:i, allow_missing:i, files:s, file:s, swaps:s, postfix:s)=() action (lib_general)

swap_text_core2(arguments:s)=() patch (lib_general)

swap_text_core(arguments:s)=() patch (lib_general)

transcribe_polygons(delta_x:i, delta_y:i, st, retch_numerator:i=1, st, retch_denominator:i=1, st, retch_base_x:i, st, retch_base_y:i, from_area:s, to_area:s, polygons:s)=() action (lib_wed)

truncate_bitmap_row(row_num:i, xmin:i, ymin:i, xmax:i, ymax:i, divisor:i, row:s)=(row_out:s, row_empty:s) patch (lib_wed)

truncate_polygon(xmax:i, ymax:i, xmin:i, ymin:i, bb_ymax:i, vertices:s)=(vertices:s, bb_xmin:s, bb_xmax:s, bb_ymin:s, bb_ymax:s) patch (lib_wed)

truncate_wall(xmin:i, xmax:i, ymin:i, ymax:i, vertices:s)=(vertices:s, in_bounds:s) patch (lib_wed)

u_d_crossing_point(x1:i, x2:i, y1:i, y2:i, bdy:i)=(xcross:s, ycross:s) patch (lib_wed)

UI_add_function(function:s)=() patch (lib_ui)

UI_add_string(tra_entry:i, string_id:s, string:s)=() action (lib_ui)

UI_alter_object(object:s, object_type:s, object_name_field:s="name", patch:s)=() patch (lib_ui)

UI_analyze_object(object:s, object_type:s, object_name_field:s="name", patch:s)=(patch_output:a) patch (lib_ui)

UI_get_coordinates()=(patch_output:a) patch (lib_ui)

UI_insert_into_object(object:s, object_type:s, object_name_field:s="name", insert:s)=() patch (lib_ui)

UI_patch_object_master(object:s, object_type:s, object_name_field:s="name", patch:s, type:s, insert_data:s)=(object_data:s, patch_output:a) patch (lib_ui)

UI_replace_object(object:s, object_type:s, object_name_field:s="name", replace:s)=() patch (lib_ui)

UI_return_object(object:s, object_type:s, object_name_field:s="name", patch:s)=(object_data:s) patch (lib_ui)

update_bb(x:i, y:i, bb_xmin:i, bb_xmax:i, bb_ymin:i, bb_ymax:i)=(bb_xmin:s, bb_xmax:s, bb_ymin:s, bb_ymax:s) patch (lib_wed)

update_lookup_indices(offset_base:i, entry_type:s)=() patch (lib_patch)

update_lookup_indices_of_type(offset_base:i, entry_type:s, secondary_type:s)=() patch (lib_patch)

update_offsets(bytes_added:i, entry_type:s)=() patch (lib_patch)

VEF_build()=() patch (lib_vef)

VEF_postbuild()=() patch (lib_vef)

VVC_build()=() patch (lib_vvc)

VVC_postbuild()=() patch (lib_vvc)

warning(warning:s, arguments:s, repeat:s="no")=() action (lib_tools)
warning(warning:s, arguments:s, repeat:s="no")=() patch (lib_tools)

wipe_soundset(arguments:s)=() patch (lib_cre)

WMP_both_labels(arguments:s)=() patch (lib_wmp)

WMP_build()=() patch (lib_wmp)

WMP_delete_all_links()=() patch (lib_wmp)

WMP_delete_area(arguments:s)=() patch (lib_wmp)

WMP_delete_link(arguments:s)=() patch (lib_wmp)

WMP_delete_link_between(arguments:s)=() patch (lib_wmp)

WMP_deletion_helper(deleted:i, to_delete:s)=(to_delete:s) patch (lib_wmp)

WMP_edit_link_between(arguments:s)=(value:s) patch (lib_wmp)

WMP_find_link_between(arguments:s)=(value:s) patch (lib_wmp)

WMP_find_links_from(arguments:i)=(value:s) patch (lib_wmp)

WMP_find_links_to(arguments:i)=(value:s) patch (lib_wmp)

WMP_index_of_area(arguments:s)=(value:s) patch (lib_wmp)

WMP_insert_link(arguments:s)=() patch (lib_wmp)

WMP_insert_link_by_codes(area_ind:i, area_dir:s)=(insert_offset:s) patch (lib_wmp)

WMP_link_deletion_update_helper(ind:i, num:i, deleted:i)=(ind:s, num:s) patch (lib_wmp)

WMP_name_of_area(arguments:s=0)=(value:s) patch (lib_wmp)

WMP_quick_resource(arguments:s)=() patch (lib_wmp)

WMP_space_for_new_link(new_ind:i, area_ind:i, area_dir:s)=() patch (lib_wmp)

WMP_to_dir(arguments:s)=() patch (lib_wmp)

WMP_travel_time(arguments:s)=() patch (lib_wmp)

WMP_update_for_link_deletion(deleted:i)=() patch (lib_wmp)

write_array_into_file(file:s, file_contents:s)=() action (lib_general)

write_color(red:i, green:i, blue:i, offset:i)=() patch (lib_bam)

write_list(list:s, file:s, locabs:s="weidu_external/data/dw_talents", location:s, locbase:s)=() action (lib_list)
write_list(list:s, file:s, locabs:s="weidu_external/data/dw_talents", location:s, locbase:s)=() patch (lib_list)

write_table_entry(lookup_column:i, do_not_insert:i, rownum:i="-1", colnum:i="-1", all_rows:i, arguments:s, row:s, column:s, default_fill:s="0")=() patch (lib_table)
write_table_entry(lookup_column:i, do_not_insert:i, rownum:i="-1", colnum:i="-1", all_rows:i, arguments:s, row:s, column:s, file:s, default_fill:s="0")=() action (lib_table)

write_table_entry_external(lookup_column:i, do_not_insert:i, rownum:i="-1", colnum:i="-1", arguments:s, row:s, column:s, file:s, default_fill:s="0", location:s, locbase:s, locabs:s)=() action (lib_table)