granicus.if.org Git - postgresql/blob - contrib/tsearch2/snowball/english_stem.c

   1 /* $PostgreSQL: pgsql/contrib/tsearch2/snowball/english_stem.c,v 1.8 2006/03/11 04:38:30 momjian Exp $ */
   2
   3 /* This file was generated automatically by the Snowball to ANSI C compiler */
   4
   5 #include "header.h"
   6
   7 extern int      english_ISO_8859_1_stem(struct SN_env * z);
   8 static int      r_exception2(struct SN_env * z);
   9 static int      r_exception1(struct SN_env * z);
  10 static int      r_Step_5(struct SN_env * z);
  11 static int      r_Step_4(struct SN_env * z);
  12 static int      r_Step_3(struct SN_env * z);
  13 static int      r_Step_2(struct SN_env * z);
  14 static int      r_Step_1c(struct SN_env * z);
  15 static int      r_Step_1b(struct SN_env * z);
  16 static int      r_Step_1a(struct SN_env * z);
  17 static int      r_R2(struct SN_env * z);
  18 static int      r_R1(struct SN_env * z);
  19 static int      r_shortv(struct SN_env * z);
  20 static int      r_mark_regions(struct SN_env * z);
  21 static int      r_postlude(struct SN_env * z);
  22 static int      r_prelude(struct SN_env * z);
  23
  24 extern struct SN_env *english_ISO_8859_1_create_env(void);
  25 extern void english_ISO_8859_1_close_env(struct SN_env * z);
  26
  27 static symbol s_0_0[6] = {'c', 'o', 'm', 'm', 'u', 'n'};
  28 static symbol s_0_1[5] = {'g', 'e', 'n', 'e', 'r'};
  29
  30 static struct among a_0[2] =
  31 {
  32          /* 0 */ {6, s_0_0, -1, -1, 0},
  33          /* 1 */ {5, s_0_1, -1, -1, 0}
  34 };
  35
  36 static symbol s_1_0[1] = {'\''};
  37 static symbol s_1_1[3] = {'\'', 's', '\''};
  38 static symbol s_1_2[2] = {'\'', 's'};
  39
  40 static struct among a_1[3] =
  41 {
  42          /* 0 */ {1, s_1_0, -1, 1, 0},
  43          /* 1 */ {3, s_1_1, 0, 1, 0},
  44          /* 2 */ {2, s_1_2, -1, 1, 0}
  45 };
  46
  47 static symbol s_2_0[3] = {'i', 'e', 'd'};
  48 static symbol s_2_1[1] = {'s'};
  49 static symbol s_2_2[3] = {'i', 'e', 's'};
  50 static symbol s_2_3[4] = {'s', 's', 'e', 's'};
  51 static symbol s_2_4[2] = {'s', 's'};
  52 static symbol s_2_5[2] = {'u', 's'};
  53
  54 static struct among a_2[6] =
  55 {
  56          /* 0 */ {3, s_2_0, -1, 2, 0},
  57          /* 1 */ {1, s_2_1, -1, 3, 0},
  58          /* 2 */ {3, s_2_2, 1, 2, 0},
  59          /* 3 */ {4, s_2_3, 1, 1, 0},
  60          /* 4 */ {2, s_2_4, 1, -1, 0},
  61          /* 5 */ {2, s_2_5, 1, -1, 0}
  62 };
  63
  64 static symbol s_3_1[2] = {'b', 'b'};
  65 static symbol s_3_2[2] = {'d', 'd'};
  66 static symbol s_3_3[2] = {'f', 'f'};
  67 static symbol s_3_4[2] = {'g', 'g'};
  68 static symbol s_3_5[2] = {'b', 'l'};
  69 static symbol s_3_6[2] = {'m', 'm'};
  70 static symbol s_3_7[2] = {'n', 'n'};
  71 static symbol s_3_8[2] = {'p', 'p'};
  72 static symbol s_3_9[2] = {'r', 'r'};
  73 static symbol s_3_10[2] = {'a', 't'};
  74 static symbol s_3_11[2] = {'t', 't'};
  75 static symbol s_3_12[2] = {'i', 'z'};
  76
  77 static struct among a_3[13] =
  78 {
  79          /* 0 */ {0, 0, -1, 3, 0},
  80          /* 1 */ {2, s_3_1, 0, 2, 0},
  81          /* 2 */ {2, s_3_2, 0, 2, 0},
  82          /* 3 */ {2, s_3_3, 0, 2, 0},
  83          /* 4 */ {2, s_3_4, 0, 2, 0},
  84          /* 5 */ {2, s_3_5, 0, 1, 0},
  85          /* 6 */ {2, s_3_6, 0, 2, 0},
  86          /* 7 */ {2, s_3_7, 0, 2, 0},
  87          /* 8 */ {2, s_3_8, 0, 2, 0},
  88          /* 9 */ {2, s_3_9, 0, 2, 0},
  89          /* 10 */ {2, s_3_10, 0, 1, 0},
  90          /* 11 */ {2, s_3_11, 0, 2, 0},
  91          /* 12 */ {2, s_3_12, 0, 1, 0}
  92 };
  93
  94 static symbol s_4_0[2] = {'e', 'd'};
  95 static symbol s_4_1[3] = {'e', 'e', 'd'};
  96 static symbol s_4_2[3] = {'i', 'n', 'g'};
  97 static symbol s_4_3[4] = {'e', 'd', 'l', 'y'};
  98 static symbol s_4_4[5] = {'e', 'e', 'd', 'l', 'y'};
  99 static symbol s_4_5[5] = {'i', 'n', 'g', 'l', 'y'};
 100
 101 static struct among a_4[6] =
 102 {
 103          /* 0 */ {2, s_4_0, -1, 2, 0},
 104          /* 1 */ {3, s_4_1, 0, 1, 0},
 105          /* 2 */ {3, s_4_2, -1, 2, 0},
 106          /* 3 */ {4, s_4_3, -1, 2, 0},
 107          /* 4 */ {5, s_4_4, 3, 1, 0},
 108          /* 5 */ {5, s_4_5, -1, 2, 0}
 109 };
 110
 111 static symbol s_5_0[4] = {'a', 'n', 'c', 'i'};
 112 static symbol s_5_1[4] = {'e', 'n', 'c', 'i'};
 113 static symbol s_5_2[3] = {'o', 'g', 'i'};
 114 static symbol s_5_3[2] = {'l', 'i'};
 115 static symbol s_5_4[3] = {'b', 'l', 'i'};
 116 static symbol s_5_5[4] = {'a', 'b', 'l', 'i'};
 117 static symbol s_5_6[4] = {'a', 'l', 'l', 'i'};
 118 static symbol s_5_7[5] = {'f', 'u', 'l', 'l', 'i'};
 119 static symbol s_5_8[6] = {'l', 'e', 's', 's', 'l', 'i'};
 120 static symbol s_5_9[5] = {'o', 'u', 's', 'l', 'i'};
 121 static symbol s_5_10[5] = {'e', 'n', 't', 'l', 'i'};
 122 static symbol s_5_11[5] = {'a', 'l', 'i', 't', 'i'};
 123 static symbol s_5_12[6] = {'b', 'i', 'l', 'i', 't', 'i'};
 124 static symbol s_5_13[5] = {'i', 'v', 'i', 't', 'i'};
 125 static symbol s_5_14[6] = {'t', 'i', 'o', 'n', 'a', 'l'};
 126 static symbol s_5_15[7] = {'a', 't', 'i', 'o', 'n', 'a', 'l'};
 127 static symbol s_5_16[5] = {'a', 'l', 'i', 's', 'm'};
 128 static symbol s_5_17[5] = {'a', 't', 'i', 'o', 'n'};
 129 static symbol s_5_18[7] = {'i', 'z', 'a', 't', 'i', 'o', 'n'};
 130 static symbol s_5_19[4] = {'i', 'z', 'e', 'r'};
 131 static symbol s_5_20[4] = {'a', 't', 'o', 'r'};
 132 static symbol s_5_21[7] = {'i', 'v', 'e', 'n', 'e', 's', 's'};
 133 static symbol s_5_22[7] = {'f', 'u', 'l', 'n', 'e', 's', 's'};
 134 static symbol s_5_23[7] = {'o', 'u', 's', 'n', 'e', 's', 's'};
 135
 136 static struct among a_5[24] =
 137 {
 138          /* 0 */ {4, s_5_0, -1, 3, 0},
 139          /* 1 */ {4, s_5_1, -1, 2, 0},
 140          /* 2 */ {3, s_5_2, -1, 13, 0},
 141          /* 3 */ {2, s_5_3, -1, 16, 0},
 142          /* 4 */ {3, s_5_4, 3, 12, 0},
 143          /* 5 */ {4, s_5_5, 4, 4, 0},
 144          /* 6 */ {4, s_5_6, 3, 8, 0},
 145          /* 7 */ {5, s_5_7, 3, 14, 0},
 146          /* 8 */ {6, s_5_8, 3, 15, 0},
 147          /* 9 */ {5, s_5_9, 3, 10, 0},
 148          /* 10 */ {5, s_5_10, 3, 5, 0},
 149          /* 11 */ {5, s_5_11, -1, 8, 0},
 150          /* 12 */ {6, s_5_12, -1, 12, 0},
 151          /* 13 */ {5, s_5_13, -1, 11, 0},
 152          /* 14 */ {6, s_5_14, -1, 1, 0},
 153          /* 15 */ {7, s_5_15, 14, 7, 0},
 154          /* 16 */ {5, s_5_16, -1, 8, 0},
 155          /* 17 */ {5, s_5_17, -1, 7, 0},
 156          /* 18 */ {7, s_5_18, 17, 6, 0},
 157          /* 19 */ {4, s_5_19, -1, 6, 0},
 158          /* 20 */ {4, s_5_20, -1, 7, 0},
 159          /* 21 */ {7, s_5_21, -1, 11, 0},
 160          /* 22 */ {7, s_5_22, -1, 9, 0},
 161          /* 23 */ {7, s_5_23, -1, 10, 0}
 162 };
 163
 164 static symbol s_6_0[5] = {'i', 'c', 'a', 't', 'e'};
 165 static symbol s_6_1[5] = {'a', 't', 'i', 'v', 'e'};
 166 static symbol s_6_2[5] = {'a', 'l', 'i', 'z', 'e'};
 167 static symbol s_6_3[5] = {'i', 'c', 'i', 't', 'i'};
 168 static symbol s_6_4[4] = {'i', 'c', 'a', 'l'};
 169 static symbol s_6_5[6] = {'t', 'i', 'o', 'n', 'a', 'l'};
 170 static symbol s_6_6[7] = {'a', 't', 'i', 'o', 'n', 'a', 'l'};
 171 static symbol s_6_7[3] = {'f', 'u', 'l'};
 172 static symbol s_6_8[4] = {'n', 'e', 's', 's'};
 173
 174 static struct among a_6[9] =
 175 {
 176          /* 0 */ {5, s_6_0, -1, 4, 0},
 177          /* 1 */ {5, s_6_1, -1, 6, 0},
 178          /* 2 */ {5, s_6_2, -1, 3, 0},
 179          /* 3 */ {5, s_6_3, -1, 4, 0},
 180          /* 4 */ {4, s_6_4, -1, 4, 0},
 181          /* 5 */ {6, s_6_5, -1, 1, 0},
 182          /* 6 */ {7, s_6_6, 5, 2, 0},
 183          /* 7 */ {3, s_6_7, -1, 5, 0},
 184          /* 8 */ {4, s_6_8, -1, 5, 0}
 185 };
 186
 187 static symbol s_7_0[2] = {'i', 'c'};
 188 static symbol s_7_1[4] = {'a', 'n', 'c', 'e'};
 189 static symbol s_7_2[4] = {'e', 'n', 'c', 'e'};
 190 static symbol s_7_3[4] = {'a', 'b', 'l', 'e'};
 191 static symbol s_7_4[4] = {'i', 'b', 'l', 'e'};
 192 static symbol s_7_5[3] = {'a', 't', 'e'};
 193 static symbol s_7_6[3] = {'i', 'v', 'e'};
 194 static symbol s_7_7[3] = {'i', 'z', 'e'};
 195 static symbol s_7_8[3] = {'i', 't', 'i'};
 196 static symbol s_7_9[2] = {'a', 'l'};
 197 static symbol s_7_10[3] = {'i', 's', 'm'};
 198 static symbol s_7_11[3] = {'i', 'o', 'n'};
 199 static symbol s_7_12[2] = {'e', 'r'};
 200 static symbol s_7_13[3] = {'o', 'u', 's'};
 201 static symbol s_7_14[3] = {'a', 'n', 't'};
 202 static symbol s_7_15[3] = {'e', 'n', 't'};
 203 static symbol s_7_16[4] = {'m', 'e', 'n', 't'};
 204 static symbol s_7_17[5] = {'e', 'm', 'e', 'n', 't'};
 205
 206 static struct among a_7[18] =
 207 {
 208          /* 0 */ {2, s_7_0, -1, 1, 0},
 209          /* 1 */ {4, s_7_1, -1, 1, 0},
 210          /* 2 */ {4, s_7_2, -1, 1, 0},
 211          /* 3 */ {4, s_7_3, -1, 1, 0},
 212          /* 4 */ {4, s_7_4, -1, 1, 0},
 213          /* 5 */ {3, s_7_5, -1, 1, 0},
 214          /* 6 */ {3, s_7_6, -1, 1, 0},
 215          /* 7 */ {3, s_7_7, -1, 1, 0},
 216          /* 8 */ {3, s_7_8, -1, 1, 0},
 217          /* 9 */ {2, s_7_9, -1, 1, 0},
 218          /* 10 */ {3, s_7_10, -1, 1, 0},
 219          /* 11 */ {3, s_7_11, -1, 2, 0},
 220          /* 12 */ {2, s_7_12, -1, 1, 0},
 221          /* 13 */ {3, s_7_13, -1, 1, 0},
 222          /* 14 */ {3, s_7_14, -1, 1, 0},
 223          /* 15 */ {3, s_7_15, -1, 1, 0},
 224          /* 16 */ {4, s_7_16, 15, 1, 0},
 225          /* 17 */ {5, s_7_17, 16, 1, 0}
 226 };
 227
 228 static symbol s_8_0[1] = {'e'};
 229 static symbol s_8_1[1] = {'l'};
 230
 231 static struct among a_8[2] =
 232 {
 233          /* 0 */ {1, s_8_0, -1, 1, 0},
 234          /* 1 */ {1, s_8_1, -1, 2, 0}
 235 };
 236
 237 static symbol s_9_0[7] = {'s', 'u', 'c', 'c', 'e', 'e', 'd'};
 238 static symbol s_9_1[7] = {'p', 'r', 'o', 'c', 'e', 'e', 'd'};
 239 static symbol s_9_2[6] = {'e', 'x', 'c', 'e', 'e', 'd'};
 240 static symbol s_9_3[7] = {'c', 'a', 'n', 'n', 'i', 'n', 'g'};
 241 static symbol s_9_4[6] = {'i', 'n', 'n', 'i', 'n', 'g'};
 242 static symbol s_9_5[7] = {'e', 'a', 'r', 'r', 'i', 'n', 'g'};
 243 static symbol s_9_6[7] = {'h', 'e', 'r', 'r', 'i', 'n', 'g'};
 244 static symbol s_9_7[6] = {'o', 'u', 't', 'i', 'n', 'g'};
 245
 246 static struct among a_9[8] =
 247 {
 248          /* 0 */ {7, s_9_0, -1, -1, 0},
 249          /* 1 */ {7, s_9_1, -1, -1, 0},
 250          /* 2 */ {6, s_9_2, -1, -1, 0},
 251          /* 3 */ {7, s_9_3, -1, -1, 0},
 252          /* 4 */ {6, s_9_4, -1, -1, 0},
 253          /* 5 */ {7, s_9_5, -1, -1, 0},
 254          /* 6 */ {7, s_9_6, -1, -1, 0},
 255          /* 7 */ {6, s_9_7, -1, -1, 0}
 256 };
 257
 258 static symbol s_10_0[5] = {'a', 'n', 'd', 'e', 's'};
 259 static symbol s_10_1[5] = {'a', 't', 'l', 'a', 's'};
 260 static symbol s_10_2[4] = {'b', 'i', 'a', 's'};
 261 static symbol s_10_3[6] = {'c', 'o', 's', 'm', 'o', 's'};
 262 static symbol s_10_4[5] = {'d', 'y', 'i', 'n', 'g'};
 263 static symbol s_10_5[5] = {'e', 'a', 'r', 'l', 'y'};
 264 static symbol s_10_6[6] = {'g', 'e', 'n', 't', 'l', 'y'};
 265 static symbol s_10_7[4] = {'h', 'o', 'w', 'e'};
 266 static symbol s_10_8[4] = {'i', 'd', 'l', 'y'};
 267 static symbol s_10_9[5] = {'l', 'y', 'i', 'n', 'g'};
 268 static symbol s_10_10[4] = {'n', 'e', 'w', 's'};
 269 static symbol s_10_11[4] = {'o', 'n', 'l', 'y'};
 270 static symbol s_10_12[6] = {'s', 'i', 'n', 'g', 'l', 'y'};
 271 static symbol s_10_13[5] = {'s', 'k', 'i', 'e', 's'};
 272 static symbol s_10_14[4] = {'s', 'k', 'i', 's'};
 273 static symbol s_10_15[3] = {'s', 'k', 'y'};
 274 static symbol s_10_16[5] = {'t', 'y', 'i', 'n', 'g'};
 275 static symbol s_10_17[4] = {'u', 'g', 'l', 'y'};
 276
 277 static struct among a_10[18] =
 278 {
 279          /* 0 */ {5, s_10_0, -1, -1, 0},
 280          /* 1 */ {5, s_10_1, -1, -1, 0},
 281          /* 2 */ {4, s_10_2, -1, -1, 0},
 282          /* 3 */ {6, s_10_3, -1, -1, 0},
 283          /* 4 */ {5, s_10_4, -1, 3, 0},
 284          /* 5 */ {5, s_10_5, -1, 9, 0},
 285          /* 6 */ {6, s_10_6, -1, 7, 0},
 286          /* 7 */ {4, s_10_7, -1, -1, 0},
 287          /* 8 */ {4, s_10_8, -1, 6, 0},
 288          /* 9 */ {5, s_10_9, -1, 4, 0},
 289          /* 10 */ {4, s_10_10, -1, -1, 0},
 290          /* 11 */ {4, s_10_11, -1, 10, 0},
 291          /* 12 */ {6, s_10_12, -1, 11, 0},
 292          /* 13 */ {5, s_10_13, -1, 2, 0},
 293          /* 14 */ {4, s_10_14, -1, 1, 0},
 294          /* 15 */ {3, s_10_15, -1, -1, 0},
 295          /* 16 */ {5, s_10_16, -1, 5, 0},
 296          /* 17 */ {4, s_10_17, -1, 8, 0}
 297 };
 298
 299 static unsigned char g_v[] = {17, 65, 16, 1};
 300
 301 static unsigned char g_v_WXY[] = {1, 17, 65, 208, 1};
 302
 303 static unsigned char g_valid_LI[] = {55, 141, 2};
 304
 305 static symbol s_0[] = {'\''};
 306 static symbol s_1[] = {'y'};
 307 static symbol s_2[] = {'Y'};
 308 static symbol s_3[] = {'y'};
 309 static symbol s_4[] = {'Y'};
 310 static symbol s_5[] = {'s', 's'};
 311 static symbol s_6[] = {'i', 'e'};
 312 static symbol s_7[] = {'i'};
 313 static symbol s_8[] = {'e', 'e'};
 314 static symbol s_9[] = {'e'};
 315 static symbol s_10[] = {'e'};
 316 static symbol s_11[] = {'y'};
 317 static symbol s_12[] = {'Y'};
 318 static symbol s_13[] = {'i'};
 319 static symbol s_14[] = {'t', 'i', 'o', 'n'};
 320 static symbol s_15[] = {'e', 'n', 'c', 'e'};
 321 static symbol s_16[] = {'a', 'n', 'c', 'e'};
 322 static symbol s_17[] = {'a', 'b', 'l', 'e'};
 323 static symbol s_18[] = {'e', 'n', 't'};
 324 static symbol s_19[] = {'i', 'z', 'e'};
 325 static symbol s_20[] = {'a', 't', 'e'};
 326 static symbol s_21[] = {'a', 'l'};
 327 static symbol s_22[] = {'f', 'u', 'l'};
 328 static symbol s_23[] = {'o', 'u', 's'};
 329 static symbol s_24[] = {'i', 'v', 'e'};
 330 static symbol s_25[] = {'b', 'l', 'e'};
 331 static symbol s_26[] = {'l'};
 332 static symbol s_27[] = {'o', 'g'};
 333 static symbol s_28[] = {'f', 'u', 'l'};
 334 static symbol s_29[] = {'l', 'e', 's', 's'};
 335 static symbol s_30[] = {'t', 'i', 'o', 'n'};
 336 static symbol s_31[] = {'a', 't', 'e'};
 337 static symbol s_32[] = {'a', 'l'};
 338 static symbol s_33[] = {'i', 'c'};
 339 static symbol s_34[] = {'s'};
 340 static symbol s_35[] = {'t'};
 341 static symbol s_36[] = {'l'};
 342 static symbol s_37[] = {'s', 'k', 'i'};
 343 static symbol s_38[] = {'s', 'k', 'y'};
 344 static symbol s_39[] = {'d', 'i', 'e'};
 345 static symbol s_40[] = {'l', 'i', 'e'};
 346 static symbol s_41[] = {'t', 'i', 'e'};
 347 static symbol s_42[] = {'i', 'd', 'l'};
 348 static symbol s_43[] = {'g', 'e', 'n', 't', 'l'};
 349 static symbol s_44[] = {'u', 'g', 'l', 'i'};
 350 static symbol s_45[] = {'e', 'a', 'r', 'l', 'i'};
 351 static symbol s_46[] = {'o', 'n', 'l', 'i'};
 352 static symbol s_47[] = {'s', 'i', 'n', 'g', 'l'};
 353 static symbol s_48[] = {'Y'};
 354 static symbol s_49[] = {'y'};
 355
 356 static int
 357 r_prelude(struct SN_env * z)
 358 {
 359         z->B[0] = 0;                            /* unset Y_found, line 26 */
 360         {
 361                 int                     c = z->c;       /* do, line 27 */
 362
 363                 z->bra = z->c;                  /* [, line 27 */
 364                 if (!(eq_s(z, 1, s_0)))
 365                         goto lab0;
 366                 z->ket = z->c;                  /* ], line 27 */
 367                 {
 368                         int                     ret;
 369
 370                         ret = slice_del(z); /* delete, line 27 */
 371                         if (ret < 0)
 372                                 return ret;
 373                 }
 374 lab0:
 375                 z->c = c;
 376         }
 377         {
 378                 int                     c = z->c;       /* do, line 28 */
 379
 380                 z->bra = z->c;                  /* [, line 28 */
 381                 if (!(eq_s(z, 1, s_1)))
 382                         goto lab1;
 383                 z->ket = z->c;                  /* ], line 28 */
 384                 if (!(in_grouping(z, g_v, 97, 121)))
 385                         goto lab1;
 386                 {
 387                         int                     ret;
 388
 389                         ret = slice_from_s(z, 1, s_2);          /* <-, line 28 */
 390                         if (ret < 0)
 391                                 return ret;
 392                 }
 393                 z->B[0] = 1;                    /* set Y_found, line 28 */
 394 lab1:
 395                 z->c = c;
 396         }
 397         {
 398                 int                     c = z->c;       /* do, line 29 */
 399
 400                 while (1)
 401                 {                                               /* repeat, line 29 */
 402                         int                     c = z->c;
 403
 404                         while (1)
 405                         {                                       /* goto, line 29 */
 406                                 int                     c = z->c;
 407
 408                                 if (!(in_grouping(z, g_v, 97, 121)))
 409                                         goto lab4;
 410                                 z->bra = z->c;  /* [, line 29 */
 411                                 if (!(eq_s(z, 1, s_3)))
 412                                         goto lab4;
 413                                 z->ket = z->c;  /* ], line 29 */
 414                                 z->c = c;
 415                                 break;
 416                 lab4:
 417                                 z->c = c;
 418                                 if (z->c >= z->l)
 419                                         goto lab3;
 420                                 z->c++;                 /* goto, line 29 */
 421                         }
 422                         {
 423                                 int                     ret;
 424
 425                                 ret = slice_from_s(z, 1, s_4);  /* <-, line 29 */
 426                                 if (ret < 0)
 427                                         return ret;
 428                         }
 429                         z->B[0] = 1;            /* set Y_found, line 29 */
 430                         continue;
 431         lab3:
 432                         z->c = c;
 433                         break;
 434                 }
 435                 z->c = c;
 436         }
 437         return 1;
 438 }
 439
 440 static int
 441 r_mark_regions(struct SN_env * z)
 442 {
 443         z->I[0] = z->l;
 444         z->I[1] = z->l;
 445         {
 446                 int                     c = z->c;       /* do, line 35 */
 447
 448                 {
 449                         int                     c = z->c;               /* or, line 40 */
 450
 451                         if (!(find_among(z, a_0, 2)))
 452                                 goto lab2;              /* among, line 36 */
 453                         goto lab1;
 454         lab2:
 455                         z->c = c;
 456                         while (1)
 457                         {                                       /* gopast, line 40 */
 458                                 if (!(in_grouping(z, g_v, 97, 121)))
 459                                         goto lab3;
 460                                 break;
 461                 lab3:
 462                                 if (z->c >= z->l)
 463                                         goto lab0;
 464                                 z->c++;                 /* gopast, line 40 */
 465                         }
 466                         while (1)
 467                         {                                       /* gopast, line 40 */
 468                                 if (!(out_grouping(z, g_v, 97, 121)))
 469                                         goto lab4;
 470                                 break;
 471                 lab4:
 472                                 if (z->c >= z->l)
 473                                         goto lab0;
 474                                 z->c++;                 /* gopast, line 40 */
 475                         }
 476                 }
 477 lab1:
 478                 z->I[0] = z->c;                 /* setmark p1, line 41 */
 479                 while (1)
 480                 {                                               /* gopast, line 42 */
 481                         if (!(in_grouping(z, g_v, 97, 121)))
 482                                 goto lab5;
 483                         break;
 484         lab5:
 485                         if (z->c >= z->l)
 486                                 goto lab0;
 487                         z->c++;                         /* gopast, line 42 */
 488                 }
 489                 while (1)
 490                 {                                               /* gopast, line 42 */
 491                         if (!(out_grouping(z, g_v, 97, 121)))
 492                                 goto lab6;
 493                         break;
 494         lab6:
 495                         if (z->c >= z->l)
 496                                 goto lab0;
 497                         z->c++;                         /* gopast, line 42 */
 498                 }
 499                 z->I[1] = z->c;                 /* setmark p2, line 42 */
 500 lab0:
 501                 z->c = c;
 502         }
 503         return 1;
 504 }
 505
 506 static int
 507 r_shortv(struct SN_env * z)
 508 {
 509         {
 510                 int                     m = z->l - z->c;
 511
 512                 (void) m;                               /* or, line 50 */
 513                 if (!(out_grouping_b(z, g_v_WXY, 89, 121)))
 514                         goto lab1;
 515                 if (!(in_grouping_b(z, g_v, 97, 121)))
 516                         goto lab1;
 517                 if (!(out_grouping_b(z, g_v, 97, 121)))
 518                         goto lab1;
 519                 goto lab0;
 520 lab1:
 521                 z->c = z->l - m;
 522                 if (!(out_grouping_b(z, g_v, 97, 121)))
 523                         return 0;
 524                 if (!(in_grouping_b(z, g_v, 97, 121)))
 525                         return 0;
 526                 if (z->c > z->lb)
 527                         return 0;                       /* atlimit, line 51 */
 528         }
 529 lab0:
 530         return 1;
 531 }
 532
 533 static int
 534 r_R1(struct SN_env * z)
 535 {
 536         if (!(z->I[0] <= z->c))
 537                 return 0;
 538         return 1;
 539 }
 540
 541 static int
 542 r_R2(struct SN_env * z)
 543 {
 544         if (!(z->I[1] <= z->c))
 545                 return 0;
 546         return 1;
 547 }
 548
 549 static int
 550 r_Step_1a(struct SN_env * z)
 551 {
 552         int                     among_var;
 553
 554         {
 555                 int                     m = z->l - z->c;
 556
 557                 (void) m;                               /* try, line 58 */
 558                 z->ket = z->c;                  /* [, line 59 */
 559                 among_var = find_among_b(z, a_1, 3);    /* substring, line 59 */
 560                 if (!(among_var))
 561                 {
 562                         z->c = z->l - m;
 563                         goto lab0;
 564                 }
 565                 z->bra = z->c;                  /* ], line 59 */
 566                 switch (among_var)
 567                 {
 568                         case 0:
 569                                 {
 570                                         z->c = z->l - m;
 571                                         goto lab0;
 572                                 }
 573                         case 1:
 574                                 {
 575                                         int                     ret;
 576
 577                                         ret = slice_del(z); /* delete, line 61 */
 578                                         if (ret < 0)
 579                                                 return ret;
 580                                 }
 581                                 break;
 582                 }
 583 lab0:
 584                 ;
 585         }
 586         z->ket = z->c;                          /* [, line 64 */
 587         among_var = find_among_b(z, a_2, 6);            /* substring, line 64 */
 588         if (!(among_var))
 589                 return 0;
 590         z->bra = z->c;                          /* ], line 64 */
 591         switch (among_var)
 592         {
 593                 case 0:
 594                         return 0;
 595                 case 1:
 596                         {
 597                                 int                     ret;
 598
 599                                 ret = slice_from_s(z, 2, s_5);  /* <-, line 65 */
 600                                 if (ret < 0)
 601                                         return ret;
 602                         }
 603                         break;
 604                 case 2:
 605                         {
 606                                 int                     m = z->l - z->c;
 607
 608                                 (void) m;               /* or, line 67 */
 609                                 if (z->c <= z->lb)
 610                                         goto lab2;
 611                                 z->c--;                 /* next, line 67 */
 612                                 if (z->c > z->lb)
 613                                         goto lab2;      /* atlimit, line 67 */
 614                                 {
 615                                         int                     ret;
 616
 617                                         ret = slice_from_s(z, 2, s_6);          /* <-, line 67 */
 618                                         if (ret < 0)
 619                                                 return ret;
 620                                 }
 621                                 goto lab1;
 622                 lab2:
 623                                 z->c = z->l - m;
 624                                 {
 625                                         int                     ret;
 626
 627                                         ret = slice_from_s(z, 1, s_7);          /* <-, line 67 */
 628                                         if (ret < 0)
 629                                                 return ret;
 630                                 }
 631                         }
 632         lab1:
 633                         break;
 634                 case 3:
 635                         if (z->c <= z->lb)
 636                                 return 0;
 637                         z->c--;                         /* next, line 68 */
 638                         while (1)
 639                         {                                       /* gopast, line 68 */
 640                                 if (!(in_grouping_b(z, g_v, 97, 121)))
 641                                         goto lab3;
 642                                 break;
 643                 lab3:
 644                                 if (z->c <= z->lb)
 645                                         return 0;
 646                                 z->c--;                 /* gopast, line 68 */
 647                         }
 648                         {
 649                                 int                     ret;
 650
 651                                 ret = slice_del(z);             /* delete, line 68 */
 652                                 if (ret < 0)
 653                                         return ret;
 654                         }
 655                         break;
 656         }
 657         return 1;
 658 }
 659
 660 static int
 661 r_Step_1b(struct SN_env * z)
 662 {
 663         int                     among_var;
 664
 665         z->ket = z->c;                          /* [, line 74 */
 666         among_var = find_among_b(z, a_4, 6);            /* substring, line 74 */
 667         if (!(among_var))
 668                 return 0;
 669         z->bra = z->c;                          /* ], line 74 */
 670         switch (among_var)
 671         {
 672                 case 0:
 673                         return 0;
 674                 case 1:
 675                         {
 676                                 int                     ret = r_R1(z);
 677
 678                                 if (ret == 0)
 679                                         return 0;       /* call R1, line 76 */
 680                                 if (ret < 0)
 681                                         return ret;
 682                         }
 683                         {
 684                                 int                     ret;
 685
 686                                 ret = slice_from_s(z, 2, s_8);  /* <-, line 76 */
 687                                 if (ret < 0)
 688                                         return ret;
 689                         }
 690                         break;
 691                 case 2:
 692                         {
 693                                 int                     m_test = z->l - z->c;           /* test, line 79 */
 694
 695                                 while (1)
 696                                 {                               /* gopast, line 79 */
 697                                         if (!(in_grouping_b(z, g_v, 97, 121)))
 698                                                 goto lab0;
 699                                         break;
 700                         lab0:
 701                                         if (z->c <= z->lb)
 702                                                 return 0;
 703                                         z->c--;         /* gopast, line 79 */
 704                                 }
 705                                 z->c = z->l - m_test;
 706                         }
 707                         {
 708                                 int                     ret;
 709
 710                                 ret = slice_del(z);             /* delete, line 79 */
 711                                 if (ret < 0)
 712                                         return ret;
 713                         }
 714                         {
 715                                 int                     m_test = z->l - z->c;           /* test, line 80 */
 716
 717                                 among_var = find_among_b(z, a_3, 13);   /* substring, line 80 */
 718                                 if (!(among_var))
 719                                         return 0;
 720                                 z->c = z->l - m_test;
 721                         }
 722                         switch (among_var)
 723                         {
 724                                 case 0:
 725                                         return 0;
 726                                 case 1:
 727                                         {
 728                                                 int                     ret;
 729
 730                                                 {
 731                                                         int                     c = z->c;
 732
 733                                                         ret = insert_s(z, z->c, z->c, 1, s_9);          /* <+, line 82 */
 734                                                         z->c = c;
 735                                                 }
 736                                                 if (ret < 0)
 737                                                         return ret;
 738                                         }
 739                                         break;
 740                                 case 2:
 741                                         z->ket = z->c;          /* [, line 85 */
 742                                         if (z->c <= z->lb)
 743                                                 return 0;
 744                                         z->c--;         /* next, line 85 */
 745                                         z->bra = z->c;          /* ], line 85 */
 746                                         {
 747                                                 int                     ret;
 748
 749                                                 ret = slice_del(z);             /* delete, line 85 */
 750                                                 if (ret < 0)
 751                                                         return ret;
 752                                         }
 753                                         break;
 754                                 case 3:
 755                                         if (z->c != z->I[0])
 756                                                 return 0;               /* atmark, line 86 */
 757                                         {
 758                                                 int                     m_test = z->l - z->c;           /* test, line 86 */
 759
 760                                                 {
 761                                                         int                     ret = r_shortv(z);
 762
 763                                                         if (ret == 0)
 764                                                                 return 0;               /* call shortv, line 86 */
 765                                                         if (ret < 0)
 766                                                                 return ret;
 767                                                 }
 768                                                 z->c = z->l - m_test;
 769                                         }
 770                                         {
 771                                                 int                     ret;
 772
 773                                                 {
 774                                                         int                     c = z->c;
 775
 776                                                         ret = insert_s(z, z->c, z->c, 1, s_10);         /* <+, line 86 */
 777                                                         z->c = c;
 778                                                 }
 779                                                 if (ret < 0)
 780                                                         return ret;
 781                                         }
 782                                         break;
 783                         }
 784                         break;
 785         }
 786         return 1;
 787 }
 788
 789 static int
 790 r_Step_1c(struct SN_env * z)
 791 {
 792         z->ket = z->c;                          /* [, line 93 */
 793         {
 794                 int                     m = z->l - z->c;
 795
 796                 (void) m;                               /* or, line 93 */
 797                 if (!(eq_s_b(z, 1, s_11)))
 798                         goto lab1;
 799                 goto lab0;
 800 lab1:
 801                 z->c = z->l - m;
 802                 if (!(eq_s_b(z, 1, s_12)))
 803                         return 0;
 804         }
 805 lab0:
 806         z->bra = z->c;                          /* ], line 93 */
 807         if (!(out_grouping_b(z, g_v, 97, 121)))
 808                 return 0;
 809         {
 810                 int                     m = z->l - z->c;
 811
 812                 (void) m;                               /* not, line 94 */
 813                 if (z->c > z->lb)
 814                         goto lab2;                      /* atlimit, line 94 */
 815                 return 0;
 816 lab2:
 817                 z->c = z->l - m;
 818         }
 819         {
 820                 int                     ret;
 821
 822                 ret = slice_from_s(z, 1, s_13); /* <-, line 95 */
 823                 if (ret < 0)
 824                         return ret;
 825         }
 826         return 1;
 827 }
 828
 829 static int
 830 r_Step_2(struct SN_env * z)
 831 {
 832         int                     among_var;
 833
 834         z->ket = z->c;                          /* [, line 99 */
 835         among_var = find_among_b(z, a_5, 24);           /* substring, line 99 */
 836         if (!(among_var))
 837                 return 0;
 838         z->bra = z->c;                          /* ], line 99 */
 839         {
 840                 int                     ret = r_R1(z);
 841
 842                 if (ret == 0)
 843                         return 0;                       /* call R1, line 99 */
 844                 if (ret < 0)
 845                         return ret;
 846         }
 847         switch (among_var)
 848         {
 849                 case 0:
 850                         return 0;
 851                 case 1:
 852                         {
 853                                 int                     ret;
 854
 855                                 ret = slice_from_s(z, 4, s_14); /* <-, line 100 */
 856                                 if (ret < 0)
 857                                         return ret;
 858                         }
 859                         break;
 860                 case 2:
 861                         {
 862                                 int                     ret;
 863
 864                                 ret = slice_from_s(z, 4, s_15); /* <-, line 101 */
 865                                 if (ret < 0)
 866                                         return ret;
 867                         }
 868                         break;
 869                 case 3:
 870                         {
 871                                 int                     ret;
 872
 873                                 ret = slice_from_s(z, 4, s_16); /* <-, line 102 */
 874                                 if (ret < 0)
 875                                         return ret;
 876                         }
 877                         break;
 878                 case 4:
 879                         {
 880                                 int                     ret;
 881
 882                                 ret = slice_from_s(z, 4, s_17); /* <-, line 103 */
 883                                 if (ret < 0)
 884                                         return ret;
 885                         }
 886                         break;
 887                 case 5:
 888                         {
 889                                 int                     ret;
 890
 891                                 ret = slice_from_s(z, 3, s_18); /* <-, line 104 */
 892                                 if (ret < 0)
 893                                         return ret;
 894                         }
 895                         break;
 896                 case 6:
 897                         {
 898                                 int                     ret;
 899
 900                                 ret = slice_from_s(z, 3, s_19); /* <-, line 106 */
 901                                 if (ret < 0)
 902                                         return ret;
 903                         }
 904                         break;
 905                 case 7:
 906                         {
 907                                 int                     ret;
 908
 909                                 ret = slice_from_s(z, 3, s_20); /* <-, line 108 */
 910                                 if (ret < 0)
 911                                         return ret;
 912                         }
 913                         break;
 914                 case 8:
 915                         {
 916                                 int                     ret;
 917
 918                                 ret = slice_from_s(z, 2, s_21); /* <-, line 110 */
 919                                 if (ret < 0)
 920                                         return ret;
 921                         }
 922                         break;
 923                 case 9:
 924                         {
 925                                 int                     ret;
 926
 927                                 ret = slice_from_s(z, 3, s_22); /* <-, line 111 */
 928                                 if (ret < 0)
 929                                         return ret;
 930                         }
 931                         break;
 932                 case 10:
 933                         {
 934                                 int                     ret;
 935
 936                                 ret = slice_from_s(z, 3, s_23); /* <-, line 113 */
 937                                 if (ret < 0)
 938                                         return ret;
 939                         }
 940                         break;
 941                 case 11:
 942                         {
 943                                 int                     ret;
 944
 945                                 ret = slice_from_s(z, 3, s_24); /* <-, line 115 */
 946                                 if (ret < 0)
 947                                         return ret;
 948                         }
 949                         break;
 950                 case 12:
 951                         {
 952                                 int                     ret;
 953
 954                                 ret = slice_from_s(z, 3, s_25); /* <-, line 117 */
 955                                 if (ret < 0)
 956                                         return ret;
 957                         }
 958                         break;
 959                 case 13:
 960                         if (!(eq_s_b(z, 1, s_26)))
 961                                 return 0;
 962                         {
 963                                 int                     ret;
 964
 965                                 ret = slice_from_s(z, 2, s_27); /* <-, line 118 */
 966                                 if (ret < 0)
 967                                         return ret;
 968                         }
 969                         break;
 970                 case 14:
 971                         {
 972                                 int                     ret;
 973
 974                                 ret = slice_from_s(z, 3, s_28); /* <-, line 119 */
 975                                 if (ret < 0)
 976                                         return ret;
 977                         }
 978                         break;
 979                 case 15:
 980                         {
 981                                 int                     ret;
 982
 983                                 ret = slice_from_s(z, 4, s_29); /* <-, line 120 */
 984                                 if (ret < 0)
 985                                         return ret;
 986                         }
 987                         break;
 988                 case 16:
 989                         if (!(in_grouping_b(z, g_valid_LI, 99, 116)))
 990                                 return 0;
 991                         {
 992                                 int                     ret;
 993
 994                                 ret = slice_del(z);             /* delete, line 121 */
 995                                 if (ret < 0)
 996                                         return ret;
 997                         }
 998                         break;
 999         }
1000         return 1;
1001 }
1002
1003 static int
1004 r_Step_3(struct SN_env * z)
1005 {
1006         int                     among_var;
1007
1008         z->ket = z->c;                          /* [, line 126 */
1009         among_var = find_among_b(z, a_6, 9);            /* substring, line 126 */
1010         if (!(among_var))
1011                 return 0;
1012         z->bra = z->c;                          /* ], line 126 */
1013         {
1014                 int                     ret = r_R1(z);
1015
1016                 if (ret == 0)
1017                         return 0;                       /* call R1, line 126 */
1018                 if (ret < 0)
1019                         return ret;
1020         }
1021         switch (among_var)
1022         {
1023                 case 0:
1024                         return 0;
1025                 case 1:
1026                         {
1027                                 int                     ret;
1028
1029                                 ret = slice_from_s(z, 4, s_30); /* <-, line 127 */
1030                                 if (ret < 0)
1031                                         return ret;
1032                         }
1033                         break;
1034                 case 2:
1035                         {
1036                                 int                     ret;
1037
1038                                 ret = slice_from_s(z, 3, s_31); /* <-, line 128 */
1039                                 if (ret < 0)
1040                                         return ret;
1041                         }
1042                         break;
1043                 case 3:
1044                         {
1045                                 int                     ret;
1046
1047                                 ret = slice_from_s(z, 2, s_32); /* <-, line 129 */
1048                                 if (ret < 0)
1049                                         return ret;
1050                         }
1051                         break;
1052                 case 4:
1053                         {
1054                                 int                     ret;
1055
1056                                 ret = slice_from_s(z, 2, s_33); /* <-, line 131 */
1057                                 if (ret < 0)
1058                                         return ret;
1059                         }
1060                         break;
1061                 case 5:
1062                         {
1063                                 int                     ret;
1064
1065                                 ret = slice_del(z);             /* delete, line 133 */
1066                                 if (ret < 0)
1067                                         return ret;
1068                         }
1069                         break;
1070                 case 6:
1071                         {
1072                                 int                     ret = r_R2(z);
1073
1074                                 if (ret == 0)
1075                                         return 0;       /* call R2, line 135 */
1076                                 if (ret < 0)
1077                                         return ret;
1078                         }
1079                         {
1080                                 int                     ret;
1081
1082                                 ret = slice_del(z);             /* delete, line 135 */
1083                                 if (ret < 0)
1084                                         return ret;
1085                         }
1086                         break;
1087         }
1088         return 1;
1089 }
1090
1091 static int
1092 r_Step_4(struct SN_env * z)
1093 {
1094         int                     among_var;
1095
1096         z->ket = z->c;                          /* [, line 140 */
1097         among_var = find_among_b(z, a_7, 18);           /* substring, line 140 */
1098         if (!(among_var))
1099                 return 0;
1100         z->bra = z->c;                          /* ], line 140 */
1101         {
1102                 int                     ret = r_R2(z);
1103
1104                 if (ret == 0)
1105                         return 0;                       /* call R2, line 140 */
1106                 if (ret < 0)
1107                         return ret;
1108         }
1109         switch (among_var)
1110         {
1111                 case 0:
1112                         return 0;
1113                 case 1:
1114                         {
1115                                 int                     ret;
1116
1117                                 ret = slice_del(z);             /* delete, line 143 */
1118                                 if (ret < 0)
1119                                         return ret;
1120                         }
1121                         break;
1122                 case 2:
1123                         {
1124                                 int                     m = z->l - z->c;
1125
1126                                 (void) m;               /* or, line 144 */
1127                                 if (!(eq_s_b(z, 1, s_34)))
1128                                         goto lab1;
1129                                 goto lab0;
1130                 lab1:
1131                                 z->c = z->l - m;
1132                                 if (!(eq_s_b(z, 1, s_35)))
1133                                         return 0;
1134                         }
1135         lab0:
1136                         {
1137                                 int                     ret;
1138
1139                                 ret = slice_del(z);             /* delete, line 144 */
1140                                 if (ret < 0)
1141                                         return ret;
1142                         }
1143                         break;
1144         }
1145         return 1;
1146 }
1147
1148 static int
1149 r_Step_5(struct SN_env * z)
1150 {
1151         int                     among_var;
1152
1153         z->ket = z->c;                          /* [, line 149 */
1154         among_var = find_among_b(z, a_8, 2);            /* substring, line 149 */
1155         if (!(among_var))
1156                 return 0;
1157         z->bra = z->c;                          /* ], line 149 */
1158         switch (among_var)
1159         {
1160                 case 0:
1161                         return 0;
1162                 case 1:
1163                         {
1164                                 int                     m = z->l - z->c;
1165
1166                                 (void) m;               /* or, line 150 */
1167                                 {
1168                                         int                     ret = r_R2(z);
1169
1170                                         if (ret == 0)
1171                                                 goto lab1;              /* call R2, line 150 */
1172                                         if (ret < 0)
1173                                                 return ret;
1174                                 }
1175                                 goto lab0;
1176                 lab1:
1177                                 z->c = z->l - m;
1178                                 {
1179                                         int                     ret = r_R1(z);
1180
1181                                         if (ret == 0)
1182                                                 return 0;               /* call R1, line 150 */
1183                                         if (ret < 0)
1184                                                 return ret;
1185                                 }
1186                                 {
1187                                         int                     m = z->l - z->c;
1188
1189                                         (void) m;       /* not, line 150 */
1190                                         {
1191                                                 int                     ret = r_shortv(z);
1192
1193                                                 if (ret == 0)
1194                                                         goto lab2;      /* call shortv, line 150 */
1195                                                 if (ret < 0)
1196                                                         return ret;
1197                                         }
1198                                         return 0;
1199                         lab2:
1200                                         z->c = z->l - m;
1201                                 }
1202                         }
1203         lab0:
1204                         {
1205                                 int                     ret;
1206
1207                                 ret = slice_del(z);             /* delete, line 150 */
1208                                 if (ret < 0)
1209                                         return ret;
1210                         }
1211                         break;
1212                 case 2:
1213                         {
1214                                 int                     ret = r_R2(z);
1215
1216                                 if (ret == 0)
1217                                         return 0;       /* call R2, line 151 */
1218                                 if (ret < 0)
1219                                         return ret;
1220                         }
1221                         if (!(eq_s_b(z, 1, s_36)))
1222                                 return 0;
1223                         {
1224                                 int                     ret;
1225
1226                                 ret = slice_del(z);             /* delete, line 151 */
1227                                 if (ret < 0)
1228                                         return ret;
1229                         }
1230                         break;
1231         }
1232         return 1;
1233 }
1234
1235 static int
1236 r_exception2(struct SN_env * z)
1237 {
1238         z->ket = z->c;                          /* [, line 157 */
1239         if (!(find_among_b(z, a_9, 8)))
1240                 return 0;                               /* substring, line 157 */
1241         z->bra = z->c;                          /* ], line 157 */
1242         if (z->c > z->lb)
1243                 return 0;                               /* atlimit, line 157 */
1244         return 1;
1245 }
1246
1247 static int
1248 r_exception1(struct SN_env * z)
1249 {
1250         int                     among_var;
1251
1252         z->bra = z->c;                          /* [, line 169 */
1253         among_var = find_among(z, a_10, 18);            /* substring, line 169 */
1254         if (!(among_var))
1255                 return 0;
1256         z->ket = z->c;                          /* ], line 169 */
1257         if (z->c < z->l)
1258                 return 0;                               /* atlimit, line 169 */
1259         switch (among_var)
1260         {
1261                 case 0:
1262                         return 0;
1263                 case 1:
1264                         {
1265                                 int                     ret;
1266
1267                                 ret = slice_from_s(z, 3, s_37); /* <-, line 173 */
1268                                 if (ret < 0)
1269                                         return ret;
1270                         }
1271                         break;
1272                 case 2:
1273                         {
1274                                 int                     ret;
1275
1276                                 ret = slice_from_s(z, 3, s_38); /* <-, line 174 */
1277                                 if (ret < 0)
1278                                         return ret;
1279                         }
1280                         break;
1281                 case 3:
1282                         {
1283                                 int                     ret;
1284
1285                                 ret = slice_from_s(z, 3, s_39); /* <-, line 175 */
1286                                 if (ret < 0)
1287                                         return ret;
1288                         }
1289                         break;
1290                 case 4:
1291                         {
1292                                 int                     ret;
1293
1294                                 ret = slice_from_s(z, 3, s_40); /* <-, line 176 */
1295                                 if (ret < 0)
1296                                         return ret;
1297                         }
1298                         break;
1299                 case 5:
1300                         {
1301                                 int                     ret;
1302
1303                                 ret = slice_from_s(z, 3, s_41); /* <-, line 177 */
1304                                 if (ret < 0)
1305                                         return ret;
1306                         }
1307                         break;
1308                 case 6:
1309                         {
1310                                 int                     ret;
1311
1312                                 ret = slice_from_s(z, 3, s_42); /* <-, line 181 */
1313                                 if (ret < 0)
1314                                         return ret;
1315                         }
1316                         break;
1317                 case 7:
1318                         {
1319                                 int                     ret;
1320
1321                                 ret = slice_from_s(z, 5, s_43); /* <-, line 182 */
1322                                 if (ret < 0)
1323                                         return ret;
1324                         }
1325                         break;
1326                 case 8:
1327                         {
1328                                 int                     ret;
1329
1330                                 ret = slice_from_s(z, 4, s_44); /* <-, line 183 */
1331                                 if (ret < 0)
1332                                         return ret;
1333                         }
1334                         break;
1335                 case 9:
1336                         {
1337                                 int                     ret;
1338
1339                                 ret = slice_from_s(z, 5, s_45); /* <-, line 184 */
1340                                 if (ret < 0)
1341                                         return ret;
1342                         }
1343                         break;
1344                 case 10:
1345                         {
1346                                 int                     ret;
1347
1348                                 ret = slice_from_s(z, 4, s_46); /* <-, line 185 */
1349                                 if (ret < 0)
1350                                         return ret;
1351                         }
1352                         break;
1353                 case 11:
1354                         {
1355                                 int                     ret;
1356
1357                                 ret = slice_from_s(z, 5, s_47); /* <-, line 186 */
1358                                 if (ret < 0)
1359                                         return ret;
1360                         }
1361                         break;
1362         }
1363         return 1;
1364 }
1365
1366 static int
1367 r_postlude(struct SN_env * z)
1368 {
1369         if (!(z->B[0]))
1370                 return 0;                               /* Boolean test Y_found, line 202 */
1371         while (1)
1372         {                                                       /* repeat, line 202 */
1373                 int                     c = z->c;
1374
1375                 while (1)
1376                 {                                               /* goto, line 202 */
1377                         int                     c = z->c;
1378
1379                         z->bra = z->c;          /* [, line 202 */
1380                         if (!(eq_s(z, 1, s_48)))
1381                                 goto lab1;
1382                         z->ket = z->c;          /* ], line 202 */
1383                         z->c = c;
1384                         break;
1385         lab1:
1386                         z->c = c;
1387                         if (z->c >= z->l)
1388                                 goto lab0;
1389                         z->c++;                         /* goto, line 202 */
1390                 }
1391                 {
1392                         int                     ret;
1393
1394                         ret = slice_from_s(z, 1, s_49);         /* <-, line 202 */
1395                         if (ret < 0)
1396                                 return ret;
1397                 }
1398                 continue;
1399 lab0:
1400                 z->c = c;
1401                 break;
1402         }
1403         return 1;
1404 }
1405
1406 extern int
1407 english_ISO_8859_1_stem(struct SN_env * z)
1408 {
1409         {
1410                 int                     c = z->c;       /* or, line 206 */
1411
1412                 {
1413                         int                     ret = r_exception1(z);
1414
1415                         if (ret == 0)
1416                                 goto lab1;              /* call exception1, line 206 */
1417                         if (ret < 0)
1418                                 return ret;
1419                 }
1420                 goto lab0;
1421 lab1:
1422                 z->c = c;
1423                 {
1424                         int                     c = z->c;               /* not, line 207 */
1425
1426                         {
1427                                 int                     c = z->c + 3;
1428
1429                                 if (0 > c || c > z->l)
1430                                         goto lab3;
1431                                 z->c = c;               /* hop, line 207 */
1432                         }
1433                         goto lab2;
1434         lab3:
1435                         z->c = c;
1436                 }
1437                 goto lab0;
1438 lab2:
1439                 z->c = c;
1440                 {
1441                         int                     c = z->c;               /* do, line 208 */
1442
1443                         {
1444                                 int                     ret = r_prelude(z);
1445
1446                                 if (ret == 0)
1447                                         goto lab4;      /* call prelude, line 208 */
1448                                 if (ret < 0)
1449                                         return ret;
1450                         }
1451         lab4:
1452                         z->c = c;
1453                 }
1454                 {
1455                         int                     c = z->c;               /* do, line 209 */
1456
1457                         {
1458                                 int                     ret = r_mark_regions(z);
1459
1460                                 if (ret == 0)
1461                                         goto lab5;      /* call mark_regions, line 209 */
1462                                 if (ret < 0)
1463                                         return ret;
1464                         }
1465         lab5:
1466                         z->c = c;
1467                 }
1468                 z->lb = z->c;
1469                 z->c = z->l;                    /* backwards, line 210 */
1470
1471                 {
1472                         int                     m = z->l - z->c;
1473
1474                         (void) m;                       /* do, line 212 */
1475                         {
1476                                 int                     ret = r_Step_1a(z);
1477
1478                                 if (ret == 0)
1479                                         goto lab6;      /* call Step_1a, line 212 */
1480                                 if (ret < 0)
1481                                         return ret;
1482                         }
1483         lab6:
1484                         z->c = z->l - m;
1485                 }
1486                 {
1487                         int                     m = z->l - z->c;
1488
1489                         (void) m;                       /* or, line 214 */
1490                         {
1491                                 int                     ret = r_exception2(z);
1492
1493                                 if (ret == 0)
1494                                         goto lab8;      /* call exception2, line 214 */
1495                                 if (ret < 0)
1496                                         return ret;
1497                         }
1498                         goto lab7;
1499         lab8:
1500                         z->c = z->l - m;
1501                         {
1502                                 int                     m = z->l - z->c;
1503
1504                                 (void) m;               /* do, line 216 */
1505                                 {
1506                                         int                     ret = r_Step_1b(z);
1507
1508                                         if (ret == 0)
1509                                                 goto lab9;              /* call Step_1b, line 216 */
1510                                         if (ret < 0)
1511                                                 return ret;
1512                                 }
1513                 lab9:
1514                                 z->c = z->l - m;
1515                         }
1516                         {
1517                                 int                     m = z->l - z->c;
1518
1519                                 (void) m;               /* do, line 217 */
1520                                 {
1521                                         int                     ret = r_Step_1c(z);
1522
1523                                         if (ret == 0)
1524                                                 goto lab10;             /* call Step_1c, line 217 */
1525                                         if (ret < 0)
1526                                                 return ret;
1527                                 }
1528                 lab10:
1529                                 z->c = z->l - m;
1530                         }
1531                         {
1532                                 int                     m = z->l - z->c;
1533
1534                                 (void) m;               /* do, line 219 */
1535                                 {
1536                                         int                     ret = r_Step_2(z);
1537
1538                                         if (ret == 0)
1539                                                 goto lab11;             /* call Step_2, line 219 */
1540                                         if (ret < 0)
1541                                                 return ret;
1542                                 }
1543                 lab11:
1544                                 z->c = z->l - m;
1545                         }
1546                         {
1547                                 int                     m = z->l - z->c;
1548
1549                                 (void) m;               /* do, line 220 */
1550                                 {
1551                                         int                     ret = r_Step_3(z);
1552
1553                                         if (ret == 0)
1554                                                 goto lab12;             /* call Step_3, line 220 */
1555                                         if (ret < 0)
1556                                                 return ret;
1557                                 }
1558                 lab12:
1559                                 z->c = z->l - m;
1560                         }
1561                         {
1562                                 int                     m = z->l - z->c;
1563
1564                                 (void) m;               /* do, line 221 */
1565                                 {
1566                                         int                     ret = r_Step_4(z);
1567
1568                                         if (ret == 0)
1569                                                 goto lab13;             /* call Step_4, line 221 */
1570                                         if (ret < 0)
1571                                                 return ret;
1572                                 }
1573                 lab13:
1574                                 z->c = z->l - m;
1575                         }
1576                         {
1577                                 int                     m = z->l - z->c;
1578
1579                                 (void) m;               /* do, line 223 */
1580                                 {
1581                                         int                     ret = r_Step_5(z);
1582
1583                                         if (ret == 0)
1584                                                 goto lab14;             /* call Step_5, line 223 */
1585                                         if (ret < 0)
1586                                                 return ret;
1587                                 }
1588                 lab14:
1589                                 z->c = z->l - m;
1590                         }
1591                 }
1592 lab7:
1593                 z->c = z->lb;
1594                 {
1595                         int                     c = z->c;               /* do, line 226 */
1596
1597                         {
1598                                 int                     ret = r_postlude(z);
1599
1600                                 if (ret == 0)
1601                                         goto lab15; /* call postlude, line 226 */
1602                                 if (ret < 0)
1603                                         return ret;
1604                         }
1605         lab15:
1606                         z->c = c;
1607                 }
1608         }
1609 lab0:
1610         return 1;
1611 }
1612
1613 extern struct SN_env *
1614 english_ISO_8859_1_create_env(void)
1615 {
1616         return SN_create_env(0, 2, 1);
1617 }
1618
1619 extern void
1620 english_ISO_8859_1_close_env(struct SN_env * z)
1621 {
1622         SN_close_env(z);
1623 }