src/backend/snowball/libstemmer/stem_UTF_8_turkish.c

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