← Back to branch summary

~ubuntu-branches/ubuntu/precise/postgresql-9.1/precise-security

« back to all changes in this revision

Viewing changes to src/backend/snowball/libstemmer/stem_UTF_8_turkish.c

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2011-05-11 10:41:53 UTC
  • Revision ID: james.westby@ubuntu.com-20110511104153-psbh2o58553fv1m0
Tags: upstream-9.1~beta1
Import upstream version 9.1~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/backend/snowball/libstemmer/stem_UTF_8_turkish.c
 
1
 
 
2
/* This file was generated automatically by the Snowball to ANSI C compiler */
 
3
 
 
4
#include "header.h"
 
5
 
 
6
#ifdef __cplusplus
 
7
extern "C" {
 
8
#endif
 
9
extern int turkish_UTF_8_stem(struct SN_env * z);
 
10
#ifdef __cplusplus
 
11
}
 
12
#endif
 
13
static int r_stem_suffix_chain_before_ki(struct SN_env * z);
 
14
static int r_stem_noun_suffixes(struct SN_env * z);
 
15
static int r_stem_nominal_verb_suffixes(struct SN_env * z);
 
16
static int r_postlude(struct SN_env * z);
 
17
static int r_post_process_last_consonants(struct SN_env * z);
 
18
static int r_more_than_one_syllable_word(struct SN_env * z);
 
19
static int r_mark_suffix_with_optional_s_consonant(struct SN_env * z);
 
20
static int r_mark_suffix_with_optional_n_consonant(struct SN_env * z);
 
21
static int r_mark_suffix_with_optional_U_vowel(struct SN_env * z);
 
22
static int r_mark_suffix_with_optional_y_consonant(struct SN_env * z);
 
23
static int r_mark_ysA(struct SN_env * z);
 
24
static int r_mark_ymUs_(struct SN_env * z);
 
25
static int r_mark_yken(struct SN_env * z);
 
26
static int r_mark_yDU(struct SN_env * z);
 
27
static int r_mark_yUz(struct SN_env * z);
 
28
static int r_mark_yUm(struct SN_env * z);
 
29
static int r_mark_yU(struct SN_env * z);
 
30
static int r_mark_ylA(struct SN_env * z);
 
31
static int r_mark_yA(struct SN_env * z);
 
32
static int r_mark_possessives(struct SN_env * z);
 
33
static int r_mark_sUnUz(struct SN_env * z);
 
34
static int r_mark_sUn(struct SN_env * z);
 
35
static int r_mark_sU(struct SN_env * z);
 
36
static int r_mark_nUz(struct SN_env * z);
 
37
static int r_mark_nUn(struct SN_env * z);
 
38
static int r_mark_nU(struct SN_env * z);
 
39
static int r_mark_ndAn(struct SN_env * z);
 
40
static int r_mark_ndA(struct SN_env * z);
 
41
static int r_mark_ncA(struct SN_env * z);
 
42
static int r_mark_nA(struct SN_env * z);
 
43
static int r_mark_lArI(struct SN_env * z);
 
44
static int r_mark_lAr(struct SN_env * z);
 
45
static int r_mark_ki(struct SN_env * z);
 
46
static int r_mark_DUr(struct SN_env * z);
 
47
static int r_mark_DAn(struct SN_env * z);
 
48
static int r_mark_DA(struct SN_env * z);
 
49
static int r_mark_cAsInA(struct SN_env * z);
 
50
static int r_is_reserved_word(struct SN_env * z);
 
51
static int r_check_vowel_harmony(struct SN_env * z);
 
52
static int r_append_U_to_stems_ending_with_d_or_g(struct SN_env * z);
 
53
#ifdef __cplusplus
 
54
extern "C" {
 
55
#endif
 
56
 
 
57
 
 
58
extern struct SN_env * turkish_UTF_8_create_env(void);
 
59
extern void turkish_UTF_8_close_env(struct SN_env * z);
 
60
 
 
61
 
 
62
#ifdef __cplusplus
 
63
}
 
64
#endif
 
65
static const symbol s_0_0[1] = { 'm' };
 
66
static const symbol s_0_1[1] = { 'n' };
 
67
static const symbol s_0_2[3] = { 'm', 'i', 'z' };
 
68
static const symbol s_0_3[3] = { 'n', 'i', 'z' };
 
69
static const symbol s_0_4[3] = { 'm', 'u', 'z' };
 
70
static const symbol s_0_5[3] = { 'n', 'u', 'z' };
 
71
static const symbol s_0_6[4] = { 'm', 0xC4, 0xB1, 'z' };
 
72
static const symbol s_0_7[4] = { 'n', 0xC4, 0xB1, 'z' };
 
73
static const symbol s_0_8[4] = { 'm', 0xC3, 0xBC, 'z' };
 
74
static const symbol s_0_9[4] = { 'n', 0xC3, 0xBC, 'z' };
 
75
 
 
76
static const struct among a_0[10] =
 
77
{
 
78
/*  0 */ { 1, s_0_0, -1, -1, 0},
 
79
/*  1 */ { 1, s_0_1, -1, -1, 0},
 
80
/*  2 */ { 3, s_0_2, -1, -1, 0},
 
81
/*  3 */ { 3, s_0_3, -1, -1, 0},
 
82
/*  4 */ { 3, s_0_4, -1, -1, 0},
 
83
/*  5 */ { 3, s_0_5, -1, -1, 0},
 
84
/*  6 */ { 4, s_0_6, -1, -1, 0},
 
85
/*  7 */ { 4, s_0_7, -1, -1, 0},
 
86
/*  8 */ { 4, s_0_8, -1, -1, 0},
 
87
/*  9 */ { 4, s_0_9, -1, -1, 0}
 
88
};
 
89
 
 
90
static const symbol s_1_0[4] = { 'l', 'e', 'r', 'i' };
 
91
static const symbol s_1_1[5] = { 'l', 'a', 'r', 0xC4, 0xB1 };
 
92
 
 
93
static const struct among a_1[2] =
 
94
{
 
95
/*  0 */ { 4, s_1_0, -1, -1, 0},
 
96
/*  1 */ { 5, s_1_1, -1, -1, 0}
 
97
};
 
98
 
 
99
static const symbol s_2_0[2] = { 'n', 'i' };
 
100
static const symbol s_2_1[2] = { 'n', 'u' };
 
101
static const symbol s_2_2[3] = { 'n', 0xC4, 0xB1 };
 
102
static const symbol s_2_3[3] = { 'n', 0xC3, 0xBC };
 
103
 
 
104
static const struct among a_2[4] =
 
105
{
 
106
/*  0 */ { 2, s_2_0, -1, -1, 0},
 
107
/*  1 */ { 2, s_2_1, -1, -1, 0},
 
108
/*  2 */ { 3, s_2_2, -1, -1, 0},
 
109
/*  3 */ { 3, s_2_3, -1, -1, 0}
 
110
};
 
111
 
 
112
static const symbol s_3_0[2] = { 'i', 'n' };
 
113
static const symbol s_3_1[2] = { 'u', 'n' };
 
114
static const symbol s_3_2[3] = { 0xC4, 0xB1, 'n' };
 
115
static const symbol s_3_3[3] = { 0xC3, 0xBC, 'n' };
 
116
 
 
117
static const struct among a_3[4] =
 
118
{
 
119
/*  0 */ { 2, s_3_0, -1, -1, 0},
 
120
/*  1 */ { 2, s_3_1, -1, -1, 0},
 
121
/*  2 */ { 3, s_3_2, -1, -1, 0},
 
122
/*  3 */ { 3, s_3_3, -1, -1, 0}
 
123
};
 
124
 
 
125
static const symbol s_4_0[1] = { 'a' };
 
126
static const symbol s_4_1[1] = { 'e' };
 
127
 
 
128
static const struct among a_4[2] =
 
129
{
 
130
/*  0 */ { 1, s_4_0, -1, -1, 0},
 
131
/*  1 */ { 1, s_4_1, -1, -1, 0}
 
132
};
 
133
 
 
134
static const symbol s_5_0[2] = { 'n', 'a' };
 
135
static const symbol s_5_1[2] = { 'n', 'e' };
 
136
 
 
137
static const struct among a_5[2] =
 
138
{
 
139
/*  0 */ { 2, s_5_0, -1, -1, 0},
 
140
/*  1 */ { 2, s_5_1, -1, -1, 0}
 
141
};
 
142
 
 
143
static const symbol s_6_0[2] = { 'd', 'a' };
 
144
static const symbol s_6_1[2] = { 't', 'a' };
 
145
static const symbol s_6_2[2] = { 'd', 'e' };
 
146
static const symbol s_6_3[2] = { 't', 'e' };
 
147
 
 
148
static const struct among a_6[4] =
 
149
{
 
150
/*  0 */ { 2, s_6_0, -1, -1, 0},
 
151
/*  1 */ { 2, s_6_1, -1, -1, 0},
 
152
/*  2 */ { 2, s_6_2, -1, -1, 0},
 
153
/*  3 */ { 2, s_6_3, -1, -1, 0}
 
154
};
 
155
 
 
156
static const symbol s_7_0[3] = { 'n', 'd', 'a' };
 
157
static const symbol s_7_1[3] = { 'n', 'd', 'e' };
 
158
 
 
159
static const struct among a_7[2] =
 
160
{
 
161
/*  0 */ { 3, s_7_0, -1, -1, 0},
 
162
/*  1 */ { 3, s_7_1, -1, -1, 0}
 
163
};
 
164
 
 
165
static const symbol s_8_0[3] = { 'd', 'a', 'n' };
 
166
static const symbol s_8_1[3] = { 't', 'a', 'n' };
 
167
static const symbol s_8_2[3] = { 'd', 'e', 'n' };
 
168
static const symbol s_8_3[3] = { 't', 'e', 'n' };
 
169
 
 
170
static const struct among a_8[4] =
 
171
{
 
172
/*  0 */ { 3, s_8_0, -1, -1, 0},
 
173
/*  1 */ { 3, s_8_1, -1, -1, 0},
 
174
/*  2 */ { 3, s_8_2, -1, -1, 0},
 
175
/*  3 */ { 3, s_8_3, -1, -1, 0}
 
176
};
 
177
 
 
178
static const symbol s_9_0[4] = { 'n', 'd', 'a', 'n' };
 
179
static const symbol s_9_1[4] = { 'n', 'd', 'e', 'n' };
 
180
 
 
181
static const struct among a_9[2] =
 
182
{
 
183
/*  0 */ { 4, s_9_0, -1, -1, 0},
 
184
/*  1 */ { 4, s_9_1, -1, -1, 0}
 
185
};
 
186
 
 
187
static const symbol s_10_0[2] = { 'l', 'a' };
 
188
static const symbol s_10_1[2] = { 'l', 'e' };
 
189
 
 
190
static const struct among a_10[2] =
 
191
{
 
192
/*  0 */ { 2, s_10_0, -1, -1, 0},
 
193
/*  1 */ { 2, s_10_1, -1, -1, 0}
 
194
};
 
195
 
 
196
static const symbol s_11_0[2] = { 'c', 'a' };
 
197
static const symbol s_11_1[2] = { 'c', 'e' };
 
198
 
 
199
static const struct among a_11[2] =
 
200
{
 
201
/*  0 */ { 2, s_11_0, -1, -1, 0},
 
202
/*  1 */ { 2, s_11_1, -1, -1, 0}
 
203
};
 
204
 
 
205
static const symbol s_12_0[2] = { 'i', 'm' };
 
206
static const symbol s_12_1[2] = { 'u', 'm' };
 
207
static const symbol s_12_2[3] = { 0xC4, 0xB1, 'm' };
 
208
static const symbol s_12_3[3] = { 0xC3, 0xBC, 'm' };
 
209
 
 
210
static const struct among a_12[4] =
 
211
{
 
212
/*  0 */ { 2, s_12_0, -1, -1, 0},
 
213
/*  1 */ { 2, s_12_1, -1, -1, 0},
 
214
/*  2 */ { 3, s_12_2, -1, -1, 0},
 
215
/*  3 */ { 3, s_12_3, -1, -1, 0}
 
216
};
 
217
 
 
218
static const symbol s_13_0[3] = { 's', 'i', 'n' };
 
219
static const symbol s_13_1[3] = { 's', 'u', 'n' };
 
220
static const symbol s_13_2[4] = { 's', 0xC4, 0xB1, 'n' };
 
221
static const symbol s_13_3[4] = { 's', 0xC3, 0xBC, 'n' };
 
222
 
 
223
static const struct among a_13[4] =
 
224
{
 
225
/*  0 */ { 3, s_13_0, -1, -1, 0},
 
226
/*  1 */ { 3, s_13_1, -1, -1, 0},
 
227
/*  2 */ { 4, s_13_2, -1, -1, 0},
 
228
/*  3 */ { 4, s_13_3, -1, -1, 0}
 
229
};
 
230
 
 
231
static const symbol s_14_0[2] = { 'i', 'z' };
 
232
static const symbol s_14_1[2] = { 'u', 'z' };
 
233
static const symbol s_14_2[3] = { 0xC4, 0xB1, 'z' };
 
234
static const symbol s_14_3[3] = { 0xC3, 0xBC, 'z' };
 
235
 
 
236
static const struct among a_14[4] =
 
237
{
 
238
/*  0 */ { 2, s_14_0, -1, -1, 0},
 
239
/*  1 */ { 2, s_14_1, -1, -1, 0},
 
240
/*  2 */ { 3, s_14_2, -1, -1, 0},
 
241
/*  3 */ { 3, s_14_3, -1, -1, 0}
 
242
};
 
243
 
 
244
static const symbol s_15_0[5] = { 's', 'i', 'n', 'i', 'z' };
 
245
static const symbol s_15_1[5] = { 's', 'u', 'n', 'u', 'z' };
 
246
static const symbol s_15_2[7] = { 's', 0xC4, 0xB1, 'n', 0xC4, 0xB1, 'z' };
 
247
static const symbol s_15_3[7] = { 's', 0xC3, 0xBC, 'n', 0xC3, 0xBC, 'z' };
 
248
 
 
249
static const struct among a_15[4] =
 
