[unix-history] / usr / src / usr.bin / diction / style2 / ehash.c

#ifndef lint
static char ehash_sccsid[] = "@(#)ehash.c	4.2	(Berkeley)	82/11/06";
#endif not lint

#
struct hnode {
	char *aakey;
	struct dict *aadata;
};
struct dict {
	char *entry;
	char val;
};
char able();
struct dict able_d[];
char ace();
struct dict ace_d[];
char age();
struct dict age_d[];
char ance();
struct dict ance_d[];
char ant();
struct dict ant_d[];
char cal();
struct dict cal_d[];
char cle();
struct dict cle_d[];
char ee();
struct dict ee_d[];
char ence();
struct dict ence_d[];
char ess();
struct dict ess_d[];
char est();
struct dict est_d[];
char ful();
struct dict ful_d[];
char ible();
struct dict ible_d[];
char ic();
struct dict ic_d[];
char ice();
struct dict ice_d[];
char ion();
struct dict ion_d[];
char ional();
struct dict ional_d[];
char is();
struct dict is_d[];
char ish();
struct dict ish_d[];
char ist();
struct dict ist_d[];
char ite();
struct dict ite_d[];
char ive();
struct dict ive_d[];
char ize();
struct dict ize_d[];
char lar();
struct dict lar_d[];
char less();
struct dict less_d[];
char man();
struct dict man_d[];
char ment();
struct dict ment_d[];
char ness();
struct dict ness_d[];
char ous();
struct dict ous_d[];
char ship();
struct dict ship_d[];
char ss();
struct dict ss_d[];
char ure();
struct dict ure_d[];
char us();
struct dict us_d[];
char ing();
struct dict ing_d[];
char ed();
struct dict ed_d[];
struct fandd {
	char (*fun)();
	struct dict *yd;
} arr[] = {
able,	able_d,
ace,	ace_d,
age,	age_d,
ance,	ance_d,
ant,	ant_d,
cal,	cal_d,
cle,	cle_d,
ee,	ee_d,
ence,	ence_d,
ess,	ess_d,
est,	est_d,
ful,	ful_d,
ible,	ible_d,
ic,	ic_d,
ice,	ice_d,
ion,	ion_d,
ional,	ional_d,
is,	is_d,
ish,	ish_d,
ist,	ist_d,
ite,	ite_d,
ive,	ive_d,
ize,	ize_d,
lar,	lar_d,
less,	less_d,
man,	man_d,
ment,	ment_d,
ness,	ness_d,
ous,	ous_d,
ship,	ship_d,
ss,	ss_d,
ure,	ure_d,
us,	us_d,
ing,	ing_d,
ed,	ed_d,
0,	0
};
egetd(){
	struct dict *pp;
	struct fandd *ptr;
	ptr = arr;
	while(ptr->fun != 0){
		pp = ptr->yd;
		while(pp->entry != 0){
			(*ptr->fun)(pp->entry,0,pp);
			pp++;
		}
		ptr++;
	}
}
char 
aahash(s,ex,aatsize,aapr1,aapr2,tbl,data)
char *s;
struct hnode tbl[];
struct dict *data;
{
	char *cp;
	int i, key, c, p1, p2;
	cp = s;
	key =0;
	while (c = *cp++)
		key = key + (key<<5) + c;
	key &= 077777;
	p1 = key%aapr1;
	p2 = key%aapr2;
	if (p2==0) p2=17;
	for(i=0; i<aatsize; i++)
	{
		if (tbl[p1].aakey==0)
		{ /* new item */
			if (ex ==0)
			{
				tbl[p1].aakey = s;
				tbl[p1].aadata= data;
				return(tbl[p1].aadata->val);
			}
			else
				return(0);
		}
		else
			if(strcmp(tbl[p1].aakey, s)== 0)
			{
				return(tbl[p1].aadata->val);
			}
		p1 = (p1+p2)%aatsize;
	}
	fprintf(stderr, "hash table full\n");
	exit();
}
struct hnode aa1root[43];
#define aa1tsize 43
#define aa1p1 37
#define aa1p2 41
char
able(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa1tsize,aa1p1,aa1p2,aa1root,ptr));
}
struct hnode aa2root[11];
#define aa2tsize 11
#define aa2p1 5
#define aa2p2 7
char
ace(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa2tsize,aa2p1,aa2p2,aa2root,ptr));
}
struct hnode aa3root[61];
#define aa3tsize 61
#define aa3p1 53
#define aa3p2 59
char
age(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa3tsize,aa3p1,aa3p2,aa3root,ptr));
}
struct hnode aa4root[37];
#define aa4tsize 37
#define aa4p1 29
#define aa4p2 31
char
ance(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa4tsize,aa4p1,aa4p2,aa4root,ptr));
}
struct hnode aa5root[31];
#define aa5tsize 31
#define aa5p1 23
#define aa5p2 29
char
ant(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa5tsize,aa5p1,aa5p2,aa5root,ptr));
}
struct hnode aa7root[19];
#define aa7tsize 19
#define aa7p1 13
#define aa7p2 17
char
cal(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa7tsize,aa7p1,aa7p2,aa7root,ptr));
}
struct hnode aa8root[13];
#define aa8tsize 13
#define aa8p1 7
#define aa8p2 11
char
cle(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa8tsize,aa8p1,aa8p2,aa8root,ptr));
}
struct hnode aa10root[31];
#define aa10tsize 31
#define aa10p1 23
#define aa10p2 29
char
ee(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa10tsize,aa10p1,aa10p2,aa10root,ptr));
}
struct hnode aa11root[31];
#define aa11tsize 31
#define aa11p1 23
#define aa11p2 29
char
ence(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa11tsize,aa11p1,aa11p2,aa11root,ptr));
}
struct hnode aa13root[47];
#define aa13tsize 47
#define aa13p1 41
#define aa13p2 43
char
ess(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa13tsize,aa13p1,aa13p2,aa13root,ptr));
}
struct hnode aa14root[67];
#define aa14tsize 67
#define aa14p1 59
#define aa14p2 61
char
est(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa14tsize,aa14p1,aa14p2,aa14root,ptr));
}
struct hnode aa15root[43];
#define aa15tsize 43
#define aa15p1 37
#define aa15p2 41
char
ful(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa15tsize,aa15p1,aa15p2,aa15root,ptr));
}
struct hnode aa18root[19];
#define aa18tsize 19
#define aa18p1 13
#define aa18p2 17
char
ible(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa18tsize,aa18p1,aa18p2,aa18root,ptr));
}
struct hnode aa19root[151];
#define aa19tsize 151
#define aa19p1 139
#define aa19p2 149
char
ic(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa19tsize,aa19p1,aa19p2,aa19root,ptr));
}
struct hnode aa20root[11];
#define aa20tsize 11
#define aa20p1 5
#define aa20p2 7
char
ice(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa20tsize,aa20p1,aa20p2,aa20root,ptr));
}
struct hnode aa21root[89];
#define aa21tsize 89
#define aa21p1 79
#define aa21p2 83
char
ion(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa21tsize,aa21p1,aa21p2,aa21root,ptr));
}
struct hnode aa22root[13];
#define aa22tsize 13
#define aa22p1 7
#define aa22p2 11
char
ional(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa22tsize,aa22p1,aa22p2,aa22root,ptr));
}
struct hnode aa23root[11];
#define aa23tsize 11
#define aa23p1 5
#define aa23p2 7
char
is(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa23tsize,aa23p1,aa23p2,aa23root,ptr));
}
struct hnode aa24root[71];
#define aa24tsize 71
#define aa24p1 61
#define aa24p2 67
char
ish(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa24tsize,aa24p1,aa24p2,aa24root,ptr));
}
struct hnode aa25root[151];
#define aa25tsize 151
#define aa25p1 139
#define aa25p2 149
char
ist(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa25tsize,aa25p1,aa25p2,aa25root,ptr));
}
struct hnode aa26root[79];
#define aa26tsize 79
#define aa26p1 71
#define aa26p2 73
char
ite(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa26tsize,aa26p1,aa26p2,aa26root,ptr));
}
struct hnode aa28root[151];
#define aa28tsize 151
#define aa28p1 139
#define aa28p2 149
char
ive(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa28tsize,aa28p1,aa28p2,aa28root,ptr));
}
struct hnode aa29root[11];
#define aa29tsize 11
#define aa29p1 5
#define aa29p2 7
char
ize(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa29tsize,aa29p1,aa29p2,aa29root,ptr));
}
struct hnode aa30root[37];
#define aa30tsize 37
#define aa30p1 29
#define aa30p2 31
char
lar(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa30tsize,aa30p1,aa30p2,aa30root,ptr));
}
struct hnode aa31root[11];
#define aa31tsize 11
#define aa31p1 5
#define aa31p2 7
char
less(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa31tsize,aa31p1,aa31p2,aa31root,ptr));
}
struct hnode aa33root[11];
#define aa33tsize 11
#define aa33p1 5
#define aa33p2 7
char
man(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa33tsize,aa33p1,aa33p2,aa33root,ptr));
}
struct hnode aa34root[37];
#define aa34tsize 37
#define aa34p1 29
#define aa34p2 31
char
ment(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa34tsize,aa34p1,aa34p2,aa34root,ptr));
}
struct hnode aa35root[11];
#define aa35tsize 11
#define aa35p1 5
#define aa35p2 7
char
ness(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa35tsize,aa35p1,aa35p2,aa35root,ptr));
}
struct hnode aa37root[11];
#define aa37tsize 11
#define aa37p1 5
#define aa37p2 7
char
ous(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa37tsize,aa37p1,aa37p2,aa37root,ptr));
}
struct hnode aa39root[11];
#define aa39tsize 11
#define aa39p1 5
#define aa39p2 7
char
ship(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa39tsize,aa39p1,aa39p2,aa39root,ptr));
}
struct hnode aa40root[61];
#define aa40tsize 61
#define aa40p1 53
#define aa40p2 59
char
ss(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa40tsize,aa40p1,aa40p2,aa40root,ptr));
}
struct hnode aa42root[89];
#define aa42tsize 89
#define aa42p1 79
#define aa42p2 83
char
ure(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa42tsize,aa42p1,aa42p2,aa42root,ptr));
}
struct hnode aa43root[19];
#define aa43tsize 19
#define aa43p1 13
#define aa43p2 17
char
us(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa43tsize,aa43p1,aa43p2,aa43root,ptr));
}
struct hnode aa44root[23];
#define aa44tsize 23
#define aa44p1 17
#define aa44p2 19
char
ing(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa44tsize,aa44p1,aa44p2,aa44root,ptr));
}
struct hnode aa45root[47];
#define aa45tsize 47
#define aa45p1 41
#define aa45p2 43
char
ed(a0,a1,ptr)
	char *a0;
	struct dict *ptr;
{
	return(aahash(a0,a1,aa45tsize,aa45p1,aa45p2,aa45root,ptr));
}
Commit	Line	Data
2958d0fe	1	#ifndef lint
1a1cc2cb	2	static char ehash_sccsid[] = "@(#)ehash.c 4.2 (Berkeley) 82/11/06";
2958d0fe RH	3	#endif not lint
	4
	5	#
	6	struct hnode {
	7	char *aakey;
	8	struct dict *aadata;
	9	};
	10	struct dict {
	11	char *entry;
	12	char val;
	13	};
	14	char able();
	15	struct dict able_d[];
	16	char ace();
	17	struct dict ace_d[];
	18	char age();
	19	struct dict age_d[];
	20	char ance();
	21	struct dict ance_d[];
	22	char ant();
	23	struct dict ant_d[];
	24	char cal();
	25	struct dict cal_d[];
	26	char cle();
	27	struct dict cle_d[];
	28	char ee();
	29	struct dict ee_d[];
	30	char ence();
	31	struct dict ence_d[];
	32	char ess();
	33	struct dict ess_d[];
	34	char est();
	35	struct dict est_d[];
	36	char ful();
	37	struct dict ful_d[];
	38	char ible();
	39	struct dict ible_d[];
	40	char ic();
	41	struct dict ic_d[];
	42	char ice();
	43	struct dict ice_d[];
	44	char ion();
	45	struct dict ion_d[];
	46	char ional();
	47	struct dict ional_d[];
	48	char is();
	49	struct dict is_d[];
	50	char ish();
	51	struct dict ish_d[];
	52	char ist();
	53	struct dict ist_d[];
	54	char ite();
	55	struct dict ite_d[];
	56	char ive();
	57	struct dict ive_d[];
	58	char ize();
	59	struct dict ize_d[];
	60	char lar();
	61	struct dict lar_d[];
	62	char less();
	63	struct dict less_d[];
	64	char man();
	65	struct dict man_d[];
	66	char ment();
