AdjustStack	macutils.c	/^void AdjustStack(void)$/
BIND	unify.c	/^#define BIND(i, c1, t2, c2, trp) { struct trail *t/
CLEAR_BIT	macros.h	/^#define CLEAR_BIT(bits, flag)  (bits = bits & ~fla/
CLOCK_START	macros.h	/^#define CLOCK_START(c)   \/* empty string *\/$/
CLOCK_STOP	macros.h	/^#define CLOCK_STOP(c)   \/* empty string *\/$/
CPU_TIME	macros.h	/^#define CPU_TIME(sec, usec) {sec = usec = 0;}$/
DEREFERENCE	unify.c	/^#define DEREFERENCE(t, c) { int i; \\$/
Mlisp	lisp.c	/^int main(int argc, char **argv)$/
Mmain	main.c	/^ int main(argc, argv)$/
SET_BIT	macros.h	/^#define SET_BIT(bits, flag)    (bits = bits | flag/
SetCreator	macutils.c	/^void SetCreator(void)$/
TP_BIT	macros.h	/^#define TP_BIT(bits, flag)        (bits & flag)$/
abend	misc.c	/^void abend(str)$/
activity	prune.c	/^void activity(c, t)$/
add_subcase	case.c	/^void add_subcase(i)$/
adjust_weight_with_hints	hints.c	/^void adjust_weight_with_hints(c)$/
all_args_vars	fpa.c	/^static int all_args_vars(t)$/
all_cont_cl	clause.c	/^void all_cont_cl(t, cpp)$/
all_factors	resolve.c	/^void all_factors(c, lst)$/
all_instances	share.c	/^struct term_ptr *all_instances(atom)$/
all_instances_fpa	share.c	/^struct term_ptr *all_instances_fpa(atom)$/
alloc_fpa_index	fpa.c	/^struct fpa_index *alloc_fpa_index()$/
always_split	case.c	/^void always_split()$/
anc_subsume	clause.c	/^int anc_subsume(c, d)$/
answer_lit	clause.c	/^int answer_lit(lit)$/
anti_skolemize	formula.c	/^struct formula *anti_skolemize(f)$/
append_cl	clause.c	/^void append_cl(l, c)$/
append_lists	misc.c	/^void append_lists(l1, l2)$/
apply	unify.c	/^struct term *apply(t, c)$/
apply_clause	resolve.c	/^struct clause *apply_clause(c, s)$/
apply_demod	demod.c	/^struct term *apply_demod(t, c, pf)$/
apply_substitute	paramod.c	/^static struct term *apply_substitute(t, into_term,/
assign_cl_id	clause.c	/^void assign_cl_id(c)$/
assumps_to_parent	case.c	/^void assumps_to_parent(e)$/
atom	lisp.c	/^int atom(Bnode p) { return p->atom; }  \/* atom *\/$/
attribute_type	attrib.c	/^int attribute_type(name)$/
auto_change_flag	options.c	/^void auto_change_flag(fp, index, val)$/
auto_change_parm	options.c	/^void auto_change_parm(fp, index, val)$/
auto_lex_order	io.c	/^void auto_lex_order()$/
automatic_1_settings	misc.c	/^void automatic_1_settings()$/
automatic_2_settings	misc.c	/^void automatic_2_settings()$/
back_demod	demod.c	/^void back_demod(d, c, input, lst)$/
back_subsume	clause.c	/^struct clause_ptr *back_subsume(c)$/
back_subsume_hint	hints.c	/^int back_subsume_hint(c)$/
back_unit_deletion	clause.c	/^void back_unit_deletion(c, input)$/
backward	linkur.c	/^static struct link_node *backward(tree, node, targ/
bd_kludge_delete	share.c	/^void bd_kludge_delete(t)$/
bd_kludge_insert	share.c	/^void bd_kludge_insert(t)$/
biggest_var	misc.c	/^int biggest_var(t)$/
biggest_var_clause	misc.c	/^int biggest_var_clause(c)$/
bin_res	resolve.c	/^void bin_res(giv_cl)$/
bird_print	io.c	/^void bird_print(fp, t)$/
bits_ulong	io.c	/^int bits_ulong(s, np)$/
bnode_to_clause	ivy.c	/^struct clause *bnode_to_clause(Bnode b)$/
bnode_to_natural	ivy.c	/^int bnode_to_natural(Bnode b)$/
bnode_to_otterterm	ivy.c	/^struct term *bnode_to_otterterm(Bnode b, char **va/
bool_to_term	foreign.c	/^struct term *bool_to_term(i)$/
build_bin_para	paramod.c	/^static struct clause *build_bin_para(alpha, from_s/
build_bin_res	resolve.c	/^struct clause *build_bin_res(a1, s1, a2, s2)$/
build_binary_term	dp_util.c	/^static struct term *build_binary_term(sn, t1, t2)$/
build_for_all	fpa.c	/^struct fpa_tree *build_for_all(index)$/
build_hyper	resolve.c	/^static struct clause *build_hyper(cla, nuc_subst, /
build_parental_chain	linkur.c	/^static struct int_ptr *build_parental_chain(node, /
build_proof_object	check.c	/^void build_proof_object(c)$/
build_term	resolve.c	/^struct term *build_term(sn, arg1, arg2, arg3)$/
build_tree	fpa.c	/^struct fpa_tree *build_tree(t, u_type, bound, inde/
build_tree_local	fpa.c	/^static struct fpa_tree *build_tree_local(t, u_type/
build_ur_resolvent	linkur.c	/^static struct clause *build_ur_resolvent(target, t/
built_in_symbols	io.c	/^void built_in_symbols()$/
caddr	lisp.c	/^Bnode caddr(Bnode p) { return p->cdr->cdr->car;}  /
cadr	lisp.c	/^Bnode cadr(Bnode p) { return p->cdr->car;}  \/* cad/
canc_fs_pos	is.c	/^void canc_fs_pos(pos, subst)$/
cancel_unifiable	linkur.c	/^static void cancel_unifiable(pos)$/
car	lisp.c	/^Bnode car(Bnode p) { return p->car;}  \/* car *\/$/
case_depth	case.c	/^int case_depth()$/
cat_str	io.c	/^void cat_str(s1, s2, s3)$/
cdr	lisp.c	/^Bnode cdr(Bnode p) { return p->cdr;}  \/* cdr *\/$/
change_flag	options.c	/^int change_flag(fp, t, set)$/
change_parm	options.c	/^int change_parm(fp, t)$/
check_down_tree	linkur.c	/^static BOOLEAN check_down_tree(node, my_depth)$/
check_eq_lit	check.c	/^static int check_eq_lit(lit)$/
check_for_bad_things	dp_util.c	/^void check_for_bad_things(c)$/
check_for_proof	misc.c	/^struct clause *check_for_proof(c)$/
check_input_demod	demod.c	/^int check_input_demod(c)$/
check_options	options.c	/^void check_options()$/
check_stop	misc.c	/^int check_stop()$/
check_transformed_clause	dp_util.c	/^static void check_transformed_clause(c, orig)$/
check_up_tree	linkur.c	/^static BOOLEAN check_up_tree(node, my_depth)$/
child_of_geometry	geometry.c	/^int child_of_geometry(c)$/
cl_append	check.c	/^struct clause *cl_append(c1, c2)$/
cl_clear_vars	clause.c	/^void cl_clear_vars(c)$/
cl_copy	clause.c	/^struct clause *cl_copy(c)$/
cl_copy_delete_literal	check.c	/^struct clause *cl_copy_delete_literal(c, n)$/
cl_del_int	clause.c	/^void cl_del_int(c)$/
cl_del_non	clause.c	/^void cl_del_non(c)$/
cl_delete_tab	clause.c	/^void cl_delete_tab(c)$/
cl_find	clause.c	/^struct clause *cl_find(id)$/
cl_insert_tab	clause.c	/^void cl_insert_tab(c)$/
cl_int_chk	clause.c	/^void cl_int_chk(c)$/
cl_integrate	clause.c	/^void cl_integrate(c)$/
cl_merge	clause.c	/^void cl_merge(c)$/
clash	resolve.c	/^static void clash(c_start, nuc_subst, nuc_lits, nu/
clause_ident	clause.c	/^int clause_ident(c1, c2)$/
clause_to_clauses	dp_util.c	/^static struct list *clause_to_clauses(c)$/
clause_to_pair	dp_util.c	/^int clause_to_pair(c, dp, ep)$/
clause_to_term	clause.c	/^struct term *clause_to_term(c)$/
clausify	formula.c	/^struct list *clausify(f)$/
clausify_formed	formula.c	/^struct formula *clausify_formed(f)$/
clausify_formula_list	formula.c	/^struct list *clausify_formula_list(fp)$/
cleanup	misc.c	/^void cleanup()$/
clear_subst_1	unify.c	/^void clear_subst_1(t1)$/
clear_subst_2	unify.c	/^void clear_subst_2(t1, t2)$/
clear_var_names	clause.c	/^void clear_var_names(t)$/
clock_init	clocks.c	/^void clock_init()$/
clock_reset	clocks.c	/^void clock_reset(c)$/
clock_val	clocks.c	/^long clock_val(c)$/
cnf	formula.c	/^struct formula *cnf(f)$/
cnf_to_list	formula.c	/^static struct list *cnf_to_list(f)$/
collect_symbols	dp_util.c	/^static void collect_symbols(t, type)$/
combine_answers	resolve.c	/^void combine_answers(res, a1, s1, a2, s2)$/
compare_for_auto_lex_order	io.c	/^int compare_for_auto_lex_order(d1, d2)$/
compare_literal_data	case.c	/^struct literal_data compare_literal_data(d1, d2)$/
compare_splitable_clauses	case.c	/^struct clause *compare_splitable_clauses(c, d)$/
conflict_tautology	formula.c	/^void conflict_tautology(f)$/
connect_new_node	check.c	/^struct proof_object_node *connect_new_node(new_pro/
construct_children_nodes	linkur.c	/^static void construct_children_nodes(curr_node, tp/
contains_answer_literal	check.c	/^int contains_answer_literal(c)$/
contains_rule	check.c	/^int contains_rule(c, rule)$/
contains_skolem_symbol	formula.c	/^int contains_skolem_symbol(t)$/
contract_imd	imd.c	/^struct term *contract_imd(t_in, demods, subst, dem/
contract_lin	demod.c	/^static struct term *contract_lin(t, demods, c, dem/
control_memory	misc.c	/^void control_memory()$/
convenient_demod	demod.c	/^struct term *convenient_demod(t)$/
copy_formula	formula.c	/^struct formula *copy_formula(f)$/
copy_int_ptr_list	misc.c	/^struct int_ptr *copy_int_ptr_list(p)$/
copy_ip_segment	check.c	/^struct int_ptr *copy_ip_segment(ip, n)$/
copy_subst_to_proof_object	check.c	/^static void copy_subst_to_proof_object(subst, p)$/
copy_term	misc.c	/^struct term *copy_term(t)$/
current_case	case.c	/^struct int_ptr *current_case()$/
d_term	io.c	/^void d_term(t)$/
declare_op	io.c	/^int declare_op(prec, type, str)$/
declare_user_functions	foreign.c	/^void declare_user_functions()$/
del_hidden_clauses	clause.c	/^void del_hidden_clauses()$/
delete_attributes	attrib.c	/^void delete_attributes(c)$/
delete_fpa_tab	fpa.c	/^static void delete_fpa_tab(t, path, index)$/
demod	demod.c	/^static struct term *demod(t, contract_proc, demods/
demod_cl	demod.c	/^void demod_cl(c)$/
demod_out_in	demod.c	/^static struct term *demod_out_in(t, contract_proc,/
dependent_flags	options.c	/^void dependent_flags(fp, index)$/
dependent_parms	options.c	/^void dependent_parms(fp, index)$/
disintegrate_term	share.c	/^void disintegrate_term(t)$/
disj_to_clause	formula.c	/^static struct clause *disj_to_clause(f)$/
display_term	io.c	/^void display_term(fp, t)$/
distinct_vars	clause.c	/^int distinct_vars(c)$/
distinct_vars_rec	clause.c	/^static void distinct_vars_rec(t, a, max)$/
distribute	formula.c	/^static struct formula *distribute(f)$/
distribute_quantifier	formula.c	/^struct formula *distribute_quantifier(f)$/
dnf	formula.c	/^struct formula *dnf(f)$/
dollar_contract	demod.c	/^static struct term *dollar_contract(t)$/
dollar_out	demod.c	/^static void dollar_out(t)$/
dollar_out_non_list	demod.c	/^static void dollar_out_non_list(t)$/
domain_element	dp_util.c	/^int domain_element(t)$/
domain_element_process	dp_util.c	/^static void domain_element_process(c)$/
dot_trans	lisp.c	/^static void dot_trans (Bnode p)$/
dotp	lisp.c	/^static BOOLEAN dotp(Bnode p)$/
double_str	io.c	/^void double_str(d, s)$/
double_to_term	foreign.c	/^struct term *double_to_term(d)$/
dp_p_clause	dp_util.c	/^static void dp_p_clause(c)$/
dp_p_term	dp_util.c	/^void dp_p_term(t)$/
dp_transform	dp_util.c	/^void dp_transform()$/
dynamic_demodulator	demod.c	/^int dynamic_demodulator(c)$/
end_term_imd	imd.c	/^static struct imd_tree *end_term_imd(t, imd, path_/
end_term_is	is.c	/^static struct is_tree *end_term_is(t, is, path_p)$/
eq_lit	clause.c	/^int eq_lit(lit)$/
equality_clause	clause.c	/^int equality_clause(c)$/
evaluate_user_function	foreign.c	/^struct term *evaluate_user_function(t, op_code)$/
exit_with_possible_model	case.c	/^void exit_with_possible_model()$/
expand_imp	formula.c	/^struct formula *expand_imp(f)$/
extract_given_clause	clause.c	/^struct clause *extract_given_clause()$/
factor_simplify	resolve.c	/^int factor_simplify(c)$/
fill_in_op_data	io.c	/^static void fill_in_op_data(p, t)$/
fill_word	lisp.c	/^static int fill_word(FILE *fp)$/
find_atom_to_split	case.c	/^struct term *find_atom_to_split()$/
find_clause_to_split	case.c	/^struct clause *find_clause_to_split()$/
find_first_cl	clause.c	/^struct clause *find_first_cl(l)$/
find_given_clause	clause.c	/^struct clause *find_given_clause()$/
find_interactive_cl	clause.c	/^struct clause *find_interactive_cl()$/
find_last_cl	clause.c	/^struct clause *find_last_cl(l)$/
find_lightest_cl	clause.c	/^struct clause *find_lightest_cl(l)$/
find_lightest_geo_child	clause.c	/^struct clause *find_lightest_geo_child(l)$/
find_match2	check.c	/^struct proof_object_node *find_match2(struct claus/
find_random_cl	clause.c	/^struct clause *find_random_cl(l)$/
finish_translating	check.c	/^int finish_translating(c, rest_of_history, current/
first_nonvar_arg	dp_util.c	/^static struct term *first_nonvar_arg(c)$/
first_nonvar_arg_term	dp_util.c	/^static struct term *first_nonvar_arg_term(t, check/
first_or_next_factor	resolve.c	/^struct clause *first_or_next_factor(c, l1p, l2p)$/
first_rewrite	check.c	/^static struct int_ptr *first_rewrite(t, pos, c, de/
first_rewrite_clause	check.c	/^static struct int_ptr *first_rewrite_clause(c, dem/
first_unifiable	linkur.c	/^static struct term *first_unifiable(t, index, subs/
flatten_clause	dp_util.c	/^static void flatten_clause(d)$/
flatten_top	formula.c	/^void flatten_top(f)$/
flatten_top_2	formula.c	/^static void flatten_top_2(f, start, end_p)$/
foo	foreign.c	/^long foo(l, d, s)$/
for_sub_prop	clause.c	/^struct clause *for_sub_prop(d)$/
formula_args_to_term	formula.c	/^static struct term *formula_args_to_term(f, type)$/
formula_ident	formula.c	/^int formula_ident(f, g)$/
formula_to_term	formula.c	/^struct term *formula_to_term(f)$/
forward	linkur.c	/^static struct link_node *forward(cn, target)$/
forward_from_resolved_tree	linkur.c	/^static struct link_node *forward_from_resolved_tre/
forward_subsume	clause.c	/^struct clause *forward_subsume(d)$/
fpa_delete	fpa.c	/^void fpa_delete(t, level, index)$/
fpa_insert	fpa.c	/^void fpa_insert(t, level, index)$/
fprint_btree	lisp.c	/^void fprint_btree(FILE *fp, Bnode p)$/
free_all_mem	misc.c	/^void free_all_mem()$/
free_ans_lit_node	av.c	/^void free_ans_lit_node(p)$/
free_bnode	lisp.c	/^static void free_bnode(Bnode p)$/
free_cl_attribute	av.c	/^void free_cl_attribute(p)$/
free_clash_nd	av.c	/^void free_clash_nd(p)$/
free_clause	av.c	/^void free_clause(p)$/
free_clause_ptr	av.c	/^void free_clause_ptr(p)$/
free_context	av.c	/^void free_context(p)$/
free_formula	av.c	/^void free_formula(p)$/
free_formula_box	av.c	/^void free_formula_box(p)$/
free_formula_ptr	av.c	/^void free_formula_ptr(p)$/
free_formula_ptr_2	av.c	/^void free_formula_ptr_2(p)$/
free_fpa_head	av.c	/^void free_fpa_head(p)$/
free_fpa_tree	av.c	/^void free_fpa_tree(p)$/
free_fsub_pos	av.c	/^void free_fsub_pos(p)$/
free_imd_pos	av.c	/^void free_imd_pos(p)$/
free_imd_pos_list	av.c	/^void free_imd_pos_list(p)$/
free_imd_tree	av.c	/^void free_imd_tree(p)$/
free_int_ptr	av.c	/^void free_int_ptr(p)$/
free_is_pos	av.c	/^void free_is_pos(p)$/
free_is_pos_list	av.c	/^void free_is_pos_list(p)$/
free_is_tree	av.c	/^void free_is_tree(p)$/
free_link_node	av.c	/^void free_link_node(p)$/
free_linked_node_tree	linkur.c	/^static void free_linked_node_tree(tree, target)$/
free_list	av.c	/^void free_list(p)$/
free_literal	av.c	/^void free_literal(p)$/
free_occurrence	formula.c	/^int free_occurrence(v, f)$/
free_rel	av.c	/^void free_rel(p)$/
free_sym_ent	av.c	/^void free_sym_ent(p)$/
free_sym_tab	io.c	/^void free_sym_tab()$/
free_term	av.c	/^void free_term(p)$/
free_term_ptr	av.c	/^void free_term_ptr(p)$/
free_trail	av.c	/^void free_trail(p)$/
fs_retrieve	is.c	/^struct term *fs_retrieve(t, subst, is, fs_pos)$/
gen_conflict	formula.c	/^int gen_conflict(c, d)$/
gen_sk_sym	formula.c	/^void gen_sk_sym(t)$/
gen_subsume	formula.c	/^int gen_subsume(c, d)$/
gen_subsume_prop	formula.c	/^int gen_subsume_prop(c, d)$/
gen_subsume_rec	formula.c	/^int gen_subsume_rec(c, cs, d, ds, tr_p)$/
gen_tautology	formula.c	/^int gen_tautology(c, d)$/
generate_resolvent	linkur.c	/^static struct term *generate_resolvent(curr_node, /
geo_generate_unif	geometry.c	/^static void geo_generate_unif(giv_cl, pos_vec, dep/
geo_recurse_unif	geometry.c	/^static void geo_recurse_unif(a, b, giv_cl, pos_vec/
geo_replace_unif	geometry.c	/^static struct term *geo_replace_unif(t, pos_vec, d/
geo_rewrite	geometry.c	/^int geo_rewrite(c)$/
geo_rewrite_recurse	geometry.c	/^static int geo_rewrite_recurse(a, b, cl, next_var)/
geometry_rule_unif	geometry.c	/^void geometry_rule_unif(giv_cl)$/
get_ancestors	clause.c	/^int get_ancestors(c, cpp, ipp)$/
get_ans_lit_node	av.c	/^struct ans_lit_node *get_ans_lit_node()$/
get_args_for_user_function	foreign.c	/^int get_args_for_user_function(t, op_code, long_ar/
get_attribute	attrib.c	/^struct cl_attribute *get_attribute(c, name)$/
get_attribute_index	attrib.c	/^int get_attribute_index(s)$/
get_bnode	lisp.c	/^static Bnode get_bnode(void)$/
get_cl_attribute	av.c	/^struct cl_attribute *get_cl_attribute()$/
get_clash_nd	av.c	/^struct clash_nd *get_clash_nd()$/
get_clause	av.c	/^struct clause *get_clause()$/
get_clause_ptr	av.c	/^struct clause_ptr *get_clause_ptr()$/
get_context	av.c	/^struct context *get_context()$/
get_formula	av.c	/^struct formula *get_formula()$/
get_formula_box	av.c	/^struct formula_box *get_formula_box()$/
get_formula_ptr	av.c	/^struct formula_ptr *get_formula_ptr()$/
get_formula_ptr_2	av.c	/^struct formula_ptr_2 *get_formula_ptr_2()$/
get_fpa_head	av.c	/^struct fpa_head *get_fpa_head()$/
get_fpa_tree	av.c	/^struct fpa_tree *get_fpa_tree()$/
get_fsub_pos	av.c	/^struct fsub_pos *get_fsub_pos()$/
get_gen_node	check.c	/^struct gen_node *get_gen_node()$/
get_imd_pos	av.c	/^struct imd_pos *get_imd_pos()$/
get_imd_tree	av.c	/^struct imd_tree *get_imd_tree()$/
get_int_ptr	av.c	/^struct int_ptr *get_int_ptr()$/
get_is_pos	av.c	/^struct is_pos *get_is_pos()$/
get_is_tree	av.c	/^struct is_tree *get_is_tree()$/
get_leaf_node	fpa.c	/^static struct fpa_tree *get_leaf_node(path, index)/
get_link_node	av.c	/^struct link_node *get_link_node()$/
get_list	av.c	/^struct list *get_list()$/
get_literal	av.c	/^struct literal *get_literal()$/
get_literal_data	case.c	/^void get_literal_data(lit, p)$/
get_name	io.c	/^static void get_name(buf, p, name, in_list)$/
get_proof_object	check.c	/^struct proof_object *get_proof_object()$/
get_proof_object_node	check.c	/^struct proof_object_node *get_proof_object_node()$/
get_rel	av.c	/^struct rel *get_rel()$/
get_sym_ent	av.c	/^struct sym_ent *get_sym_ent()$/
get_term	av.c	/^struct term *get_term()$/
get_term_ptr	av.c	/^struct term_ptr *get_term_ptr()$/
get_time	clocks.c	/^char *get_time()$/
get_trail	av.c	/^struct trail *get_trail()$/
get_var_multiset	weight.c	/^static void get_var_multiset(t, a)$/
getrusage	header.h	/^#  define getrusage(a, b)  syscall(SYS_GETRUSAGE, /
given_clause_ok	process.c	/^static int given_clause_ok(id)$/
gl_demod	geometry.c	/^void gl_demod(c, lst)$/
ground	misc.c	/^int ground(t)$/
ground_clause	misc.c	/^int ground_clause(c)$/
hash_path	fpa.c	/^static int hash_path(path)$/
hash_term	share.c	/^static int hash_term(t)$/
heat_is_on	hot.c	/^int heat_is_on()$/
hide_clause	clause.c	/^void hide_clause(c)$/
horn_clause	clause.c	/^int horn_clause(c)$/
hostname	nonport.c	/^char *hostname()$/
hot_cl_integrate	clause.c	/^void hot_cl_integrate(c)$/
hot_dynamic	hot.c	/^void hot_dynamic(c)$/
hot_index_clause	hot.c	/^void hot_index_clause(c)$/
hot_inference	hot.c	/^void hot_inference(new_cl)$/
hot_mark_clash	hot.c	/^static void hot_mark_clash(r)$/
hot_mark_clash_cl	hot.c	/^void hot_mark_clash_cl(c, mark)$/
hot_unmark_clash	hot.c	/^static void hot_unmark_clash(r)$/
hyper_res	resolve.c	/^void hyper_res(giv_cl)$/
id_nested_skolems	misc.c	/^static int id_nested_skolems(t)$/
ident_nested_skolems	misc.c	/^int ident_nested_skolems(c)$/
identity_paramod	check.c	/^static struct clause *identity_paramod(from_cl, fr/
identity_resolve	check.c	/^struct clause *identity_resolve(c1, i1, c2, i2)$/
iff_to_conj	formula.c	/^struct formula *iff_to_conj(f)$/
iff_to_disj	formula.c	/^struct formula *iff_to_disj(f)$/
imd_delete	imd.c	/^void imd_delete(demod, root_imd)$/
imd_insert	imd.c	/^void imd_insert(demod, imd)$/
in_sym_tab	io.c	/^int in_sym_tab(s)$/
index_lits_all	index.c	/^void index_lits_all(c)$/
index_lits_clash	index.c	/^void index_lits_clash(c)$/
index_mark_clash	index.c	/^static void index_mark_clash(r)$/
index_paramod	index.c	/^static void index_paramod(atom)$/
infer_and_process	process.c	/^void infer_and_process(giv_cl)$/
init	misc.c	/^void init()$/
init_attributes	attrib.c	/^void init_attributes()$/
init_gen_tab	check.c	/^static struct gen_tab *init_gen_tab()$/
init_hot	hot.c	/^void init_hot()$/
init_literal_data	case.c	/^void init_literal_data(p)$/
init_log_for_x_show	nonport.c	/^FILE *init_log_for_x_show()$/
init_options	options.c	/^void init_options()$/
init_proof_object	ivy.c	/^struct list *init_proof_object(FILE *fin, FILE *fo/
init_proof_object_environment	check.c	/^void init_proof_object_environment(void)$/
init_special_ops	io.c	/^void init_special_ops()$/
initial_str	io.c	/^int initial_str(s, t)$/
initialize_tree	linkur.c	/^static struct link_node *initialize_tree(giv_cl)$/
input_clauses_in_list	prune.c	/^int input_clauses_in_list(lst)$/
insert_after_cl	clause.c	/^void insert_after_cl(c, c_new)$/
insert_before_cl	clause.c	/^void insert_before_cl(c, c_new)$/
insert_clause	clause.c	/^void insert_clause(c, cpp)$/
insert_detailed_para_history	paramod.c	/^static void insert_detailed_para_history(ip_from, /
insert_fpa_tab	fpa.c	/^static void insert_fpa_tab(t, path, index)$/
insert_imd_tree	imd.c	/^static struct imd_tree *insert_imd_tree(t, imd)$/
insert_into_gen_tab	check.c	/^static int insert_into_gen_tab(tab, id, v)$/
insert_is_tree	is.c	/^static struct is_tree *insert_is_tree(t, is)$/
insert_sym	io.c	/^struct sym_ent *insert_sym(s, arity)$/
int_list_length	misc.c	/^int int_list_length(p)$/
int_str	io.c	/^void int_str(i, s)$/
int_term	dp_util.c	/^int int_term(t)$/
intcompare	prune.c	/^static int intcompare(i,j)$/
integrate_term	share.c	/^struct term *integrate_term(t)$/
interact	nonport.c	/^void interact()$/
introduce_var	formula.c	/^static void introduce_var(f, t, vnum)$/
introduce_var_term	formula.c	/^static void introduce_var_term(t, v, vnum)$/
ipx	check.c	/^int ipx(ip, n)$/
is_alpha_numeric	io.c	/^static int is_alpha_numeric(c)$/
is_atom	misc.c	/^int is_atom(t)$/
is_delete	is.c	/^void is_delete(t, root_is)$/
is_eq	clause.c	/^int is_eq(sym_num)$/
is_geometry_symbol	geometry.c	/^static int is_geometry_symbol(sn)$/
is_in_ancestry	linkur.c	/^static BOOLEAN is_in_ancestry(curr_node, inf_tree)/
is_insert	is.c	/^void is_insert(t, root_is)$/
is_retrieve	is.c	/^struct term_ptr *is_retrieve(t, subst, is, is_pos)/
is_skolem	io.c	/^int is_skolem(sym_num)$/
is_symbol	io.c	/^int is_symbol(t, str, arity)$/
is_symbol_char	io.c	/^static int is_symbol_char(c, in_list)$/
is_white	io.c	/^static int is_white(c)$/
ith_literal	clause.c	/^struct literal *ith_literal(c, n)$/
keep_clause	linkur.c	/^static BOOLEAN keep_clause(node, target, target_he/
kludgey_e_subsume	dp_util.c	/^int kludgey_e_subsume(c, d)$/
left_most_one_step	demod.c	/^static struct term *left_most_one_step(t, contract/
length	lisp.c	/^int length(Bnode p)$/
lex_check	weight.c	/^int lex_check(t1, t2)$/
lex_compare_sym_nums	weight.c	/^static int lex_compare_sym_nums(n1, n2)$/
lex_order	weight.c	/^int lex_order(t1, t2)$/
lex_order_vars	weight.c	/^int lex_order_vars(t1, t2)$/
linked_hyper_res	linkhyp.c	/^void linked_hyper_res(giv_cl)$/
linked_print_clause	linkur.c	/^static void linked_print_clause(cp)$/
linked_print_link_node	linkur.c	/^static void linked_print_link_node(lnp, lvl)$/
linked_print_link_node_tree	linkur.c	/^static void linked_print_link_node_tree(lnp, lvl)$/
linked_unit_del	linkur.c	/^static struct clause *linked_unit_del(sign, d)$/
linked_ur_res	linkur.c	/^void linked_ur_res(giv_cl)$/
lit_compare	clause.c	/^int lit_compare(l1, l2)$/
lit_t_f_reduce	demod.c	/^int lit_t_f_reduce(c)$/
literal_number	clause.c	/^int literal_number(lit)$/
literals_to_term	clause.c	/^static struct term *literals_to_term(l)$/
log_for_x_show	misc.c	/^void log_for_x_show(fp)$/
lone_variable_process	dp_util.c	/^static void lone_variable_process(c)$/
long_str	io.c	/^void long_str(i, s)$/
long_to_term	foreign.c	/^struct term *long_to_term(i)$/
lrpo	lrpo.c	/^int lrpo(t1, t2)$/
lrpo_greater	lrpo.c	/^int lrpo_greater(t1, t2)$/
lrpo_lex	lrpo.c	/^static int lrpo_lex(t1, t2)$/
lrpo_multiset	lrpo.c	/^static int lrpo_multiset(t1, t2)$/
lrpo_status	lrpo.c	/^static int lrpo_status(sym_num)$/
map_rest	clause.c	/^int map_rest(c, d, s, trp)$/
mark_as_skolem	io.c	/^void mark_as_skolem(sym_num)$/
mark_free_var_formula	formula.c	/^static void mark_free_var_formula(v, f)$/
mark_free_var_term	formula.c	/^static void mark_free_var_term(v, t)$/
mark_literal	clause.c	/^void mark_literal(lit)$/
match	unify.c	/^int match(t1, c1, t2, trp)$/
match2	check.c	/^static BOOLEAN match2(struct clause *c1, struct cl/
match_clauses	check.c	/^struct int_ptr *match_clauses(c1, c2)$/
match_literals	check.c	/^static int match_literals(c1, s1, m1, c2, s2, m2, /
max_literal_weight	clause.c	/^int max_literal_weight(c, wt_index)$/
max_split_depth	case.c	/^int max_split_depth()$/
maximal_lit	resolve.c	/^int maximal_lit(l1)$/
merge_sort	io.c	/^void merge_sort(a, w, start, end, comp_proc)$/
middle_clause	prune.c	/^struct clause *middle_clause(l, size)$/
more_targets_here	linkur.c	/^static BOOLEAN more_targets_here(tp)$/
move_clauses	misc.c	/^void move_clauses(clause_proc, source, destination/
my_process_id	nonport.c	/^int my_process_id()$/
name_sym	io.c	/^int name_sym(s)$/
neg_clause	clause.c	/^int neg_clause(c)$/
neg_eq_lit	clause.c	/^int neg_eq_lit(lit)$/
neg_hyper_res	resolve.c	/^void neg_hyper_res(giv_cl)$/
negate_formula	formula.c	/^struct formula *negate_formula(f)$/
negation_inward	formula.c	/^struct formula *negation_inward(f)$/
new_demod	demod.c	/^struct clause *new_demod(c, demod_flag)$/
new_functor_name	formula.c	/^int new_functor_name(arity)$/
new_literal_index	check.c	/^static int new_literal_index(ip, v)$/
new_str_copy	lisp.c	/^static char *new_str_copy(char *str)$/
new_sym_num	fpa.c	/^int new_sym_num()$/
new_var_name	formula.c	/^int new_var_name()$/
next_cl_num	clause.c	/^int next_cl_num()$/
next_term	fpa.c	/^struct term *next_term(n, max)$/
next_token_type	io.c	/^static int next_token_type(t, n)$/
next_unifiable	linkur.c	/^static struct term *next_unifiable(t, subst_t, sub/
nnf	formula.c	/^struct formula *nnf(f)$/
nnf_cnf	formula.c	/^struct formula *nnf_cnf(f)$/
nnf_dnf	formula.c	/^struct formula *nnf_dnf(f)$/
nnf_skolemize	formula.c	/^struct formula *nnf_skolemize(f)$/
non_portable_init	nonport.c	/^void non_portable_init(argc, argv)$/
noncomplexifying	weight.c	/^int noncomplexifying(c)$/
nullp	lisp.c	/^BOOLEAN nullp(Bnode p)$/
num_answers	clause.c	/^int num_answers(c)$/
num_literals	clause.c	/^int num_literals(c)$/
num_literals_including_answers	clause.c	/^int num_literals_including_answers(c)$/
num_occurrences	lrpo.c	/^static int num_occurrences(t_arg, t)$/
occur_check	unify.c	/^int occur_check(vn, vc, t, c)$/
occurrences	misc.c	/^int occurrences(s, t)$/
occurrences_cl	dp_util.c	/^static int occurrences_cl(t, c)$/
occurs_in	misc.c	/^int occurs_in(t1, t2)$/
one_unary_answer	resolve.c	/^int one_unary_answer(c)$/
order_equalities	weight.c	/^void order_equalities(c)$/
order_equalities_lrpo	lrpo.c	/^void order_equalities_lrpo(c)$/
order_new_lits_for_hyper	check.c	/^static struct int_ptr *order_new_lits_for_hyper(pn/
ordered_sub_clause	clause.c	/^int ordered_sub_clause(c1, c2)$/
output_stats	misc.c	/^void output_stats(fp, level)$/
overbeek_match	weight.c	/^int overbeek_match(t)$/
p_activity	prune.c	/^void p_activity(l)$/
p_assumption_depths	case.c	/^void p_assumption_depths(assumptions)$/
p_btree	lisp.c	/^void p_btree(Bnode p)$/
p_case	case.c	/^void p_case()$/
p_case_n	case.c	/^void p_case_n(n)$/
p_clause	clause.c	/^void p_clause(cl)$/
p_clause_s	check.c	/^void p_clause_s(c)$/
p_clause_s2	check.c	/^void p_clause_s2(c)$/
p_formula	formula.c	/^void p_formula(f)$/
p_fpa_tab	fpa.c	/^void p_fpa_tab(index)$/
p_gen_tab	check.c	/^void p_gen_tab(tab)$/
p_hint_clause	hints.c	/^void p_hint_clause(c)$/
p_hints_cl_list	hints.c	/^void p_hints_cl_list(lst)$/
p_imd_tree	imd.c	/^void p_imd_tree(imd)$/
p_int_list	check.c	/^void p_int_list(ip)$/
p_is_tree	is.c	/^void p_is_tree(is)$/
p_literal_data	case.c	/^void p_literal_data(data)$/
p_options	options.c	/^void p_options()$/
p_path	fpa.c	/^void p_path(path)$/
p_proof_object	check.c	/^void p_proof_object(po)$/
p_proof_object_node	check.c	/^void p_proof_object_node(pn)$/
p_prop_tree	fpa.c	/^void p_prop_tree(n)$/
p_stats	misc.c	/^void p_stats()$/
p_subst	unify.c	/^void p_subst(c)$/
p_syms	io.c	/^void p_syms()$/
p_term	io.c	/^void p_term(t)$/
p_term_s	check.c	/^void p_term_s(t)$/
p_term_tab	share.c	/^void p_term_tab()$/
p_times	misc.c	/^void p_times()$/
para_from	paramod.c	/^void para_from(giv_cl)$/
para_from_alpha	paramod.c	/^static void para_from_alpha(alpha)$/
para_from_up	paramod.c	/^static void para_from_up(t, into_term, into_subst,/
para_into	paramod.c	/^void para_into(giv_cl)$/
para_into_terms	paramod.c	/^static void para_into_terms(into_term, into_lit, f/
para_position	check.c	/^static struct term *para_position(c, ip)$/
paren	lisp.c	/^BOOLEAN paren(char c)$/
parse_initial_proof_object	ivy.c	/^struct proof_object *parse_initial_proof_object(FI/
parse_lisp	lisp.c	/^Bnode parse_lisp(FILE *fp)$/
pass_parms_check	linkur.c	/^static BOOLEAN pass_parms_check(curr_node, nres, n/
pass_target_depth_check	linkur.c	/^static BOOLEAN pass_target_depth_check(curr_node)$/
path_comp	fpa.c	/^static int path_comp(p1, p2)$/
path_copy	fpa.c	/^static int *path_copy(path)$/
path_mark_end	fpa.c	/^static void path_mark_end(path, j)$/
path_size	fpa.c	/^static int path_size(path)$/
po_rule	check.c	/^static char *po_rule(rule)$/
pos_clause	clause.c	/^int pos_clause(c)$/
pos_eq_lit	clause.c	/^int pos_eq_lit(lit)$/
poss_nuc_link	linkur.c	/^static BOOLEAN poss_nuc_link(lnp)$/
possible_given_split	case.c	/^void possible_given_split(c)$/
possible_prune	prune.c	/^void possible_prune()$/
possible_split	case.c	/^void possible_split()$/
post_proc_all	process.c	/^void post_proc_all(lst_pos, input, lst)$/
post_process	process.c	/^static void post_process(c, input, lst)$/
pre_process	process.c	/^void pre_process(c, input, lst)$/
prefix_application	io.c	/^static int prefix_application(seq, n, name, white,/
prepend_cl	clause.c	/^void prepend_cl(l, c)$/
pretty_print_term	io.c	/^void  pretty_print_term(fp, t, indents)$/
prf_weight	clause.c	/^int prf_weight(c)$/
print_attributes	attrib.c	/^void print_attributes(fp, a)$/
print_banner	main.c	/^void print_banner(argc, argv)$/
print_case	case.c	/^void print_case(fp)$/
print_case_n	case.c	/^void print_case_n(fp, n)$/
print_cl_list	clause.c	/^void print_cl_list(fp, lst)$/
print_clause	clause.c	/^void print_clause(fp, cl)$/
print_clause_s	check.c	/^void print_clause_s(fp, c)$/
print_clause_s2	check.c	/^void print_clause_s2(fp, c)$/
print_error	io.c	/^void print_error(fp, buf, pos)$/
print_formula	formula.c	/^void print_formula(fp, f)$/
print_formula_list	formula.c	/^void print_formula_list(fp, p)$/
print_fpa_tab	fpa.c	/^void print_fpa_tab(fp, index)$/
print_hint_clause	hints.c	/^void print_hint_clause(fp, c)$/
print_hints_cl_list	hints.c	/^void print_hints_cl_list(fp, lst)$/
print_imd_tree	imd.c	/^void print_imd_tree(fp, imd, level)$/
print_int_list	check.c	/^void print_int_list(fp, ip)$/
print_is_tree	is.c	/^void print_is_tree(fp, is)$/
print_linked_ur_mem_stats	av.c	/^void print_linked_ur_mem_stats()$/
print_list	io.c	/^void print_list(fp, p)$/
print_mem	av.c	/^void print_mem(fp)$/
print_mem_brief	av.c	/^void print_mem_brief(fp)$/
print_options	options.c	/^void print_options(fp)$/
print_path	fpa.c	/^void print_path(fp, path)$/
print_proof	misc.c	/^void print_proof(fp, c)$/
print_proof_object	check.c	/^void print_proof_object(fp, po)$/
print_proof_object_node	check.c	/^void print_proof_object_node(fp, pn)$/
print_prop_tree	fpa.c	/^void print_prop_tree(fp, n, level)$/
print_sequent_clause	clause.c	/^void print_sequent_clause(fp, c)$/
print_stats	misc.c	/^void print_stats(fp)$/
print_stats_brief	misc.c	/^void print_stats_brief(fp)$/
print_subst	unify.c	/^void print_subst(fp, c)$/
print_syms	io.c	/^void print_syms(fp)$/
print_term	io.c	/^void print_term(fp, t)$/
print_term_length	io.c	/^int print_term_length(t)$/
print_term_nl	io.c	/^void print_term_nl(fp, t)$/
print_term_s	check.c	/^void print_term_s(fp, t)$/
print_term_tab	share.c	/^void print_term_tab(fp)$/
print_times	misc.c	/^void print_times(fp)$/
print_times_brief	misc.c	/^void print_times_brief(fp)$/
print_trail	unify.c	/^void print_trail(fp, t)$/
print_variable	io.c	/^void print_variable(fp, t)$/
proc_gen	process.c	/^int proc_gen(c, input)$/
process_hint_attributes	hints.c	/^void process_hint_attributes(c)$/
process_linked_tags	linkur.c	/^int process_linked_tags(cp)$/
process_negative_equalities	dp_util.c	/^static void process_negative_equalities(c)$/
process_op_command	io.c	/^int process_op_command(t)$/
process_this_resolution	linkur.c	/^static BOOLEAN process_this_resolution(curr_node, /
proof_length	clause.c	/^int proof_length(c)$/
proof_message	misc.c	/^static void proof_message(c)$/
proper_list	misc.c	/^int proper_list(t)$/
propositional_clause	clause.c	/^int propositional_clause(c)$/
prover_forks	case.c	/^int prover_forks(n, ip, assumptions)$/
push_free	formula.c	/^static struct formula *push_free(f)$/
read_a_file	misc.c	/^void read_a_file(in_fp, out_fp)$/
read_all_input	misc.c	/^void read_all_input(argc, argv)$/
read_buf	io.c	/^int read_buf(fp, buf)$/
read_cl_list	clause.c	/^struct list *read_cl_list(fp, ep)$/
read_clause	clause.c	/^struct clause *read_clause(fp, rcp)$/
read_formula	formula.c	/^struct formula *read_formula(fp, rcp)$/
read_formula_list	formula.c	/^struct formula_ptr *read_formula_list(fp, ep)$/
read_list	io.c	/^struct term_ptr *read_list(fp, ep, integrate)$/
read_sequent_clause	clause.c	/^struct clause *read_sequent_clause(fp, rcp)$/
read_term	io.c	/^struct term *read_term(fp, rcp)$/
read_wt_list	weight.c	/^struct term_ptr *read_wt_list(fp, ep)$/
rem_from_list	clause.c	/^void rem_from_list(c)$/
remove_var_syms	clause.c	/^void remove_var_syms(t)$/
rename_free_formula	formula.c	/^static void rename_free_formula(f, old_sn, new_sn)/
rename_syms_formula	formula.c	/^void rename_syms_formula(f, fr)$/
rename_syms_term	formula.c	/^static void rename_syms_term(t, fr)$/
renum_vars_term	clause.c	/^int renum_vars_term(t, varnums)$/
renumber_unique	formula.c	/^struct formula *renumber_unique(f, vnum_p)$/
renumber_vars	clause.c	/^int renumber_vars(c)$/
renumber_vars_subst	check.c	/^void renumber_vars_subst(c, terms)$/
replace_special	demod.c	/^static struct term *replace_special(t, target, rep/
replace_term	dp_util.c	/^static struct term *replace_term(t, ct, vt)$/
report	misc.c	/^void report()$/
reset_clause_counter	clause.c	/^void reset_clause_counter()$/
retrieve_from_gen_tab	check.c	/^static void * retrieve_from_gen_tab(tab, id)$/
retrieve_initial_proof_object	ivy.c	/^struct proof_object *retrieve_initial_proof_object/
reverse	io.c	/^void reverse(s)$/
rms	formula.c	/^struct formula *rms(f)$/
rms_cnf	formula.c	/^struct formula *rms_cnf(f)$/
rms_conflict_tautology	formula.c	/^void rms_conflict_tautology(f)$/
rms_distribute	formula.c	/^static struct formula *rms_distribute(f)$/
rms_distribute_quants	formula.c	/^struct formula *rms_distribute_quants(f_quant)$/
rms_dnf	formula.c	/^struct formula *rms_dnf(f)$/
rms_push_free	formula.c	/^struct formula *rms_push_free(f)$/
rms_quantifiers	formula.c	/^struct formula *rms_quantifiers(f)$/
rms_subsume_conj	formula.c	/^struct formula *rms_subsume_conj(c)$/
rms_subsume_disj	formula.c	/^struct formula *rms_subsume_disj(c)$/
run_time	clocks.c	/^long run_time()$/
same_structure	misc.c	/^int same_structure(t1, t2)$/
separate_free	formula.c	/^static void separate_free(v, f, p_free, p_not_free/
seq_to_quant_term	io.c	/^static struct term *seq_to_quant_term(seq, n)$/
seq_to_term	io.c	/^struct term *seq_to_term(seq, start, end, m)$/
set_attribute	attrib.c	/^void set_attribute(c, name, val_ptr)$/
set_lex_vals	misc.c	/^void set_lex_vals(t)$/
set_lrpo_status	misc.c	/^void set_lrpo_status(t, val)$/
set_multiset_diff	lrpo.c	/^static struct term *set_multiset_diff(t1, t2)$/
set_skolem	misc.c	/^void set_skolem(t)$/
set_special_unary	misc.c	/^void set_special_unary(t)$/
set_up_pointers	share.c	/^void set_up_pointers(t)$/
set_vars	io.c	/^int set_vars(t)$/
set_vars_cl	clause.c	/^int set_vars_cl(cl)$/
set_vars_cl_2	formula.c	/^static int set_vars_cl_2(cl)$/
set_vars_term	io.c	/^int set_vars_term(t, varnames)$/
set_vars_term_2	formula.c	/^static int set_vars_term_2(t, sn)$/
set_wt_list	weight.c	/^void set_wt_list(wt_list, wt_index, ep)$/
set_wt_template	weight.c	/^static int set_wt_template(t)$/
set_wt_term	weight.c	/^static void set_wt_term(t)$/
sig_handler	nonport.c	/^void sig_handler(condition)$/
skip_white	io.c	/^void skip_white(buf, p)$/
skolem	formula.c	/^static struct formula *skolem(f, vars)$/
skolem_symbol	formula.c	/^int skolem_symbol(sn)$/
skolemize	formula.c	/^struct formula *skolemize(f)$/
sn_occur	misc.c	/^int sn_occur(sn, t)$/
sn_to_arity	io.c	/^int sn_to_arity(sym_num)$/
sn_to_ec	io.c	/^int sn_to_ec(sym_num)$/
sn_to_node	io.c	/^struct sym_ent *sn_to_node(sym_num)$/
sn_to_str	io.c	/^char *sn_to_str(sym_num)$/
sort_lits	clause.c	/^int sort_lits(c)$/
sos_has_pos_nonground	misc.c	/^static int sos_has_pos_nonground()$/
special_is_symbol	ivy.c	/^int special_is_symbol(struct term *t, char *str, i/
split_atom	case.c	/^int split_atom()$/
split_clause	case.c	/^int split_clause(giv_cl)$/
splitable_clause	case.c	/^int splitable_clause(c)$/
splitable_literal	case.c	/^int splitable_literal(c, l)$/
splitting	case.c	/^int splitting()$/
str_double	io.c	/^int str_double(s, dp)$/
str_ident	io.c	/^int str_ident(s, t)$/
str_int	io.c	/^int str_int(s, np)$/
str_long	io.c	/^int str_long(s, np)$/
str_to_args	io.c	/^static struct term *str_to_args(buf, p, name)$/
str_to_list	io.c	/^static struct term *str_to_list(buf, p)$/
str_to_sequence	io.c	/^static int str_to_sequence(buf, p, seq, in_list)$/
str_to_sn	io.c	/^int str_to_sn(str, arity)$/
str_to_term	io.c	/^struct term *str_to_term(buf, p, in_list)$/
string_to_term	foreign.c	/^struct term *string_to_term(s)$/
sub_clause	clause.c	/^int sub_clause(c1, c2)$/
subst_free_formula	formula.c	/^void subst_free_formula(var, f, sk)$/
subst_free_term	formula.c	/^static void subst_free_term(var, t, sk)$/
subst_sn_formula	formula.c	/^void subst_sn_formula(old_sn, f, new_sn, type)$/
subst_sn_term	formula.c	/^void subst_sn_term(old_sn, t, new_sn, type)$/
subsumable_unit	linkur.c	/^static struct clause *subsumable_unit(sign, d)$/
subsume	clause.c	/^int subsume(c, d)$/
subsume_conj	formula.c	/^struct formula *subsume_conj(c)$/
subsume_disj	formula.c	/^struct formula *subsume_disj(c)$/
switch_to_hot_index	hot.c	/^void switch_to_hot_index()$/
switch_to_ordinary_index	hot.c	/^void switch_to_ordinary_index()$/
sym_elim	weight.c	/^static int sym_elim(alpha, beta)$/
sym_occur	weight.c	/^static int sym_occur(sym_num, t)$/
sym_precedence	lrpo.c	/^static int sym_precedence(sym_num_1, sym_num_2)$/
sym_tab_member	io.c	/^struct sym_ent *sym_tab_member(str, arity)$/
symmetry_clause	clause.c	/^int symmetry_clause(c)$/
system_time	clocks.c	/^long system_time()$/
tautology	clause.c	/^int tautology(c)$/
term_compare	share.c	/^static int term_compare(t1, t2)$/
term_fixup	io.c	/^struct term *term_fixup(t)$/
term_fixup_2	io.c	/^struct term *term_fixup_2(t)$/
term_fpa_rec	fpa.c	/^void term_fpa_rec(insert, t, super_term, index, pa/
term_ident	unify.c	/^int term_ident(t1, t2)$/
term_ident_subst	linkur.c	/^static int term_ident_subst(t1, c1, t2, c2)$/
term_ident_x_vars	weight.c	/^int term_ident_x_vars(t1, t2)$/
term_to_attributes	attrib.c	/^struct cl_attribute *term_to_attributes(t)$/
term_to_clause	clause.c	/^struct clause *term_to_clause(t)$/
term_to_formula	formula.c	/^struct formula *term_to_formula(t)$/
term_to_literals	clause.c	/^static struct literal *term_to_literals(t, lits)$/
test_terms	share.c	/^void test_terms(fp)$/
total_mem	av.c	/^int total_mem()$/
total_mem_calls	av.c	/^int total_mem_calls()$/
tp_alloc	av.c	/^int **tp_alloc(n)$/
trans_2_pos	check.c	/^struct int_ptr *trans_2_pos(id, pos)$/
trans_logic_symbols	ivy.c	/^void trans_logic_symbols(struct term *t)$/
translate_demod_nonunit	check.c	/^static int translate_demod_nonunit(current, ip, ne/
translate_demod_unit	check.c	/^static int translate_demod_unit(current, ip, new_p/
translate_factor	check.c	/^static int translate_factor(c, new_proof)$/
translate_factor_simp	check.c	/^static int translate_factor_simp(current, new_proo/
translate_hyper	check.c	/^static int translate_hyper(c, new_proof)$/
translate_paramod	check.c	/^static int translate_paramod(c, new_proof)$/
translate_resolution	check.c	/^static int translate_resolution(c, new_proof)$/
translate_step	check.c	/^static int translate_step(c, new_proof)$/
translate_unit_deletion	check.c	/^static int translate_unit_deletion(current, unit, /
translate_ur	check.c	/^static int translate_ur(c, new_proof)$/
trivial_subst	check.c	/^int trivial_subst(c)$/
true_listp	lisp.c	/^BOOLEAN true_listp(Bnode p)$/
ts_and_fs	formula.c	/^void ts_and_fs(f)$/
type_2_trans	check.c	/^void type_2_trans(po)$/
ulong_bits	io.c	/^void ulong_bits(i, s)$/
un_index_lits_all	index.c	/^void un_index_lits_all(c)$/
un_index_lits_clash	index.c	/^void un_index_lits_clash(c)$/
un_index_mark_clash	index.c	/^static void un_index_mark_clash(r)$/
un_index_paramod	index.c	/^static void un_index_paramod(atom)$/
un_share_special	demod.c	/^static void un_share_special(t)$/
unify	unify.c	/^int unify(t1, c1, t2, c2, trp)$/
unify_no_occur_check	unify.c	/^int unify_no_occur_check(t1, c1, t2, c2, trp)$/
unique_all	formula.c	/^void unique_all(f)$/
unit_clause	clause.c	/^int unit_clause(c)$/
unit_conflict	clause.c	/^struct clause_ptr *unit_conflict(c)$/
unit_del	clause.c	/^int unit_del(c)$/
uq_all	formula.c	/^static void uq_all(f, vars)$/
ur_res	resolve.c	/^void ur_res(giv_cl)$/
user_test_bool	foreign.c	/^int user_test_bool(l, d, b, s, t)$/
user_test_double	foreign.c	/^double user_test_double(l, d, b, s, t)$/
user_test_long	foreign.c	/^long user_test_long(l, d, b, s, t)$/
user_test_string	foreign.c	/^char *user_test_string(l, d, b, s, t)$/
user_test_term	foreign.c	/^struct term *user_test_term(l, d, b, s, t)$/
username	nonport.c	/^char *username()$/
var_name	io.c	/^int var_name(s)$/
var_subset	weight.c	/^int var_subset(t1, t2)$/
variant	check.c	/^int variant(t1, c1, t2, c2, trp, flip)$/
varmap	check.c	/^static void varmap(struct term *t, struct term **v/
wall_seconds	clocks.c	/^long wall_seconds()$/
weight	weight.c	/^int weight(t, wt_index)$/
weight_cl	clause.c	/^int weight_cl(c, wt_index)$/
weight_index_delete	weight.c	/^void weight_index_delete(wt_index)$/
weight_insert	weight.c	/^static void weight_insert(t, wt_index)$/
weight_retrieve	weight.c	/^static struct is_tree *weight_retrieve(t, wt_index/
white_char	lisp.c	/^static BOOLEAN white_char(char c)$/
write_down_tree	linkur.c	/^static void write_down_tree(node, my_depth)$/
write_target_distances	linkur.c	/^static void write_target_distances(curr_node)$/
write_term	io.c	/^void write_term(fp, t, n, prev)$/
write_up_tree	linkur.c	/^static void write_up_tree(node, my_depth)$/
wt_lex_order	weight.c	/^static int wt_lex_order(t1, t2)$/
wt_match	weight.c	/^int wt_match(t, template, wtp, wt_index)$/
wt_match_dots	weight.c	/^static int wt_match_dots(t, template, wtp, wt_inde/
xx_resolvable	clause.c	/^int xx_resolvable(c)$/
zap_btree	lisp.c	/^void zap_btree(Bnode p)$/
zap_cl_list	clause.c	/^void zap_cl_list(lst)$/
zap_formula	formula.c	/^void zap_formula(f)$/
zap_int_ptr_list	check.c	/^void zap_int_ptr_list(p)$/
zap_list	misc.c	/^void zap_list(p)$/
zap_prop_tree	fpa.c	/^void zap_prop_tree(n)$/
zap_quant	formula.c	/^struct formula *zap_quant(f)$/
zap_term	share.c	/^void zap_term(t)$/
zap_term_special	demod.c	/^void zap_term_special(t)$/