250
{
 
251
/*  0 */ { 5, s_15_0, -1, -1, 0},
 
252
/*  1 */ { 5, s_15_1, -1, -1, 0},
 
253
/*  2 */ { 7, s_15_2, -1, -1, 0},
 
254
/*  3 */ { 7, s_15_3, -1, -1, 0}
 
255
};
 
256
 
 
257
static const symbol s_16_0[3] = { 'l', 'a', 'r' };
 
258
static const symbol s_16_1[3] = { 'l', 'e', 'r' };
 
259
 
 
260
static const struct among a_16[2] =
 
261
{
 
262
/*  0 */ { 3, s_16_0, -1, -1, 0},
 
263
/*  1 */ { 3, s_16_1, -1, -1, 0}
 
264
};
 
265
 
 
266
static const symbol s_17_0[3] = { 'n', 'i', 'z' };
 
267
static const symbol s_17_1[3] = { 'n', 'u', 'z' };
 
268
static const symbol s_17_2[4] = { 'n', 0xC4, 0xB1, 'z' };
 
269
static const symbol s_17_3[4] = { 'n', 0xC3, 0xBC, 'z' };
 
270
 
 
271
static const struct among a_17[4] =
 
272
{
 
273
/*  0 */ { 3, s_17_0, -1, -1, 0},
 
274
/*  1 */ { 3, s_17_1, -1, -1, 0},
 
275
/*  2 */ { 4, s_17_2, -1, -1, 0},
 
276
/*  3 */ { 4, s_17_3, -1, -1, 0}
 
277
};
 
278
 
 
279
static const symbol s_18_0[3] = { 'd', 'i', 'r' };
 
280
static const symbol s_18_1[3] = { 't', 'i', 'r' };
 
281
static const symbol s_18_2[3] = { 'd', 'u', 'r' };
 
282
static const symbol s_18_3[3] = { 't', 'u', 'r' };
 
283
static const symbol s_18_4[4] = { 'd', 0xC4, 0xB1, 'r' };
 
284
static const symbol s_18_5[4] = { 't', 0xC4, 0xB1, 'r' };
 
285
static const symbol s_18_6[4] = { 'd', 0xC3, 0xBC, 'r' };
 
286
static const symbol s_18_7[4] = { 't', 0xC3, 0xBC, 'r' };
 
287
 
 
288
static const struct among a_18[8] =
 
289
{
 
290
/*  0 */ { 3, s_18_0, -1, -1, 0},
 
291
/*  1 */ { 3, s_18_1, -1, -1, 0},
 
292
/*  2 */ { 3, s_18_2, -1, -1, 0},
 
293
/*  3 */ { 3, s_18_3, -1, -1, 0},
 
294
/*  4 */ { 4, s_18_4, -1, -1, 0},
 
295
/*  5 */ { 4, s_18_5, -1, -1, 0},
 
296
/*  6 */ { 4, s_18_6, -1, -1, 0},
 
297
/*  7 */ { 4, s_18_7, -1, -1, 0}
 
298
};
 
299
 
 
300
static const symbol s_19_0[7] = { 'c', 'a', 's', 0xC4, 0xB1, 'n', 'a' };
 
301
static const symbol s_19_1[6] = { 'c', 'e', 's', 'i', 'n', 'e' };
 
302
 
 
303
static const struct among a_19[2] =
 
304
{
 
305
/*  0 */ { 7, s_19_0, -1, -1, 0},
 
306
/*  1 */ { 6, s_19_1, -1, -1, 0}
 
307
};
 
308
 
 
309
static const symbol s_20_0[2] = { 'd', 'i' };
 
310
static const symbol s_20_1[2] = { 't', 'i' };
 
311
static const symbol s_20_2[3] = { 'd', 'i', 'k' };
 
312
static const symbol s_20_3[3] = { 't', 'i', 'k' };
 
313
static const symbol s_20_4[3] = { 'd', 'u', 'k' };
 
314
static const symbol s_20_5[3] = { 't', 'u', 'k' };
 
315
static const symbol s_20_6[4] = { 'd', 0xC4, 0xB1, 'k' };
 
316
static const symbol s_20_7[4] = { 't', 0xC4, 0xB1, 'k' };
 
317
static const symbol s_20_8[4] = { 'd', 0xC3, 0xBC, 'k' };
 
318
static const symbol s_20_9[4] = { 't', 0xC3, 0xBC, 'k' };
 
319
static const symbol s_20_10[3] = { 'd', 'i', 'm' };
 
320
static const symbol s_20_11[3] = { 't', 'i', 'm' };
 
321
static const symbol s_20_12[3] = { 'd', 'u', 'm' };
 
322
static const symbol s_20_13[3] = { 't', 'u', 'm' };
 
323
static const symbol s_20_14[4] = { 'd', 0xC4, 0xB1, 'm' };
 
324
static const symbol s_20_15[4] = { 't', 0xC4, 0xB1, 'm' };
 
325
static const symbol s_20_16[4] = { 'd', 0xC3, 0xBC, 'm' };
 
326
static const symbol s_20_17[4] = { 't', 0xC3, 0xBC, 'm' };
 
327
static const symbol s_20_18[3] = { 'd', 'i', 'n' };
 
328
static const symbol s_20_19[3] = { 't', 'i', 'n' };
 
329
static const symbol s_20_20[3] = { 'd', 'u', 'n' };
 
330
static const symbol s_20_21[3] = { 't', 'u', 'n' };
 
331
static const symbol s_20_22[4] = { 'd', 0xC4, 0xB1, 'n' };
 
332
static const symbol s_20_23[4] = { 't', 0xC4, 0xB1, 'n' };
 
333
static const symbol s_20_24[4] = { 'd', 0xC3, 0xBC, 'n' };
 
334
static const symbol s_20_25[4] = { 't', 0xC3, 0xBC, 'n' };
 
335
static const symbol s_20_26[2] = { 'd', 'u' };
 
336
static const symbol s_20_27[2] = { 't', 'u' };
 
337
static const symbol s_20_28[3] = { 'd', 0xC4, 0xB1 };
 
338
static const symbol s_20_29[3] = { 't', 0xC4, 0xB1 };
 
339
static const symbol s_20_30[3] = { 'd', 0xC3, 0xBC };
 
340
static const symbol s_20_31[3] = { 't', 0xC3, 0xBC };
 
341
 
 
342
static const struct among a_20[32] =
 
343
{
 
344
/*  0 */ { 2, s_20_0, -1, -1, 0},
 
345
/*  1 */ { 2, s_20_1, -1, -1, 0},
 
346
/*  2 */ { 3, s_20_2, -1, -1, 0},
 
347
/*  3 */ { 3, s_20_3, -1, -1, 0},
 
348
/*  4 */ { 3, s_20_4, -1, -1, 0},
 
349
/*  5 */ { 3, s_20_5, -1, -1, 0},
 
350
/*  6 */ { 4, s_20_6, -1, -1, 0},
 
351
/*  7 */ { 4, s_20_7, -1, -1, 0},
 
352
/*  8 */ { 4, s_20_8, -1, -1, 0},
 
353
/*  9 */ { 4, s_20_9, -1, -1, 0},
 
354
/* 10 */ { 3, s_20_10, -1, -1, 0},
 
355
/* 11 */ { 3, s_20_11, -1, -1, 0},
 
356
/* 12 */ { 3, s_20_12, -1, -1, 0},
 
357
/* 13 */ { 3, s_20_13, -1, -1, 0},
 
358
/* 14 */ { 4, s_20_14, -1, -1, 0},
 
359
/* 15 */ { 4, s_20_15, -1, -1, 0},
 
360
/* 16 */ { 4, s_20_16, -1, -1, 0},
 
361
/* 17 */ { 4, s_20_17, -1, -1, 0},
 
362
/* 18 */ { 3, s_20_18, -1, -1, 0},
 
363
/* 19 */ { 3, s_20_19, -1, -1, 0},
 
364
/* 20 */ { 3, s_20_20, -1, -1, 0},
 
365
/* 21 */ { 3, s_20_21, -1, -1, 0},
 
366
/* 22 */ { 4, s_20_22, -1, -1, 0},
 
367
/* 23 */ { 4, s_20_23, -1, -1, 0},
 
368
/* 24 */ { 4, s_20_24, -1, -1, 0},
 
369
/* 25 */ { 4, s_20_25, -1, -1, 0},
 
370
/* 26 */ { 2, s_20_26, -1, -1, 0},
 
371
/* 27 */ { 2, s_20_27, -1, -1, 0},
 
372
/* 28 */ { 3, s_20_28, -1, -1, 0},
 
373
/* 29 */ { 3, s_20_29, -1, -1, 0},
 
374
/* 30 */ { 3, s_20_30, -1, -1, 0},
 
375
/* 31 */ { 3, s_20_31, -1, -1, 0}
 
376
};
 
377
 
 
378
static const symbol s_21_0[2] = { 's', 'a' };
 
379
static const symbol s_21_1[2] = { 's', 'e' };
 
380
static const symbol s_21_2[3] = { 's', 'a', 'k' };
 
381
static const symbol s_21_3[3] = { 's', 'e', 'k' };
 
382
static const symbol s_21_4[3] = { 's', 'a', 'm' };
 
383
static const symbol s_21_5[3] = { 's', 'e', 'm' };
 
384
static const symbol s_21_6[3] = { 's', 'a', 'n' };
 
385
static const symbol s_21_7[3] = { 's', 'e', 'n' };
 
386
 
 
387
static const struct among a_21[8] =
 
388
{
 
389
/*  0 */ { 2, s_21_0, -1, -1, 0},
 
390
/*  1 */ { 2, s_21_1, -1, -1, 0},
 
391
/*  2 */ { 3, s_21_2, -1, -1, 0},
 
392
/*  3 */ { 3, s_21_3, -1, -1, 0},
 
393
/*  4 */ { 3, s_21_4, -1, -1, 0},
 
394
/*  5 */ { 3, s_21_5, -1, -1, 0},
 
395
/*  6 */ { 3, s_21_6, -1, -1, 0},
 
396
/*  7 */ { 3, s_21_7, -1, -1, 0}
 
397
};
 
398
 
 
399
static const symbol s_22_0[4] = { 'm', 'i', 0xC5, 0x9F };
 
400
static const symbol s_22_1[4] = { 'm', 'u', 0xC5, 0x9F };
 
401
static const symbol s_22_2[5] = { 'm', 0xC4, 0xB1, 0xC5, 0x9F };
 
402
static const symbol s_22_3[5] = { 'm', 0xC3, 0xBC, 0xC5, 0x9F };
 
403
 
 
404
static const struct among a_22[4] =
 
405
{
 
406
/*  0 */ { 4, s_22_0, -1, -1, 0},
 
407
/*  1 */ { 4, s_22_1, -1, -1, 0},
 
408
/*  2 */ { 5, s_22_2, -1, -1, 0},
 
409
/*  3 */ { 5, s_22_3, -1, -1, 0}
 
410
};
 
411
 
 
412
static const symbol s_23_0[1] = { 'b' };
 
413
static const symbol s_23_1[1] = { 'c' };
 
414
static const symbol s_23_2[1] = { 'd' };
 
415
static const symbol s_23_3[2] = { 0xC4, 0x9F };
 
416
 
 
417
static const struct among a_23[4] =
 
418
{
 
419
/*  0 */ { 1, s_23_0, -1, 1, 0},
 
420
/*  1 */ { 1, s_23_1, -1, 2, 0},
 
421
/*  2 */ { 1, s_23_2, -1, 3, 0},
 
422
/*  3 */ { 2, s_23_3, -1, 4, 0}
 
423
};
 
424
 
 
425
static const unsigned char g_vowel[] = { 17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 8, 0, 0, 0, 0, 0, 0, 1 };
 
426
 
 
427
static const unsigned char g_U[] = { 1, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 1 };
 