67	struct dict ment_d[];
68	char ness();
69	struct dict ness_d[];
70	char ous();
71	struct dict ous_d[];
72	char ship();
73	struct dict ship_d[];
74	char ss();
75	struct dict ss_d[];
76	char ure();
77	struct dict ure_d[];
78	char us();
79	struct dict us_d[];
80	char ing();
81	struct dict ing_d[];
82	char ed();
83	struct dict ed_d[];
84	struct fandd {
85	char (*fun)();
86	struct dict *yd;
87	} arr[] = {
88	able, able_d,
89	ace, ace_d,
90	age, age_d,
91	ance, ance_d,
92	ant, ant_d,
93	cal, cal_d,
94	cle, cle_d,
95	ee, ee_d,
96	ence, ence_d,
97	ess, ess_d,
98	est, est_d,
99	ful, ful_d,
100	ible, ible_d,
101	ic, ic_d,
102	ice, ice_d,
103	ion, ion_d,
104	ional, ional_d,
105	is, is_d,
106	ish, ish_d,
107	ist, ist_d,
108	ite, ite_d,
109	ive, ive_d,
110	ize, ize_d,
111	lar, lar_d,
112	less, less_d,
113	man, man_d,
114	ment, ment_d,
115	ness, ness_d,
116	ous, ous_d,
117	ship, ship_d,
118	ss, ss_d,
119	ure, ure_d,
120	us, us_d,
121	ing, ing_d,
122	ed, ed_d,
123	0, 0
124	};
125	egetd(){
126	struct dict *pp;
127	struct fandd *ptr;
128	ptr = arr;
129	while(ptr->fun != 0){
130	pp = ptr->yd;
131	while(pp->entry != 0){
132	(*ptr->fun)(pp->entry,0,pp);
133	pp++;
134	}
135	ptr++;
136	}
137	}
138	char
139	aahash(s,ex,aatsize,aapr1,aapr2,tbl,data)
140	char *s;
141	struct hnode tbl[];
142	struct dict *data;
143	{
144	char *cp;
145	int i, key, c, p1, p2;
146	cp = s;
147	key =0;
148	while (c = *cp++)
149	key = key + (key<<5) + c;
150	key &= 077777;
151	p1 = key%aapr1;
152	p2 = key%aapr2;
153	if (p2==0) p2=17;
154	for(i=0; i<aatsize; i++)
155	{
156	if (tbl[p1].aakey==0)
157	{ /* new item */
158	if (ex ==0)
159	{
160	tbl[p1].aakey = s;
161	tbl[p1].aadata= data;
162	return(tbl[p1].aadata->val);
163	}
164	else
165	return(0);
166	}
167	else
168	if(strcmp(tbl[p1].aakey, s)== 0)
169	{
170	return(tbl[p1].aadata->val);
171	}
172	p1 = (p1+p2)%aatsize;
173	}
174	fprintf(stderr, "hash table full\n");
175	exit();
176	}
177	struct hnode aa1root[43];
178	#define aa1tsize 43
179	#define aa1p1 37
180	#define aa1p2 41
181	char
182	able(a0,a1,ptr)
183	char *a0;
184	struct dict *ptr;
185	{
186	return(aahash(a0,a1,aa1tsize,aa1p1,aa1p2,aa1root,ptr));
187	}
188	struct hnode aa2root[11];
189	#define aa2tsize 11
190	#define aa2p1 5
191	#define aa2p2 7
192	char
193	ace(a0,a1,ptr)
194	char *a0;
195	struct dict *ptr;
196	{
197	return(aahash(a0,a1,aa2tsize,aa2p1,aa2p2,aa2root,ptr));
198	}
199	struct hnode aa3root[61];
200	#define aa3tsize 61
201	#define aa3p1 53
202	#define aa3p2 59
203	char
204	age(a0,a1,ptr)
205	char *a0;
206	struct dict *ptr;
207	{
208	return(aahash(a0,a1,aa3tsize,aa3p1,aa3p2,aa3root,ptr));
209	}
1a1cc2cb RH	210	struct hnode aa4root[37];
	211	#define aa4tsize 37
	212	#define aa4p1 29
	213	#define aa4p2 31
