Header And Logo

PostgreSQL
| The world's most advanced open source database.

stem_UTF_8_turkish.c

Go to the documentation of this file.
00001 
00002 /* This file was generated automatically by the Snowball to ANSI C compiler */
00003 
00004 #include "header.h"
00005 
00006 #ifdef __cplusplus
00007 extern "C" {
00008 #endif
00009 extern int turkish_UTF_8_stem(struct SN_env * z);
00010 #ifdef __cplusplus
00011 }
00012 #endif
00013 static int r_stem_suffix_chain_before_ki(struct SN_env * z);
00014 static int r_stem_noun_suffixes(struct SN_env * z);
00015 static int r_stem_nominal_verb_suffixes(struct SN_env * z);
00016 static int r_postlude(struct SN_env * z);
00017 static int r_post_process_last_consonants(struct SN_env * z);
00018 static int r_more_than_one_syllable_word(struct SN_env * z);
00019 static int r_mark_suffix_with_optional_s_consonant(struct SN_env * z);
00020 static int r_mark_suffix_with_optional_n_consonant(struct SN_env * z);
00021 static int r_mark_suffix_with_optional_U_vowel(struct SN_env * z);
00022 static int r_mark_suffix_with_optional_y_consonant(struct SN_env * z);
00023 static int r_mark_ysA(struct SN_env * z);
00024 static int r_mark_ymUs_(struct SN_env * z);
00025 static int r_mark_yken(struct SN_env * z);
00026 static int r_mark_yDU(struct SN_env * z);
00027 static int r_mark_yUz(struct SN_env * z);
00028 static int r_mark_yUm(struct SN_env * z);
00029 static int r_mark_yU(struct SN_env * z);
00030 static int r_mark_ylA(struct SN_env * z);
00031 static int r_mark_yA(struct SN_env * z);
00032 static int r_mark_possessives(struct SN_env * z);
00033 static int r_mark_sUnUz(struct SN_env * z);
00034 static int r_mark_sUn(struct SN_env * z);
00035 static int r_mark_sU(struct SN_env * z);
00036 static int r_mark_nUz(struct SN_env * z);
00037 static int r_mark_nUn(struct SN_env * z);
00038 static int r_mark_nU(struct SN_env * z);
00039 static int r_mark_ndAn(struct SN_env * z);
00040 static int r_mark_ndA(struct SN_env * z);
00041 static int r_mark_ncA(struct SN_env * z);
00042 static int r_mark_nA(struct SN_env * z);
00043 static int r_mark_lArI(struct SN_env * z);
00044 static int r_mark_lAr(struct SN_env * z);
00045 static int r_mark_ki(struct SN_env * z);
00046 static int r_mark_DUr(struct SN_env * z);
00047 static int r_mark_DAn(struct SN_env * z);
00048 static int r_mark_DA(struct SN_env * z);
00049 static int r_mark_cAsInA(struct SN_env * z);
00050 static int r_is_reserved_word(struct SN_env * z);
00051 static int r_check_vowel_harmony(struct SN_env * z);
00052 static int r_append_U_to_stems_ending_with_d_or_g(struct SN_env * z);
00053 #ifdef __cplusplus
00054 extern "C" {
00055 #endif
00056 
00057 
00058 extern struct SN_env * turkish_UTF_8_create_env(void);
00059 extern void turkish_UTF_8_close_env(struct SN_env * z);
00060 
00061 
00062 #ifdef __cplusplus
00063 }
00064 #endif
00065 static const symbol s_0_0[1] = { 'm' };
00066 static const symbol s_0_1[1] = { 'n' };
00067 static const symbol s_0_2[3] = { 'm', 'i', 'z' };
00068 static const symbol s_0_3[3] = { 'n', 'i', 'z' };
00069 static const symbol s_0_4[3] = { 'm', 'u', 'z' };
00070 static const symbol s_0_5[3] = { 'n', 'u', 'z' };
00071 static const symbol s_0_6[4] = { 'm', 0xC4, 0xB1, 'z' };
00072 static const symbol s_0_7[4] = { 'n', 0xC4, 0xB1, 'z' };
00073 static const symbol s_0_8[4] = { 'm', 0xC3, 0xBC, 'z' };
00074 static const symbol s_0_9[4] = { 'n', 0xC3, 0xBC, 'z' };
00075 
00076 static const struct among a_0[10] =
00077 {
00078 /*  0 */ { 1, s_0_0, -1, -1, 0},
00079 /*  1 */ { 1, s_0_1, -1, -1, 0},
00080 /*  2 */ { 3, s_0_2, -1, -1, 0},
00081 /*  3 */ { 3, s_0_3, -1, -1, 0},
00082 /*  4 */ { 3, s_0_4, -1, -1, 0},
00083 /*  5 */ { 3, s_0_5, -1, -1, 0},
00084 /*  6 */ { 4, s_0_6, -1, -1, 0},
00085 /*  7 */ { 4, s_0_7, -1, -1, 0},
00086 /*  8 */ { 4, s_0_8, -1, -1, 0},
00087 /*  9 */ { 4, s_0_9, -1, -1, 0}
00088 };
00089 
00090 static const symbol s_1_0[4] = { 'l', 'e', 'r', 'i' };
00091 static const symbol s_1_1[5] = { 'l', 'a', 'r', 0xC4, 0xB1 };
00092 
00093 static const struct among a_1[2] =
00094 {
00095 /*  0 */ { 4, s_1_0, -1, -1, 0},
00096 /*  1 */ { 5, s_1_1, -1, -1, 0}
00097 };
00098 
00099 static const symbol s_2_0[2] = { 'n', 'i' };
00100 static const symbol s_2_1[2] = { 'n', 'u' };
00101 static const symbol s_2_2[3] = { 'n', 0xC4, 0xB1 };
00102 static const symbol s_2_3[3] = { 'n', 0xC3, 0xBC };
00103 
00104 static const struct among a_2[4] =
00105 {
00106 /*  0 */ { 2, s_2_0, -1, -1, 0},
00107 /*  1 */ { 2, s_2_1, -1, -1, 0},
00108 /*  2 */ { 3, s_2_2, -1, -1, 0},
00109 /*  3 */ { 3, s_2_3, -1, -1, 0}
00110 };
00111 
00112 static const symbol s_3_0[2] = { 'i', 'n' };
00113 static const symbol s_3_1[2] = { 'u', 'n' };
00114 static const symbol s_3_2[3] = { 0xC4, 0xB1, 'n' };
00115 static const symbol s_3_3[3] = { 0xC3, 0xBC, 'n' };
00116 
00117 static const struct among a_3[4] =
00118 {
00119 /*  0 */ { 2, s_3_0, -1, -1, 0},
00120 /*  1 */ { 2, s_3_1, -1, -1, 0},
00121 /*  2 */ { 3, s_3_2, -1, -1, 0},
00122 /*  3 */ { 3, s_3_3, -1, -1, 0}
00123 };
00124 
00125 static const symbol s_4_0[1] = { 'a' };
00126 static const symbol s_4_1[1] = { 'e' };
00127 
00128 static const struct among a_4[2] =
00129 {
00130 /*  0 */ { 1, s_4_0, -1, -1, 0},
00131 /*  1 */ { 1, s_4_1, -1, -1, 0}
00132 };
00133 
00134 static const symbol s_5_0[2] = { 'n', 'a' };
00135 static const symbol s_5_1[2] = { 'n', 'e' };
00136 
00137 static const struct among a_5[2] =
00138 {
00139 /*  0 */ { 2, s_5_0, -1, -1, 0},
00140 /*  1 */ { 2, s_5_1, -1, -1, 0}
00141 };
00142 
00143 static const symbol s_6_0[2] = { 'd', 'a' };
00144 static const symbol s_6_1[2] = { 't', 'a' };
00145 static const symbol s_6_2[2] = { 'd', 'e' };
00146 static const symbol s_6_3[2] = { 't', 'e' };
00147 
00148 static const struct among a_6[4] =
00149 {
00150 /*  0 */ { 2, s_6_0, -1, -1, 0},
00151 /*  1 */ { 2, s_6_1, -1, -1, 0},
00152 /*  2 */ { 2, s_6_2, -1, -1, 0},
00153 /*  3 */ { 2, s_6_3, -1, -1, 0}
00154 };
00155 
00156 static const symbol s_7_0[3] = { 'n', 'd', 'a' };
00157 static const symbol s_7_1[3] = { 'n', 'd', 'e' };
00158 
00159 static const struct among a_7[2] =
00160 {
00161 /*  0 */ { 3, s_7_0, -1, -1, 0},
00162 /*  1 */ { 3, s_7_1, -1, -1, 0}
00163 };
00164 
00165 static const symbol s_8_0[3] = { 'd', 'a', 'n' };
00166 static const symbol s_8_1[3] = { 't', 'a', 'n' };
00167 static const symbol s_8_2[3] = { 'd', 'e', 'n' };
00168 static const symbol s_8_3[3] = { 't', 'e', 'n' };
00169 
00170 static const struct among a_8[4] =
00171 {
00172 /*  0 */ { 3, s_8_0, -1, -1, 0},
00173 /*  1 */ { 3, s_8_1, -1, -1, 0},
00174 /*  2 */ { 3, s_8_2, -1, -1, 0},
00175 /*  3 */ { 3, s_8_3, -1, -1, 0}
00176 };
00177 
00178 static const symbol s_9_0[4] = { 'n', 'd', 'a', 'n' };
00179 static const symbol s_9_1[4] = { 'n', 'd', 'e', 'n' };
00180 
00181 static const struct among a_9[2] =
00182 {
00183 /*  0 */ { 4, s_9_0, -1, -1, 0},
00184 /*  1 */ { 4, s_9_1, -1, -1, 0}
00185 };
00186 
00187 static const symbol s_10_0[2] = { 'l', 'a' };
00188 static const symbol s_10_1[2] = { 'l', 'e' };
00189 
00190 static const struct among a_10[2] =
00191 {
00192 /*  0 */ { 2, s_10_0, -1, -1, 0},
00193 /*  1 */ { 2, s_10_1, -1, -1, 0}
00194 };
00195 
00196 static const symbol s_11_0[2] = { 'c', 'a' };
00197 static const symbol s_11_1[2] = { 'c', 'e' };
00198 
00199 static const struct among a_11[2] =
00200 {
00201 /*  0 */ { 2, s_11_0, -1, -1, 0},
00202 /*  1 */ { 2, s_11_1, -1, -1, 0}
00203 };
00204 
00205 static const symbol s_12_0[2] = { 'i', 'm' };
00206 static const symbol s_12_1[2] = { 'u', 'm' };
00207 static const symbol s_12_2[3] = { 0xC4, 0xB1, 'm' };
00208 static const symbol s_12_3[3] = { 0xC3, 0xBC, 'm' };
00209 
00210 static const struct among a_12[4] =
00211 {
00212 /*  0 */ { 2, s_12_0, -1, -1, 0},
00213 /*  1 */ { 2, s_12_1, -1, -1, 0},
00214 /*  2 */ { 3, s_12_2, -1, -1, 0},
00215 /*  3 */ { 3, s_12_3, -1, -1, 0}
00216 };
00217 
00218 static const symbol s_13_0[3] = { 's', 'i', 'n' };
00219 static const symbol s_13_1[3] = { 's', 'u', 'n' };
00220 static const symbol s_13_2[4] = { 's', 0xC4, 0xB1, 'n' };
00221 static const symbol s_13_3[4] = { 's', 0xC3, 0xBC, 'n' };
00222 
00223 static const struct among a_13[4] =
00224 {
00225 /*  0 */ { 3, s_13_0, -1, -1, 0},
00226 /*  1 */ { 3, s_13_1, -1, -1, 0},
00227 /*  2 */ { 4, s_13_2, -1, -1, 0},
00228 /*  3 */ { 4, s_13_3, -1, -1, 0}
00229 };
00230 
00231 static const symbol s_14_0[2] = { 'i', 'z' };
00232 static const symbol s_14_1[2] = { 'u', 'z' };
00233 static const symbol s_14_2[3] = { 0xC4, 0xB1, 'z' };
00234 static const symbol s_14_3[3] = { 0xC3, 0xBC, 'z' };
00235 
00236 static const struct among a_14[4] =
00237 {
00238 /*  0 */ { 2, s_14_0, -1, -1, 0},
00239 /*  1 */ { 2, s_14_1, -1, -1, 0},
00240 /*  2 */ { 3, s_14_2, -1, -1, 0},
00241 /*  3 */ { 3, s_14_3, -1, -1, 0}
00242 };
00243 
00244 static const symbol s_15_0[5] = { 's', 'i', 'n', 'i', 'z' };
00245 static const symbol s_15_1[5] = { 's', 'u', 'n', 'u', 'z' };
00246 static const symbol s_15_2[7] = { 's', 0xC4, 0xB1, 'n', 0xC4, 0xB1, 'z' };
00247 static const symbol s_15_3[7] = { 's', 0xC3, 0xBC, 'n', 0xC3, 0xBC, 'z' };
00248 
00249 static const struct among a_15[4] =
00250 {
00251 /*  0 */ { 5, s_15_0, -1, -1, 0},
00252 /*  1 */ { 5, s_15_1, -1, -1, 0},
00253 /*  2 */ { 7, s_15_2, -1, -1, 0},
00254 /*  3 */ { 7, s_15_3, -1, -1, 0}
00255 };
00256 
00257 static const symbol s_16_0[3] = { 'l', 'a', 'r' };
00258 static const symbol s_16_1[3] = { 'l', 'e', 'r' };
00259 
00260 static const struct among a_16[2] =
00261 {
00262 /*  0 */ { 3, s_16_0, -1, -1, 0},
00263 /*  1 */ { 3, s_16_1, -1, -1, 0}
00264 };
00265 
00266 static const symbol s_17_0[3] = { 'n', 'i', 'z' };
00267 static const symbol s_17_1[3] = { 'n', 'u', 'z' };
00268 static const symbol s_17_2[4] = { 'n', 0xC4, 0xB1, 'z' };
00269 static const symbol s_17_3[4] = { 'n', 0xC3, 0xBC, 'z' };
00270 
00271 static const struct among a_17[4] =
00272 {
00273 /*  0 */ { 3, s_17_0, -1, -1, 0},
00274 /*  1 */ { 3, s_17_1, -1, -1, 0},
00275 /*  2 */ { 4, s_17_2, -1, -1, 0},
00276 /*  3 */ { 4, s_17_3, -1, -1, 0}
00277 };
00278 
00279 static const symbol s_18_0[3] = { 'd', 'i', 'r' };
00280 static const symbol s_18_1[3] = { 't', 'i', 'r' };
00281 static const symbol s_18_2[3] = { 'd', 'u', 'r' };
00282 static const symbol s_18_3[3] = { 't', 'u', 'r' };
00283 static const symbol s_18_4[4] = { 'd', 0xC4, 0xB1, 'r' };
00284 static const symbol s_18_5[4] = { 't', 0xC4, 0xB1, 'r' };
00285 static const symbol s_18_6[4] = { 'd', 0xC3, 0xBC, 'r' };
00286 static const symbol s_18_7[4] = { 't', 0xC3, 0xBC, 'r' };
00287 
00288 static const struct among a_18[8] =
00289 {
00290 /*  0 */ { 3, s_18_0, -1, -1, 0},
00291 /*  1 */ { 3, s_18_1, -1, -1, 0},
00292 /*  2 */ { 3, s_18_2, -1, -1, 0},
00293 /*  3 */ { 3, s_18_3, -1, -1, 0},
00294 /*  4 */ { 4, s_18_4, -1, -1, 0},
00295 /*  5 */ { 4, s_18_5, -1, -1, 0},
00296 /*  6 */ { 4, s_18_6, -1, -1, 0},
00297 /*  7 */ { 4, s_18_7, -1, -1, 0}
00298 };
00299 
00300 static const symbol s_19_0[7] = { 'c', 'a', 's', 0xC4, 0xB1, 'n', 'a' };
00301 static const symbol s_19_1[6] = { 'c', 'e', 's', 'i', 'n', 'e' };
00302 
00303 static const struct among a_19[2] =
00304 {
00305 /*  0 */ { 7, s_19_0, -1, -1, 0},
00306 /*  1 */ { 6, s_19_1, -1, -1, 0}
00307 };
00308 
00309 static const symbol s_20_0[2] = { 'd', 'i' };
00310 static const symbol s_20_1[2] = { 't', 'i' };
00311 static const symbol s_20_2[3] = { 'd', 'i', 'k' };
00312 static const symbol s_20_3[3] = { 't', 'i', 'k' };
00313 static const symbol s_20_4[3] = { 'd', 'u', 'k' };
00314 static const symbol s_20_5[3] = { 't', 'u', 'k' };
00315 static const symbol s_20_6[4] = { 'd', 0xC4, 0xB1, 'k' };
00316 static const symbol s_20_7[4] = { 't', 0xC4, 0xB1, 'k' };
00317 static const symbol s_20_8[4] = { 'd', 0xC3, 0xBC, 'k' };
00318 static const symbol s_20_9[4] = { 't', 0xC3, 0xBC, 'k' };
00319 static const symbol s_20_10[3] = { 'd', 'i', 'm' };
00320 static const symbol s_20_11[3] = { 't', 'i', 'm' };
00321 static const symbol s_20_12[3] = { 'd', 'u', 'm' };
00322 static const symbol s_20_13[3] = { 't', 'u', 'm' };
00323 static const symbol s_20_14[4] = { 'd', 0xC4, 0xB1, 'm' };
00324 static const symbol s_20_15[4] = { 't', 0xC4, 0xB1, 'm' };
00325 static const symbol s_20_16[4] = { 'd', 0xC3, 0xBC, 'm' };
00326 static const symbol s_20_17[4] = { 't', 0xC3, 0xBC, 'm' };
00327 static const symbol s_20_18[3] = { 'd', 'i', 'n' };
00328 static const symbol s_20_19[3] = { 't', 'i', 'n' };
00329 static const symbol s_20_20[3] = { 'd', 'u', 'n' };
00330 static const symbol s_20_21[3] = { 't', 'u', 'n' };
00331 static const symbol s_20_22[4] = { 'd', 0xC4, 0xB1, 'n' };
00332 static const symbol s_20_23[4] = { 't', 0xC4, 0xB1, 'n' };
00333 static const symbol s_20_24[4] = { 'd', 0xC3, 0xBC, 'n' };
00334 static const symbol s_20_25[4] = { 't', 0xC3, 0xBC, 'n' };
00335 static const symbol s_20_26[2] = { 'd', 'u' };
00336 static const symbol s_20_27[2] = { 't', 'u' };
00337 static const symbol s_20_28[3] = { 'd', 0xC4, 0xB1 };
00338 static const symbol s_20_29[3] = { 't', 0xC4, 0xB1 };
00339 static const symbol s_20_30[3] = { 'd', 0xC3, 0xBC };
00340 static const symbol s_20_31[3] = { 't', 0xC3, 0xBC };
00341 
00342 static const struct among a_20[32] =
00343 {
00344 /*  0 */ { 2, s_20_0, -1, -1, 0},
00345 /*  1 */ { 2, s_20_1, -1, -1, 0},
00346 /*  2 */ { 3, s_20_2, -1, -1, 0},
00347 /*  3 */ { 3, s_20_3, -1, -1, 0},
00348 /*  4 */ { 3, s_20_4, -1, -1, 0},
00349 /*  5 */ { 3, s_20_5, -1, -1, 0},
00350 /*  6 */ { 4, s_20_6, -1, -1, 0},
00351 /*  7 */ { 4, s_20_7, -1, -1, 0},
00352 /*  8 */ { 4, s_20_8, -1, -1, 0},
00353 /*  9 */ { 4, s_20_9, -1, -1, 0},
00354 /* 10 */ { 3, s_20_10, -1, -1, 0},
00355 /* 11 */ { 3, s_20_11, -1, -1, 0},
00356 /* 12 */ { 3, s_20_12, -1, -1, 0},
00357 /* 13 */ { 3, s_20_13, -1, -1, 0},
00358 /* 14 */ { 4, s_20_14, -1, -1, 0},
00359 /* 15 */ { 4, s_20_15, -1, -1, 0},
00360 /* 16 */ { 4, s_20_16, -1, -1, 0},
00361 /* 17 */ { 4, s_20_17, -1, -1, 0},
00362 /* 18 */ { 3, s_20_18, -1, -1, 0},
00363 /* 19 */ { 3, s_20_19, -1, -1, 0},
00364 /* 20 */ { 3, s_20_20, -1, -1, 0},
00365 /* 21 */ { 3, s_20_21, -1, -1, 0},
00366 /* 22 */ { 4, s_20_22, -1, -1, 0},
00367 /* 23 */ { 4, s_20_23, -1, -1, 0},
00368 /* 24 */ { 4, s_20_24, -1, -1, 0},
00369 /* 25 */ { 4, s_20_25, -1, -1, 0},
00370 /* 26 */ { 2, s_20_26, -1, -1, 0},
00371 /* 27 */ { 2, s_20_27, -1, -1, 0},
00372 /* 28 */ { 3, s_20_28, -1, -1, 0},
00373 /* 29 */ { 3, s_20_29, -1, -1, 0},
00374 /* 30 */ { 3, s_20_30, -1, -1, 0},
00375 /* 31 */ { 3, s_20_31, -1, -1, 0}
00376 };
00377 
00378 static const symbol s_21_0[2] = { 's', 'a' };
00379 static const symbol s_21_1[2] = { 's', 'e' };
00380 static const symbol s_21_2[3] = { 's', 'a', 'k' };
00381 static const symbol s_21_3[3] = { 's', 'e', 'k' };
00382 static const symbol s_21_4[3] = { 's', 'a', 'm' };
00383 static const symbol s_21_5[3] = { 's', 'e', 'm' };
00384 static const symbol s_21_6[3] = { 's', 'a', 'n' };
00385 static const symbol s_21_7[3] = { 's', 'e', 'n' };
00386 
00387 static const struct among a_21[8] =
00388 {
00389 /*  0 */ { 2, s_21_0, -1, -1, 0},
00390 /*  1 */ { 2, s_21_1, -1, -1, 0},
00391 /*  2 */ { 3, s_21_2, -1, -1, 0},
00392 /*  3 */ { 3, s_21_3, -1, -1, 0},
00393 /*  4 */ { 3, s_21_4, -1, -1, 0},
00394 /*  5 */ { 3, s_21_5, -1, -1, 0},
00395 /*  6 */ { 3, s_21_6, -1, -1, 0},
00396 /*  7 */ { 3, s_21_7, -1, -1, 0}
00397 };
00398 
00399 static const symbol s_22_0[4] = { 'm', 'i', 0xC5, 0x9F };
00400 static const symbol s_22_1[4] = { 'm', 'u', 0xC5, 0x9F };
00401 static const symbol s_22_2[5] = { 'm', 0xC4, 0xB1, 0xC5, 0x9F };
00402 static const symbol s_22_3[5] = { 'm', 0xC3, 0xBC, 0xC5, 0x9F };
00403 
00404 static const struct among a_22[4] =
00405 {
00406 /*  0 */ { 4, s_22_0, -1, -1, 0},
00407 /*  1 */ { 4, s_22_1, -1, -1, 0},
00408 /*  2 */ { 5, s_22_2, -1, -1, 0},
00409 /*  3 */ { 5, s_22_3, -1, -1, 0}
00410 };
00411 
00412 static const symbol s_23_0[1] = { 'b' };
00413 static const symbol s_23_1[1] = { 'c' };
00414 static const symbol s_23_2[1] = { 'd' };
00415 static const symbol s_23_3[2] = { 0xC4, 0x9F };
00416 
00417 static const struct among a_23[4] =
00418 {
00419 /*  0 */ { 1, s_23_0, -1, 1, 0},
00420 /*  1 */ { 1, s_23_1, -1, 2, 0},
00421 /*  2 */ { 1, s_23_2, -1, 3, 0},
00422 /*  3 */ { 2, s_23_3, -1, 4, 0}
00423 };
00424 
00425 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 };
00426 
00427 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 };
00428 
00429 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 };
00430 
00431 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 };
00432 
00433 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 };
00434 
00435 static const unsigned char g_vowel4[] = { 17 };
00436 
00437 static const unsigned char g_vowel5[] = { 65 };
00438 
00439 static const unsigned char g_vowel6[] = { 65 };
00440 
00441 static const symbol s_0[] = { 'a' };
00442 static const symbol s_1[] = { 'e' };
00443 static const symbol s_2[] = { 0xC4, 0xB1 };
00444 static const symbol s_3[] = { 'i' };
00445 static const symbol s_4[] = { 'o' };
00446 static const symbol s_5[] = { 0xC3, 0xB6 };
00447 static const symbol s_6[] = { 'u' };
00448 static const symbol s_7[] = { 0xC3, 0xBC };
00449 static const symbol s_8[] = { 'n' };
00450 static const symbol s_9[] = { 'n' };
00451 static const symbol s_10[] = { 's' };
00452 static const symbol s_11[] = { 's' };
00453 static const symbol s_12[] = { 'y' };
00454 static const symbol s_13[] = { 'y' };
00455 static const symbol s_14[] = { 'k', 'i' };
00456 static const symbol s_15[] = { 'k', 'e', 'n' };
00457 static const symbol s_16[] = { 'p' };
00458 static const symbol s_17[] = { 0xC3, 0xA7 };
00459 static const symbol s_18[] = { 't' };
00460 static const symbol s_19[] = { 'k' };
00461 static const symbol s_20[] = { 'd' };
00462 static const symbol s_21[] = { 'g' };
00463 static const symbol s_22[] = { 'a' };
00464 static const symbol s_23[] = { 0xC4, 0xB1 };
00465 static const symbol s_24[] = { 0xC4, 0xB1 };
00466 static const symbol s_25[] = { 'e' };
00467 static const symbol s_26[] = { 'i' };
00468 static const symbol s_27[] = { 'i' };
00469 static const symbol s_28[] = { 'o' };
00470 static const symbol s_29[] = { 'u' };
00471 static const symbol s_30[] = { 'u' };
00472 static const symbol s_31[] = { 0xC3, 0xB6 };
00473 static const symbol s_32[] = { 0xC3, 0xBC };
00474 static const symbol s_33[] = { 0xC3, 0xBC };
00475 static const symbol s_34[] = { 'a', 'd' };
00476 static const symbol s_35[] = { 's', 'o', 'y', 'a', 'd' };
00477 
00478 static int r_check_vowel_harmony(struct SN_env * z) {
00479     {   int m_test = z->l - z->c; /* test, line 112 */
00480         if (out_grouping_b_U(z, g_vowel, 97, 305, 1) < 0) return 0; /* goto */ /* grouping vowel, line 114 */
00481         {   int m1 = z->l - z->c; (void)m1; /* or, line 116 */
00482             if (!(eq_s_b(z, 1, s_0))) goto lab1;
00483             if (out_grouping_b_U(z, g_vowel1, 97, 305, 1) < 0) goto lab1; /* goto */ /* grouping vowel1, line 116 */
00484             goto lab0;
00485         lab1:
00486             z->c = z->l - m1;
00487             if (!(eq_s_b(z, 1, s_1))) goto lab2;
00488             if (out_grouping_b_U(z, g_vowel2, 101, 252, 1) < 0) goto lab2; /* goto */ /* grouping vowel2, line 117 */
00489             goto lab0;
00490         lab2:
00491             z->c = z->l - m1;
00492             if (!(eq_s_b(z, 2, s_2))) goto lab3;
00493             if (out_grouping_b_U(z, g_vowel3, 97, 305, 1) < 0) goto lab3; /* goto */ /* grouping vowel3, line 118 */
00494             goto lab0;
00495         lab3:
00496             z->c = z->l - m1;
00497             if (!(eq_s_b(z, 1, s_3))) goto lab4;
00498             if (out_grouping_b_U(z, g_vowel4, 101, 105, 1) < 0) goto lab4; /* goto */ /* grouping vowel4, line 119 */
00499             goto lab0;
00500         lab4:
00501             z->c = z->l - m1;
00502             if (!(eq_s_b(z, 1, s_4))) goto lab5;
00503             if (out_grouping_b_U(z, g_vowel5, 111, 117, 1) < 0) goto lab5; /* goto */ /* grouping vowel5, line 120 */
00504             goto lab0;
00505         lab5:
00506             z->c = z->l - m1;
00507             if (!(eq_s_b(z, 2, s_5))) goto lab6;
00508             if (out_grouping_b_U(z, g_vowel6, 246, 252, 1) < 0) goto lab6; /* goto */ /* grouping vowel6, line 121 */
00509             goto lab0;
00510         lab6:
00511             z->c = z->l - m1;
00512             if (!(eq_s_b(z, 1, s_6))) goto lab7;
00513             if (out_grouping_b_U(z, g_vowel5, 111, 117, 1) < 0) goto lab7; /* goto */ /* grouping vowel5, line 122 */
00514             goto lab0;
00515         lab7:
00516             z->c = z->l - m1;
00517             if (!(eq_s_b(z, 2, s_7))) return 0;
00518             if (out_grouping_b_U(z, g_vowel6, 246, 252, 1) < 0) return 0; /* goto */ /* grouping vowel6, line 123 */
00519         }
00520     lab0:
00521         z->c = z->l - m_test;
00522     }
00523     return 1;
00524 }
00525 
00526 static int r_mark_suffix_with_optional_n_consonant(struct SN_env * z) {
00527     {   int m1 = z->l - z->c; (void)m1; /* or, line 134 */
00528         {   int m_test = z->l - z->c; /* test, line 133 */
00529             if (!(eq_s_b(z, 1, s_8))) goto lab1;
00530             z->c = z->l - m_test;
00531         }
00532         {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
00533             if (ret < 0) goto lab1;
00534             z->c = ret; /* next, line 133 */
00535         }
00536         {   int m_test = z->l - z->c; /* test, line 133 */
00537             if (in_grouping_b_U(z, g_vowel, 97, 305, 0)) goto lab1;
00538             z->c = z->l - m_test;
00539         }
00540         goto lab0;
00541     lab1:
00542         z->c = z->l - m1;
00543         {   int m2 = z->l - z->c; (void)m2; /* not, line 135 */
00544             {   int m_test = z->l - z->c; /* test, line 135 */
00545                 if (!(eq_s_b(z, 1, s_9))) goto lab2;
00546                 z->c = z->l - m_test;
00547             }
00548             return 0;
00549         lab2:
00550             z->c = z->l - m2;
00551         }
00552         {   int m_test = z->l - z->c; /* test, line 135 */
00553             {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
00554                 if (ret < 0) return 0;
00555                 z->c = ret; /* next, line 135 */
00556             }
00557             {   int m_test = z->l - z->c; /* test, line 135 */
00558                 if (in_grouping_b_U(z, g_vowel, 97, 305, 0)) return 0;
00559                 z->c = z->l - m_test;
00560             }
00561             z->c = z->l - m_test;
00562         }
00563     }
00564 lab0:
00565     return 1;
00566 }
00567 
00568 static int r_mark_suffix_with_optional_s_consonant(struct SN_env * z) {
00569     {   int m1 = z->l - z->c; (void)m1; /* or, line 145 */
00570         {   int m_test = z->l - z->c; /* test, line 144 */
00571             if (!(eq_s_b(z, 1, s_10))) goto lab1;
00572             z->c = z->l - m_test;
00573         }
00574         {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
00575             if (ret < 0) goto lab1;
00576             z->c = ret; /* next, line 144 */
00577         }
00578         {   int m_test = z->l - z->c; /* test, line 144 */
00579             if (in_grouping_b_U(z, g_vowel, 97, 305, 0)) goto lab1;
00580             z->c = z->l - m_test;
00581         }
00582         goto lab0;
00583     lab1:
00584         z->c = z->l - m1;
00585         {   int m2 = z->l - z->c; (void)m2; /* not, line 146 */
00586             {   int m_test = z->l - z->c; /* test, line 146 */
00587                 if (!(eq_s_b(z, 1, s_11))) goto lab2;
00588                 z->c = z->l - m_test;
00589             }
00590             return 0;
00591         lab2:
00592             z->c = z->l - m2;
00593         }
00594         {   int m_test = z->l - z->c; /* test, line 146 */
00595             {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
00596                 if (ret < 0) return 0;
00597                 z->c = ret; /* next, line 146 */
00598             }
00599             {   int m_test = z->l - z->c; /* test, line 146 */
00600                 if (in_grouping_b_U(z, g_vowel, 97, 305, 0)) return 0;
00601                 z->c = z->l - m_test;
00602             }
00603             z->c = z->l - m_test;
00604         }
00605     }
00606 lab0:
00607     return 1;
00608 }
00609 
00610 static int r_mark_suffix_with_optional_y_consonant(struct SN_env * z) {
00611     {   int m1 = z->l - z->c; (void)m1; /* or, line 155 */
00612         {   int m_test = z->l - z->c; /* test, line 154 */
00613             if (!(eq_s_b(z, 1, s_12))) goto lab1;
00614             z->c = z->l - m_test;
00615         }
00616         {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
00617             if (ret < 0) goto lab1;
00618             z->c = ret; /* next, line 154 */
00619         }
00620         {   int m_test = z->l - z->c; /* test, line 154 */
00621             if (in_grouping_b_U(z, g_vowel, 97, 305, 0)) goto lab1;
00622             z->c = z->l - m_test;
00623         }
00624         goto lab0;
00625     lab1:
00626         z->c = z->l - m1;
00627         {   int m2 = z->l - z->c; (void)m2; /* not, line 156 */
00628             {   int m_test = z->l - z->c; /* test, line 156 */
00629                 if (!(eq_s_b(z, 1, s_13))) goto lab2;
00630                 z->c = z->l - m_test;
00631             }
00632             return 0;
00633         lab2:
00634             z->c = z->l - m2;
00635         }
00636         {   int m_test = z->l - z->c; /* test, line 156 */
00637             {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
00638                 if (ret < 0) return 0;
00639                 z->c = ret; /* next, line 156 */
00640             }
00641             {   int m_test = z->l - z->c; /* test, line 156 */
00642                 if (in_grouping_b_U(z, g_vowel, 97, 305, 0)) return 0;
00643                 z->c = z->l - m_test;
00644             }
00645             z->c = z->l - m_test;
00646         }
00647     }
00648 lab0:
00649     return 1;
00650 }
00651 
00652 static int r_mark_suffix_with_optional_U_vowel(struct SN_env * z) {
00653     {   int m1 = z->l - z->c; (void)m1; /* or, line 161 */
00654         {   int m_test = z->l - z->c; /* test, line 160 */
00655             if (in_grouping_b_U(z, g_U, 105, 305, 0)) goto lab1;
00656             z->c = z->l - m_test;
00657         }
00658         {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
00659             if (ret < 0) goto lab1;
00660             z->c = ret; /* next, line 160 */
00661         }
00662         {   int m_test = z->l - z->c; /* test, line 160 */
00663             if (out_grouping_b_U(z, g_vowel, 97, 305, 0)) goto lab1;
00664             z->c = z->l - m_test;
00665         }
00666         goto lab0;
00667     lab1:
00668         z->c = z->l - m1;
00669         {   int m2 = z->l - z->c; (void)m2; /* not, line 162 */
00670             {   int m_test = z->l - z->c; /* test, line 162 */
00671                 if (in_grouping_b_U(z, g_U, 105, 305, 0)) goto lab2;
00672                 z->c = z->l - m_test;
00673             }
00674             return 0;
00675         lab2:
00676             z->c = z->l - m2;
00677         }
00678         {   int m_test = z->l - z->c; /* test, line 162 */
00679             {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
00680                 if (ret < 0) return 0;
00681                 z->c = ret; /* next, line 162 */
00682             }
00683             {   int m_test = z->l - z->c; /* test, line 162 */
00684                 if (out_grouping_b_U(z, g_vowel, 97, 305, 0)) return 0;
00685                 z->c = z->l - m_test;
00686             }
00687             z->c = z->l - m_test;
00688         }
00689     }
00690 lab0:
00691     return 1;
00692 }
00693 
00694 static int r_mark_possessives(struct SN_env * z) {
00695     if (z->c <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((67133440 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0;
00696     if (!(find_among_b(z, a_0, 10))) return 0; /* among, line 167 */
00697     {   int ret = r_mark_suffix_with_optional_U_vowel(z);
00698         if (ret == 0) return 0; /* call mark_suffix_with_optional_U_vowel, line 169 */
00699         if (ret < 0) return ret;
00700     }
00701     return 1;
00702 }
00703 
00704 static int r_mark_sU(struct SN_env * z) {
00705     {   int ret = r_check_vowel_harmony(z);
00706         if (ret == 0) return 0; /* call check_vowel_harmony, line 173 */
00707         if (ret < 0) return ret;
00708     }
00709     if (in_grouping_b_U(z, g_U, 105, 305, 0)) return 0;
00710     {   int ret = r_mark_suffix_with_optional_s_consonant(z);
00711         if (ret == 0) return 0; /* call mark_suffix_with_optional_s_consonant, line 175 */
00712         if (ret < 0) return ret;
00713     }
00714     return 1;
00715 }
00716 
00717 static int r_mark_lArI(struct SN_env * z) {
00718     if (z->c - 3 <= z->lb || (z->p[z->c - 1] != 105 && z->p[z->c - 1] != 177)) return 0;
00719     if (!(find_among_b(z, a_1, 2))) return 0; /* among, line 179 */
00720     return 1;
00721 }
00722 
00723 static int r_mark_yU(struct SN_env * z) {
00724     {   int ret = r_check_vowel_harmony(z);
00725         if (ret == 0) return 0; /* call check_vowel_harmony, line 183 */
00726         if (ret < 0) return ret;
00727     }
00728     if (in_grouping_b_U(z, g_U, 105, 305, 0)) return 0;
00729     {   int ret = r_mark_suffix_with_optional_y_consonant(z);
00730         if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 185 */
00731         if (ret < 0) return ret;
00732     }
00733     return 1;
00734 }
00735 
00736 static int r_mark_nU(struct SN_env * z) {
00737     {   int ret = r_check_vowel_harmony(z);
00738         if (ret == 0) return 0; /* call check_vowel_harmony, line 189 */
00739         if (ret < 0) return ret;
00740     }
00741     if (!(find_among_b(z, a_2, 4))) return 0; /* among, line 190 */
00742     return 1;
00743 }
00744 
00745 static int r_mark_nUn(struct SN_env * z) {
00746     {   int ret = r_check_vowel_harmony(z);
00747         if (ret == 0) return 0; /* call check_vowel_harmony, line 194 */
00748         if (ret < 0) return ret;
00749     }
00750     if (z->c - 1 <= z->lb || z->p[z->c - 1] != 110) return 0;
00751     if (!(find_among_b(z, a_3, 4))) return 0; /* among, line 195 */
00752     {   int ret = r_mark_suffix_with_optional_n_consonant(z);
00753         if (ret == 0) return 0; /* call mark_suffix_with_optional_n_consonant, line 196 */
00754         if (ret < 0) return ret;
00755     }
00756     return 1;
00757 }
00758 
00759 static int r_mark_yA(struct SN_env * z) {
00760     {   int ret = r_check_vowel_harmony(z);
00761         if (ret == 0) return 0; /* call check_vowel_harmony, line 200 */
00762         if (ret < 0) return ret;
00763     }
00764     if (z->c <= z->lb || (z->p[z->c - 1] != 97 && z->p[z->c - 1] != 101)) return 0;
00765     if (!(find_among_b(z, a_4, 2))) return 0; /* among, line 201 */
00766     {   int ret = r_mark_suffix_with_optional_y_consonant(z);
00767         if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 202 */
00768         if (ret < 0) return ret;
00769     }
00770     return 1;
00771 }
00772 
00773 static int r_mark_nA(struct SN_env * z) {
00774     {   int ret = r_check_vowel_harmony(z);
00775         if (ret == 0) return 0; /* call check_vowel_harmony, line 206 */
00776         if (ret < 0) return ret;
00777     }
00778     if (z->c - 1 <= z->lb || (z->p[z->c - 1] != 97 && z->p[z->c - 1] != 101)) return 0;
00779     if (!(find_among_b(z, a_5, 2))) return 0; /* among, line 207 */
00780     return 1;
00781 }
00782 
00783 static int r_mark_DA(struct SN_env * z) {
00784     {   int ret = r_check_vowel_harmony(z);
00785         if (ret == 0) return 0; /* call check_vowel_harmony, line 211 */
00786         if (ret < 0) return ret;
00787     }
00788     if (z->c - 1 <= z->lb || (z->p[z->c - 1] != 97 && z->p[z->c - 1] != 101)) return 0;
00789     if (!(find_among_b(z, a_6, 4))) return 0; /* among, line 212 */
00790     return 1;
00791 }
00792 
00793 static int r_mark_ndA(struct SN_env * z) {
00794     {   int ret = r_check_vowel_harmony(z);
00795         if (ret == 0) return 0; /* call check_vowel_harmony, line 216 */
00796         if (ret < 0) return ret;
00797     }
00798     if (z->c - 2 <= z->lb || (z->p[z->c - 1] != 97 && z->p[z->c - 1] != 101)) return 0;
00799     if (!(find_among_b(z, a_7, 2))) return 0; /* among, line 217 */
00800     return 1;
00801 }
00802 
00803 static int r_mark_DAn(struct SN_env * z) {
00804     {   int ret = r_check_vowel_harmony(z);
00805         if (ret == 0) return 0; /* call check_vowel_harmony, line 221 */
00806         if (ret < 0) return ret;
00807     }
00808     if (z->c - 2 <= z->lb || z->p[z->c - 1] != 110) return 0;
00809     if (!(find_among_b(z, a_8, 4))) return 0; /* among, line 222 */
00810     return 1;
00811 }
00812 
00813 static int r_mark_ndAn(struct SN_env * z) {
00814     {   int ret = r_check_vowel_harmony(z);
00815         if (ret == 0) return 0; /* call check_vowel_harmony, line 226 */
00816         if (ret < 0) return ret;
00817     }
00818     if (z->c - 3 <= z->lb || z->p[z->c - 1] != 110) return 0;
00819     if (!(find_among_b(z, a_9, 2))) return 0; /* among, line 227 */
00820     return 1;
00821 }
00822 
00823 static int r_mark_ylA(struct SN_env * z) {
00824     {   int ret = r_check_vowel_harmony(z);
00825         if (ret == 0) return 0; /* call check_vowel_harmony, line 231 */
00826         if (ret < 0) return ret;
00827     }
00828     if (z->c - 1 <= z->lb || (z->p[z->c - 1] != 97 && z->p[z->c - 1] != 101)) return 0;
00829     if (!(find_among_b(z, a_10, 2))) return 0; /* among, line 232 */
00830     {   int ret = r_mark_suffix_with_optional_y_consonant(z);
00831         if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 233 */
00832         if (ret < 0) return ret;
00833     }
00834     return 1;
00835 }
00836 
00837 static int r_mark_ki(struct SN_env * z) {
00838     if (!(eq_s_b(z, 2, s_14))) return 0;
00839     return 1;
00840 }
00841 
00842 static int r_mark_ncA(struct SN_env * z) {
00843     {   int ret = r_check_vowel_harmony(z);
00844         if (ret == 0) return 0; /* call check_vowel_harmony, line 241 */
00845         if (ret < 0) return ret;
00846     }
00847     if (z->c - 1 <= z->lb || (z->p[z->c - 1] != 97 && z->p[z->c - 1] != 101)) return 0;
00848     if (!(find_among_b(z, a_11, 2))) return 0; /* among, line 242 */
00849     {   int ret = r_mark_suffix_with_optional_n_consonant(z);
00850         if (ret == 0) return 0; /* call mark_suffix_with_optional_n_consonant, line 243 */
00851         if (ret < 0) return ret;
00852     }
00853     return 1;
00854 }
00855 
00856 static int r_mark_yUm(struct SN_env * z) {
00857     {   int ret = r_check_vowel_harmony(z);
00858         if (ret == 0) return 0; /* call check_vowel_harmony, line 247 */
00859         if (ret < 0) return ret;
00860     }
00861     if (z->c - 1 <= z->lb || z->p[z->c - 1] != 109) return 0;
00862     if (!(find_among_b(z, a_12, 4))) return 0; /* among, line 248 */
00863     {   int ret = r_mark_suffix_with_optional_y_consonant(z);
00864         if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 249 */
00865         if (ret < 0) return ret;
00866     }
00867     return 1;
00868 }
00869 
00870 static int r_mark_sUn(struct SN_env * z) {
00871     {   int ret = r_check_vowel_harmony(z);
00872         if (ret == 0) return 0; /* call check_vowel_harmony, line 253 */
00873         if (ret < 0) return ret;
00874     }
00875     if (z->c - 2 <= z->lb || z->p[z->c - 1] != 110) return 0;
00876     if (!(find_among_b(z, a_13, 4))) return 0; /* among, line 254 */
00877     return 1;
00878 }
00879 
00880 static int r_mark_yUz(struct SN_env * z) {
00881     {   int ret = r_check_vowel_harmony(z);
00882         if (ret == 0) return 0; /* call check_vowel_harmony, line 258 */
00883         if (ret < 0) return ret;
00884     }
00885     if (z->c - 1 <= z->lb || z->p[z->c - 1] != 122) return 0;
00886     if (!(find_among_b(z, a_14, 4))) return 0; /* among, line 259 */
00887     {   int ret = r_mark_suffix_with_optional_y_consonant(z);
00888         if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 260 */
00889         if (ret < 0) return ret;
00890     }
00891     return 1;
00892 }
00893 
00894 static int r_mark_sUnUz(struct SN_env * z) {
00895     if (z->c - 4 <= z->lb || z->p[z->c - 1] != 122) return 0;
00896     if (!(find_among_b(z, a_15, 4))) return 0; /* among, line 264 */
00897     return 1;
00898 }
00899 
00900 static int r_mark_lAr(struct SN_env * z) {
00901     {   int ret = r_check_vowel_harmony(z);
00902         if (ret == 0) return 0; /* call check_vowel_harmony, line 268 */
00903         if (ret < 0) return ret;
00904     }
00905     if (z->c - 2 <= z->lb || z->p[z->c - 1] != 114) return 0;
00906     if (!(find_among_b(z, a_16, 2))) return 0; /* among, line 269 */
00907     return 1;
00908 }
00909 
00910 static int r_mark_nUz(struct SN_env * z) {
00911     {   int ret = r_check_vowel_harmony(z);
00912         if (ret == 0) return 0; /* call check_vowel_harmony, line 273 */
00913         if (ret < 0) return ret;
00914     }
00915     if (z->c - 2 <= z->lb || z->p[z->c - 1] != 122) return 0;
00916     if (!(find_among_b(z, a_17, 4))) return 0; /* among, line 274 */
00917     return 1;
00918 }
00919 
00920 static int r_mark_DUr(struct SN_env * z) {
00921     {   int ret = r_check_vowel_harmony(z);
00922         if (ret == 0) return 0; /* call check_vowel_harmony, line 278 */
00923         if (ret < 0) return ret;
00924     }
00925     if (z->c - 2 <= z->lb || z->p[z->c - 1] != 114) return 0;
00926     if (!(find_among_b(z, a_18, 8))) return 0; /* among, line 279 */
00927     return 1;
00928 }
00929 
00930 static int r_mark_cAsInA(struct SN_env * z) {
00931     if (z->c - 5 <= z->lb || (z->p[z->c - 1] != 97 && z->p[z->c - 1] != 101)) return 0;
00932     if (!(find_among_b(z, a_19, 2))) return 0; /* among, line 283 */
00933     return 1;
00934 }
00935 
00936 static int r_mark_yDU(struct SN_env * z) {
00937     {   int ret = r_check_vowel_harmony(z);
00938         if (ret == 0) return 0; /* call check_vowel_harmony, line 287 */
00939         if (ret < 0) return ret;
00940     }
00941     if (!(find_among_b(z, a_20, 32))) return 0; /* among, line 288 */
00942     {   int ret = r_mark_suffix_with_optional_y_consonant(z);
00943         if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 292 */
00944         if (ret < 0) return ret;
00945     }
00946     return 1;
00947 }
00948 
00949 static int r_mark_ysA(struct SN_env * z) {
00950     if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((26658 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0;
00951     if (!(find_among_b(z, a_21, 8))) return 0; /* among, line 297 */
00952     {   int ret = r_mark_suffix_with_optional_y_consonant(z);
00953         if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 298 */
00954         if (ret < 0) return ret;
00955     }
00956     return 1;
00957 }
00958 
00959 static int r_mark_ymUs_(struct SN_env * z) {
00960     {   int ret = r_check_vowel_harmony(z);
00961         if (ret == 0) return 0; /* call check_vowel_harmony, line 302 */
00962         if (ret < 0) return ret;
00963     }
00964     if (z->c - 3 <= z->lb || z->p[z->c - 1] != 159) return 0;
00965     if (!(find_among_b(z, a_22, 4))) return 0; /* among, line 303 */
00966     {   int ret = r_mark_suffix_with_optional_y_consonant(z);
00967         if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 304 */
00968         if (ret < 0) return ret;
00969     }
00970     return 1;
00971 }
00972 
00973 static int r_mark_yken(struct SN_env * z) {
00974     if (!(eq_s_b(z, 3, s_15))) return 0;
00975     {   int ret = r_mark_suffix_with_optional_y_consonant(z);
00976         if (ret == 0) return 0; /* call mark_suffix_with_optional_y_consonant, line 308 */
00977         if (ret < 0) return ret;
00978     }
00979     return 1;
00980 }
00981 
00982 static int r_stem_nominal_verb_suffixes(struct SN_env * z) {
00983     z->ket = z->c; /* [, line 312 */
00984     z->B[0] = 1; /* set continue_stemming_noun_suffixes, line 313 */
00985     {   int m1 = z->l - z->c; (void)m1; /* or, line 315 */
00986         {   int m2 = z->l - z->c; (void)m2; /* or, line 314 */
00987             {   int ret = r_mark_ymUs_(z);
00988                 if (ret == 0) goto lab3; /* call mark_ymUs_, line 314 */
00989                 if (ret < 0) return ret;
00990             }
00991             goto lab2;
00992         lab3:
00993             z->c = z->l - m2;
00994             {   int ret = r_mark_yDU(z);
00995                 if (ret == 0) goto lab4; /* call mark_yDU, line 314 */
00996                 if (ret < 0) return ret;
00997             }
00998             goto lab2;
00999         lab4:
01000             z->c = z->l - m2;
01001             {   int ret = r_mark_ysA(z);
01002                 if (ret == 0) goto lab5; /* call mark_ysA, line 314 */
01003                 if (ret < 0) return ret;
01004             }
01005             goto lab2;
01006         lab5:
01007             z->c = z->l - m2;
01008             {   int ret = r_mark_yken(z);
01009                 if (ret == 0) goto lab1; /* call mark_yken, line 314 */
01010                 if (ret < 0) return ret;
01011             }
01012         }
01013     lab2:
01014         goto lab0;
01015     lab1:
01016         z->c = z->l - m1;
01017         {   int ret = r_mark_cAsInA(z);
01018             if (ret == 0) goto lab6; /* call mark_cAsInA, line 316 */
01019             if (ret < 0) return ret;
01020         }
01021         {   int m3 = z->l - z->c; (void)m3; /* or, line 316 */
01022             {   int ret = r_mark_sUnUz(z);
01023                 if (ret == 0) goto lab8; /* call mark_sUnUz, line 316 */
01024                 if (ret < 0) return ret;
01025             }
01026             goto lab7;
01027         lab8:
01028             z->c = z->l - m3;
01029             {   int ret = r_mark_lAr(z);
01030                 if (ret == 0) goto lab9; /* call mark_lAr, line 316 */
01031                 if (ret < 0) return ret;
01032             }
01033             goto lab7;
01034         lab9:
01035             z->c = z->l - m3;
01036             {   int ret = r_mark_yUm(z);
01037                 if (ret == 0) goto lab10; /* call mark_yUm, line 316 */
01038                 if (ret < 0) return ret;
01039             }
01040             goto lab7;
01041         lab10:
01042             z->c = z->l - m3;
01043             {   int ret = r_mark_sUn(z);
01044                 if (ret == 0) goto lab11; /* call mark_sUn, line 316 */
01045                 if (ret < 0) return ret;
01046             }
01047             goto lab7;
01048         lab11:
01049             z->c = z->l - m3;
01050             {   int ret = r_mark_yUz(z);
01051                 if (ret == 0) goto lab12; /* call mark_yUz, line 316 */
01052                 if (ret < 0) return ret;
01053             }
01054             goto lab7;
01055         lab12:
01056             z->c = z->l - m3;
01057         }
01058     lab7:
01059         {   int ret = r_mark_ymUs_(z);
01060             if (ret == 0) goto lab6; /* call mark_ymUs_, line 316 */
01061             if (ret < 0) return ret;
01062         }
01063         goto lab0;
01064     lab6:
01065         z->c = z->l - m1;
01066         {   int ret = r_mark_lAr(z);
01067             if (ret == 0) goto lab13; /* call mark_lAr, line 319 */
01068             if (ret < 0) return ret;
01069         }
01070         z->bra = z->c; /* ], line 319 */
01071         {   int ret = slice_del(z); /* delete, line 319 */
01072             if (ret < 0) return ret;
01073         }
01074         {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 319 */
01075             z->ket = z->c; /* [, line 319 */
01076             {   int m4 = z->l - z->c; (void)m4; /* or, line 319 */
01077                 {   int ret = r_mark_DUr(z);
01078                     if (ret == 0) goto lab16; /* call mark_DUr, line 319 */
01079                     if (ret < 0) return ret;
01080                 }
01081                 goto lab15;
01082             lab16:
01083                 z->c = z->l - m4;
01084                 {   int ret = r_mark_yDU(z);
01085                     if (ret == 0) goto lab17; /* call mark_yDU, line 319 */
01086                     if (ret < 0) return ret;
01087                 }
01088                 goto lab15;
01089             lab17:
01090                 z->c = z->l - m4;
01091                 {   int ret = r_mark_ysA(z);
01092                     if (ret == 0) goto lab18; /* call mark_ysA, line 319 */
01093                     if (ret < 0) return ret;
01094                 }
01095                 goto lab15;
01096             lab18:
01097                 z->c = z->l - m4;
01098                 {   int ret = r_mark_ymUs_(z);
01099                     if (ret == 0) { z->c = z->l - m_keep; goto lab14; } /* call mark_ymUs_, line 319 */
01100                     if (ret < 0) return ret;
01101                 }
01102             }
01103         lab15:
01104         lab14:
01105             ;
01106         }
01107         z->B[0] = 0; /* unset continue_stemming_noun_suffixes, line 320 */
01108         goto lab0;
01109     lab13:
01110         z->c = z->l - m1;
01111         {   int ret = r_mark_nUz(z);
01112             if (ret == 0) goto lab19; /* call mark_nUz, line 323 */
01113             if (ret < 0) return ret;
01114         }
01115         {   int m5 = z->l - z->c; (void)m5; /* or, line 323 */
01116             {   int ret = r_mark_yDU(z);
01117                 if (ret == 0) goto lab21; /* call mark_yDU, line 323 */
01118                 if (ret < 0) return ret;
01119             }
01120             goto lab20;
01121         lab21:
01122             z->c = z->l - m5;
01123             {   int ret = r_mark_ysA(z);
01124                 if (ret == 0) goto lab19; /* call mark_ysA, line 323 */
01125                 if (ret < 0) return ret;
01126             }
01127         }
01128     lab20:
01129         goto lab0;
01130     lab19:
01131         z->c = z->l - m1;
01132         {   int m6 = z->l - z->c; (void)m6; /* or, line 325 */
01133             {   int ret = r_mark_sUnUz(z);
01134                 if (ret == 0) goto lab24; /* call mark_sUnUz, line 325 */
01135                 if (ret < 0) return ret;
01136             }
01137             goto lab23;
01138         lab24:
01139             z->c = z->l - m6;
01140             {   int ret = r_mark_yUz(z);
01141                 if (ret == 0) goto lab25; /* call mark_yUz, line 325 */
01142                 if (ret < 0) return ret;
01143             }
01144             goto lab23;
01145         lab25:
01146             z->c = z->l - m6;
01147             {   int ret = r_mark_sUn(z);
01148                 if (ret == 0) goto lab26; /* call mark_sUn, line 325 */
01149                 if (ret < 0) return ret;
01150             }
01151             goto lab23;
01152         lab26:
01153             z->c = z->l - m6;
01154             {   int ret = r_mark_yUm(z);
01155                 if (ret == 0) goto lab22; /* call mark_yUm, line 325 */
01156                 if (ret < 0) return ret;
01157             }
01158         }
01159     lab23:
01160         z->bra = z->c; /* ], line 325 */
01161         {   int ret = slice_del(z); /* delete, line 325 */
01162             if (ret < 0) return ret;
01163         }
01164         {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 325 */
01165             z->ket = z->c; /* [, line 325 */
01166             {   int ret = r_mark_ymUs_(z);
01167                 if (ret == 0) { z->c = z->l - m_keep; goto lab27; } /* call mark_ymUs_, line 325 */
01168                 if (ret < 0) return ret;
01169             }
01170         lab27:
01171             ;
01172         }
01173         goto lab0;
01174     lab22:
01175         z->c = z->l - m1;
01176         {   int ret = r_mark_DUr(z);
01177             if (ret == 0) return 0; /* call mark_DUr, line 327 */
01178             if (ret < 0) return ret;
01179         }
01180         z->bra = z->c; /* ], line 327 */
01181         {   int ret = slice_del(z); /* delete, line 327 */
01182             if (ret < 0) return ret;
01183         }
01184         {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 327 */
01185             z->ket = z->c; /* [, line 327 */
01186             {   int m7 = z->l - z->c; (void)m7; /* or, line 327 */
01187                 {   int ret = r_mark_sUnUz(z);
01188                     if (ret == 0) goto lab30; /* call mark_sUnUz, line 327 */
01189                     if (ret < 0) return ret;
01190                 }
01191                 goto lab29;
01192             lab30:
01193                 z->c = z->l - m7;
01194                 {   int ret = r_mark_lAr(z);
01195                     if (ret == 0) goto lab31; /* call mark_lAr, line 327 */
01196                     if (ret < 0) return ret;
01197                 }
01198                 goto lab29;
01199             lab31:
01200                 z->c = z->l - m7;
01201                 {   int ret = r_mark_yUm(z);
01202                     if (ret == 0) goto lab32; /* call mark_yUm, line 327 */
01203                     if (ret < 0) return ret;
01204                 }
01205                 goto lab29;
01206             lab32:
01207                 z->c = z->l - m7;
01208                 {   int ret = r_mark_sUn(z);
01209                     if (ret == 0) goto lab33; /* call mark_sUn, line 327 */
01210                     if (ret < 0) return ret;
01211                 }
01212                 goto lab29;
01213             lab33:
01214                 z->c = z->l - m7;
01215                 {   int ret = r_mark_yUz(z);
01216                     if (ret == 0) goto lab34; /* call mark_yUz, line 327 */
01217                     if (ret < 0) return ret;
01218                 }
01219                 goto lab29;
01220             lab34:
01221                 z->c = z->l - m7;
01222             }
01223         lab29:
01224             {   int ret = r_mark_ymUs_(z);
01225                 if (ret == 0) { z->c = z->l - m_keep; goto lab28; } /* call mark_ymUs_, line 327 */
01226                 if (ret < 0) return ret;
01227             }
01228         lab28:
01229             ;
01230         }
01231     }
01232 lab0:
01233     z->bra = z->c; /* ], line 328 */
01234     {   int ret = slice_del(z); /* delete, line 328 */
01235         if (ret < 0) return ret;
01236     }
01237     return 1;
01238 }
01239 
01240 static int r_stem_suffix_chain_before_ki(struct SN_env * z) {
01241     z->ket = z->c; /* [, line 333 */
01242     {   int ret = r_mark_ki(z);
01243         if (ret == 0) return 0; /* call mark_ki, line 334 */
01244         if (ret < 0) return ret;
01245     }
01246     {   int m1 = z->l - z->c; (void)m1; /* or, line 342 */
01247         {   int ret = r_mark_DA(z);
01248             if (ret == 0) goto lab1; /* call mark_DA, line 336 */
01249             if (ret < 0) return ret;
01250         }
01251         z->bra = z->c; /* ], line 336 */
01252         {   int ret = slice_del(z); /* delete, line 336 */
01253             if (ret < 0) return ret;
01254         }
01255         {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 336 */
01256             z->ket = z->c; /* [, line 336 */
01257             {   int m2 = z->l - z->c; (void)m2; /* or, line 338 */
01258                 {   int ret = r_mark_lAr(z);
01259                     if (ret == 0) goto lab4; /* call mark_lAr, line 337 */
01260                     if (ret < 0) return ret;
01261                 }
01262                 z->bra = z->c; /* ], line 337 */
01263                 {   int ret = slice_del(z); /* delete, line 337 */
01264                     if (ret < 0) return ret;
01265                 }
01266                 {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 337 */
01267                     {   int ret = r_stem_suffix_chain_before_ki(z);
01268                         if (ret == 0) { z->c = z->l - m_keep; goto lab5; } /* call stem_suffix_chain_before_ki, line 337 */
01269                         if (ret < 0) return ret;
01270                     }
01271                 lab5:
01272                     ;
01273                 }
01274                 goto lab3;
01275             lab4:
01276                 z->c = z->l - m2;
01277                 {   int ret = r_mark_possessives(z);
01278                     if (ret == 0) { z->c = z->l - m_keep; goto lab2; } /* call mark_possessives, line 339 */
01279                     if (ret < 0) return ret;
01280                 }
01281                 z->bra = z->c; /* ], line 339 */
01282                 {   int ret = slice_del(z); /* delete, line 339 */
01283                     if (ret < 0) return ret;
01284                 }
01285                 {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 339 */
01286                     z->ket = z->c; /* [, line 339 */
01287                     {   int ret = r_mark_lAr(z);
01288                         if (ret == 0) { z->c = z->l - m_keep; goto lab6; } /* call mark_lAr, line 339 */
01289                         if (ret < 0) return ret;
01290                     }
01291                     z->bra = z->c; /* ], line 339 */
01292                     {   int ret = slice_del(z); /* delete, line 339 */
01293                         if (ret < 0) return ret;
01294                     }
01295                     {   int ret = r_stem_suffix_chain_before_ki(z);
01296                         if (ret == 0) { z->c = z->l - m_keep; goto lab6; } /* call stem_suffix_chain_before_ki, line 339 */
01297                         if (ret < 0) return ret;
01298                     }
01299                 lab6:
01300                     ;
01301                 }
01302             }
01303         lab3:
01304         lab2:
01305             ;
01306         }
01307         goto lab0;
01308     lab1:
01309         z->c = z->l - m1;
01310         {   int ret = r_mark_nUn(z);
01311             if (ret == 0) goto lab7; /* call mark_nUn, line 343 */
01312             if (ret < 0) return ret;
01313         }
01314         z->bra = z->c; /* ], line 343 */
01315         {   int ret = slice_del(z); /* delete, line 343 */
01316             if (ret < 0) return ret;
01317         }
01318         {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 343 */
01319             z->ket = z->c; /* [, line 343 */
01320             {   int m3 = z->l - z->c; (void)m3; /* or, line 345 */
01321                 {   int ret = r_mark_lArI(z);
01322                     if (ret == 0) goto lab10; /* call mark_lArI, line 344 */
01323                     if (ret < 0) return ret;
01324                 }
01325                 z->bra = z->c; /* ], line 344 */
01326                 {   int ret = slice_del(z); /* delete, line 344 */
01327                     if (ret < 0) return ret;
01328                 }
01329                 goto lab9;
01330             lab10:
01331                 z->c = z->l - m3;
01332                 z->ket = z->c; /* [, line 346 */
01333                 {   int m4 = z->l - z->c; (void)m4; /* or, line 346 */
01334                     {   int ret = r_mark_possessives(z);
01335                         if (ret == 0) goto lab13; /* call mark_possessives, line 346 */
01336                         if (ret < 0) return ret;
01337                     }
01338                     goto lab12;
01339                 lab13:
01340                     z->c = z->l - m4;
01341                     {   int ret = r_mark_sU(z);
01342                         if (ret == 0) goto lab11; /* call mark_sU, line 346 */
01343                         if (ret < 0) return ret;
01344                     }
01345                 }
01346             lab12:
01347                 z->bra = z->c; /* ], line 346 */
01348                 {   int ret = slice_del(z); /* delete, line 346 */
01349                     if (ret < 0) return ret;
01350                 }
01351                 {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 346 */
01352                     z->ket = z->c; /* [, line 346 */
01353                     {   int ret = r_mark_lAr(z);
01354                         if (ret == 0) { z->c = z->l - m_keep; goto lab14; } /* call mark_lAr, line 346 */
01355                         if (ret < 0) return ret;
01356                     }
01357                     z->bra = z->c; /* ], line 346 */
01358                     {   int ret = slice_del(z); /* delete, line 346 */
01359                         if (ret < 0) return ret;
01360                     }
01361                     {   int ret = r_stem_suffix_chain_before_ki(z);
01362                         if (ret == 0) { z->c = z->l - m_keep; goto lab14; } /* call stem_suffix_chain_before_ki, line 346 */
01363                         if (ret < 0) return ret;
01364                     }
01365                 lab14:
01366                     ;
01367                 }
01368                 goto lab9;
01369             lab11:
01370                 z->c = z->l - m3;
01371                 {   int ret = r_stem_suffix_chain_before_ki(z);
01372                     if (ret == 0) { z->c = z->l - m_keep; goto lab8; } /* call stem_suffix_chain_before_ki, line 348 */
01373                     if (ret < 0) return ret;
01374                 }
01375             }
01376         lab9:
01377         lab8:
01378             ;
01379         }
01380         goto lab0;
01381     lab7:
01382         z->c = z->l - m1;
01383         {   int ret = r_mark_ndA(z);
01384             if (ret == 0) return 0; /* call mark_ndA, line 351 */
01385             if (ret < 0) return ret;
01386         }
01387         {   int m5 = z->l - z->c; (void)m5; /* or, line 353 */
01388             {   int ret = r_mark_lArI(z);
01389                 if (ret == 0) goto lab16; /* call mark_lArI, line 352 */
01390                 if (ret < 0) return ret;
01391             }
01392             z->bra = z->c; /* ], line 352 */
01393             {   int ret = slice_del(z); /* delete, line 352 */
01394                 if (ret < 0) return ret;
01395             }
01396             goto lab15;
01397         lab16:
01398             z->c = z->l - m5;
01399             {   int ret = r_mark_sU(z);
01400                 if (ret == 0) goto lab17; /* call mark_sU, line 354 */
01401                 if (ret < 0) return ret;
01402             }
01403             z->bra = z->c; /* ], line 354 */
01404             {   int ret = slice_del(z); /* delete, line 354 */
01405                 if (ret < 0) return ret;
01406             }
01407             {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 354 */
01408                 z->ket = z->c; /* [, line 354 */
01409                 {   int ret = r_mark_lAr(z);
01410                     if (ret == 0) { z->c = z->l - m_keep; goto lab18; } /* call mark_lAr, line 354 */
01411                     if (ret < 0) return ret;
01412                 }
01413                 z->bra = z->c; /* ], line 354 */
01414                 {   int ret = slice_del(z); /* delete, line 354 */
01415                     if (ret < 0) return ret;
01416                 }
01417                 {   int ret = r_stem_suffix_chain_before_ki(z);
01418                     if (ret == 0) { z->c = z->l - m_keep; goto lab18; } /* call stem_suffix_chain_before_ki, line 354 */
01419                     if (ret < 0) return ret;
01420                 }
01421             lab18:
01422                 ;
01423             }
01424             goto lab15;
01425         lab17:
01426             z->c = z->l - m5;
01427             {   int ret = r_stem_suffix_chain_before_ki(z);
01428                 if (ret == 0) return 0; /* call stem_suffix_chain_before_ki, line 356 */
01429                 if (ret < 0) return ret;
01430             }
01431         }
01432     lab15:
01433         ;
01434     }
01435 lab0:
01436     return 1;
01437 }
01438 
01439 static int r_stem_noun_suffixes(struct SN_env * z) {
01440     {   int m1 = z->l - z->c; (void)m1; /* or, line 363 */
01441         z->ket = z->c; /* [, line 362 */
01442         {   int ret = r_mark_lAr(z);
01443             if (ret == 0) goto lab1; /* call mark_lAr, line 362 */
01444             if (ret < 0) return ret;
01445         }
01446         z->bra = z->c; /* ], line 362 */
01447         {   int ret = slice_del(z); /* delete, line 362 */
01448             if (ret < 0) return ret;
01449         }
01450         {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 362 */
01451             {   int ret = r_stem_suffix_chain_before_ki(z);
01452                 if (ret == 0) { z->c = z->l - m_keep; goto lab2; } /* call stem_suffix_chain_before_ki, line 362 */
01453                 if (ret < 0) return ret;
01454             }
01455         lab2:
01456             ;
01457         }
01458         goto lab0;
01459     lab1:
01460         z->c = z->l - m1;
01461         z->ket = z->c; /* [, line 364 */
01462         {   int ret = r_mark_ncA(z);
01463             if (ret == 0) goto lab3; /* call mark_ncA, line 364 */
01464             if (ret < 0) return ret;
01465         }
01466         z->bra = z->c; /* ], line 364 */
01467         {   int ret = slice_del(z); /* delete, line 364 */
01468             if (ret < 0) return ret;
01469         }
01470         {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 365 */
01471             {   int m2 = z->l - z->c; (void)m2; /* or, line 367 */
01472                 z->ket = z->c; /* [, line 366 */
01473                 {   int ret = r_mark_lArI(z);
01474                     if (ret == 0) goto lab6; /* call mark_lArI, line 366 */
01475                     if (ret < 0) return ret;
01476                 }
01477                 z->bra = z->c; /* ], line 366 */
01478                 {   int ret = slice_del(z); /* delete, line 366 */
01479                     if (ret < 0) return ret;
01480                 }
01481                 goto lab5;
01482             lab6:
01483                 z->c = z->l - m2;
01484                 z->ket = z->c; /* [, line 368 */
01485                 {   int m3 = z->l - z->c; (void)m3; /* or, line 368 */
01486                     {   int ret = r_mark_possessives(z);
01487                         if (ret == 0) goto lab9; /* call mark_possessives, line 368 */
01488                         if (ret < 0) return ret;
01489                     }
01490                     goto lab8;
01491                 lab9:
01492                     z->c = z->l - m3;
01493                     {   int ret = r_mark_sU(z);
01494                         if (ret == 0) goto lab7; /* call mark_sU, line 368 */
01495                         if (ret < 0) return ret;
01496                     }
01497                 }
01498             lab8:
01499                 z->bra = z->c; /* ], line 368 */
01500                 {   int ret = slice_del(z); /* delete, line 368 */
01501                     if (ret < 0) return ret;
01502                 }
01503                 {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 368 */
01504                     z->ket = z->c; /* [, line 368 */
01505                     {   int ret = r_mark_lAr(z);
01506                         if (ret == 0) { z->c = z->l - m_keep; goto lab10; } /* call mark_lAr, line 368 */
01507                         if (ret < 0) return ret;
01508                     }
01509                     z->bra = z->c; /* ], line 368 */
01510                     {   int ret = slice_del(z); /* delete, line 368 */
01511                         if (ret < 0) return ret;
01512                     }
01513                     {   int ret = r_stem_suffix_chain_before_ki(z);
01514                         if (ret == 0) { z->c = z->l - m_keep; goto lab10; } /* call stem_suffix_chain_before_ki, line 368 */
01515                         if (ret < 0) return ret;
01516                     }
01517                 lab10:
01518                     ;
01519                 }
01520                 goto lab5;
01521             lab7:
01522                 z->c = z->l - m2;
01523                 z->ket = z->c; /* [, line 370 */
01524                 {   int ret = r_mark_lAr(z);
01525                     if (ret == 0) { z->c = z->l - m_keep; goto lab4; } /* call mark_lAr, line 370 */
01526                     if (ret < 0) return ret;
01527                 }
01528                 z->bra = z->c; /* ], line 370 */
01529                 {   int ret = slice_del(z); /* delete, line 370 */
01530                     if (ret < 0) return ret;
01531                 }
01532                 {   int ret = r_stem_suffix_chain_before_ki(z);
01533                     if (ret == 0) { z->c = z->l - m_keep; goto lab4; } /* call stem_suffix_chain_before_ki, line 370 */
01534                     if (ret < 0) return ret;
01535                 }
01536             }
01537         lab5:
01538         lab4:
01539             ;
01540         }
01541         goto lab0;
01542     lab3:
01543         z->c = z->l - m1;
01544         z->ket = z->c; /* [, line 374 */
01545         {   int m4 = z->l - z->c; (void)m4; /* or, line 374 */
01546             {   int ret = r_mark_ndA(z);
01547                 if (ret == 0) goto lab13; /* call mark_ndA, line 374 */
01548                 if (ret < 0) return ret;
01549             }
01550             goto lab12;
01551         lab13:
01552             z->c = z->l - m4;
01553             {   int ret = r_mark_nA(z);
01554                 if (ret == 0) goto lab11; /* call mark_nA, line 374 */
01555                 if (ret < 0) return ret;
01556             }
01557         }
01558     lab12:
01559         {   int m5 = z->l - z->c; (void)m5; /* or, line 377 */
01560             {   int ret = r_mark_lArI(z);
01561                 if (ret == 0) goto lab15; /* call mark_lArI, line 376 */
01562                 if (ret < 0) return ret;
01563             }
01564             z->bra = z->c; /* ], line 376 */
01565             {   int ret = slice_del(z); /* delete, line 376 */
01566                 if (ret < 0) return ret;
01567             }
01568             goto lab14;
01569         lab15:
01570             z->c = z->l - m5;
01571             {   int ret = r_mark_sU(z);
01572                 if (ret == 0) goto lab16; /* call mark_sU, line 378 */
01573                 if (ret < 0) return ret;
01574             }
01575             z->bra = z->c; /* ], line 378 */
01576             {   int ret = slice_del(z); /* delete, line 378 */
01577                 if (ret < 0) return ret;
01578             }
01579             {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 378 */
01580                 z->ket = z->c; /* [, line 378 */
01581                 {   int ret = r_mark_lAr(z);
01582                     if (ret == 0) { z->c = z->l - m_keep; goto lab17; } /* call mark_lAr, line 378 */
01583                     if (ret < 0) return ret;
01584                 }
01585                 z->bra = z->c; /* ], line 378 */
01586                 {   int ret = slice_del(z); /* delete, line 378 */
01587                     if (ret < 0) return ret;
01588                 }
01589                 {   int ret = r_stem_suffix_chain_before_ki(z);
01590                     if (ret == 0) { z->c = z->l - m_keep; goto lab17; } /* call stem_suffix_chain_before_ki, line 378 */
01591                     if (ret < 0) return ret;
01592                 }
01593             lab17:
01594                 ;
01595             }
01596             goto lab14;
01597         lab16:
01598             z->c = z->l - m5;
01599             {   int ret = r_stem_suffix_chain_before_ki(z);
01600                 if (ret == 0) goto lab11; /* call stem_suffix_chain_before_ki, line 380 */
01601                 if (ret < 0) return ret;
01602             }
01603         }
01604     lab14:
01605         goto lab0;
01606     lab11:
01607         z->c = z->l - m1;
01608         z->ket = z->c; /* [, line 384 */
01609         {   int m6 = z->l - z->c; (void)m6; /* or, line 384 */
01610             {   int ret = r_mark_ndAn(z);
01611                 if (ret == 0) goto lab20; /* call mark_ndAn, line 384 */
01612                 if (ret < 0) return ret;
01613             }
01614             goto lab19;
01615         lab20:
01616             z->c = z->l - m6;
01617             {   int ret = r_mark_nU(z);
01618                 if (ret == 0) goto lab18; /* call mark_nU, line 384 */
01619                 if (ret < 0) return ret;
01620             }
01621         }
01622     lab19:
01623         {   int m7 = z->l - z->c; (void)m7; /* or, line 384 */
01624             {   int ret = r_mark_sU(z);
01625                 if (ret == 0) goto lab22; /* call mark_sU, line 384 */
01626                 if (ret < 0) return ret;
01627             }
01628             z->bra = z->c; /* ], line 384 */
01629             {   int ret = slice_del(z); /* delete, line 384 */
01630                 if (ret < 0) return ret;
01631             }
01632             {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 384 */
01633                 z->ket = z->c; /* [, line 384 */
01634                 {   int ret = r_mark_lAr(z);
01635                     if (ret == 0) { z->c = z->l - m_keep; goto lab23; } /* call mark_lAr, line 384 */
01636                     if (ret < 0) return ret;
01637                 }
01638                 z->bra = z->c; /* ], line 384 */
01639                 {   int ret = slice_del(z); /* delete, line 384 */
01640                     if (ret < 0) return ret;
01641                 }
01642                 {   int ret = r_stem_suffix_chain_before_ki(z);
01643                     if (ret == 0) { z->c = z->l - m_keep; goto lab23; } /* call stem_suffix_chain_before_ki, line 384 */
01644                     if (ret < 0) return ret;
01645                 }
01646             lab23:
01647                 ;
01648             }
01649             goto lab21;
01650         lab22:
01651             z->c = z->l - m7;
01652             {   int ret = r_mark_lArI(z);
01653                 if (ret == 0) goto lab18; /* call mark_lArI, line 384 */
01654                 if (ret < 0) return ret;
01655             }
01656         }
01657     lab21:
01658         goto lab0;
01659     lab18:
01660         z->c = z->l - m1;
01661         z->ket = z->c; /* [, line 386 */
01662         {   int ret = r_mark_DAn(z);
01663             if (ret == 0) goto lab24; /* call mark_DAn, line 386 */
01664             if (ret < 0) return ret;
01665         }
01666         z->bra = z->c; /* ], line 386 */
01667         {   int ret = slice_del(z); /* delete, line 386 */
01668             if (ret < 0) return ret;
01669         }
01670         {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 386 */
01671             z->ket = z->c; /* [, line 386 */
01672             {   int m8 = z->l - z->c; (void)m8; /* or, line 389 */
01673                 {   int ret = r_mark_possessives(z);
01674                     if (ret == 0) goto lab27; /* call mark_possessives, line 388 */
01675                     if (ret < 0) return ret;
01676                 }
01677                 z->bra = z->c; /* ], line 388 */
01678                 {   int ret = slice_del(z); /* delete, line 388 */
01679                     if (ret < 0) return ret;
01680                 }
01681                 {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 388 */
01682                     z->ket = z->c; /* [, line 388 */
01683                     {   int ret = r_mark_lAr(z);
01684                         if (ret == 0) { z->c = z->l - m_keep; goto lab28; } /* call mark_lAr, line 388 */
01685                         if (ret < 0) return ret;
01686                     }
01687                     z->bra = z->c; /* ], line 388 */
01688                     {   int ret = slice_del(z); /* delete, line 388 */
01689                         if (ret < 0) return ret;
01690                     }
01691                     {   int ret = r_stem_suffix_chain_before_ki(z);
01692                         if (ret == 0) { z->c = z->l - m_keep; goto lab28; } /* call stem_suffix_chain_before_ki, line 388 */
01693                         if (ret < 0) return ret;
01694                     }
01695                 lab28:
01696                     ;
01697                 }
01698                 goto lab26;
01699             lab27:
01700                 z->c = z->l - m8;
01701                 {   int ret = r_mark_lAr(z);
01702                     if (ret == 0) goto lab29; /* call mark_lAr, line 390 */
01703                     if (ret < 0) return ret;
01704                 }
01705                 z->bra = z->c; /* ], line 390 */
01706                 {   int ret = slice_del(z); /* delete, line 390 */
01707                     if (ret < 0) return ret;
01708                 }
01709                 {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 390 */
01710                     {   int ret = r_stem_suffix_chain_before_ki(z);
01711                         if (ret == 0) { z->c = z->l - m_keep; goto lab30; } /* call stem_suffix_chain_before_ki, line 390 */
01712                         if (ret < 0) return ret;
01713                     }
01714                 lab30:
01715                     ;
01716                 }
01717                 goto lab26;
01718             lab29:
01719                 z->c = z->l - m8;
01720                 {   int ret = r_stem_suffix_chain_before_ki(z);
01721                     if (ret == 0) { z->c = z->l - m_keep; goto lab25; } /* call stem_suffix_chain_before_ki, line 392 */
01722                     if (ret < 0) return ret;
01723                 }
01724             }
01725         lab26:
01726         lab25:
01727             ;
01728         }
01729         goto lab0;
01730     lab24:
01731         z->c = z->l - m1;
01732         z->ket = z->c; /* [, line 396 */
01733         {   int m9 = z->l - z->c; (void)m9; /* or, line 396 */
01734             {   int ret = r_mark_nUn(z);
01735                 if (ret == 0) goto lab33; /* call mark_nUn, line 396 */
01736                 if (ret < 0) return ret;
01737             }
01738             goto lab32;
01739         lab33:
01740             z->c = z->l - m9;
01741             {   int ret = r_mark_ylA(z);
01742                 if (ret == 0) goto lab31; /* call mark_ylA, line 396 */
01743                 if (ret < 0) return ret;
01744             }
01745         }
01746     lab32:
01747         z->bra = z->c; /* ], line 396 */
01748         {   int ret = slice_del(z); /* delete, line 396 */
01749             if (ret < 0) return ret;
01750         }
01751         {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 397 */
01752             {   int m10 = z->l - z->c; (void)m10; /* or, line 399 */
01753                 z->ket = z->c; /* [, line 398 */
01754                 {   int ret = r_mark_lAr(z);
01755                     if (ret == 0) goto lab36; /* call mark_lAr, line 398 */
01756                     if (ret < 0) return ret;
01757                 }
01758                 z->bra = z->c; /* ], line 398 */
01759                 {   int ret = slice_del(z); /* delete, line 398 */
01760                     if (ret < 0) return ret;
01761                 }
01762                 {   int ret = r_stem_suffix_chain_before_ki(z);
01763                     if (ret == 0) goto lab36; /* call stem_suffix_chain_before_ki, line 398 */
01764                     if (ret < 0) return ret;
01765                 }
01766                 goto lab35;
01767             lab36:
01768                 z->c = z->l - m10;
01769                 z->ket = z->c; /* [, line 400 */
01770                 {   int m11 = z->l - z->c; (void)m11; /* or, line 400 */
01771                     {   int ret = r_mark_possessives(z);
01772                         if (ret == 0) goto lab39; /* call mark_possessives, line 400 */
01773                         if (ret < 0) return ret;
01774                     }
01775                     goto lab38;
01776                 lab39:
01777                     z->c = z->l - m11;
01778                     {   int ret = r_mark_sU(z);
01779                         if (ret == 0) goto lab37; /* call mark_sU, line 400 */
01780                         if (ret < 0) return ret;
01781                     }
01782                 }
01783             lab38:
01784                 z->bra = z->c; /* ], line 400 */
01785                 {   int ret = slice_del(z); /* delete, line 400 */
01786                     if (ret < 0) return ret;
01787                 }
01788                 {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 400 */
01789                     z->ket = z->c; /* [, line 400 */
01790                     {   int ret = r_mark_lAr(z);
01791                         if (ret == 0) { z->c = z->l - m_keep; goto lab40; } /* call mark_lAr, line 400 */
01792                         if (ret < 0) return ret;
01793                     }
01794                     z->bra = z->c; /* ], line 400 */
01795                     {   int ret = slice_del(z); /* delete, line 400 */
01796                         if (ret < 0) return ret;
01797                     }
01798                     {   int ret = r_stem_suffix_chain_before_ki(z);
01799                         if (ret == 0) { z->c = z->l - m_keep; goto lab40; } /* call stem_suffix_chain_before_ki, line 400 */
01800                         if (ret < 0) return ret;
01801                     }
01802                 lab40:
01803                     ;
01804                 }
01805                 goto lab35;
01806             lab37:
01807                 z->c = z->l - m10;
01808                 {   int ret = r_stem_suffix_chain_before_ki(z);
01809                     if (ret == 0) { z->c = z->l - m_keep; goto lab34; } /* call stem_suffix_chain_before_ki, line 402 */
01810                     if (ret < 0) return ret;
01811                 }
01812             }
01813         lab35:
01814         lab34:
01815             ;
01816         }
01817         goto lab0;
01818     lab31:
01819         z->c = z->l - m1;
01820         z->ket = z->c; /* [, line 406 */
01821         {   int ret = r_mark_lArI(z);
01822             if (ret == 0) goto lab41; /* call mark_lArI, line 406 */
01823             if (ret < 0) return ret;
01824         }
01825         z->bra = z->c; /* ], line 406 */
01826         {   int ret = slice_del(z); /* delete, line 406 */
01827             if (ret < 0) return ret;
01828         }
01829         goto lab0;
01830     lab41:
01831         z->c = z->l - m1;
01832         {   int ret = r_stem_suffix_chain_before_ki(z);
01833             if (ret == 0) goto lab42; /* call stem_suffix_chain_before_ki, line 408 */
01834             if (ret < 0) return ret;
01835         }
01836         goto lab0;
01837     lab42:
01838         z->c = z->l - m1;
01839         z->ket = z->c; /* [, line 410 */
01840         {   int m12 = z->l - z->c; (void)m12; /* or, line 410 */
01841             {   int ret = r_mark_DA(z);
01842                 if (ret == 0) goto lab45; /* call mark_DA, line 410 */
01843                 if (ret < 0) return ret;
01844             }
01845             goto lab44;
01846         lab45:
01847             z->c = z->l - m12;
01848             {   int ret = r_mark_yU(z);
01849                 if (ret == 0) goto lab46; /* call mark_yU, line 410 */
01850                 if (ret < 0) return ret;
01851             }
01852             goto lab44;
01853         lab46:
01854             z->c = z->l - m12;
01855             {   int ret = r_mark_yA(z);
01856                 if (ret == 0) goto lab43; /* call mark_yA, line 410 */
01857                 if (ret < 0) return ret;
01858             }
01859         }
01860     lab44:
01861         z->bra = z->c; /* ], line 410 */
01862         {   int ret = slice_del(z); /* delete, line 410 */
01863             if (ret < 0) return ret;
01864         }
01865         {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 410 */
01866             z->ket = z->c; /* [, line 410 */
01867             {   int m13 = z->l - z->c; (void)m13; /* or, line 410 */
01868                 {   int ret = r_mark_possessives(z);
01869                     if (ret == 0) goto lab49; /* call mark_possessives, line 410 */
01870                     if (ret < 0) return ret;
01871                 }
01872                 z->bra = z->c; /* ], line 410 */
01873                 {   int ret = slice_del(z); /* delete, line 410 */
01874                     if (ret < 0) return ret;
01875                 }
01876                 {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 410 */
01877                     z->ket = z->c; /* [, line 410 */
01878                     {   int ret = r_mark_lAr(z);
01879                         if (ret == 0) { z->c = z->l - m_keep; goto lab50; } /* call mark_lAr, line 410 */
01880                         if (ret < 0) return ret;
01881                     }
01882                 lab50:
01883                     ;
01884                 }
01885                 goto lab48;
01886             lab49:
01887                 z->c = z->l - m13;
01888                 {   int ret = r_mark_lAr(z);
01889                     if (ret == 0) { z->c = z->l - m_keep; goto lab47; } /* call mark_lAr, line 410 */
01890                     if (ret < 0) return ret;
01891                 }
01892             }
01893         lab48:
01894             z->bra = z->c; /* ], line 410 */
01895             {   int ret = slice_del(z); /* delete, line 410 */
01896                 if (ret < 0) return ret;
01897             }
01898             z->ket = z->c; /* [, line 410 */
01899             {   int ret = r_stem_suffix_chain_before_ki(z);
01900                 if (ret == 0) { z->c = z->l - m_keep; goto lab47; } /* call stem_suffix_chain_before_ki, line 410 */
01901                 if (ret < 0) return ret;
01902             }
01903         lab47:
01904             ;
01905         }
01906         goto lab0;
01907     lab43:
01908         z->c = z->l - m1;
01909         z->ket = z->c; /* [, line 412 */
01910         {   int m14 = z->l - z->c; (void)m14; /* or, line 412 */
01911             {   int ret = r_mark_possessives(z);
01912                 if (ret == 0) goto lab52; /* call mark_possessives, line 412 */
01913                 if (ret < 0) return ret;
01914             }
01915             goto lab51;
01916         lab52:
01917             z->c = z->l - m14;
01918             {   int ret = r_mark_sU(z);
01919                 if (ret == 0) return 0; /* call mark_sU, line 412 */
01920                 if (ret < 0) return ret;
01921             }
01922         }
01923     lab51:
01924         z->bra = z->c; /* ], line 412 */
01925         {   int ret = slice_del(z); /* delete, line 412 */
01926             if (ret < 0) return ret;
01927         }
01928         {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 412 */
01929             z->ket = z->c; /* [, line 412 */
01930             {   int ret = r_mark_lAr(z);
01931                 if (ret == 0) { z->c = z->l - m_keep; goto lab53; } /* call mark_lAr, line 412 */
01932                 if (ret < 0) return ret;
01933             }
01934             z->bra = z->c; /* ], line 412 */
01935             {   int ret = slice_del(z); /* delete, line 412 */
01936                 if (ret < 0) return ret;
01937             }
01938             {   int ret = r_stem_suffix_chain_before_ki(z);
01939                 if (ret == 0) { z->c = z->l - m_keep; goto lab53; } /* call stem_suffix_chain_before_ki, line 412 */
01940                 if (ret < 0) return ret;
01941             }
01942         lab53:
01943             ;
01944         }
01945     }
01946 lab0:
01947     return 1;
01948 }
01949 
01950 static int r_post_process_last_consonants(struct SN_env * z) {
01951     int among_var;
01952     z->ket = z->c; /* [, line 416 */
01953     among_var = find_among_b(z, a_23, 4); /* substring, line 416 */
01954     if (!(among_var)) return 0;
01955     z->bra = z->c; /* ], line 416 */
01956     switch(among_var) {
01957         case 0: return 0;
01958         case 1:
01959             {   int ret = slice_from_s(z, 1, s_16); /* <-, line 417 */
01960                 if (ret < 0) return ret;
01961             }
01962             break;
01963         case 2:
01964             {   int ret = slice_from_s(z, 2, s_17); /* <-, line 418 */
01965                 if (ret < 0) return ret;
01966             }
01967             break;
01968         case 3:
01969             {   int ret = slice_from_s(z, 1, s_18); /* <-, line 419 */
01970                 if (ret < 0) return ret;
01971             }
01972             break;
01973         case 4:
01974             {   int ret = slice_from_s(z, 1, s_19); /* <-, line 420 */
01975                 if (ret < 0) return ret;
01976             }
01977             break;
01978     }
01979     return 1;
01980 }
01981 
01982 static int r_append_U_to_stems_ending_with_d_or_g(struct SN_env * z) {
01983     {   int m_test = z->l - z->c; /* test, line 431 */
01984         {   int m1 = z->l - z->c; (void)m1; /* or, line 431 */
01985             if (!(eq_s_b(z, 1, s_20))) goto lab1;
01986             goto lab0;
01987         lab1:
01988             z->c = z->l - m1;
01989             if (!(eq_s_b(z, 1, s_21))) return 0;
01990         }
01991     lab0:
01992         z->c = z->l - m_test;
01993     }
01994     {   int m2 = z->l - z->c; (void)m2; /* or, line 433 */
01995         {   int m_test = z->l - z->c; /* test, line 432 */
01996             if (out_grouping_b_U(z, g_vowel, 97, 305, 1) < 0) goto lab3; /* goto */ /* grouping vowel, line 432 */
01997             {   int m3 = z->l - z->c; (void)m3; /* or, line 432 */
01998                 if (!(eq_s_b(z, 1, s_22))) goto lab5;
01999                 goto lab4;
02000             lab5:
02001                 z->c = z->l - m3;
02002                 if (!(eq_s_b(z, 2, s_23))) goto lab3;
02003             }
02004         lab4:
02005             z->c = z->l - m_test;
02006         }
02007         {   int c_keep = z->c;
02008             int ret = insert_s(z, z->c, z->c, 2, s_24); /* <+, line 432 */
02009             z->c = c_keep;
02010             if (ret < 0) return ret;
02011         }
02012         goto lab2;
02013     lab3:
02014         z->c = z->l - m2;
02015         {   int m_test = z->l - z->c; /* test, line 434 */
02016             if (out_grouping_b_U(z, g_vowel, 97, 305, 1) < 0) goto lab6; /* goto */ /* grouping vowel, line 434 */
02017             {   int m4 = z->l - z->c; (void)m4; /* or, line 434 */
02018                 if (!(eq_s_b(z, 1, s_25))) goto lab8;
02019                 goto lab7;
02020             lab8:
02021                 z->c = z->l - m4;
02022                 if (!(eq_s_b(z, 1, s_26))) goto lab6;
02023             }
02024         lab7:
02025             z->c = z->l - m_test;
02026         }
02027         {   int c_keep = z->c;
02028             int ret = insert_s(z, z->c, z->c, 1, s_27); /* <+, line 434 */
02029             z->c = c_keep;
02030             if (ret < 0) return ret;
02031         }
02032         goto lab2;
02033     lab6:
02034         z->c = z->l - m2;
02035         {   int m_test = z->l - z->c; /* test, line 436 */
02036             if (out_grouping_b_U(z, g_vowel, 97, 305, 1) < 0) goto lab9; /* goto */ /* grouping vowel, line 436 */
02037             {   int m5 = z->l - z->c; (void)m5; /* or, line 436 */
02038                 if (!(eq_s_b(z, 1, s_28))) goto lab11;
02039                 goto lab10;
02040             lab11:
02041                 z->c = z->l - m5;
02042                 if (!(eq_s_b(z, 1, s_29))) goto lab9;
02043             }
02044         lab10:
02045             z->c = z->l - m_test;
02046         }
02047         {   int c_keep = z->c;
02048             int ret = insert_s(z, z->c, z->c, 1, s_30); /* <+, line 436 */
02049             z->c = c_keep;
02050             if (ret < 0) return ret;
02051         }
02052         goto lab2;
02053     lab9:
02054         z->c = z->l - m2;
02055         {   int m_test = z->l - z->c; /* test, line 438 */
02056             if (out_grouping_b_U(z, g_vowel, 97, 305, 1) < 0) return 0; /* goto */ /* grouping vowel, line 438 */
02057             {   int m6 = z->l - z->c; (void)m6; /* or, line 438 */
02058                 if (!(eq_s_b(z, 2, s_31))) goto lab13;
02059                 goto lab12;
02060             lab13:
02061                 z->c = z->l - m6;
02062                 if (!(eq_s_b(z, 2, s_32))) return 0;
02063             }
02064         lab12:
02065             z->c = z->l - m_test;
02066         }
02067         {   int c_keep = z->c;
02068             int ret = insert_s(z, z->c, z->c, 2, s_33); /* <+, line 438 */
02069             z->c = c_keep;
02070             if (ret < 0) return ret;
02071         }
02072     }
02073 lab2:
02074     return 1;
02075 }
02076 
02077 static int r_more_than_one_syllable_word(struct SN_env * z) {
02078     {   int c_test = z->c; /* test, line 446 */
02079         {   int i = 2;
02080             while(1) { /* atleast, line 446 */
02081                 int c1 = z->c;
02082                 {    /* gopast */ /* grouping vowel, line 446 */
02083                     int ret = out_grouping_U(z, g_vowel, 97, 305, 1);
02084                     if (ret < 0) goto lab0;
02085                     z->c += ret;
02086                 }
02087                 i--;
02088                 continue;
02089             lab0:
02090                 z->c = c1;
02091                 break;
02092             }
02093             if (i > 0) return 0;
02094         }
02095         z->c = c_test;
02096     }
02097     return 1;
02098 }
02099 
02100 static int r_is_reserved_word(struct SN_env * z) {
02101     {   int c1 = z->c; /* or, line 451 */
02102         {   int c_test = z->c; /* test, line 450 */
02103             while(1) { /* gopast, line 450 */
02104                 if (!(eq_s(z, 2, s_34))) goto lab2;
02105                 break;
02106             lab2:
02107                 {   int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
02108                     if (ret < 0) goto lab1;
02109                     z->c = ret; /* gopast, line 450 */
02110                 }
02111             }
02112             z->I[0] = 2;
02113             if (!(z->I[0] == z->l)) goto lab1;
02114             z->c = c_test;
02115         }
02116         goto lab0;
02117     lab1:
02118         z->c = c1;
02119         {   int c_test = z->c; /* test, line 452 */
02120             while(1) { /* gopast, line 452 */
02121                 if (!(eq_s(z, 5, s_35))) goto lab3;
02122                 break;
02123             lab3:
02124                 {   int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
02125                     if (ret < 0) return 0;
02126                     z->c = ret; /* gopast, line 452 */
02127                 }
02128             }
02129             z->I[0] = 5;
02130             if (!(z->I[0] == z->l)) return 0;
02131             z->c = c_test;
02132         }
02133     }
02134 lab0:
02135     return 1;
02136 }
02137 
02138 static int r_postlude(struct SN_env * z) {
02139     {   int c1 = z->c; /* not, line 456 */
02140         {   int ret = r_is_reserved_word(z);
02141             if (ret == 0) goto lab0; /* call is_reserved_word, line 456 */
02142             if (ret < 0) return ret;
02143         }
02144         return 0;
02145     lab0:
02146         z->c = c1;
02147     }
02148     z->lb = z->c; z->c = z->l; /* backwards, line 457 */
02149 
02150     {   int m2 = z->l - z->c; (void)m2; /* do, line 458 */
02151         {   int ret = r_append_U_to_stems_ending_with_d_or_g(z);
02152             if (ret == 0) goto lab1; /* call append_U_to_stems_ending_with_d_or_g, line 458 */
02153             if (ret < 0) return ret;
02154         }
02155     lab1:
02156         z->c = z->l - m2;
02157     }
02158     {   int m3 = z->l - z->c; (void)m3; /* do, line 459 */
02159         {   int ret = r_post_process_last_consonants(z);
02160             if (ret == 0) goto lab2; /* call post_process_last_consonants, line 459 */
02161             if (ret < 0) return ret;
02162         }
02163     lab2:
02164         z->c = z->l - m3;
02165     }
02166     z->c = z->lb;
02167     return 1;
02168 }
02169 
02170 extern int turkish_UTF_8_stem(struct SN_env * z) {
02171     {   int ret = r_more_than_one_syllable_word(z);
02172         if (ret == 0) return 0; /* call more_than_one_syllable_word, line 465 */
02173         if (ret < 0) return ret;
02174     }
02175     z->lb = z->c; z->c = z->l; /* backwards, line 467 */
02176 
02177     {   int m1 = z->l - z->c; (void)m1; /* do, line 468 */
02178         {   int ret = r_stem_nominal_verb_suffixes(z);
02179             if (ret == 0) goto lab0; /* call stem_nominal_verb_suffixes, line 468 */
02180             if (ret < 0) return ret;
02181         }
02182     lab0:
02183         z->c = z->l - m1;
02184     }
02185     if (!(z->B[0])) return 0; /* Boolean test continue_stemming_noun_suffixes, line 469 */
02186     {   int m2 = z->l - z->c; (void)m2; /* do, line 470 */
02187         {   int ret = r_stem_noun_suffixes(z);
02188             if (ret == 0) goto lab1; /* call stem_noun_suffixes, line 470 */
02189             if (ret < 0) return ret;
02190         }
02191     lab1:
02192         z->c = z->l - m2;
02193     }
02194     z->c = z->lb;
02195     {   int ret = r_postlude(z);
02196         if (ret == 0) return 0; /* call postlude, line 473 */
02197         if (ret < 0) return ret;
02198     }
02199     return 1;
02200 }
02201 
02202 extern struct SN_env * turkish_UTF_8_create_env(void) { return SN_create_env(0, 1, 1); }
02203 
02204 extern void turkish_UTF_8_close_env(struct SN_env * z) { SN_close_env(z, 0); }
02205