428
 
 
429
static const unsigned char g_vowel1[] = { 1, 64, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
 
430
 
 
431
static const unsigned char g_vowel2[] = { 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 130 };
 
432
 
 
433
static const unsigned char g_vowel3[] = { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
 
434
 
 
435
static const unsigned char g_vowel4[] = { 17 };
 
436
 
 
437
static const unsigned char g_vowel5[] = { 65 };
 
438
 
 
439
static const unsigned char g_vowel6[] = { 65 };
 
440
 
 
441
static const symbol s_0[] = { 'a' };
 
442
static const symbol s_1[] = { 'e' };
 
443
static const symbol s_2[] = { 0xC4, 0xB1 };
 
444
static const symbol s_3[] = { 'i' };
 
445
static const symbol s_4[] = { 'o' };
 
446
static const symbol s_5[] = { 0xC3, 0xB6 };
 
447
static const symbol s_6[] = { 'u' };
 
448
static const symbol s_7[] = { 0xC3, 0xBC };
 
449
static const symbol s_8[] = { 'n' };
 
450
static const symbol s_9[] = { 'n' };
 
451
static const symbol s_10[] = { 's' };
 
452
static const symbol s_11[] = { 's' };
 
453
static const symbol s_12[] = { 'y' };
 
454
static const symbol s_13[] = { 'y' };
 
455
static const symbol s_14[] = { 'k', 'i' };
 
456
static const symbol s_15[] = { 'k', 'e', 'n' };
 
457
static const symbol s_16[] = { 'p' };
 
458
static const symbol s_17[] = { 0xC3, 0xA7 };
 
459
static const symbol s_18[] = { 't' };
 
460
static const symbol s_19[] = { 'k' };
 
461
static const symbol s_20[] = { 'd' };
 
462
static const symbol s_21[] = { 'g' };
 
463
static const symbol s_22[] = { 'a' };
 
464
static const symbol s_23[] = { 0xC4, 0xB1 };
 
465
static const symbol s_24[] = { 0xC4, 0xB1 };
 
466
static const symbol s_25[] = { 'e' };
 
467
static const symbol s_26[] = { 'i' };
 
468
static const symbol s_27[] = { 'i' };
 
469
static const symbol s_28[] = { 'o' };
 
470
static const symbol s_29[] = { 'u' };
 
471
static const symbol s_30[] = { 'u' };
 
472
static const symbol s_31[] = { 0xC3, 0xB6 };
 
473
static const symbol s_32[] = { 0xC3, 0xBC };
 
474
static const symbol s_33[] = { 0xC3, 0xBC };
 
475
static const symbol s_34[] = { 'a', 'd' };
 
476
static const symbol s_35[] = { 's', 'o', 'y', 'a', 'd' };
 
477
 
 
478
static int r_check_vowel_harmony(struct SN_env * z) {
 
479
    {   int m_test = z->l - z->c; /* test, line 112 */
 
480
        if (out_grouping_b_U(z, g_vowel, 97, 305, 1) < 0) return 0; /* goto */ /* grouping vowel, line 114 */
 
481
        {   int m1 = z->l - z->c; (void)m1; /* or, line 116 */
 
482
            if (!(eq_s_b(z, 1, s_0))) goto lab1;
 
483
            if (out_grouping_b_U(z, g_vowel1, 97, 305, 1) < 0) goto lab1; /* goto */ /* grouping vowel1, line 116 */
 
484
            goto lab0;
 
485
        lab1:
 
486
            z->c = z->l - m1;
 
487
            if (!(eq_s_b(z, 1, s_1))) goto lab2;
 
488
            if (out_grouping_b_U(z, g_vowel2, 101, 252, 1) < 0) goto lab2; /* goto */ /* grouping vowel2, line 117 */
 
489
            goto lab0;
 
490
        lab2:
 
491
            z->c = z->l - m1;
 
492
            if (!(eq_s_b(z, 2, s_2))) goto lab3;
 
493
            if (out_grouping_b_U(z, g_vowel3, 97, 305, 1) < 0) goto lab3; /* goto */ /* grouping vowel3, line 118 */
 
494
            goto lab0;
 
495
        lab3:
 
496
            z->c = z->l - m1;
 
497
            if (!(eq_s_b(z, 1, s_3))) goto lab4;
 
498
            if (out_grouping_b_U(z, g_vowel4, 101, 105, 1) < 0) goto lab4; /* goto */ /* grouping vowel4, line 119 */
 
499
            goto lab0;
 
500
        lab4:
 
501
            z->c = z->l - m1;
 
502
            if (!(eq_s_b(z, 1, s_4))) goto lab5;
 
503
            if (out_grouping_b_U(z, g_vowel5, 111, 117, 1) < 0) goto lab5; /* goto */ /* grouping vowel5, line 120 */
 
504
            goto lab0;
 
505
        lab5:
 
506
            z->c = z->l - m1;
 
507
            if (!(eq_s_b(z, 2, s_5))) goto lab6;
 
508
            if (out_grouping_b_U(z, g_vowel6, 246, 252, 1) < 0) goto lab6; /* goto */ /* grouping vowel6, line 121 */
 
509
            goto lab0;
 
510
        lab6:
 
511
            z->c = z->l - m1;
 
512
            if (!(eq_s_b(z, 1, s_6))) goto lab7;
 
513
            if (out_grouping_b_U(z, g_vowel5, 111, 117, 1) < 0) goto lab7; /* goto */ /* grouping vowel5, line 122 */
 
514
            goto lab0;
 
515
        lab7:
 
516
            z->c = z->l - m1;
 
517
            if (!(eq_s_b(z, 2, s_7))) return 0;
 
518
            if (out_grouping_b_U(z, g_vowel6, 246, 252, 1) < 0) return 0; /* goto */ /* grouping vowel6, line 123 */
 
519
        }
 
520
    lab0:
 
521
        z->c = z->l - m_test;
 
522
    }
 
523
    return 1;
 
524
}
 
525
 
 
526
static int r_mark_suffix_with_optional_n_consonant(struct SN_env * z) {
 
527
    {   int m1 = z->l - z->c; (void)m1; /* or, line 134 */
 
528
        {   int m_test = z->l - z->c; /* test, line 133 */
 
529
            if (!(eq_s_b(z, 1, s_8))) goto lab1;
 
530
            z->c = z->l - m_test;
 
531
        }
 
532
        {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
 
533
            if (ret < 0) goto lab1;
 
534
            z->c = ret; /* next, line 133 */
 
535
        }
 
536
        {   int m_test = z->l - z->c; /* test, line 133 */
 
537
            if (in_grouping_b_U(z, g_vowel, 97, 305, 0)) goto lab1;
 
538
            z->c = z->l - m_test;
 
539
        }
 
540
        goto lab0;
 
541
    lab1:
 
542
        z->c = z->l - m1;
 
543
        {   int m2 = z->l - z->c; (void)m2; /* not, line 135 */
 
544
            {   int m_test = z->l - z->c; /* test, line 135 */
 
545
                if (!(eq_s_b(z, 1, s_9))) goto lab2;
 
546
                z->c = z->l - m_test;
 
547
            }
 
548
            return 0;
 
549
        lab2:
 
550
            z->c = z->l - m2;
 
551
        }
 
552
        {   int m_test = z->l - z->c; /* test, line 135 */
 
553
            {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
 
554
                if (ret < 0) return 0;
 
555
                z->c = ret; /* next, line 135 */
 
556
            }
 
557
            {   int m_test = z->l - z->c; /* test, line 135 */
 
558
                if (in_grouping_b_U(z, g_vowel, 97, 305, 0)) return 0;
 
559
                z->c = z->l - m_test;
 
560
            }
 
561
            z->c = z->l - m_test;
 
562
        }
 
563
    }
 
564
lab0:
 
565
    return 1;
 
566
}
 
567
 
 
568
static int r_mark_suffix_with_optional_s_consonant(struct SN_env * z) {
 
569
    {   int m1 = z->l - z->c; (void)m1; /* or, line 145 */
 
570
        {   int m_test = z->l - z->c; /* test, line 144 */
 
571
            if (!(eq_s_b(z, 1, s_10))) goto lab1;
 
572
            z->c = z->l - m_test;
 
573
        }
 
574
        {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
 
575
            if (ret < 0) goto lab1;
 
576
            z->c = ret; /* next, line 144 */
 
577
        }
 
578
        {   int m_test = z->l - z->c; /* test, line 144 */
 
579
            if (in_grouping_b_U(z, g_vowel, 97, 305, 0)) goto lab1;
 
580
            z->c = z->l - m_test;
 
581
        }
 
582
        goto lab0;
 
583
    lab1:
 
584
        z->c = z->l - m1;
 
585
        {   int m2 = z->l - z->c; (void)m2; /* not, line 146 */
 
586
            {   int m_test = z->l - z->c; /* test, line 146 */
 
587
                if (!(eq_s_b(z, 1, s_11))) goto lab2;
 
588
                z->c = z->l - m_test;
 
589
            }
 
590
            return 0;
 
591
        lab2:
 
592
            z->c = z->l - m2;
 
593
        }
 
594
        {   int m_test = z->l - z->c; /* test, line 146 */
 
595
            {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
 
596
                if (ret < 0) return 0;
 
597
                z->c = ret; /* next, line 146 */
 
598
            }
 
599
            {   int m_test = z->l - z->c; /* test, line 146 */
 
600
                if (in_grouping_b_U(z, g_vowel, 97, 305, 0)) return 0;
 
601
                z->c = z->l - m_test;
 
602
            }
 
603
            z->c = z->l - m_test;
 
604
        }
 
605
    }
 
606
lab0:
 
607
    return 1;
 
608
}
 
609
 
 
610
static int r_mark_suffix_with_optional_y_consonant(struct SN_env * z) {
 
611
    {   int m1 = z->l - z->c; (void)m1; /* or, line 155 */
 
612
        {   int m_test = z->l - z->c; /* test, line 154 */
 
613
            if (!(eq_s_b(z, 1, s_12))) goto lab1;
 
614
            z->c = z->l - m_test;
 
615
        }
 
616
        {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
 
617
            if (ret < 0) goto lab1;
 
618
            z->c = ret; /* next, line 154 */
 
619
        }
 
620
        {   int m_test = z->l - z->c; /* test, line 154 */
 
621
            if (in_grouping_b_U(z, g_vowel, 97, 305, 0)) goto lab1;
 
622
            z->c = z->l - m_test;
 
623
        }
 
624
        goto lab0;
 
625
    lab1:
 
626
        z->c = z->l - m1;
 
627
        {   int m2 = z->l - z->c; (void)m2; /* not, line 156 */
 
628
            {   int m_test = z->l - z->c; /* test, line 156 */
 
629
                if (!(eq_s_b(z, 1, s_13))) goto lab2;
 
630
                z->c = z->l - m_test;
 
631
            }
 
632
            return 0;
 
633
        lab2:
 
634
            z->c = z->l - m2;
 
635
        }
 
636
        {   int m_test = z->l - z->c; /* test, line 156 */
 
637
            {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
 
638
                if (ret < 0) return 0;
 
639
                z->c = ret; /* next, line 156 */
 
640
            }
 
641
            {   int m_test = z->l - z->c; /* test, line 156 */
 
642
                if (in_grouping_b_U(z, g_vowel, 97, 305, 0)) return 0;
 
643
                z->c = z->l - m_test;
 
644
            }
 
645
            z->c = z->l - m_test;
 
646
        }
 
647
    }
 
648
lab0:
 
649
    return 1;
 
650
}
 
651
 
 
652
static int r_mark_suffix_with_optional_U_vowel(struct SN_env * z) {
 
653
    {   int m1 = z->l - z->c; (void)m1; /* or, line 161 */
 
654
        {   int m_test = z->l - z->c; /* test, line 160 */
 
655
            if (in_grouping_b_U(z, g_U, 105, 305, 0)) goto lab1;
 
656
            z->c = z->l - m_test;
 
657
        }
 
658
        {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
 
659
            if (ret < 0) goto lab1;
 
660
            z->c = ret; /* next, line 160 */
 
661
        }
 
662
        {   int m_test = z->l - z->c; /* test, line 160 */
 
663
            if (out_grouping_b_U(z, g_vowel, 97, 305, 0)) goto lab1;
 
664
            z->c = z->l - m_test;
 
665
        }
 
666
        goto lab0;
 
667
    lab1:
 
668
        z->c = z->l - m1;
 
669
        {   int m2 = z->l - z->c; (void)m2; /* not, line 162 */
 
670
            {   int m_test = z->l - z->c; /* test, line 162 */
 
671
                if (in_grouping_b_U(z, g_U, 105, 305, 0)) goto lab2;
 
672
                z->c = z->l - m_test;
 
673
            }
 
674
            return 0;
 
675
        lab2:
 
676
            z->c = z->l - m2;
 
677
        }
 
678
        {   int m_test = z->l - z->c; /* test, line 162 */
 
679
            {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
 
680
                if (ret < 0) return 0;
 
681
                z->c = ret; /* next, line 162 */
 
682
            }
 
683
            {   int m_test = z->l - z->c; /* test, line 162 */
 
684
                if (out_grouping_b_U(z, g_vowel, 97, 305, 0)) return 0;
 
685
                z->c = z->l - m_test;
 
686
            }
 
687
            z->c = z->l - m_test;
 
688
        }
 
689
    }
 
690
lab0:
 
691
    return 1;
 
692
}
 
693
 
 
694
static int r_mark_possessives(struct SN_env * z) {
 
695
    if (z->c <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((67133440 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0;
 
696
    if (!(find_among_b(z, a_0, 10))) return 0; /* among, line 167 */
 
697
    {   int ret = r_mark_suffix_with_optional_U_vowel(z);
 
698
        if (ret == 0) return 0; /* call mark_suffix_with_optional_U_vowel, line 169 */
 
699
        if (ret < 0) return ret;
 
700
    }
 
701
    return 1;
 
702
}
 
703
 
 
704
static int r_mark_sU(struct SN_env * z) {
 
705
    {   int ret = r_check_vowel_harmony(z);
 
706
        if (ret == 0) return 0; /* call check_vowel_harmony, line 173 */
 
707
        if (ret < 0) return ret;
 
708
    }
 
709
    if (in_grouping_b_U(z, g_U, 105, 305, 0)) return 0;
 
710
    {   int ret = r_mark_suffix_with_optional_s_consonant(z);
 
711
        if (ret == 0) return 0; /* call mark_suffix_with_optional_s_consonant, line 175 */
 
712
        if (ret < 0) return ret;
 
713
    }
 
714
    return 1;
 
715
}
 
716
 
 
717
static int r_mark_lArI(struct SN_env * z) {
 
718
    if (z->c - 3 <= z->lb || (z->p[z->c - 1] != 105 && z->p[z->c - 1] != 177)) return 0;
 
719
    if (!(find_among_b(z, a_1, 2))) return 0; /* among, line 179 */
 
720
    return 1;
 
721
}
 
722
 
 
723
static int r_mark_yU(struct SN_env * z) {
 
724
    {   int ret = r_check_vowel_harmony(z);
 
725
        if (ret == 0) return 0; /* call check_vowel_harmony, line 183 */
 
726
        if (ret < 0) return ret;
 
727
    }
 
728
    if (in_grouping_b_U(z, g_U, 105, 305, 0)) return 0;
 
729
    {   int ret = r_mark_suffix_with_optional_y_consonant(z);
 
730
        if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 185 */
 
731
        if (ret < 0) return ret;
 
732
    }
 
733
    return 1;
 
734
}
 
735
 
 
736
static int r_mark_nU(struct SN_env * z) {
 
737
    {   int ret = r_check_vowel_harmony(z);
 
738
        if (ret == 0) return 0; /* call check_vowel_harmony, line 189 */
 
739
        if (ret < 0) return ret;
 
740
    }
 
741
    if (!(find_among_b(z, a_2, 4))) return 0; /* among, line 190 */
 
742
    return 1;
 
743
}
 
744
 
 
745
static int r_mark_nUn(struct SN_env * z) {
 
746
    {   int ret = r_check_vowel_harmony(z);
 
747
        if (ret == 0) return 0; /* call check_vowel_harmony, line 194 */
 
748
        if (ret < 0) return ret;
 
749
    }
 
750
    if (z->c - 1 <= z->lb || z->p[z->c - 1] != 110) return 0;
 
751
    if (!(find_among_b(z, a_3, 4))) return 0; /* among, line 195 */
 
752
    {   int ret = r_mark_suffix_with_optional_n_consonant(z);
 
753
        if (ret == 0) return 0; /* call mark_suffix_with_optional_n_consonant, line 196 */
 
754
        if (ret < 0) return ret;
 
755
    }
 
756
    return 1;
 
757
}
 
758
 
 
759
static int r_mark_yA(struct SN_env * z) {
 
760
    {   int ret = r_check_vowel_harmony(z);
 
761
        if (ret == 0) return 0; /* call check_vowel_harmony, line 200 */
 
762
        if (ret < 0) return ret;
 
763
    }
 
764
    if (z->c <= z->lb || (z->p[z->c - 1] != 97 && z->p[z->c - 1] != 101)) return 0;
 
765
    if (!(find_among_b(z, a_4, 2))) return 0; /* among, line 201 */
 
766
    {   int ret = r_mark_suffix_with_optional_y_consonant(z);
 
767
        if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 202 */
 
768
        if (ret < 0) return ret;
 
769
    }
 
770
    return 1;
 
771
}
 
772
 
 
773
static int r_mark_nA(struct SN_env * z) {
 
774
    {   int ret = r_check_vowel_harmony(z);
 
775
        if (ret == 0) return 0; /* call check_vowel_harmony, line 206 */
 
776
        if (ret < 0) return ret;
 
777
    }
 
778
    if (z->c - 1 <= z->lb || (z->p[z->c - 1] != 97 && z->p[z->c - 1] != 101)) return 0;
 
779
    if (!(find_among_b(z, a_5, 2))) return 0; /* among, line 207 */
 
780
    return 1;
 
781
}
 
782
 
 
783
static int r_mark_DA(struct SN_env * z) {
 
784
    {   int ret = r_check_vowel_harmony(z);
 
785
        if (ret == 0) return 0; /* call check_vowel_harmony, line 211 */
 
786
        if (ret < 0) return ret;
 
787
    }
 
788
    if (z->c - 1 <= z->lb || (z->p[z->c - 1] != 97 && z->p[z->c - 1] != 101)) return 0;
 
789
    if (!(find_among_b(z, a_6, 4))) return 0; /* among, line 212 */
 
790
    return 1;
 
791
}
 
792
 
 
793
static int r_mark_ndA(struct SN_env * z) {
 
794
    {   int ret = r_check_vowel_harmony(z);
 
795
        if (ret == 0) return 0; /* call check_vowel_harmony, line 216 */
 
796
        if (ret < 0) return ret;
 
797
    }
 
798
    if (z->c - 2 <= z->lb || (z->p[z->c - 1] != 97 && z->p[z->c - 1] != 101)) return 0;
 
799
    if (!(find_among_b(z, a_7, 2))) return 0; /* among, line 217 */
 
800
    return 1;
 
801
}
 
802
 
 
803
static int r_mark_DAn(struct SN_env * z) {
 
804
    {   int ret = r_check_vowel_harmony(z);
 
805
        if (ret == 0) return 0; /* call check_vowel_harmony, line 221 */
 
806
        if (ret < 0) return ret;
 
807
    }
 
808
    if (z->c - 2 <= z->lb || z->p[z->c - 1] != 110) return 0;
 
809
    if (!(find_among_b(z, a_8, 4))) return 0; /* among, line 222 */
 
810
    return 1;
 
811
}
 
812
 
 
813
static int r_mark_ndAn(struct SN_env * z) {
 
814
    {   int ret = r_check_vowel_harmony(z);
 
815
        if (ret == 0) return 0; /* call check_vowel_harmony, line 226 */
 
816
        if (ret < 0) return ret;
 
817
    }
 
818
    if (z->c - 3 <= z->lb || z->p[z->c - 1] != 110) return 0;
 
819
    if (!(find_among_b(z, a_9, 2))) return 0; /* among, line 227 */
 
820
    return 1;
 
821
}
 
822
 
 
823
static int r_mark_ylA(struct SN_env * z) {
 
824
    {   int ret = r_check_vowel_harmony(z);
 
825
        if (ret == 0) return 0; /* call check_vowel_harmony, line 231 */
 
826
        if (ret < 0) return ret;
 
827
    }
 
828
    if (z->c - 1 <= z->lb || (z->p[z->c - 1] != 97 && z->p[z->c - 1] != 101)) return 0;
 
829
    if (!(find_among_b(z, a_10, 2))) return 0; /* among, line 232 */
 
830
    {   int ret = r_mark_suffix_with_optional_y_consonant(z);
 
831
        if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 233 */
 
832
        if (ret < 0) return ret;
 
833
    }
 
834
    return 1;
 
835
}
 
836
 
 
837
static int r_mark_ki(struct SN_env * z) {
 
838
    if (!(eq_s_b(z, 2, s_14))) return 0;
 
839
    return 1;
 
840
}
 
841
 
 
842
static int r_mark_ncA(struct SN_env * z) {
 
843
    {   int ret = r_check_vowel_harmony(z);
 
844
        if (ret == 0) return 0; /* call check_vowel_harmony, line 241 */
 
845
        if (ret < 0) return ret;
 
846
    }
 
847
    if (z->c - 1 <= z->lb || (z->p[z->c - 1] != 97 && z->p[z->c - 1] != 101)) return 0;
 
848
    if (!(find_among_b(z, a_11, 2))) return 0; /* among, line 242 */
 
849
    {   int ret = r_mark_suffix_with_optional_n_consonant(z);
 
850
        if (ret == 0) return 0; /* call mark_suffix_with_optional_n_consonant, line 243 */
 
851
        if (ret < 0) return ret;
 
852
    }
 
853
    return 1;
 
854
}
 
855
 
 
856
static int r_mark_yUm(struct SN_env * z) {
 
857
    {   int ret = r_check_vowel_harmony(z);
 
858
        if (ret == 0) return 0; /* call check_vowel_harmony, line 247 */
 
859
        if (ret < 0) return ret;
 
860
    }
 
861
    if (z->c - 1 <= z->lb || z->p[z->c - 1] != 109) return 0;
 
862
    if (!(find_among_b(z, a_12, 4))) return 0; /* among, line 248 */
 
863
    {   int ret = r_mark_suffix_with_optional_y_consonant(z);
 
864
        if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 249 */
 
865
        if (ret < 0) return ret;
 
866
    }
 
867
    return 1;
 
868
}
 
869
 
 
870
static int r_mark_sUn(struct SN_env * z) {
 
871
    {   int ret = r_check_vowel_harmony(z);
 
872
        if (ret == 0) return 0; /* call check_vowel_harmony, line 253 */
 
873
        if (ret < 0) return ret;
 
874
    }
 
875
    if (z->c - 2 <= z->lb || z->p[z->c - 1] != 110) return 0;
 
876
    if (!(find_among_b(z, a_13, 4))) return 0; /* among, line 254 */
 
877
    return 1;
 
878
}
 
879
 
 
880
static int r_mark_yUz(struct SN_env * z) {
 
881
    {   int ret = r_check_vowel_harmony(z);
 
882
        if (ret == 0) return 0; /* call check_vowel_harmony, line 258 */
 
883
        if (ret < 0) return ret;
 
884
    }
 
885
    if (z->c - 1 <= z->lb || z->p[z->c - 1] != 122) return 0;
 
886
    if (!(find_among_b(z, a_14, 4))) return 0; /* among, line 259 */
 
887
    {   int ret = r_mark_suffix_with_optional_y_consonant(z);
 
888
        if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 260 */
 
889
        if (ret < 0) return ret;
 
890
    }
 
891
    return 1;
 
892
}
 
893
 
 
894
static int r_mark_sUnUz(struct SN_env * z) {
 
895
    if (z->c - 4 <= z->lb || z->p[z->c - 1] != 122) return 0;
 
896
    if (!(find_among_b(z, a_15, 4))) return 0; /* among, line 264 */
 
897
    return 1;
 
898
}
 
899
 
 
900
static int r_mark_lAr(struct SN_env * z) {
 
901
    {   int ret = r_check_vowel_harmony(z);
 
902
        if (ret == 0) return 0; /* call check_vowel_harmony, line 268 */
 
903
        if (ret < 0) return ret;
 
904
    }
 
905
    if (z->c - 2 <= z->lb || z->p[z->c - 1] != 114) return 0;
 
906
    if (!(find_among_b(z, a_16, 2))) return 0; /* among, line 269 */
 
907
    return 1;
 
908
}
 
909
 
 
910
static int r_mark_nUz(struct SN_env * z) {
 
911
    {   int ret = r_check_vowel_harmony(z);
 
912
        if (ret == 0) return 0; /* call check_vowel_harmony, line 273 */
 
913
        if (ret < 0) return ret;
 
914
    }
 
915
    if (z->c - 2 <= z->lb || z->p[z->c - 1] != 122) return 0;
 
916
    if (!(find_among_b(z, a_17, 4))) return 0; /* among, line 274 */
 
917
    return 1;
 
918
}
 
919
 
 
920
static int r_mark_DUr(struct SN_env * z) {
 
921
    {   int ret = r_check_vowel_harmony(z);
 
922
        if (ret == 0) return 0; /* call check_vowel_harmony, line 278 */
 
923
        if (ret < 0) return ret;
 
924
    }
 
925
    if (z->c - 2 <= z->lb || z->p[z->c - 1] != 114) return 0;
 
926
    if (!(find_among_b(z, a_18, 8))) return 0; /* among, line 279 */
 
927
    return 1;
 
928
}
 
929
 
 
930
static int r_mark_cAsInA(struct SN_env * z) {
 
931
    if (z->c - 5 <= z->lb || (z->p[z->c - 1] != 97 && z->p[z->c - 1] != 101)) return 0;
 
932
    if (!(find_among_b(z, a_19, 2))) return 0; /* among, line 283 */
 
933
    return 1;
 
934
}
 
935
 
 
936
static int r_mark_yDU(struct SN_env * z) {
 
937
    {   int ret = r_check_vowel_harmony(z);
 
938
        if (ret == 0) return 0; /* call check_vowel_harmony, line 287 */
 
939
        if (ret < 0) return ret;
 
940
    }
 
941
    if (!(find_among_b(z, a_20, 32))) return 0; /* among, line 288 */
 
942
    {   int ret = r_mark_suffix_with_optional_y_consonant(z);
 
943
        if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 292 */
 
944
        if (ret < 0) return ret;
 
945
    }
 
946
    return 1;
 
947
}
 
948
 
 
949
static int r_mark_ysA(struct SN_env * z) {
 
950
    if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((26658 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0;
 
951
    if (!(find_among_b(z, a_21, 8))) return 0; /* among, line 297 */
 
952
    {   int ret = r_mark_suffix_with_optional_y_consonant(z);
 
953
        if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 298 */
 
954
        if (ret < 0) return ret;
 
955
    }
 
956
    return 1;
 
957
}
 
958
 
 
959
static int r_mark_ymUs_(struct SN_env * z) {
 
960
    {   int ret = r_check_vowel_harmony(z);
 
961
        if (ret == 0) return 0; /* call check_vowel_harmony, line 302 */
 
962
        if (ret < 0) return ret;
 
963
    }
 
964
    if (z->c - 3 <= z->lb || z->p[z->c - 1] != 159) return 0;
 
965
    if (!(find_among_b(z, a_22, 4))) return 0; /* among, line 303 */
 
966
    {   int ret = r_mark_suffix_with_optional_y_consonant(z);
 
967
        if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 304 */
 
968
        if (ret < 0) return ret;
 
969
    }
 
970
    return 1;
 
971
}
 
972
 
 
973
static int r_mark_yken(struct SN_env * z) {
 
974
    if (!(eq_s_b(z, 3, s_15))) return 0;
 
975
    {   int ret = r_mark_suffix_with_optional_y_consonant(z);
 
976
        if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 308 */
 
977
        if (ret < 0) return ret;
 
978
    }
 
979
    return 1;
 
980
}
 
981
 
 
982
static int r_stem_nominal_verb_suffixes(struct SN_env * z) {
 
983
    z->ket = z->c; /* [, line 312 */
 
984
    z->B[0] = 1; /* set continue_stemming_noun_suffixes, line 313 */
 
985
    {   int m1 = z->l - z->c; (void)m1; /* or, line 315 */
 
986
        {   int m2 = z->l - z->c; (void)m2; /* or, line 314 */
 
987
            {   int ret = r_mark_ymUs_(z);
 
988
                if (ret == 0) goto lab3; /* call mark_ymUs_, line 314 */
 
989
                if (ret < 0) return ret;
 
990
            }
 
991
            goto lab2;
 
992
        lab3:
 
993
            z->c = z->l - m2;
 
994
            {   int ret = r_mark_yDU(z);
 
995
                if (ret == 0) goto lab4; /* call mark_yDU, line 314 */
 
996
                if (ret < 0) return ret;
 
997
            }
 
998
            goto lab2;
 
999
        lab4:
 
1000
            z->c = z->l - m2;
 
1001
            {   int ret = r_mark_ysA(z);
 
1002
                if (ret == 0) goto lab5; /* call mark_ysA, line 314 */
 
1003
                if (ret < 0) return ret;
 
1004
            }
 
1005
            goto lab2;
 
1006
        lab5:
 
1007
            z->c = z->l - m2;
 
1008
            {   int ret = r_mark_yken(z);
 
1009
                if (ret == 0) goto lab1; /* call mark_yken, line 314 */
 
1010
                if (ret < 0) return ret;
 
1011
            }
 
1012
        }
 
1013
    lab2:
 
1014
        goto lab0;
 
1015
    lab1:
 
1016
        z->c = z->l - m1;
 
1017
        {   int ret = r_mark_cAsInA(z);
 
1018
            if (ret == 0) goto lab6; /* call mark_cAsInA, line 316 */
 
1019
            if (ret < 0) return ret;
 
1020
        }
 
1021
        {   int m3 = z->l - z->c; (void)m3; /* or, line 316 */
 
1022
            {   int ret = r_mark_sUnUz(z);
 
1023
                if (ret == 0) goto lab8; /* call mark_sUnUz, line 316 */
 
1024
                if (ret < 0) return ret;
 
1025
            }
 
1026
            goto lab7;
 
1027
        lab8:
 
1028
            z->c = z->l - m3;
 
1029
            {   int ret = r_mark_lAr(z);
 
1030
                if (ret == 0) goto lab9; /* call mark_lAr, line 316 */
 
1031
                if (ret < 0) return ret;
 
1032
            }
 
1033
            goto lab7;
 
1034
        lab9:
 
1035
            z->c = z->l - m3;
 
1036
            {   int ret = r_mark_yUm(z);
 
1037
                if (ret == 0) goto lab10; /* call mark_yUm, line 316 */
 
1038
                if (ret < 0) return ret;
 
1039
            }
 
1040
            goto lab7;
 
1041
        lab10:
 
1042
            z->c = z->l - m3;
 
1043
            {   int ret = r_mark_sUn(z);
 
1044
                if (ret == 0) goto lab11; /* call mark_sUn, line 316 */
 
1045
                if (ret < 0) return ret;
 
1046
            }
 
1047
            goto lab7;
 
1048
        lab11:
 
1049
            z->c = z->l - m3;
 
1050
            {   int ret = r_mark_yUz(z);
 
1051
                if (ret == 0) goto lab12; /* call mark_yUz, line 316 */
 
1052
                if (ret < 0) return ret;
 
1053
            }
 
1054
            goto lab7;
 
1055
        lab12:
 
1056
            z->c = z->l - m3;
 
1057
        }
 
1058
    lab7:
 
1059
        {   int ret = r_mark_ymUs_(z);
 
1060
            if (ret == 0) goto lab6; /* call mark_ymUs_, line 316 */
 
1061
            if (ret < 0) return ret;
 
1062
        }
 
1063
        goto lab0;
 
1064
    lab6:
 
1065
        z->c = z->l - m1;
 
1066
        {   int ret = r_mark_lAr(z);
 
1067
            if (ret == 0) goto lab13; /* call mark_lAr, line 319 */
 
1068
            if (ret < 0) return ret;
 
1069
        }
 
1070
        z->bra = z->c; /* ], line 319 */
 
1071
        {   int ret = slice_del(z); /* delete, line 319 */
 
1072
            if (ret < 0) return ret;
 
1073
        }
 
1074
        {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 319 */
 
1075
            z->ket = z->c; /* [, line 319 */
 
1076
            {   int m4 = z->l - z->c; (void)m4; /* or, line 319 */
 
1077
                {   int ret = r_mark_DUr(z);
 
1078
                    if (ret == 0) goto lab16; /* call mark_DUr, line 319 */
 
1079
                    if (ret < 0) return ret;
 
1080
                }
 
1081
                goto lab15;
 
1082
            lab16:
 
1083
                z->c = z->l - m4;
 
1084
                {   int ret = r_mark_yDU(z);
 
1085
                    if (ret == 0) goto lab17; /* call mark_yDU, line 319 */
 
1086
                    if (ret < 0) return ret;
 
1087
                }
 
1088
                goto lab15;
 
1089
            lab17:
 
1090
                z->c = z->l - m4;
 
1091
                {   int ret = r_mark_ysA(z);
 
1092
                    if (ret == 0) goto lab18; /* call mark_ysA, line 319 */
 
1093
                    if (ret < 0) return ret;
 
1094
                }
 
1095
                goto lab15;
 
1096
            lab18:
 
1097
                z->c = z->l - m4;
 
1098
                {   int ret = r_mark_ymUs_(z);
 
1099
                    if (ret == 0) { z->c = z->l - m_keep; goto lab14; } /* call mark_ymUs_, line 319 */
 
1100
                    if (ret < 0) return ret;
 
1101
                }
 
1102
            }
 
1103
        lab15:
 
1104
        lab14:
 
1105
            ;
 
1106
        }
 
1107
        z->B[0] = 0; /* unset continue_stemming_noun_suffixes, line 320 */
 
1108
        goto lab0;
 
1109
    lab13:
 
1110
        z->c = z->l - m1;
 
1111
        {   int ret = r_mark_nUz(z);
 
1112
            if (ret == 0) goto lab19; /* call mark_nUz, line 323 */
 
1113
            if (ret < 0) return ret;
 
1114
        }
 
1115
        {   int m5 = z->l - z->c; (void)m5; /* or, line 323 */
 
1116
            {   int ret = r_mark_yDU(z);
 
1117
                if (ret == 0) goto lab21; /* call mark_yDU, line 323 */
 
1118
                if (ret < 0) return ret;
 
1119
            }
 
1120
            goto lab20;
 
1121
        lab21:
 
1122
            z->c = z->l - m5;
 
1123
            {   int ret = r_mark_ysA(z);
 
1124
                if (ret == 0) goto lab19; /* call mark_ysA, line 323 */
 
1125
                if (ret < 0) return ret;
 
1126
            }
 
1127
        }
 
1128
    lab20:
 
1129
        goto lab0;
 
1130
    lab19:
 
1131
        z->c = z->l - m1;
 
1132
        {   int m6 = z->l - z->c; (void)m6; /* or, line 325 */
 
1133
            {   int ret = r_mark_sUnUz(z);
 
1134
                if (ret == 0) goto lab24; /* call mark_sUnUz, line 325 */
 
1135
                if (ret < 0) return ret;
 
1136
            }
 
1137
            goto lab23;
 
1138
        lab24:
 
1139
            z->c = z->l - m6;
 
1140
            {   int ret = r_mark_yUz(z);
 
1141
                if (ret == 0) goto lab25; /* call mark_yUz, line 325 */
 
1142
                if (ret < 0) return ret;
 
1143
            }
 
1144
            goto lab23;
 
1145
        lab25:
 
1146
            z->c = z->l - m6;
 
1147
            {   int ret = r_mark_sUn(z);
 
1148
                if (ret == 0) goto lab26; /* call mark_sUn, line 325 */
 
1149
                if (ret < 0) return ret;
 
1150
            }
 
1151
            goto lab23;
 
1152
        lab26:
 
1153
            z->c = z->l - m6;
 
1154
            {   int ret = r_mark_yUm(z);
 
1155
                if (ret == 0) goto lab22; /* call mark_yUm, line 325 */
 
1156
                if (ret < 0) return ret;
 
1157
            }
 
1158
        }
 
1159
    lab23:
 
1160
        z->bra = z->c; /* ], line 325 */
 
1161
        {   int ret = slice_del(z); /* delete, line 325 */
 
1162
            if (ret < 0) return ret;
 
1163
        }
 
1164
        {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 325 */
 
1165
            z->ket = z->c; /* [, line 325 */
 
1166
            {   int ret = r_mark_ymUs_(z);
 
1167
                if (ret == 0) { z->c = z->l - m_keep; goto lab27; } /* call mark_ymUs_, line 325 */
 
1168
                if (ret < 0) return ret;
 
1169
            }
 
1170
        lab27:
 
1171
            ;
 
1172
        }
 
1173
        goto lab0;
 
1174
    lab22:
 
1175
        z->c = z->l - m1;
 
1176
        {   int ret = r_mark_DUr(z);
 
1177
            if (ret == 0) return 0; /* call mark_DUr, line 327 */
 
1178
            if (ret < 0) return ret;
 
1179
        }
 
1180
        z->bra = z->c; /* ], line 327 */
 
1181
        {   int ret = slice_del(z); /* delete, line 327 */
 
1182
            if (ret < 0) return ret;
 
1183
        }
 
1184
        {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 327 */
 
1185
            z->ket = z->c; /* [, line 327 */
 
1186
            {   int m7 = z->l - z->c; (void)m7; /* or, line 327 */
 
1187
                {   int ret = r_mark_sUnUz(z);
 
1188
                    if (ret == 0) goto lab30; /* call mark_sUnUz, line 327 */
 
1189
                    if (ret < 0) return ret;
 
1190
                }
 
1191
                goto lab29;
 
1192
            lab30:
 
1193
                z->c = z->l - m7;
 
1194
                {   int ret = r_mark_lAr(z);
 
1195
                    if (ret == 0) goto lab31; /* call mark_lAr, line 327 */
 
1196
                    if (ret < 0) return ret;
 
1197
                }
 
1198
                goto lab29;
 
1199
            lab31:
 
1200
                z->c = z->l - m7;
 
1201
                {   int ret = r_mark_yUm(z);
 
1202
                    if (ret == 0) goto lab32; /* call mark_yUm, line 327 */
 
1203
                    if (ret < 0) return ret;
 
1204
                }
 
1205
                goto lab29;
 
1206
            lab32:
 
1207
                z->c = z->l - m7;
 
1208
                {   int ret = r_mark_sUn(z);
 
1209
                    if (ret == 0) goto lab33; /* call mark_sUn, line 327 */
 
1210
                    if (ret < 0) return ret;
 
1211
                }
 
1212
                goto lab29;
 
1213
            lab33:
 
1214
                z->c = z->l - m7;
 
1215
                {   int ret = r_mark_yUz(z);
 
1216
                    if (ret == 0) goto lab34; /* call mark_yUz, line 327 */
 
1217
                    if (ret < 0) return ret;
 
1218
                }
 
1219
                goto lab29;
 
1220
            lab34:
 
1221
                z->c = z->l - m7;
 
1222
            }
 
1223
        lab29:
 
1224
            {   int ret = r_mark_ymUs_(z);
 
1225
                if (ret == 0) { z->c = z->l - m_keep; goto lab28; } /* call mark_ymUs_, line 327 */
 
1226
                if (ret < 0) return ret;
 
1227
            }
 
1228
        lab28:
 
1229
            ;
 
1230
        }
 
1231
    }
 
1232
lab0:
 
1233
    z->bra = z->c; /* ], line 328 */
 
1234
    {   int ret = slice_del(z); /* delete, line 328 */
 
1235
        if (ret < 0) return ret;
 
1236
    }
 
1237
    return 1;
 
1238
}
 
1239
 
 
1240
static int r_stem_suffix_chain_before_ki(struct SN_env * z) {
 
1241
    z->ket = z->c; /* [, line 333 */
 
1242
    {   int ret = r_mark_ki(z);
 
1243
        if (ret == 0) return 0; /* call mark_ki, line 334 */
 
1244
        if (ret < 0) return ret;
 
1245
    }
 
1246
    {   int m1 = z->l - z->c; (void)m1; /* or, line 342 */
 
1247
        {   int ret = r_mark_DA(z);
 
1248
            if (ret == 0) goto lab1; /* call mark_DA, line 336 */
 
1249
            if (ret < 0) return ret;
 
1250
        }
 
1251
        z->bra = z->c; /* ], line 336 */
 
1252
        {   int ret = slice_del(z); /* delete, line 336 */
 
1253
            if (ret < 0) return ret;
 
1254
        }
 
1255
        {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 336 */
 
1256
            z->ket = z->c; /* [, line 336 */
 
1257
            {   int m2 = z->l - z->c; (void)m2; /* or, line 338 */
 
1258
                {   int ret = r_mark_lAr(z);
 
1259
                    if (ret == 0) goto lab4; /* call mark_lAr, line 337 */
 
1260
                    if (ret < 0) return ret;
 
1261
                }
 
1262
                z->bra = z->c; /* ], line 337 */
 
1263
                {   int ret = slice_del(z); /* delete, line 337 */
 
1264
                    if (ret < 0) return ret;
 
1265
                }
 
1266
                {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 337 */
 
1267
                    {   int ret = r_stem_suffix_chain_before_ki(z);
 
1268
                        if (ret == 0) { z->c = z->l - m_keep; goto lab5; } /* call stem_suffix_chain_before_ki, line 337 */
 
1269
                        if (ret < 0) return ret;
 
1270
                    }
 
1271
                lab5:
 
1272
                    ;
 
1273
                }
 
1274
                goto lab3;
 
1275
            lab4:
 
1276
                z->c = z->l - m2;
 
1277
                {   int ret = r_mark_possessives(z);
 
1278
                    if (ret == 0) { z->c = z->l - m_keep; goto lab2; } /* call mark_possessives, line 339 */
 
1279
                    if (ret < 0) return ret;
 
1280
                }
 
1281
                z->bra = z->c; /* ], line 339 */
 
1282
                {   int ret = slice_del(z); /* delete, line 339 */
 
1283
                    if (ret < 0) return ret;
 
1284
                }
 
1285
                {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 339 */
 
1286
                    z->ket = z->c; /* [, line 339 */
 
1287
                    {   int ret = r_mark_lAr(z);
 
1288
                        if (ret == 0) { z->c = z->l - m_keep; goto lab6; } /* call mark_lAr, line 339 */
 
1289
                        if (ret < 0) return ret;
 
1290
                    }
 
1291
                    z->bra = z->c; /* ], line 339 */
 
1292
                    {   int ret = slice_del(z); /* delete, line 339 */
 
1293
                        if (ret < 0) return ret;
 
1294
                    }
 
1295
                    {   int ret = r_stem_suffix_chain_before_ki(z);
 
1296
                        if (ret == 0) { z->c = z->l - m_keep; goto lab6; } /* call stem_suffix_chain_before_ki, line 339 */
 
1297
                        if (ret < 0) return ret;
 
1298
                    }
 
1299
                lab6:
 
1300
                    ;
 
1301
                }
 
1302
            }
 
1303
        lab3:
 
1304
        lab2:
 
1305
            ;
 
1306
        }
 
1307
        goto lab0;
 
1308
    lab1:
 
1309
        z->c = z->l - m1;
 
1310
        {   int ret = r_mark_nUn(z);
 
1311
            if (ret == 0) goto lab7; /* call mark_nUn, line 343 */
 
1312
            if (ret < 0) return ret;
 
1313
        }
 
1314
        z->bra = z->c; /* ], line 343 */
 
1315
        {   int ret = slice_del(z); /* delete, line 343 */
 
1316
            if (ret < 0) return ret;
 
1317
        }
 
1318
        {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 343 */
 
1319
            z->ket = z->c; /* [, line 343 */
 
1320
            {   int m3 = z->l - z->c; (void)m3; /* or, line 345 */
 
1321
                {   int ret = r_mark_lArI(z);
 
1322
                    if (ret == 0) goto lab10; /* call mark_lArI, line 344 */
 
1323
                    if (ret < 0) return ret;
 
1324
                }
 
1325
                z->bra = z->c; /* ], line 344 */
 
1326
                {   int ret = slice_del(z); /* delete, line 344 */
 
1327
                    if (ret < 0) return ret;
 
1328
                }
 
1329
                goto lab9;
 
1330
            lab10:
 
1331
                z->c = z->l - m3;
 
1332
                z->ket = z->c; /* [, line 346 */
 
1333
                {   int m4 = z->l - z->c; (void)m4; /* or, line 346 */
 
1334
                    {   int ret = r_mark_possessives(z);
 
1335
                        if (ret == 0) goto lab13; /* call mark_possessives, line 346 */
 
1336
                        if (ret < 0) return ret;
 
1337
                    }
 
1338
                    goto lab12;
 
1339
                lab13:
 
1340
                    z->c = z->l - m4;
 
1341
                    {   int ret = r_mark_sU(z);
 
1342
                        if (ret == 0) goto lab11; /* call mark_sU, line 346 */
 
1343
                        if (ret < 0) return ret;
 
1344
                    }
 
1345
                }
 
1346
            lab12:
 
1347
                z->bra = z->c; /* ], line 346 */
 
1348
                {   int ret = slice_del(z); /* delete, line 346 */
 
1349
                    if (ret < 0) return ret;
 
1350
                }
 
1351
                {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 346 */
 
1352
                    z->ket = z->c; /* [, line 346 */
 
1353
                    {   int ret = r_mark_lAr(z);
 
1354
                        if (ret == 0) { z->c = z->l - m_keep; goto lab14; } /* call mark_lAr, line 346 */
 
1355
                        if (ret < 0) return ret;
 
1356
                    }
 
1357
                    z->bra = z->c; /* ], line 346 */
 
1358
                    {   int ret = slice_del(z); /* delete, line 346 */
 
1359
                        if (ret < 0) return ret;
 
1360
                    }
 
1361
                    {   int ret = r_stem_suffix_chain_before_ki(z);
 
1362
                        if (ret == 0) { z->c = z->l - m_keep; goto lab14; } /* call stem_suffix_chain_before_ki, line 346 */
 
1363
                        if (ret < 0) return ret;
 
1364
                    }
 
1365
                lab14:
 
1366
                    ;
 
1367
                }
 
1368
                goto lab9;
 
1369
            lab11:
 
1370
                z->c = z->l - m3;
 
1371
                {   int ret = r_stem_suffix_chain_before_ki(z);
 
1372
                    if (ret == 0) { z->c = z->l - m_keep; goto lab8; } /* call stem_suffix_chain_before_ki, line 348 */
 
1373
                    if (ret < 0) return ret;
 
1374
                }
 
1375
            }
 
1376
        lab9:
 
1377
        lab8:
 
1378
            ;
 
1379
        }
 
1380
        goto lab0;
 
1381
    lab7:
 
1382
        z->c = z->l - m1;
 
1383
        {   int ret = r_mark_ndA(z);
 
1384
            if (ret == 0) return 0; /* call mark_ndA, line 351 */
 
1385
            if (ret < 0) return ret;
 
1386
        }
 
1387
        {   int m5 = z->l - z->c; (void)m5; /* or, line 353 */
 
1388
            {   int ret = r_mark_lArI(z);
 
1389
                if (ret == 0) goto lab16; /* call mark_lArI, line 352 */
 
1390
                if (ret < 0) return ret;
 
1391
            }
 
1392
            z->bra = z->c; /* ], line 352 */
 
1393
            {   int ret = slice_del(z); /* delete, line 352 */
 
1394
                if (ret < 0) return ret;
 
1395
            }
 
1396
            goto lab15;
 
1397
        lab16:
 
1398
            z->c = z->l - m5;
 
1399
            {   int ret = r_mark_sU(z);
 
1400
                if (ret == 0) goto lab17; /* call mark_sU, line 354 */
 
1401
                if (ret < 0) return ret;
 
1402
            }
 
1403
            z->bra = z->c; /* ], line 354 */
 
1404
            {   int ret = slice_del(z); /* delete, line 354 */
 
1405
                if (ret < 0) return ret;
 
1406
            }
 
1407
            {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 354 */
 
1408
                z->ket = z->c; /* [, line 354 */
 
1409
                {   int ret = r_mark_lAr(z);
 
1410
                    if (ret == 0) { z->c = z->l - m_keep; goto lab18; } /* call mark_lAr, line 354 */
 
1411
                    if (ret < 0) return ret;
 
1412
                }
 
1413
                z->bra = z->c; /* ], line 354 */
 
1414
                {   int ret = slice_del(z); /* delete, line 354 */
 
1415
                    if (ret < 0) return ret;
 
1416
                }
 
1417
                {   int ret = r_stem_suffix_chain_before_ki(z);
 
1418
                    if (ret == 0) { z->c = z->l - m_keep; goto lab18; } /* call stem_suffix_chain_before_ki, line 354 */
 
1419
                    if (ret < 0) return ret;
 
1420
                }
 
1421
            lab18:
 
1422
                ;
 
1423
            }
 
1424
            goto lab15;
 
1425
        lab17:
 
1426
            z->c = z->l - m5;
 
1427
            {   int ret = r_stem_suffix_chain_before_ki(z);
 
1428
                if (ret == 0) return 0; /* call stem_suffix_chain_before_ki, line 356 */
 
1429
                if (ret < 0) return ret;
 
1430
            }
 
1431
        }
 
1432
    lab15:
 
1433
        ;
 
1434
    }
 
1435
lab0:
 
1436
    return 1;
 
1437
}
 
1438
 
 
1439
static int r_stem_noun_suffixes(struct SN_env * z) {
 
1440
    {   int m1 = z->l - z->c; (void)m1; /* or, line 363 */
 
1441
        z->ket = z->c; /* [, line 362 */
 
1442
        {   int ret = r_mark_lAr(z);
 
1443
            if (ret == 0) goto lab1; /* call mark_lAr, line 362 */
 
1444
            if (ret < 0) return ret;
 
1445
        }
 
1446
        z->bra = z->c; /* ], line 362 */
 
1447
        {   int ret = slice_del(z); /* delete, line 362 */
 
1448
            if (ret < 0) return ret;
 
1449
        }
 
1450
        {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 362 */
 
1451
            {   int ret = r_stem_suffix_chain_before_ki(z);
 
1452
                if (ret == 0) { z->c = z->l - m_keep; goto lab2; } /* call stem_suffix_chain_before_ki, line 362 */
 
1453
                if (ret < 0) return ret;
 
1454
            }
 
1455
        lab2:
 
1456
            ;
 
1457
        }
 
1458
        goto lab0;
 
1459
    lab1:
 
1460
        z->c = z->l - m1;
 
1461
        z->ket = z->c; /* [, line 364 */
 
1462
        {   int ret = r_mark_ncA(z);
 
1463
            if (ret == 0) goto lab3; /* call mark_ncA, line 364 */
 
1464
            if (ret < 0) return ret;
 
1465
        }
 
1466
        z->bra = z->c; /* ], line 364 */
 
1467
        {   int ret = slice_del(z); /* delete, line 364 */
 
1468
            if (ret < 0) return ret;
 
1469
        }
 
1470
        {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 365 */
 
1471
            {   int m2 = z->l - z->c; (void)m2; /* or, line 367 */
 
1472
                z->ket = z->c; /* [, line 366 */
 
1473
                {   int ret = r_mark_lArI(z);
 
1474
                    if (ret == 0) goto lab6; /* call mark_lArI, line 366 */
 
1475
                    if (ret < 0) return ret;
 
1476
                }
 
1477
                z->bra = z->c; /* ], line 366 */
 
1478
                {   int ret = slice_del(z); /* delete, line 366 */
 
1479
                    if (ret < 0) return ret;
 
1480
                }
 
1481
                goto lab5;
 
1482
            lab6:
 
1483
                z->c = z->l - m2;
 
1484
                z->ket = z->c; /* [, line 368 */
 
1485
                {   int m3 = z->l - z->c; (void)m3; /* or, line 368 */
 
1486
                    {   int ret = r_mark_possessives(z);
 
1487
                        if (ret == 0) goto lab9; /* call mark_possessives, line 368 */
 
1488
                        if (ret < 0) return ret;
 
1489
                    }
 
1490
                    goto lab8;
 
1491
                lab9:
 
1492
                    z->c = z->l - m3;
 
1493
                    {   int ret = r_mark_sU(z);
 
1494
                        if (ret == 0) goto lab7; /* call mark_sU, line 368 */
 
1495
                        if (ret < 0) return ret;
 
1496
                    }
 
1497
                }
 
1498
            lab8:
 
1499
                z->bra = z->c; /* ], line 368 */
 
1500
                {   int ret = slice_del(z); /* delete, line 368 */
 
1501
                    if (ret < 0) return ret;
 
1502
                }
 
1503
                {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 368 */
 
1504
                    z->ket = z->c; /* [, line 368 */
 
1505
                    {   int ret = r_mark_lAr(z);
 
1506
                        if (ret == 0) { z->c = z->l - m_keep; goto lab10; } /* call mark_lAr, line 368 */
 
1507
                        if (ret < 0) return ret;
 
1508
                    }
 
1509
                    z->bra = z->c; /* ], line 368 */
 
1510
                    {   int ret = slice_del(z); /* delete, line 368 */
 
1511
                        if (ret < 0) return ret;
 
1512
                    }
 
1513
                    {   int ret = r_stem_suffix_chain_before_ki(z);
 
1514
                        if (ret == 0) { z->c = z->l - m_keep; goto lab10; } /* call stem_suffix_chain_before_ki, line 368 */
 
1515
                        if (ret < 0) return ret;
 
1516
                    }
 
1517
                lab10:
 
1518
                    ;
 
1519
                }
 
1520
                goto lab5;
 
1521
            lab7:
 
1522
                z->c = z->l - m2;
 
1523
                z->ket = z->c; /* [, line 370 */
 
1524
                {   int ret = r_mark_lAr(z);
 
1525
                    if (ret == 0) { z->c = z->l - m_keep; goto lab4; } /* call mark_lAr, line 370 */
 
1526
                    if (ret < 0) return ret;
 
1527
                }
 
1528
                z->bra = z->c; /* ], line 370 */
 
1529
                {   int ret = slice_del(z); /* delete, line 370 */
 
1530
                    if (ret < 0) return ret;
 
1531
                }
 
1532
                {   int ret = r_stem_suffix_chain_before_ki(z);
 
1533
                    if (ret == 0) { z->c = z->l - m_keep; goto lab4; } /* call stem_suffix_chain_before_ki, line 370 */
 
1534
                    if (ret < 0) return ret;
 
1535
                }
 
1536
            }
 
1537
        lab5:
 
1538
        lab4:
 
1539
            ;
 
1540
        }
 
1541
        goto lab0;
 
1542
    lab3:
 
1543
        z->c = z->l - m1;
 
1544
        z->ket = z->c; /* [, line 374 */
 
1545
        {   int m4 = z->l - z->c; (void)m4; /* or, line 374 */
 
1546
            {   int ret = r_mark_ndA(z);
 
1547
                if (ret == 0) goto lab13; /* call mark_ndA, line 374 */
 
1548
                if (ret < 0) return ret;
 
1549
            }
 
1550
            goto lab12;
 
1551
        lab13:
 
1552
            z->c = z->l - m4;
 
1553
            {   int ret = r_mark_nA(z);
 
1554
                if (ret == 0) goto lab11; /* call mark_nA, line 374 */
 
1555
                if (ret < 0) return ret;
 
1556
            }
 
1557
        }
 
1558
    lab12:
 
1559
        {   int m5 = z->l - z->c; (void)m5; /* or, line 377 */
 
1560
            {   int ret = r_mark_lArI(z);
 
1561
                if (ret == 0) goto lab15; /* call mark_lArI, line 376 */
 
1562
                if (ret < 0) return ret;
 
1563
            }
 
1564
            z->bra = z->c; /* ], line 376 */
 
1565
            {   int ret = slice_del(z); /* delete, line 376 */
 
1566
                if (ret < 0) return ret;
 
1567
            }
 
1568
            goto lab14;
 
1569
        lab15:
 
1570
            z->c = z->l - m5;
 
1571
            {   int ret = r_mark_sU(z);
 
1572
                if (ret == 0) goto lab16; /* call mark_sU, line 378 */
 
1573
                if (ret < 0) return ret;
 
1574
            }
 
1575
            z->bra = z->c; /* ], line 378 */
 
1576
            {   int ret = slice_del(z); /* delete, line 378 */
 
1577
                if (ret < 0) return ret;
 
1578
            }
 
1579
            {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 378 */
 
1580
                z->ket = z->c; /* [, line 378 */
 
1581
                {   int ret = r_mark_lAr(z);
 
1582
                    if (ret == 0) { z->c = z->l - m_keep; goto lab17; } /* call mark_lAr, line 378 */
 
1583
                    if (ret < 0) return ret;
 
1584
                }
 
1585
                z->bra = z->c; /* ], line 378 */
 
1586
                {   int ret = slice_del(z); /* delete, line 378 */
 
1587
                    if (ret < 0) return ret;
 
1588
                }
 
1589
                {   int ret = r_stem_suffix_chain_before_ki(z);
 
1590
                    if (ret == 0) { z->c = z->l - m_keep; goto lab17; } /* call stem_suffix_chain_before_ki, line 378 */
 
1591
                    if (ret < 0) return ret;
 
1592
                }
 
1593
            lab17:
 
1594
                ;
 
1595
            }
 
1596
            goto lab14;
 
1597
        lab16:
 
1598
            z->c = z->l - m5;
 
1599
            {   int ret = r_stem_suffix_chain_before_ki(z);
 
1600
                if (ret == 0) goto lab11; /* call stem_suffix_chain_before_ki, line 380 */
 
1601
                if (ret < 0) return ret;
 
1602
            }
 
1603
        }
 
1604
    lab14:
 
1605
        goto lab0;
 
1606
    lab11:
 
1607
        z->c = z->l - m1;
 
1608
        z->ket = z->c; /* [, line 384 */
 
1609
        {   int m6 = z->l - z->c; (void)m6; /* or, line 384 */
 
1610
            {   int ret = r_mark_ndAn(z);
 
1611
                if (ret == 0) goto lab20; /* call mark_ndAn, line 384 */
 
1612
                if (ret < 0) return ret;
 
1613
            }
 
1614
            goto lab19;
 
1615
        lab20:
 
1616
            z->c = z->l - m6;
 
1617
            {   int ret = r_mark_nU(z);
 
1618
                if (ret == 0) goto lab18; /* call mark_nU, line 384 */
 
1619
                if (ret < 0) return ret;
 
1620
            }
 
1621
        }
 
1622
    lab19:
 
1623
        {   int m7 = z->l - z->c; (void)m7; /* or, line 384 */
 
1624
            {   int ret = r_mark_sU(z);
 
1625
                if (ret == 0) goto lab22; /* call mark_sU, line 384 */
 
1626
                if (ret < 0) return ret;
 
1627
            }
 
1628
            z->bra = z->c; /* ], line 384 */
 
1629
            {   int ret = slice_del(z); /* delete, line 384 */
 
1630
                if (ret < 0) return ret;
 
1631
            }
 
1632
            {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 384 */
 
1633
                z->ket = z->c; /* [, line 384 */
 
1634
                {   int ret = r_mark_lAr(z);
 
1635
                    if (ret == 0) { z->c = z->l - m_keep; goto lab23; } /* call mark_lAr, line 384 */
 
1636
                    if (ret < 0) return ret;
 
1637
                }
 
1638
                z->bra = z->c; /* ], line 384 */
 
1639
                {   int ret = slice_del(z); /* delete, line 384 */
 
1640
                    if (ret < 0) return ret;
 
1641
                }
 
1642
                {   int ret = r_stem_suffix_chain_before_ki(z);
 
1643
                    if (ret == 0) { z->c = z->l - m_keep; goto lab23; } /* call stem_suffix_chain_before_ki, line 384 */
 
1644
                    if (ret < 0) return ret;
 
1645
                }
 
1646
            lab23:
 
1647
                ;
 
1648
            }
 
1649
            goto lab21;
 
1650
        lab22:
 
1651
            z->c = z->l - m7;
 
1652
            {   int ret = r_mark_lArI(z);
 
1653
                if (ret == 0) goto lab18; /* call mark_lArI, line 384 */
 
1654
                if (ret < 0) return ret;
 
1655
            }
 
1656
        }
 
1657
    lab21:
 
1658
        goto lab0;
 
1659
    lab18:
 
1660
        z->c = z->l - m1;
 
1661
        z->ket = z->c; /* [, line 386 */
 
1662
        {   int ret = r_mark_DAn(z);
 
1663
            if (ret == 0) goto lab24; /* call mark_DAn, line 386 */
 
1664
            if (ret < 0) return ret;
 
1665
        }
 
1666
        z->bra = z->c; /* ], line 386 */
 
1667
        {   int ret = slice_del(z); /* delete, line 386 */
 
1668
            if (ret < 0) return ret;
 
1669
        }
 
1670
        {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 386 */
 
1671
            z->ket = z->c; /* [, line 386 */
 
1672
            {   int m8 = z->l - z->c; (void)m8; /* or, line 389 */
 
1673
                {   int ret = r_mark_possessives(z);
 
1674
                    if (ret == 0) goto lab27; /* call mark_possessives, line 388 */
 
1675
                    if (ret < 0) return ret;
 
1676
                }
 
1677
                z->bra = z->c; /* ], line 388 */
 
1678
                {   int ret = slice_del(z); /* delete, line 388 */
 
1679
                    if (ret < 0) return ret;
 
1680
                }
 
1681
                {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 388 */
 
1682
                    z->ket = z->c; /* [, line 388 */
 
1683
                    {   int ret = r_mark_lAr(z);
 
1684
                        if (ret == 0) { z->c = z->l - m_keep; goto lab28; } /* call mark_lAr, line 388 */
 
1685
                        if (ret < 0) return ret;
 
1686
                    }
 
1687
                    z->bra = z->c; /* ], line 388 */
 
1688
                    {   int ret = slice_del(z); /* delete, line 388 */
 
1689
                        if (ret < 0) return ret;
 
1690
                    }
 
1691
                    {   int ret = r_stem_suffix_chain_before_ki(z);
 
1692
                        if (ret == 0) { z->c = z->l - m_keep; goto lab28; } /* call stem_suffix_chain_before_ki, line 388 */
 
1693
                        if (ret < 0) return ret;
 
1694
                    }
 
1695
                lab28:
 
1696
                    ;
 
1697
                }
 
1698
                goto lab26;
 
1699
            lab27:
 
1700
                z->c = z->l - m8;
 
1701
                {   int ret = r_mark_lAr(z);
 
1702
                    if (ret == 0) goto lab29; /* call mark_lAr, line 390 */
 
1703
                    if (ret < 0) return ret;
 
1704
                }
 
1705
                z->bra = z->c; /* ], line 390 */
 
1706
                {   int ret = slice_del(z); /* delete, line 390 */
 
1707
                    if (ret < 0) return ret;
 
1708
                }
 
1709
                {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 390 */
 
1710
                    {   int ret = r_stem_suffix_chain_before_ki(z);
 
1711
                        if (ret == 0) { z->c = z->l - m_keep; goto lab30; } /* call stem_suffix_chain_before_ki, line 390 */
 
1712
                        if (ret < 0) return ret;
 
1713
                    }
 
1714
                lab30:
 
1715
                    ;
 
1716
                }
 
1717
                goto lab26;
 
1718
            lab29:
 
1719
                z->c = z->l - m8;
 
1720
                {   int ret = r_stem_suffix_chain_before_ki(z);
 
1721
                    if (ret == 0) { z->c = z->l - m_keep; goto lab25; } /* call stem_suffix_chain_before_ki, line 392 */
 
1722
                    if (ret < 0) return ret;
 
1723
                }
 
1724
            }
 
1725
        lab26:
 
1726
        lab25:
 
1727
            ;
 
1728
        }
 
1729
        goto lab0;
 
1730
    lab24:
 
1731
        z->c = z->l - m1;
 
1732
        z->ket = z->c; /* [, line 396 */
 
1733
        {   int m9 = z->l - z->c; (void)m9; /* or, line 396 */
 
1734
            {   int ret = r_mark_nUn(z);
 
1735
                if (ret == 0) goto lab33; /* call mark_nUn, line 396 */
 
1736
                if (ret < 0) return ret;
 
1737
            }
 
1738
            goto lab32;
 
1739
        lab33:
 
1740
            z->c = z->l - m9;
 
1741
            {   int ret = r_mark_ylA(z);
 
1742
                if (ret == 0) goto lab31; /* call mark_ylA, line 396 */
 
1743
                if (ret < 0) return ret;
 
1744
            }
 
1745
        }
 
1746
    lab32:
 
1747
        z->bra = z->c; /* ], line 396 */
 
1748
        {   int ret = slice_del(z); /* delete, line 396 */
 
1749
            if (ret < 0) return ret;
 
1750
        }
 
1751
        {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 397 */
 
1752
            {   int m10 = z->l - z->c; (void)m10; /* or, line 399 */
 
1753
                z->ket = z->c; /* [, line 398 */
 
1754
                {   int ret = r_mark_lAr(z);
 
1755
                    if (ret == 0) goto lab36; /* call mark_lAr, line 398 */
 
1756
                    if (ret < 0) return ret;
 
1757
                }
 
1758
                z->bra = z->c; /* ], line 398 */
 
1759
                {   int ret = slice_del(z); /* delete, line 398 */
 
1760
                    if (ret < 0) return ret;
 
1761
                }
 
1762
                {   int ret = r_stem_suffix_chain_before_ki(z);
 
1763
                    if (ret == 0) goto lab36; /* call stem_suffix_chain_before_ki, line 398 */
 
1764
                    if (ret < 0) return ret;
 
1765
                }
 
1766
                goto lab35;
 
1767
            lab36:
 
1768
                z->c = z->l - m10;
 
1769
                z->ket = z->c; /* [, line 400 */
 
1770
                {   int m11 = z->l - z->c; (void)m11; /* or, line 400 */
 
1771
                    {   int ret = r_mark_possessives(z);
 
1772
                        if (ret == 0) goto lab39; /* call mark_possessives, line 400 */
 
1773
                        if (ret < 0) return ret;
 
1774
                    }
 
1775
                    goto lab38;
 
1776
                lab39:
 
1777
                    z->c = z->l - m11;
 
1778
                    {   int ret = r_mark_sU(z);
 
1779
                        if (ret == 0) goto lab37; /* call mark_sU, line 400 */
 
1780
                        if (ret < 0) return ret;
 
1781
                    }
 
1782
                }
 
1783
            lab38:
 
1784
                z->bra = z->c; /* ], line 400 */
 
1785
                {   int ret = slice_del(z); /* delete, line 400 */
 
1786
                    if (ret < 0) return ret;
 
1787
                }
 
1788
                {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 400 */
 
1789
                    z->ket = z->c; /* [, line 400 */
 
1790
                    {   int ret = r_mark_lAr(z);
 
1791
                        if (ret == 0) { z->c = z->l - m_keep; goto lab40; } /* call mark_lAr, line 400 */
 
1792
                        if (ret < 0) return ret;
 
1793
                    }
 
1794
                    z->bra = z->c; /* ], line 400 */
 
1795
                    {   int ret = slice_del(z); /* delete, line 400 */
 
1796
                        if (ret < 0) return ret;
 
1797
                    }
 
1798
                    {   int ret = r_stem_suffix_chain_before_ki(z);
 
1799
                        if (ret == 0) { z->c = z->l - m_keep; goto lab40; } /* call stem_suffix_chain_before_ki, line 400 */
 
1800
                        if (ret < 0) return ret;
 
1801
                    }
 
1802
                lab40:
 
1803
                    ;
 
1804
                }
 
1805
                goto lab35;
 
1806
            lab37:
 
1807
                z->c = z->l - m10;
 
1808
                {   int ret = r_stem_suffix_chain_before_ki(z);
 
1809
                    if (ret == 0) { z->c = z->l - m_keep; goto lab34; } /* call stem_suffix_chain_before_ki, line 402 */
 
1810
                    if (ret < 0) return ret;
 
1811
                }
 
1812
            }
 
1813
        lab35:
 
1814
        lab34:
 
1815
            ;
 
1816
        }
 
1817
        goto lab0;
 
1818
    lab31:
 
1819
        z->c = z->l - m1;
 
1820
        z->ket = z->c; /* [, line 406 */
 
1821
        {   int ret = r_mark_lArI(z);
 
1822
            if (ret == 0) goto lab41; /* call mark_lArI, line 406 */
 
1823
            if (ret < 0) return ret;
 
1824
        }
 
1825
        z->bra = z->c; /* ], line 406 */
 
1826
        {   int ret = slice_del(z); /* delete, line 406 */
 
1827
            if (ret < 0) return ret;
 
1828
        }
 
1829
        goto lab0;
 
1830
    lab41:
 
1831
        z->c = z->l - m1;
 
1832
        {   int ret = r_stem_suffix_chain_before_ki(z);
 
1833
            if (ret == 0) goto lab42; /* call stem_suffix_chain_before_ki, line 408 */
 
1834
            if (ret < 0) return ret;
 
1835
        }
 
1836
        goto lab0;
 
1837
    lab42:
 
1838
        z->c = z->l - m1;
 
1839
        z->ket = z->c; /* [, line 410 */
 
1840
        {   int m12 = z->l - z->c; (void)m12; /* or, line 410 */
 
1841
            {   int ret = r_mark_DA(z);
 
1842
                if (ret == 0) goto lab45; /* call mark_DA, line 410 */
 
1843
                if (ret < 0) return ret;
 
1844
            }
 
1845
            goto lab44;
 
1846
        lab45:
 
1847
            z->c = z->l - m12;
 
1848
            {   int ret = r_mark_yU(z);
 
1849
                if (ret == 0) goto lab46; /* call mark_yU, line 410 */
 
1850
                if (ret < 0) return ret;
 
1851
            }
 
1852
            goto lab44;
 
1853
        lab46:
 
1854
            z->c = z->l - m12;
 
1855
            {   int ret = r_mark_yA(z);
 
1856
                if (ret == 0) goto lab43; /* call mark_yA, line 410 */
 
1857
                if (ret < 0) return ret;
 
1858
            }
 
1859
        }
 
1860
    lab44:
 
1861
        z->bra = z->c; /* ], line 410 */
 
1862
        {   int ret = slice_del(z); /* delete, line 410 */
 
1863
            if (ret < 0) return ret;
 
1864
        }
 
1865
        {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 410 */
 
1866
            z->ket = z->c; /* [, line 410 */
 
1867
            {   int m13 = z->l - z->c; (void)m13; /* or, line 410 */
 
1868
                {   int ret = r_mark_possessives(z);
 
1869
                    if (ret == 0) goto lab49; /* call mark_possessives, line 410 */
 
1870
                    if (ret < 0) return ret;
 
1871
                }
 
1872
                z->bra = z->c; /* ], line 410 */
 
1873
                {   int ret = slice_del(z); /* delete, line 410 */
 
1874
                    if (ret < 0) return ret;
 
1875
                }
 
1876
                {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 410 */
 
1877
                    z->ket = z->c; /* [, line 410 */
 
1878
                    {   int ret = r_mark_lAr(z);
 
1879
                        if (ret == 0) { z->c = z->l - m_keep; goto lab50; } /* call mark_lAr, line 410 */
 
1880
                        if (ret < 0) return ret;
 
1881
                    }
 
1882
                lab50:
 
1883
                    ;
 
1884
                }
 
1885
                goto lab48;
 
1886
            lab49:
 
1887
                z->c = z->l - m13;
 
1888
                {   int ret = r_mark_lAr(z);
 
1889
                    if (ret == 0) { z->c = z->l - m_keep; goto lab47; } /* call mark_lAr, line 410 */
 
1890
                    if (ret < 0) return ret;
 
1891
                }
 
1892
            }
 
1893
        lab48:
 
1894
            z->bra = z->c; /* ], line 410 */
 
1895
            {   int ret = slice_del(z); /* delete, line 410 */
 
1896
                if (ret < 0) return ret;
 
1897
            }
 
1898
            z->ket = z->c; /* [, line 410 */
 
1899
            {   int ret = r_stem_suffix_chain_before_ki(z);
 
1900
                if (ret == 0) { z->c = z->l - m_keep; goto lab47; } /* call stem_suffix_chain_before_ki, line 410 */
 
1901
                if (ret < 0) return ret;
 
1902
            }
 
1903
        lab47:
 
1904
            ;
 
1905
        }
 
1906
        goto lab0;
 
1907
    lab43:
 
1908
        z->c = z->l - m1;
 
1909
        z->ket = z->c; /* [, line 412 */
 
1910
        {   int m14 = z->l - z->c; (void)m14; /* or, line 412 */
 
1911
            {   int ret = r_mark_possessives(z);
 
1912
                if (ret == 0) goto lab52; /* call mark_possessives, line 412 */
 
1913
                if (ret < 0) return ret;
 
1914
            }
 
1915
            goto lab51;
 
1916
        lab52:
 
1917
            z->c = z->l - m14;
 
1918
            {   int ret = r_mark_sU(z);
 
1919
                if (ret == 0) return 0; /* call mark_sU, line 412 */
 
1920
                if (ret < 0) return ret;
 
1921
            }
 
1922
        }
 
1923
    lab51:
 
1924
        z->bra = z->c; /* ], line 412 */
 
1925
        {   int ret = slice_del(z); /* delete, line 412 */
 
1926
            if (ret < 0) return ret;
 
1927
        }
 
1928
        {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 412 */
 
1929
            z->ket = z->c; /* [, line 412 */
 
1930
            {   int ret = r_mark_lAr(z);
 
1931
                if (ret == 0) { z->c = z->l - m_keep; goto lab53; } /* call mark_lAr, line 412 */
 
1932
                if (ret < 0) return ret;
 
1933
            }
 
1934
            z->bra = z->c; /* ], line 412 */
 
1935
            {   int ret = slice_del(z); /* delete, line 412 */
 
1936
                if (ret < 0) return ret;
 
1937
            }
 
1938
            {   int ret = r_stem_suffix_chain_before_ki(z);
 
1939
                if (ret == 0) { z->c = z->l - m_keep; goto lab53; } /* call stem_suffix_chain_before_ki, line 412 */
 
1940
                if (ret < 0) return ret;
 
1941
            }
 
1942
        lab53:
 
1943
            ;
 
1944
        }
 
1945
    }
 
1946
lab0:
 
1947
    return 1;
 
1948
}
 
1949
 
 
1950
static int r_post_process_last_consonants(struct SN_env * z) {
 
1951
    int among_var;
 
1952
    z->ket = z->c; /* [, line 416 */
 
1953
    among_var = find_among_b(z, a_23, 4); /* substring, line 416 */
 
1954
    if (!(among_var)) return 0;
 
1955
    z->bra = z->c; /* ], line 416 */
 
1956
    switch(among_var) {
 
1957
        case 0: return 0;
 
1958
        case 1:
 
1959
            {   int ret = slice_from_s(z, 1, s_16); /* <-, line 417 */
 
1960
                if (ret < 0) return ret;
 
1961
            }
 
1962
            break;
 
1963
        case 2:
 
1964
            {   int ret = slice_from_s(z, 2, s_17); /* <-, line 418 */
 
1965
                if (ret < 0) return ret;
 
1966
            }
 
1967
            break;
 
1968
        case 3:
 
1969
            {   int ret = slice_from_s(z, 1, s_18); /* <-, line 419 */
 
1970
                if (ret < 0) return ret;
 
1971
            }
 
1972
            break;
 
1973
        case 4:
 
1974
            {   int ret = slice_from_s(z, 1, s_19); /* <-, line 420 */
 
1975
                if (ret < 0) return ret;
 
1976
            }
 
1977
            break;
 
1978
    }
 
1979
    return 1;
 
1980
}
 
1981
 
 
1982
static int r_append_U_to_stems_ending_with_d_or_g(struct SN_env * z) {
 
1983
    {   int m_test = z->l - z->c; /* test, line 431 */
 
1984
        {   int m1 = z->l - z->c; (void)m1; /* or, line 431 */
 
1985
            if (!(eq_s_b(z, 1, s_20))) goto lab1;
 
1986
            goto lab0;
 
1987
        lab1:
 
1988
            z->c = z->l - m1;
 
1989
            if (!(eq_s_b(z, 1, s_21))) return 0;
 
1990
        }
 
1991
    lab0:
 
1992
        z->c = z->l - m_test;
 
1993
    }
 
1994
    {   int m2 = z->l - z->c; (void)m2; /* or, line 433 */
 
1995
        {   int m_test = z->l - z->c; /* test, line 432 */
 
1996
            if (out_grouping_b_U(z, g_vowel, 97, 305, 1) < 0) goto lab3; /* goto */ /* grouping vowel, line 432 */
 
1997
            {   int m3 = z->l - z->c; (void)m3; /* or, line 432 */
 
1998
                if (!(eq_s_b(z, 1, s_22))) goto lab5;
 
1999
                goto lab4;
 
2000
            lab5:
 
2001
                z->c = z->l - m3;
 
2002
                if (!(eq_s_b(z, 2, s_23))) goto lab3;
 
2003
            }
 
2004
        lab4:
 
2005
            z->c = z->l - m_test;
 
2006
        }
 
2007
        {   int c_keep = z->c;
 
2008
            int ret = insert_s(z, z->c, z->c, 2, s_24); /* <+, line 432 */
 
2009
            z->c = c_keep;
 
2010
            if (ret < 0) return ret;
 
2011
        }
 
2012
        goto lab2;
 
2013
    lab3:
 
2014
        z->c = z->l - m2;
 
2015
        {   int m_test = z->l - z->c; /* test, line 434 */
 
2016
            if (out_grouping_b_U(z, g_vowel, 97, 305, 1) < 0) goto lab6; /* goto */ /* grouping vowel, line 434 */
 
2017
            {   int m4 = z->l - z->c; (void)m4; /* or, line 434 */
 
2018
                if (!(eq_s_b(z, 1, s_25))) goto lab8;
 
2019
                goto lab7;
 
2020
            lab8:
 
2021
                z->c = z->l - m4;
 
2022
                if (!(eq_s_b(z, 1, s_26))) goto lab6;
 
2023
            }
 
2024
        lab7:
 
2025
            z->c = z->l - m_test;
 
2026
        }
 
2027
        {   int c_keep = z->c;
 
2028
            int ret = insert_s(z, z->c, z->c, 1, s_27); /* <+, line 434 */
 
2029
            z->c = c_keep;
 
2030
            if (ret < 0) return ret;
 
2031
        }
 
2032
        goto lab2;
 
2033
    lab6:
 
2034
        z->c = z->l - m2;
 
2035
        {   int m_test = z->l - z->c; /* test, line 436 */
 
2036
            if (out_grouping_b_U(z, g_vowel, 97, 305, 1) < 0) goto lab9; /* goto */ /* grouping vowel, line 436 */
 
2037
            {   int m5 = z->l - z->c; (void)m5; /* or, line 436 */
 
2038
                if (!(eq_s_b(z, 1, s_28))) goto lab11;
 
2039
                goto lab10;
 
2040
            lab11:
 
2041
                z->c = z->l - m5;
 
2042
                if (!(eq_s_b(z, 1, s_29))) goto lab9;
 
2043
            }
 
2044
        lab10:
 
2045
            z->c = z->l - m_test;
 
2046
        }
 
2047
        {   int c_keep = z->c;
 
2048
            int ret = insert_s(z, z->c, z->c, 1, s_30); /* <+, line 436 */
 
2049
            z->c = c_keep;
 
2050
            if (ret < 0) return ret;
 
2051
        }
 
2052
        goto lab2;
 
2053
    lab9:
 
2054
        z->c = z->l - m2;
 
2055
        {   int m_test = z->l - z->c; /* test, line 438 */
 
2056
            if (out_grouping_b_U(z, g_vowel, 97, 305, 1) < 0) return 0; /* goto */ /* grouping vowel, line 438 */
 
2057
            {   int m6 = z->l - z->c; (void)m6; /* or, line 438 */
 
2058
                if (!(eq_s_b(z, 2, s_31))) goto lab13;
 
2059
                goto lab12;
 
2060
            lab13:
 
2061
                z->c = z->l - m6;
 
2062
                if (!(eq_s_b(z, 2, s_32))) return 0;
 
2063
            }
 
2064
        lab12:
 
2065
            z->c = z->l - m_test;
 
2066
        }
 
2067
        {   int c_keep = z->c;
 
2068
            int ret = insert_s(z, z->c, z->c, 2, s_33); /* <+, line 438 */
 
2069
            z->c = c_keep;
 
2070
            if (ret < 0) return ret;
 
2071
        }
 
2072
    }
 
2073
lab2:
 
2074
    return 1;
 
2075
}
 
2076
 
 
2077
static int r_more_than_one_syllable_word(struct SN_env * z) {
 
2078
    {   int c_test = z->c; /* test, line 446 */
 
2079
        {   int i = 2;
 
2080
            while(1) { /* atleast, line 446 */
 
2081
                int c1 = z->c;
 
2082
                {    /* gopast */ /* grouping vowel, line 446 */
 
2083
                    int ret = out_grouping_U(z, g_vowel, 97, 305, 1);
 
2084
                    if (ret < 0) goto lab0;
 
2085
                    z->c += ret;
 
2086
                }
 
2087
                i--;
 
2088
                continue;
 
2089
            lab0:
 
2090
                z->c = c1;
 
2091
                break;
 
2092
            }
 
2093
            if (i > 0) return 0;
 
2094
        }
 
2095
        z->c = c_test;
 
2096
    }
 
2097
    return 1;
 
2098
}
 
2099
 
 
2100
static int r_is_reserved_word(struct SN_env * z) {
 
2101
    {   int c1 = z->c; /* or, line 451 */
 
2102
        {   int c_test = z->c; /* test, line 450 */
 
2103
            while(1) { /* gopast, line 450 */
 
2104
                if (!(eq_s(z, 2, s_34))) goto lab2;
 
2105
                break;
 
2106
            lab2:
 
2107
                {   int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
 
2108
                    if (ret < 0) goto lab1;
 
2109
                    z->c = ret; /* gopast, line 450 */
 
2110
                }
 
2111
            }
 
2112
            z->I[0] = 2;
 
2113
            if (!(z->I[0] == z->l)) goto lab1;
 
2114
            z->c = c_test;
 
2115
        }
 
2116
        goto lab0;
 
2117
    lab1:
 
2118
        z->c = c1;
 
2119
        {   int c_test = z->c; /* test, line 452 */
 
2120
            while(1) { /* gopast, line 452 */
 
2121
                if (!(eq_s(z, 5, s_35))) goto lab3;
 
2122
                break;
 
2123
            lab3:
 
2124
                {   int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
 
2125
                    if (ret < 0) return 0;
 
2126
                    z->c = ret; /* gopast, line 452 */
 
2127
                }
 
2128
            }
 
2129
            z->I[0] = 5;
 
2130
            if (!(z->I[0] == z->l)) return 0;
 
2131
            z->c = c_test;
 
2132
        }
 
2133
    }
 
2134
lab0:
 
2135
    return 1;
 
2136
}
 
2137
 
 
2138
static int r_postlude(struct SN_env * z) {
 
2139
    {   int c1 = z->c; /* not, line 456 */
 
2140
        {   int ret = r_is_reserved_word(z);
 
2141
            if (ret == 0) goto lab0; /* call is_reserved_word, line 456 */
 
2142
            if (ret < 0) return ret;
 
2143
        }
 
2144
        return 0;
 
2145
    lab0:
 
2146
        z->c = c1;
 
2147
    }
 
2148
    z->lb = z->c; z->c = z->l; /* backwards, line 457 */
 
2149
 
 
2150
    {   int m2 = z->l - z->c; (void)m2; /* do, line 458 */
 
2151
        {   int ret = r_append_U_to_stems_ending_with_d_or_g(z);
 
2152
            if (ret == 0) goto lab1; /* call append_U_to_stems_ending_with_d_or_g, line 458 */
 
2153
            if (ret < 0) return ret;
 
2154
        }
 
2155
    lab1:
 
2156
        z->c = z->l - m2;
 
2157
    }
 
2158
    {   int m3 = z->l - z->c; (void)m3; /* do, line 459 */
 
2159
        {   int ret = r_post_process_last_consonants(z);
 
2160
            if (ret == 0) goto lab2; /* call post_process_last_consonants, line 459 */
 
2161
            if (ret < 0) return ret;
 
2162
        }
 
2163
    lab2:
 
2164
        z->c = z->l - m3;
 
2165
    }
 
2166
    z->c = z->lb;
 
2167
    return 1;
 
2168
}
 
2169
 
 
2170
extern int turkish_UTF_8_stem(struct SN_env * z) {
 
2171
    {   int ret = r_more_than_one_syllable_word(z);
 
2172
        if (ret == 0) return 0; /* call more_than_one_syllable_word, line 465 */
 
2173
        if (ret < 0) return ret;
 
2174
    }
 
2175
    z->lb = z->c; z->c = z->l; /* backwards, line 467 */
 
2176
 
 
2177
    {   int m1 = z->l - z->c; (void)m1; /* do, line 468 */
 
2178
        {   int ret = r_stem_nominal_verb_suffixes(z);
 
2179
            if (ret == 0) goto lab0; /* call stem_nominal_verb_suffixes, line 468 */
 
2180
            if (ret < 0) return ret;
 
2181
        }
 
2182
    lab0:
 
2183
        z->c = z->l - m1;
 
2184
    }
 
2185
    if (!(z->B[0])) return 0; /* Boolean test continue_stemming_noun_suffixes, line 469 */
 
2186
    {   int m2 = z->l - z->c; (void)m2; /* do, line 470 */
 
2187
        {   int ret = r_stem_noun_suffixes(z);
 
2188
            if (ret == 0) goto lab1; /* call stem_noun_suffixes, line 470 */
 
2189
            if (ret < 0) return ret;
 
2190
        }
 
2191
    lab1:
 
2192
        z->c = z->l - m2;
 
2193
    }
 
2194
    z->c = z->lb;
 
2195
    {   int ret = r_postlude(z);
 
2196
        if (ret == 0) return 0; /* call postlude, line 473 */
 
2197
        if (ret < 0) return ret;
 
2198
    }
 
2199
    return 1;
 
2200
}
 
2201
 
 
2202
extern struct SN_env * turkish_UTF_8_create_env(void) { return SN_create_env(0, 1, 1); }
 
2203
 
 
2204
extern void turkish_UTF_8_close_env(struct SN_env * z) { SN_close_env(z, 0); }
 
2205