2958d0fe RH	214	char
	215	ance(a0,a1,ptr)
	216	char *a0;
	217	struct dict *ptr;
	218	{
	219	return(aahash(a0,a1,aa4tsize,aa4p1,aa4p2,aa4root,ptr));
	220	}
	221	struct hnode aa5root[31];
	222	#define aa5tsize 31
	223	#define aa5p1 23
	224	#define aa5p2 29
	225	char
	226	ant(a0,a1,ptr)
	227	char *a0;
	228	struct dict *ptr;
	229	{
	230	return(aahash(a0,a1,aa5tsize,aa5p1,aa5p2,aa5root,ptr));
	231	}
	232	struct hnode aa7root[19];
	233	#define aa7tsize 19
	234	#define aa7p1 13
	235	#define aa7p2 17
	236	char
	237	cal(a0,a1,ptr)
	238	char *a0;
	239	struct dict *ptr;
	240	{
	241	return(aahash(a0,a1,aa7tsize,aa7p1,aa7p2,aa7root,ptr));
	242	}
	243	struct hnode aa8root[13];
	244	#define aa8tsize 13
	245	#define aa8p1 7
	246	#define aa8p2 11
	247	char
	248	cle(a0,a1,ptr)
	249	char *a0;
	250	struct dict *ptr;
	251	{
	252	return(aahash(a0,a1,aa8tsize,aa8p1,aa8p2,aa8root,ptr));
	253	}
	254	struct hnode aa10root[31];
	255	#define aa10tsize 31
	256	#define aa10p1 23
	257	#define aa10p2 29
	258	char
	259	ee(a0,a1,ptr)
	260	char *a0;
	261	struct dict *ptr;
	262	{
	263	return(aahash(a0,a1,aa10tsize,aa10p1,aa10p2,aa10root,ptr));
	264	}
