cpp/galago/contrib/libstemmer_c/src_c/stem_UTF_8_dutch.c

   1
   2 /* This file was generated automatically by the Snowball to ANSI C compiler */
   3
   4 #include "../runtime/header.h"
   5
   6 #ifdef __cplusplus
   7 extern "C" {
   8 #endif
   9 extern int dutch_UTF_8_stem(struct SN_env * z);
  10 #ifdef __cplusplus
  11 }
  12 #endif
  13 static int r_standard_suffix(struct SN_env * z);
  14 static int r_undouble(struct SN_env * z);
  15 static int r_R2(struct SN_env * z);
  16 static int r_R1(struct SN_env * z);
  17 static int r_mark_regions(struct SN_env * z);
  18 static int r_en_ending(struct SN_env * z);
  19 static int r_e_ending(struct SN_env * z);
  20 static int r_postlude(struct SN_env * z);
  21 static int r_prelude(struct SN_env * z);
  22 #ifdef __cplusplus
  23 extern "C" {
  24 #endif
  25
  26
  27 extern struct SN_env * dutch_UTF_8_create_env(void);
  28 extern void dutch_UTF_8_close_env(struct SN_env * z);
  29
  30
  31 #ifdef __cplusplus
  32 }
  33 #endif
  34 static const symbol s_0_1[2] = { 0xC3, 0xA1 };
  35 static const symbol s_0_2[2] = { 0xC3, 0xA4 };
  36 static const symbol s_0_3[2] = { 0xC3, 0xA9 };
  37 static const symbol s_0_4[2] = { 0xC3, 0xAB };
  38 static const symbol s_0_5[2] = { 0xC3, 0xAD };
  39 static const symbol s_0_6[2] = { 0xC3, 0xAF };
  40 static const symbol s_0_7[2] = { 0xC3, 0xB3 };
  41 static const symbol s_0_8[2] = { 0xC3, 0xB6 };
  42 static const symbol s_0_9[2] = { 0xC3, 0xBA };
  43 static const symbol s_0_10[2] = { 0xC3, 0xBC };
  44
  45 static const struct among a_0[11] =
  46 {
  47 /*  0 */ { 0, 0, -1, 6, 0},
  48 /*  1 */ { 2, s_0_1, 0, 1, 0},
  49 /*  2 */ { 2, s_0_2, 0, 1, 0},
  50 /*  3 */ { 2, s_0_3, 0, 2, 0},
  51 /*  4 */ { 2, s_0_4, 0, 2, 0},
  52 /*  5 */ { 2, s_0_5, 0, 3, 0},
  53 /*  6 */ { 2, s_0_6, 0, 3, 0},
  54 /*  7 */ { 2, s_0_7, 0, 4, 0},
  55 /*  8 */ { 2, s_0_8, 0, 4, 0},
  56 /*  9 */ { 2, s_0_9, 0, 5, 0},
  57 /* 10 */ { 2, s_0_10, 0, 5, 0}
  58 };
  59
  60 static const symbol s_1_1[1] = { 'I' };
  61 static const symbol s_1_2[1] = { 'Y' };
  62
  63 static const struct among a_1[3] =
  64 {
  65 /*  0 */ { 0, 0, -1, 3, 0},
  66 /*  1 */ { 1, s_1_1, 0, 2, 0},
  67 /*  2 */ { 1, s_1_2, 0, 1, 0}
  68 };
  69
  70 static const symbol s_2_0[2] = { 'd', 'd' };
  71 static const symbol s_2_1[2] = { 'k', 'k' };
  72 static const symbol s_2_2[2] = { 't', 't' };
  73
  74 static const struct among a_2[3] =
  75 {
  76 /*  0 */ { 2, s_2_0, -1, -1, 0},
  77 /*  1 */ { 2, s_2_1, -1, -1, 0},
  78 /*  2 */ { 2, s_2_2, -1, -1, 0}
  79 };
  80
  81 static const symbol s_3_0[3] = { 'e', 'n', 'e' };
  82 static const symbol s_3_1[2] = { 's', 'e' };
  83 static const symbol s_3_2[2] = { 'e', 'n' };
  84 static const symbol s_3_3[5] = { 'h', 'e', 'd', 'e', 'n' };
  85 static const symbol s_3_4[1] = { 's' };
  86
  87 static const struct among a_3[5] =
  88 {
  89 /*  0 */ { 3, s_3_0, -1, 2, 0},
  90 /*  1 */ { 2, s_3_1, -1, 3, 0},
  91 /*  2 */ { 2, s_3_2, -1, 2, 0},
  92 /*  3 */ { 5, s_3_3, 2, 1, 0},
  93 /*  4 */ { 1, s_3_4, -1, 3, 0}
  94 };
  95
  96 static const symbol s_4_0[3] = { 'e', 'n', 'd' };
  97 static const symbol s_4_1[2] = { 'i', 'g' };
  98 static const symbol s_4_2[3] = { 'i', 'n', 'g' };
  99 static const symbol s_4_3[4] = { 'l', 'i', 'j', 'k' };
 100 static const symbol s_4_4[4] = { 'b', 'a', 'a', 'r' };
 101 static const symbol s_4_5[3] = { 'b', 'a', 'r' };
 102
 103 static const struct among a_4[6] =
 104 {
 105 /*  0 */ { 3, s_4_0, -1, 1, 0},
 106 /*  1 */ { 2, s_4_1, -1, 2, 0},
 107 /*  2 */ { 3, s_4_2, -1, 1, 0},
 108 /*  3 */ { 4, s_4_3, -1, 3, 0},
 109 /*  4 */ { 4, s_4_4, -1, 4, 0},
 110 /*  5 */ { 3, s_4_5, -1, 5, 0}
 111 };
 112
 113 static const symbol s_5_0[2] = { 'a', 'a' };
 114 static const symbol s_5_1[2] = { 'e', 'e' };
 115 static const symbol s_5_2[2] = { 'o', 'o' };
 116 static const symbol s_5_3[2] = { 'u', 'u' };
 117
 118 static const struct among a_5[4] =
 119 {
 120 /*  0 */ { 2, s_5_0, -1, -1, 0},
 121 /*  1 */ { 2, s_5_1, -1, -1, 0},
 122 /*  2 */ { 2, s_5_2, -1, -1, 0},
 123 /*  3 */ { 2, s_5_3, -1, -1, 0}
 124 };
 125
 126 static const unsigned char g_v[] = { 17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128 };
 127
 128 static const unsigned char g_v_I[] = { 1, 0, 0, 17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128 };
 129
 130 static const unsigned char g_v_j[] = { 17, 67, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128 };
 131
 132 static const symbol s_0[] = { 'a' };
 133 static const symbol s_1[] = { 'e' };
 134 static const symbol s_2[] = { 'i' };
 135 static const symbol s_3[] = { 'o' };
 136 static const symbol s_4[] = { 'u' };
 137 static const symbol s_5[] = { 'y' };
 138 static const symbol s_6[] = { 'Y' };
 139 static const symbol s_7[] = { 'i' };
 140 static const symbol s_8[] = { 'I' };
 141 static const symbol s_9[] = { 'y' };
 142 static const symbol s_10[] = { 'Y' };
 143 static const symbol s_11[] = { 'y' };
 144 static const symbol s_12[] = { 'i' };
 145 static const symbol s_13[] = { 'e' };
 146 static const symbol s_14[] = { 'g', 'e', 'm' };
 147 static const symbol s_15[] = { 'h', 'e', 'i', 'd' };
 148 static const symbol s_16[] = { 'h', 'e', 'i', 'd' };
 149 static const symbol s_17[] = { 'c' };
 150 static const symbol s_18[] = { 'e', 'n' };
 151 static const symbol s_19[] = { 'i', 'g' };
 152 static const symbol s_20[] = { 'e' };
 153 static const symbol s_21[] = { 'e' };
 154
 155 static int r_prelude(struct SN_env * z) {
 156     int among_var;
 157     {   int c_test = z->c; /* test, line 42 */
 158         while(1) { /* repeat, line 42 */
 159             int c = z->c;
 160             z->bra = z->c; /* [, line 43 */
 161             if (z->c + 1 >= z->l || z->p[z->c + 1] >> 5 != 5 || !((340306450 >> (z->p[z->c + 1] & 0x1f)) & 1)) among_var = 6; else
 162             among_var = find_among(z, a_0, 11); /* substring, line 43 */
 163             if (!(among_var)) goto lab0;
 164             z->ket = z->c; /* ], line 43 */
 165             switch(among_var) {
 166                 case 0: goto lab0;
 167                 case 1:
 168                     {   int ret;
 169                         ret = slice_from_s(z, 1, s_0); /* <-, line 45 */
 170                         if (ret < 0) return ret;
 171                     }
 172                     break;
 173                 case 2:
 174                     {   int ret;
 175                         ret = slice_from_s(z, 1, s_1); /* <-, line 47 */
 176                         if (ret < 0) return ret;
 177                     }
 178                     break;
 179                 case 3:
 180                     {   int ret;
 181                         ret = slice_from_s(z, 1, s_2); /* <-, line 49 */
 182                         if (ret < 0) return ret;
 183                     }
 184                     break;
 185                 case 4:
 186                     {   int ret;
 187                         ret = slice_from_s(z, 1, s_3); /* <-, line 51 */
 188                         if (ret < 0) return ret;
 189                     }
 190                     break;
 191                 case 5:
 192                     {   int ret;
 193                         ret = slice_from_s(z, 1, s_4); /* <-, line 53 */
 194                         if (ret < 0) return ret;
 195                     }
 196                     break;
 197                 case 6:
 198                     {   int c = skip_utf8(z->p, z->c, 0, z->l, 1);
 199                         if (c < 0) goto lab0;
 200                         z->c = c; /* next, line 54 */
 201                     }
 202                     break;
 203             }
 204             continue;
 205         lab0:
 206             z->c = c;
 207             break;
 208         }
 209         z->c = c_test;
 210     }
 211     {   int c = z->c; /* try, line 57 */
 212         z->bra = z->c; /* [, line 57 */
 213         if (!(eq_s(z, 1, s_5))) { z->c = c; goto lab1; }
 214         z->ket = z->c; /* ], line 57 */
 215         {   int ret;
 216             ret = slice_from_s(z, 1, s_6); /* <-, line 57 */
 217             if (ret < 0) return ret;
 218         }
 219     lab1:
 220         ;
 221     }
 222     while(1) { /* repeat, line 58 */
 223         int c = z->c;
 224         while(1) { /* goto, line 58 */
 225             int c = z->c;
 226             if (!(in_grouping_U(z, g_v, 97, 232))) goto lab3;
 227             z->bra = z->c; /* [, line 59 */
 228             {   int c = z->c; /* or, line 59 */
 229                 if (!(eq_s(z, 1, s_7))) goto lab5;
 230                 z->ket = z->c; /* ], line 59 */
 231                 if (!(in_grouping_U(z, g_v, 97, 232))) goto lab5;
 232                 {   int ret;
 233                     ret = slice_from_s(z, 1, s_8); /* <-, line 59 */
 234                     if (ret < 0) return ret;
 235                 }
 236                 goto lab4;
 237             lab5:
 238                 z->c = c;
 239                 if (!(eq_s(z, 1, s_9))) goto lab3;
 240                 z->ket = z->c; /* ], line 60 */
 241                 {   int ret;
 242                     ret = slice_from_s(z, 1, s_10); /* <-, line 60 */
 243                     if (ret < 0) return ret;
 244                 }
 245             }
 246         lab4:
 247             z->c = c;
 248             break;
 249         lab3:
 250             z->c = c;
 251             {   int c = skip_utf8(z->p, z->c, 0, z->l, 1);
 252                 if (c < 0) goto lab2;
 253                 z->c = c; /* goto, line 58 */
 254             }
 255         }
 256         continue;
 257     lab2:
 258         z->c = c;
 259         break;
 260     }
 261     return 1;
 262 }
 263
 264 static int r_mark_regions(struct SN_env * z) {
 265     z->I[0] = z->l;
 266     z->I[1] = z->l;
 267     while(1) { /* gopast, line 69 */
 268         if (!(in_grouping_U(z, g_v, 97, 232))) goto lab0;
 269         break;
 270     lab0:
 271         {   int c = skip_utf8(z->p, z->c, 0, z->l, 1);
 272             if (c < 0) return 0;
 273             z->c = c; /* gopast, line 69 */
 274         }
 275     }
 276     while(1) { /* gopast, line 69 */
 277         if (!(out_grouping_U(z, g_v, 97, 232))) goto lab1;
 278         break;
 279     lab1:
 280         {   int c = skip_utf8(z->p, z->c, 0, z->l, 1);
 281             if (c < 0) return 0;
 282             z->c = c; /* gopast, line 69 */
 283         }
 284     }
 285     z->I[0] = z->c; /* setmark p1, line 69 */
 286      /* try, line 70 */
 287     if (!(z->I[0] < 3)) goto lab2;
 288     z->I[0] = 3;
 289 lab2:
 290     while(1) { /* gopast, line 71 */
 291         if (!(in_grouping_U(z, g_v, 97, 232))) goto lab3;
 292         break;
 293     lab3:
 294         {   int c = skip_utf8(z->p, z->c, 0, z->l, 1);
 295             if (c < 0) return 0;
 296             z->c = c; /* gopast, line 71 */
 297         }
 298     }
 299     while(1) { /* gopast, line 71 */
 300         if (!(out_grouping_U(z, g_v, 97, 232))) goto lab4;
 301         break;
 302     lab4:
 303         {   int c = skip_utf8(z->p, z->c, 0, z->l, 1);
 304             if (c < 0) return 0;
 305             z->c = c; /* gopast, line 71 */
 306         }
 307     }
 308     z->I[1] = z->c; /* setmark p2, line 71 */
 309     return 1;
 310 }
 311
 312 static int r_postlude(struct SN_env * z) {
 313     int among_var;
 314     while(1) { /* repeat, line 75 */
 315         int c = z->c;
 316         z->bra = z->c; /* [, line 77 */
 317         if (z->c + 0 >= z->l || (z->p[z->c + 0] != 73 && z->p[z->c + 0] != 89)) among_var = 3; else
 318         among_var = find_among(z, a_1, 3); /* substring, line 77 */
 319         if (!(among_var)) goto lab0;
 320         z->ket = z->c; /* ], line 77 */
 321         switch(among_var) {
 322             case 0: goto lab0;
 323             case 1:
 324                 {   int ret;
 325                     ret = slice_from_s(z, 1, s_11); /* <-, line 78 */
 326                     if (ret < 0) return ret;
 327                 }
 328                 break;
 329             case 2:
 330                 {   int ret;
 331                     ret = slice_from_s(z, 1, s_12); /* <-, line 79 */
 332                     if (ret < 0) return ret;
 333                 }
 334                 break;
 335             case 3:
 336                 {   int c = skip_utf8(z->p, z->c, 0, z->l, 1);
 337                     if (c < 0) goto lab0;
 338                     z->c = c; /* next, line 80 */
 339                 }
 340                 break;
 341         }
 342         continue;
 343     lab0:
 344         z->c = c;
 345         break;
 346     }
 347     return 1;
 348 }
 349
 350 static int r_R1(struct SN_env * z) {
 351     if (!(z->I[0] <= z->c)) return 0;
 352     return 1;
 353 }
 354
 355 static int r_R2(struct SN_env * z) {
 356     if (!(z->I[1] <= z->c)) return 0;
 357     return 1;
 358 }
 359
 360 static int r_undouble(struct SN_env * z) {
 361     {   int m_test = z->l - z->c; /* test, line 91 */
 362         if (z->c <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((1050640 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0;
 363         if (!(find_among_b(z, a_2, 3))) return 0; /* among, line 91 */
 364         z->c = z->l - m_test;
 365     }
 366     z->ket = z->c; /* [, line 91 */
 367     {   int c = skip_utf8(z->p, z->c, z->lb, 0, -1);
 368         if (c < 0) return 0;
 369         z->c = c; /* next, line 91 */
 370     }
 371     z->bra = z->c; /* ], line 91 */
 372     {   int ret;
 373         ret = slice_del(z); /* delete, line 91 */
 374         if (ret < 0) return ret;
 375     }
 376     return 1;
 377 }
 378
 379 static int r_e_ending(struct SN_env * z) {
 380     z->B[0] = 0; /* unset e_found, line 95 */
 381     z->ket = z->c; /* [, line 96 */
 382     if (!(eq_s_b(z, 1, s_13))) return 0;
 383     z->bra = z->c; /* ], line 96 */
 384     {   int ret = r_R1(z);
 385         if (ret == 0) return 0; /* call R1, line 96 */
 386         if (ret < 0) return ret;
 387     }
 388     {   int m_test = z->l - z->c; /* test, line 96 */
 389         if (!(out_grouping_b_U(z, g_v, 97, 232))) return 0;
 390         z->c = z->l - m_test;
 391     }
 392     {   int ret;
 393         ret = slice_del(z); /* delete, line 96 */
 394         if (ret < 0) return ret;
 395     }
 396     z->B[0] = 1; /* set e_found, line 97 */
 397     {   int ret = r_undouble(z);
 398         if (ret == 0) return 0; /* call undouble, line 98 */
 399         if (ret < 0) return ret;
 400     }
 401     return 1;
 402 }
 403
 404 static int r_en_ending(struct SN_env * z) {
 405     {   int ret = r_R1(z);
 406         if (ret == 0) return 0; /* call R1, line 102 */
 407         if (ret < 0) return ret;
 408     }
 409     {   int m = z->l - z->c; (void) m; /* and, line 102 */
 410         if (!(out_grouping_b_U(z, g_v, 97, 232))) return 0;
 411         z->c = z->l - m;
 412         {   int m = z->l - z->c; (void) m; /* not, line 102 */
 413             if (!(eq_s_b(z, 3, s_14))) goto lab0;
 414             return 0;
 415         lab0:
 416             z->c = z->l - m;
 417         }
 418     }
 419     {   int ret;
 420         ret = slice_del(z); /* delete, line 102 */
 421         if (ret < 0) return ret;
 422     }
 423     {   int ret = r_undouble(z);
 424         if (ret == 0) return 0; /* call undouble, line 103 */
 425         if (ret < 0) return ret;
 426     }
 427     return 1;
 428 }
 429
 430 static int r_standard_suffix(struct SN_env * z) {
 431     int among_var;
 432     {   int m = z->l - z->c; (void) m; /* do, line 107 */
 433         z->ket = z->c; /* [, line 108 */
 434         if (z->c <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((540704 >> (z->p[z->c - 1] & 0x1f)) & 1)) goto lab0;
 435         among_var = find_among_b(z, a_3, 5); /* substring, line 108 */
 436         if (!(among_var)) goto lab0;
 437         z->bra = z->c; /* ], line 108 */
 438         switch(among_var) {
 439             case 0: goto lab0;
 440             case 1:
 441                 {   int ret = r_R1(z);
 442                     if (ret == 0) goto lab0; /* call R1, line 110 */
 443                     if (ret < 0) return ret;
 444                 }
 445                 {   int ret;
 446                     ret = slice_from_s(z, 4, s_15); /* <-, line 110 */
 447                     if (ret < 0) return ret;
 448                 }
 449                 break;
 450             case 2:
 451                 {   int ret = r_en_ending(z);
 452                     if (ret == 0) goto lab0; /* call en_ending, line 113 */
 453                     if (ret < 0) return ret;
 454                 }
 455                 break;
 456             case 3:
 457                 {   int ret = r_R1(z);
 458                     if (ret == 0) goto lab0; /* call R1, line 116 */
 459                     if (ret < 0) return ret;
 460                 }
 461                 if (!(out_grouping_b_U(z, g_v_j, 97, 232))) goto lab0;
 462                 {   int ret;
 463                     ret = slice_del(z); /* delete, line 116 */
 464                     if (ret < 0) return ret;
 465                 }
 466                 break;
 467         }
 468     lab0:
 469         z->c = z->l - m;
 470     }
 471     {   int m = z->l - z->c; (void) m; /* do, line 120 */
 472         {   int ret = r_e_ending(z);
 473             if (ret == 0) goto lab1; /* call e_ending, line 120 */
 474             if (ret < 0) return ret;
 475         }
 476     lab1:
 477         z->c = z->l - m;
 478     }
 479     {   int m = z->l - z->c; (void) m; /* do, line 122 */
 480         z->ket = z->c; /* [, line 122 */
 481         if (!(eq_s_b(z, 4, s_16))) goto lab2;
 482         z->bra = z->c; /* ], line 122 */
 483         {   int ret = r_R2(z);
 484             if (ret == 0) goto lab2; /* call R2, line 122 */
 485             if (ret < 0) return ret;
 486         }
 487         {   int m = z->l - z->c; (void) m; /* not, line 122 */
 488             if (!(eq_s_b(z, 1, s_17))) goto lab3;
 489             goto lab2;
 490         lab3:
 491             z->c = z->l - m;
 492         }
 493         {   int ret;
 494             ret = slice_del(z); /* delete, line 122 */
 495             if (ret < 0) return ret;
 496         }
 497         z->ket = z->c; /* [, line 123 */
 498         if (!(eq_s_b(z, 2, s_18))) goto lab2;
 499         z->bra = z->c; /* ], line 123 */
 500         {   int ret = r_en_ending(z);
 501             if (ret == 0) goto lab2; /* call en_ending, line 123 */
 502             if (ret < 0) return ret;
 503         }
 504     lab2:
 505         z->c = z->l - m;
 506     }
 507     {   int m = z->l - z->c; (void) m; /* do, line 126 */
 508         z->ket = z->c; /* [, line 127 */
 509         if (z->c <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((264336 >> (z->p[z->c - 1] & 0x1f)) & 1)) goto lab4;
 510         among_var = find_among_b(z, a_4, 6); /* substring, line 127 */
 511         if (!(among_var)) goto lab4;
 512         z->bra = z->c; /* ], line 127 */
 513         switch(among_var) {
 514             case 0: goto lab4;
 515             case 1:
 516                 {   int ret = r_R2(z);
 517                     if (ret == 0) goto lab4; /* call R2, line 129 */
 518                     if (ret < 0) return ret;
 519                 }
 520                 {   int ret;
 521                     ret = slice_del(z); /* delete, line 129 */
 522                     if (ret < 0) return ret;
 523                 }
 524                 {   int m = z->l - z->c; (void) m; /* or, line 130 */
 525                     z->ket = z->c; /* [, line 130 */
 526                     if (!(eq_s_b(z, 2, s_19))) goto lab6;
 527                     z->bra = z->c; /* ], line 130 */
 528                     {   int ret = r_R2(z);
 529                         if (ret == 0) goto lab6; /* call R2, line 130 */
 530                         if (ret < 0) return ret;
 531                     }
 532                     {   int m = z->l - z->c; (void) m; /* not, line 130 */
 533                         if (!(eq_s_b(z, 1, s_20))) goto lab7;
 534                         goto lab6;
 535                     lab7:
 536                         z->c = z->l - m;
 537                     }
 538                     {   int ret;
 539                         ret = slice_del(z); /* delete, line 130 */
 540                         if (ret < 0) return ret;
 541                     }
 542                     goto lab5;
 543                 lab6:
 544                     z->c = z->l - m;
 545                     {   int ret = r_undouble(z);
 546                         if (ret == 0) goto lab4; /* call undouble, line 130 */
 547                         if (ret < 0) return ret;
 548                     }
 549                 }
 550             lab5:
 551                 break;
 552             case 2:
 553                 {   int ret = r_R2(z);
 554                     if (ret == 0) goto lab4; /* call R2, line 133 */
 555                     if (ret < 0) return ret;
 556                 }
 557                 {   int m = z->l - z->c; (void) m; /* not, line 133 */
 558                     if (!(eq_s_b(z, 1, s_21))) goto lab8;
 559                     goto lab4;
 560                 lab8:
 561                     z->c = z->l - m;
 562                 }
 563                 {   int ret;
 564                     ret = slice_del(z); /* delete, line 133 */
 565                     if (ret < 0) return ret;
 566                 }
 567                 break;
 568             case 3:
 569                 {   int ret = r_R2(z);
 570                     if (ret == 0) goto lab4; /* call R2, line 136 */
 571                     if (ret < 0) return ret;
 572                 }
 573                 {   int ret;
 574                     ret = slice_del(z); /* delete, line 136 */
 575                     if (ret < 0) return ret;
 576                 }
 577                 {   int ret = r_e_ending(z);
 578                     if (ret == 0) goto lab4; /* call e_ending, line 136 */
 579                     if (ret < 0) return ret;
 580                 }
 581                 break;
 582             case 4:
 583                 {   int ret = r_R2(z);
 584                     if (ret == 0) goto lab4; /* call R2, line 139 */
 585                     if (ret < 0) return ret;
 586                 }
 587                 {   int ret;
 588                     ret = slice_del(z); /* delete, line 139 */
 589                     if (ret < 0) return ret;
 590                 }
 591                 break;
 592             case 5:
 593                 {   int ret = r_R2(z);
 594                     if (ret == 0) goto lab4; /* call R2, line 142 */
 595                     if (ret < 0) return ret;
 596                 }
 597                 if (!(z->B[0])) goto lab4; /* Boolean test e_found, line 142 */
 598                 {   int ret;
 599                     ret = slice_del(z); /* delete, line 142 */
 600                     if (ret < 0) return ret;
 601                 }
 602                 break;
 603         }
 604     lab4:
 605         z->c = z->l - m;
 606     }
 607     {   int m = z->l - z->c; (void) m; /* do, line 146 */
 608         if (!(out_grouping_b_U(z, g_v_I, 73, 232))) goto lab9;
 609         {   int m_test = z->l - z->c; /* test, line 148 */
 610             if (z->c <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((2129954 >> (z->p[z->c - 1] & 0x1f)) & 1)) goto lab9;
 611             if (!(find_among_b(z, a_5, 4))) goto lab9; /* among, line 149 */
 612             if (!(out_grouping_b_U(z, g_v, 97, 232))) goto lab9;
 613             z->c = z->l - m_test;
 614         }
 615         z->ket = z->c; /* [, line 152 */
 616         {   int c = skip_utf8(z->p, z->c, z->lb, 0, -1);
 617             if (c < 0) goto lab9;
 618             z->c = c; /* next, line 152 */
 619         }
 620         z->bra = z->c; /* ], line 152 */
 621         {   int ret;
 622             ret = slice_del(z); /* delete, line 152 */
 623             if (ret < 0) return ret;
 624         }
 625     lab9:
 626         z->c = z->l - m;
 627     }
 628     return 1;
 629 }
 630
 631 extern int dutch_UTF_8_stem(struct SN_env * z) {
 632     {   int c = z->c; /* do, line 159 */
 633         {   int ret = r_prelude(z);
 634             if (ret == 0) goto lab0; /* call prelude, line 159 */
 635             if (ret < 0) return ret;
 636         }
 637     lab0:
 638         z->c = c;
 639     }
 640     {   int c = z->c; /* do, line 160 */
 641         {   int ret = r_mark_regions(z);
 642             if (ret == 0) goto lab1; /* call mark_regions, line 160 */
 643             if (ret < 0) return ret;
 644         }
 645     lab1:
 646         z->c = c;
 647     }
 648     z->lb = z->c; z->c = z->l; /* backwards, line 161 */
 649
 650     {   int m = z->l - z->c; (void) m; /* do, line 162 */
 651         {   int ret = r_standard_suffix(z);
 652             if (ret == 0) goto lab2; /* call standard_suffix, line 162 */
 653             if (ret < 0) return ret;
 654         }
 655     lab2:
 656         z->c = z->l - m;
 657     }
 658     z->c = z->lb;
 659     {   int c = z->c; /* do, line 163 */
 660         {   int ret = r_postlude(z);
 661             if (ret == 0) goto lab3; /* call postlude, line 163 */
 662             if (ret < 0) return ret;
 663         }
 664     lab3:
 665         z->c = c;
 666     }
 667     return 1;
 668 }
 669
 670 extern struct SN_env * dutch_UTF_8_create_env(void) { return SN_create_env(0, 2, 1); }
 671
 672 extern void dutch_UTF_8_close_env(struct SN_env * z) { SN_close_env(z, 0); }
 673