1a1cc2cb RH	265	struct hnode aa11root[31];
	266	#define aa11tsize 31
	267	#define aa11p1 23
	268	#define aa11p2 29
2958d0fe RH	269	char
	270	ence(a0,a1,ptr)
	271	char *a0;
	272	struct dict *ptr;
	273	{
	274	return(aahash(a0,a1,aa11tsize,aa11p1,aa11p2,aa11root,ptr));
	275	}
	276	struct hnode aa13root[47];
	277	#define aa13tsize 47
	278	#define aa13p1 41
	279	#define aa13p2 43
	280	char
	281	ess(a0,a1,ptr)
	282	char *a0;
	283	struct dict *ptr;
	284	{
	285	return(aahash(a0,a1,aa13tsize,aa13p1,aa13p2,aa13root,ptr));
	286	}
	287	struct hnode aa14root[67];
	288	#define aa14tsize 67
	289	#define aa14p1 59
	290	#define aa14p2 61
	291	char
	292	est(a0,a1,ptr)
	293	char *a0;
	294	struct dict *ptr;
	295	{
	296	return(aahash(a0,a1,aa14tsize,aa14p1,aa14p2,aa14root,ptr));
	297	}
	298	struct hnode aa15root[43];
	299	#define aa15tsize 43
	300	#define aa15p1 37
	301	#define aa15p2 41
	302	char
	303	ful(a0,a1,ptr)
	304	char *a0;
	305	struct dict *ptr;
	306	{
	307	return(aahash(a0,a1,aa15tsize,aa15p1,aa15p2,aa15root,ptr));
	308	}
	309	struct hnode aa18root[19];
	310	#define aa18tsize 19
	311	#define aa18p1 13
	312	#define aa18p2 17
	313	char
	314	ible(a0,a1,ptr)
	315	char *a0;
	316	struct dict *ptr;
	317	{
	318	return(aahash(a0,a1,aa18tsize,aa18p1,aa18p2,aa18root,ptr));
	319	}
	320	struct hnode aa19root[151];
	321	#define aa19tsize 151
	322	#define aa19p1 139
	323	#define aa19p2 149
	324	char
	325	ic(a0,a1,ptr)
	326	char *a0;
	327	struct dict *ptr;
	328	{
	329	return(aahash(a0,a1,aa19tsize,aa19p1,aa19p2,aa19root,ptr));
	330	}
	331	struct hnode aa20root[11];
	332	#define aa20tsize 11
333	#define aa20p1 5
334	#define aa20p2 7
335	char
336	ice(a0,a1,ptr)
337	char *a0;
338	struct dict *ptr;
339	{
340	return(aahash(a0,a1,aa20tsize,aa20p1,aa20p2,aa20root,ptr));
341	}
1a1cc2cb RH	342	struct hnode aa21root[89];
	343	#define aa21tsize 89
	344	#define aa21p1 79
	345	#define aa21p2 83
2958d0fe RH	346	char
	347	ion(a0,a1,ptr)
	348	char *a0;
	349	struct dict *ptr;
	350	{
	351	return(aahash(a0,a1,aa21tsize,aa21p1,aa21p2,aa21root,ptr));
	352	}
	353	struct hnode aa22root[13];
	354	#define aa22tsize 13
	355	#define aa22p1 7
	356	#define aa22p2 11
	357	char
	358	ional(a0,a1,ptr)
	359	char *a0;
	360	struct dict *ptr;
	361	{
	362	return(aahash(a0,a1,aa22tsize,aa22p1,aa22p2,aa22root,ptr));
	363	}
	364	struct hnode aa23root[11];
	365	#define aa23tsize 11
	366	#define aa23p1 5
	367	#define aa23p2 7
	368	char
	369	is(a0,a1,ptr)
	370	char *a0;
	371	struct dict *ptr;
	372	{
	373	return(aahash(a0,a1,aa23tsize,aa23p1,aa23p2,aa23root,ptr));
	374	}
	375	struct hnode aa24root[71];
	376	#define aa24tsize 71
	377	#define aa24p1 61
	378	#define aa24p2 67
	379	char
	380	ish(a0,a1,ptr)
	381	char *a0;
	382	struct dict *ptr;
	383	{
	384	return(aahash(a0,a1,aa24tsize,aa24p1,aa24p2,aa24root,ptr));
	385	}
	386	struct hnode aa25root[151];
	387	#define aa25tsize 151
	388	#define aa25p1 139
	389	#define aa25p2 149
	390	char
	391	ist(a0,a1,ptr)
	392	char *a0;
	393	struct dict *ptr;
	394	{
	395	return(aahash(a0,a1,aa25tsize,aa25p1,aa25p2,aa25root,ptr));
	396	}
	397	struct hnode aa26root[79];
	398	#define aa26tsize 79
	399	#define aa26p1 71
	400	#define aa26p2 73
	401	char
	402	ite(a0,a1,ptr)
	403	char *a0;
	404	struct dict *ptr;
	405	{
	406	return(aahash(a0,a1,aa26tsize,aa26p1,aa26p2,aa26root,ptr));
	407	}
	408	struct hnode aa28root[151];
	409	#define aa28tsize 151
410	#define aa28p1 139
411	#define aa28p2 149
412	char
413	ive(a0,a1,ptr)
414	char *a0;
415	struct dict *ptr;
416	{
417	return(aahash(a0,a1,aa28tsize,aa28p1,aa28p2,aa28root,ptr));
418	}
419	struct hnode aa29root[11];
420	#define aa29tsize 11
421	#define aa29p1 5
422	#define aa29p2 7
423	char
424	ize(a0,a1,ptr)
425	char *a0;
426	struct dict *ptr;
427	{
428	return(aahash(a0,a1,aa29tsize,aa29p1,aa29p2,aa29root,ptr));
429	}
430	struct hnode aa30root[37];
431	#define aa30tsize 37
432	#define aa30p1 29
433	#define aa30p2 31
434	char
435	lar(a0,a1,ptr)
436	char *a0;
437	struct dict *ptr;
438	{
439	return(aahash(a0,a1,aa30tsize,aa30p1,aa30p2,aa30root,ptr));
440	}
441	struct hnode aa31root[11];
442	#define aa31tsize 11
443	#define aa31p1 5
444	#define aa31p2 7
445	char
446	less(a0,a1,ptr)
447	char *a0;
448	struct dict *ptr;
449	{
450	return(aahash(a0,a1,aa31tsize,aa31p1,aa31p2,aa31root,ptr));
451	}
452	struct hnode aa33root[11];
453	#define aa33tsize 11
454	#define aa33p1 5
455	#define aa33p2 7
456	char
457	man(a0,a1,ptr)
458	char *a0;
459	struct dict *ptr;
460	{
461	return(aahash(a0,a1,aa33tsize,aa33p1,aa33p2,aa33root,ptr));
462	}
1a1cc2cb RH	463	struct hnode aa34root[37];
	464	#define aa34tsize 37
	465	#define aa34p1 29
	466	#define aa34p2 31
2958d0fe RH	467	char
	468	ment(a0,a1,ptr)
	469	char *a0;
	470	struct dict *ptr;
	471	{
	472	return(aahash(a0,a1,aa34tsize,aa34p1,aa34p2,aa34root,ptr));
	473	}
	474	struct hnode aa35root[11];
	475	#define aa35tsize 11
	476	#define aa35p1 5
	477	#define aa35p2 7
	478	char
	479	ness(a0,a1,ptr)
	480	char *a0;
	481	struct dict *ptr;
	482	{
	483	return(aahash(a0,a1,aa35tsize,aa35p1,aa35p2,aa35root,ptr));
	484	}
	485	struct hnode aa37root[11];
	486	#define aa37tsize 11
	487	#define aa37p1 5
	488	#define aa37p2 7
	489	char
	490	ous(a0,a1,ptr)
	491	char *a0;
	492	struct dict *ptr;
	493	{
	494	return(aahash(a0,a1,aa37tsize,aa37p1,aa37p2,aa37root,ptr));
	495	}
	496	struct hnode aa39root[11];
	497	#define aa39tsize 11
	498	#define aa39p1 5
	499	#define aa39p2 7
	500	char
	501	ship(a0,a1,ptr)
	502	char *a0;
	503	struct dict *ptr;
	504	{
	505	return(aahash(a0,a1,aa39tsize,aa39p1,aa39p2,aa39root,ptr));
	506	}
	507	struct hnode aa40root[61];
	508	#define aa40tsize 61
	509	#define aa40p1 53
	510	#define aa40p2 59
	511	char
	512	ss(a0,a1,ptr)
	513	char *a0;
	514	struct dict *ptr;
	515	{
	516	return(aahash(a0,a1,aa40tsize,aa40p1,aa40p2,aa40root,ptr));
	517	}
	518	struct hnode aa42root[89];
	519	#define aa42tsize 89
	520	#define aa42p1 79
	521	#define aa42p2 83
	522	char
	523	ure(a0,a1,ptr)
	524	char *a0;
	525	struct dict *ptr;
	526	{
	527	return(aahash(a0,a1,aa42tsize,aa42p1,aa42p2,aa42root,ptr));
	528	}
	529	struct hnode aa43root[19];
	530	#define aa43tsize 19
531	#define aa43p1 13
532	#define aa43p2 17
533	char
534	us(a0,a1,ptr)
535	char *a0;
536	struct dict *ptr;
537	{
538	return(aahash(a0,a1,aa43tsize,aa43p1,aa43p2,aa43root,ptr));
539	}
540	struct hnode aa44root[23];
541	#define aa44tsize 23
542	#define aa44p1 17
543	#define aa44p2 19
544	char
545	ing(a0,a1,ptr)
546	char *a0;
547	struct dict *ptr;
548	{
549	return(aahash(a0,a1,aa44tsize,aa44p1,aa44p2,aa44root,ptr));
550	}
1a1cc2cb RH	551	struct hnode aa45root[47];
	552	#define aa45tsize 47
	553	#define aa45p1 41
	554	#define aa45p2 43
2958d0fe RH	555	char
	556	ed(a0,a1,ptr)
	557	char *a0;
	558	struct dict *ptr;
	559	{
	560	return(aahash(a0,a1,aa45tsize,aa45p1,aa45p2,aa45root,ptr));
	561	}