Header And Logo

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

stem_UTF_8_french.c

Go to the documentation of this file.
00001 
00002 /* This file was generated automatically by the Snowball to ANSI C compiler */
00003 
00004 #include "header.h"
00005 
00006 #ifdef __cplusplus
00007 extern "C" {
00008 #endif
00009 extern int french_UTF_8_stem(struct SN_env * z);
00010 #ifdef __cplusplus
00011 }
00012 #endif
00013 static int r_un_accent(struct SN_env * z);
00014 static int r_un_double(struct SN_env * z);
00015 static int r_residual_suffix(struct SN_env * z);
00016 static int r_verb_suffix(struct SN_env * z);
00017 static int r_i_verb_suffix(struct SN_env * z);
00018 static int r_standard_suffix(struct SN_env * z);
00019 static int r_R2(struct SN_env * z);
00020 static int r_R1(struct SN_env * z);
00021 static int r_RV(struct SN_env * z);
00022 static int r_mark_regions(struct SN_env * z);
00023 static int r_postlude(struct SN_env * z);
00024 static int r_prelude(struct SN_env * z);
00025 #ifdef __cplusplus
00026 extern "C" {
00027 #endif
00028 
00029 
00030 extern struct SN_env * french_UTF_8_create_env(void);
00031 extern void french_UTF_8_close_env(struct SN_env * z);
00032 
00033 
00034 #ifdef __cplusplus
00035 }
00036 #endif
00037 static const symbol s_0_0[3] = { 'c', 'o', 'l' };
00038 static const symbol s_0_1[3] = { 'p', 'a', 'r' };
00039 static const symbol s_0_2[3] = { 't', 'a', 'p' };
00040 
00041 static const struct among a_0[3] =
00042 {
00043 /*  0 */ { 3, s_0_0, -1, -1, 0},
00044 /*  1 */ { 3, s_0_1, -1, -1, 0},
00045 /*  2 */ { 3, s_0_2, -1, -1, 0}
00046 };
00047 
00048 static const symbol s_1_1[1] = { 'I' };
00049 static const symbol s_1_2[1] = { 'U' };
00050 static const symbol s_1_3[1] = { 'Y' };
00051 
00052 static const struct among a_1[4] =
00053 {
00054 /*  0 */ { 0, 0, -1, 4, 0},
00055 /*  1 */ { 1, s_1_1, 0, 1, 0},
00056 /*  2 */ { 1, s_1_2, 0, 2, 0},
00057 /*  3 */ { 1, s_1_3, 0, 3, 0}
00058 };
00059 
00060 static const symbol s_2_0[3] = { 'i', 'q', 'U' };
00061 static const symbol s_2_1[3] = { 'a', 'b', 'l' };
00062 static const symbol s_2_2[4] = { 'I', 0xC3, 0xA8, 'r' };
00063 static const symbol s_2_3[4] = { 'i', 0xC3, 0xA8, 'r' };
00064 static const symbol s_2_4[3] = { 'e', 'u', 's' };
00065 static const symbol s_2_5[2] = { 'i', 'v' };
00066 
00067 static const struct among a_2[6] =
00068 {
00069 /*  0 */ { 3, s_2_0, -1, 3, 0},
00070 /*  1 */ { 3, s_2_1, -1, 3, 0},
00071 /*  2 */ { 4, s_2_2, -1, 4, 0},
00072 /*  3 */ { 4, s_2_3, -1, 4, 0},
00073 /*  4 */ { 3, s_2_4, -1, 2, 0},
00074 /*  5 */ { 2, s_2_5, -1, 1, 0}
00075 };
00076 
00077 static const symbol s_3_0[2] = { 'i', 'c' };
00078 static const symbol s_3_1[4] = { 'a', 'b', 'i', 'l' };
00079 static const symbol s_3_2[2] = { 'i', 'v' };
00080 
00081 static const struct among a_3[3] =
00082 {
00083 /*  0 */ { 2, s_3_0, -1, 2, 0},
00084 /*  1 */ { 4, s_3_1, -1, 1, 0},
00085 /*  2 */ { 2, s_3_2, -1, 3, 0}
00086 };
00087 
00088 static const symbol s_4_0[4] = { 'i', 'q', 'U', 'e' };
00089 static const symbol s_4_1[6] = { 'a', 't', 'r', 'i', 'c', 'e' };
00090 static const symbol s_4_2[4] = { 'a', 'n', 'c', 'e' };
00091 static const symbol s_4_3[4] = { 'e', 'n', 'c', 'e' };
00092 static const symbol s_4_4[5] = { 'l', 'o', 'g', 'i', 'e' };
00093 static const symbol s_4_5[4] = { 'a', 'b', 'l', 'e' };
00094 static const symbol s_4_6[4] = { 'i', 's', 'm', 'e' };
00095 static const symbol s_4_7[4] = { 'e', 'u', 's', 'e' };
00096 static const symbol s_4_8[4] = { 'i', 's', 't', 'e' };
00097 static const symbol s_4_9[3] = { 'i', 'v', 'e' };
00098 static const symbol s_4_10[2] = { 'i', 'f' };
00099 static const symbol s_4_11[5] = { 'u', 's', 'i', 'o', 'n' };
00100 static const symbol s_4_12[5] = { 'a', 't', 'i', 'o', 'n' };
00101 static const symbol s_4_13[5] = { 'u', 't', 'i', 'o', 'n' };
00102 static const symbol s_4_14[5] = { 'a', 't', 'e', 'u', 'r' };
00103 static const symbol s_4_15[5] = { 'i', 'q', 'U', 'e', 's' };
00104 static const symbol s_4_16[7] = { 'a', 't', 'r', 'i', 'c', 'e', 's' };
00105 static const symbol s_4_17[5] = { 'a', 'n', 'c', 'e', 's' };
00106 static const symbol s_4_18[5] = { 'e', 'n', 'c', 'e', 's' };
00107 static const symbol s_4_19[6] = { 'l', 'o', 'g', 'i', 'e', 's' };
00108 static const symbol s_4_20[5] = { 'a', 'b', 'l', 'e', 's' };
00109 static const symbol s_4_21[5] = { 'i', 's', 'm', 'e', 's' };
00110 static const symbol s_4_22[5] = { 'e', 'u', 's', 'e', 's' };
00111 static const symbol s_4_23[5] = { 'i', 's', 't', 'e', 's' };
00112 static const symbol s_4_24[4] = { 'i', 'v', 'e', 's' };
00113 static const symbol s_4_25[3] = { 'i', 'f', 's' };
00114 static const symbol s_4_26[6] = { 'u', 's', 'i', 'o', 'n', 's' };
00115 static const symbol s_4_27[6] = { 'a', 't', 'i', 'o', 'n', 's' };
00116 static const symbol s_4_28[6] = { 'u', 't', 'i', 'o', 'n', 's' };
00117 static const symbol s_4_29[6] = { 'a', 't', 'e', 'u', 'r', 's' };
00118 static const symbol s_4_30[5] = { 'm', 'e', 'n', 't', 's' };
00119 static const symbol s_4_31[6] = { 'e', 'm', 'e', 'n', 't', 's' };
00120 static const symbol s_4_32[9] = { 'i', 's', 's', 'e', 'm', 'e', 'n', 't', 's' };
00121 static const symbol s_4_33[5] = { 'i', 't', 0xC3, 0xA9, 's' };
00122 static const symbol s_4_34[4] = { 'm', 'e', 'n', 't' };
00123 static const symbol s_4_35[5] = { 'e', 'm', 'e', 'n', 't' };
00124 static const symbol s_4_36[8] = { 'i', 's', 's', 'e', 'm', 'e', 'n', 't' };
00125 static const symbol s_4_37[6] = { 'a', 'm', 'm', 'e', 'n', 't' };
00126 static const symbol s_4_38[6] = { 'e', 'm', 'm', 'e', 'n', 't' };
00127 static const symbol s_4_39[3] = { 'a', 'u', 'x' };
00128 static const symbol s_4_40[4] = { 'e', 'a', 'u', 'x' };
00129 static const symbol s_4_41[3] = { 'e', 'u', 'x' };
00130 static const symbol s_4_42[4] = { 'i', 't', 0xC3, 0xA9 };
00131 
00132 static const struct among a_4[43] =
00133 {
00134 /*  0 */ { 4, s_4_0, -1, 1, 0},
00135 /*  1 */ { 6, s_4_1, -1, 2, 0},
00136 /*  2 */ { 4, s_4_2, -1, 1, 0},
00137 /*  3 */ { 4, s_4_3, -1, 5, 0},
00138 /*  4 */ { 5, s_4_4, -1, 3, 0},
00139 /*  5 */ { 4, s_4_5, -1, 1, 0},
00140 /*  6 */ { 4, s_4_6, -1, 1, 0},
00141 /*  7 */ { 4, s_4_7, -1, 11, 0},
00142 /*  8 */ { 4, s_4_8, -1, 1, 0},
00143 /*  9 */ { 3, s_4_9, -1, 8, 0},
00144 /* 10 */ { 2, s_4_10, -1, 8, 0},
00145 /* 11 */ { 5, s_4_11, -1, 4, 0},
00146 /* 12 */ { 5, s_4_12, -1, 2, 0},
00147 /* 13 */ { 5, s_4_13, -1, 4, 0},
00148 /* 14 */ { 5, s_4_14, -1, 2, 0},
00149 /* 15 */ { 5, s_4_15, -1, 1, 0},
00150 /* 16 */ { 7, s_4_16, -1, 2, 0},
00151 /* 17 */ { 5, s_4_17, -1, 1, 0},
00152 /* 18 */ { 5, s_4_18, -1, 5, 0},
00153 /* 19 */ { 6, s_4_19, -1, 3, 0},
00154 /* 20 */ { 5, s_4_20, -1, 1, 0},
00155 /* 21 */ { 5, s_4_21, -1, 1, 0},
00156 /* 22 */ { 5, s_4_22, -1, 11, 0},
00157 /* 23 */ { 5, s_4_23, -1, 1, 0},
00158 /* 24 */ { 4, s_4_24, -1, 8, 0},
00159 /* 25 */ { 3, s_4_25, -1, 8, 0},
00160 /* 26 */ { 6, s_4_26, -1, 4, 0},
00161 /* 27 */ { 6, s_4_27, -1, 2, 0},
00162 /* 28 */ { 6, s_4_28, -1, 4, 0},
00163 /* 29 */ { 6, s_4_29, -1, 2, 0},
00164 /* 30 */ { 5, s_4_30, -1, 15, 0},
00165 /* 31 */ { 6, s_4_31, 30, 6, 0},
00166 /* 32 */ { 9, s_4_32, 31, 12, 0},
00167 /* 33 */ { 5, s_4_33, -1, 7, 0},
00168 /* 34 */ { 4, s_4_34, -1, 15, 0},
00169 /* 35 */ { 5, s_4_35, 34, 6, 0},
00170 /* 36 */ { 8, s_4_36, 35, 12, 0},
00171 /* 37 */ { 6, s_4_37, 34, 13, 0},
00172 /* 38 */ { 6, s_4_38, 34, 14, 0},
00173 /* 39 */ { 3, s_4_39, -1, 10, 0},
00174 /* 40 */ { 4, s_4_40, 39, 9, 0},
00175 /* 41 */ { 3, s_4_41, -1, 1, 0},
00176 /* 42 */ { 4, s_4_42, -1, 7, 0}
00177 };
00178 
00179 static const symbol s_5_0[3] = { 'i', 'r', 'a' };
00180 static const symbol s_5_1[2] = { 'i', 'e' };
00181 static const symbol s_5_2[4] = { 'i', 's', 's', 'e' };
00182 static const symbol s_5_3[7] = { 'i', 's', 's', 'a', 'n', 't', 'e' };
00183 static const symbol s_5_4[1] = { 'i' };
00184 static const symbol s_5_5[4] = { 'i', 'r', 'a', 'i' };
00185 static const symbol s_5_6[2] = { 'i', 'r' };
00186 static const symbol s_5_7[4] = { 'i', 'r', 'a', 's' };
00187 static const symbol s_5_8[3] = { 'i', 'e', 's' };
00188 static const symbol s_5_9[5] = { 0xC3, 0xAE, 'm', 'e', 's' };
00189 static const symbol s_5_10[5] = { 'i', 's', 's', 'e', 's' };
00190 static const symbol s_5_11[8] = { 'i', 's', 's', 'a', 'n', 't', 'e', 's' };
00191 static const symbol s_5_12[5] = { 0xC3, 0xAE, 't', 'e', 's' };
00192 static const symbol s_5_13[2] = { 'i', 's' };
00193 static const symbol s_5_14[5] = { 'i', 'r', 'a', 'i', 's' };
00194 static const symbol s_5_15[6] = { 'i', 's', 's', 'a', 'i', 's' };
00195 static const symbol s_5_16[6] = { 'i', 'r', 'i', 'o', 'n', 's' };
00196 static const symbol s_5_17[7] = { 'i', 's', 's', 'i', 'o', 'n', 's' };
00197 static const symbol s_5_18[5] = { 'i', 'r', 'o', 'n', 's' };
00198 static const symbol s_5_19[6] = { 'i', 's', 's', 'o', 'n', 's' };
00199 static const symbol s_5_20[7] = { 'i', 's', 's', 'a', 'n', 't', 's' };
00200 static const symbol s_5_21[2] = { 'i', 't' };
00201 static const symbol s_5_22[5] = { 'i', 'r', 'a', 'i', 't' };
00202 static const symbol s_5_23[6] = { 'i', 's', 's', 'a', 'i', 't' };
00203 static const symbol s_5_24[6] = { 'i', 's', 's', 'a', 'n', 't' };
00204 static const symbol s_5_25[7] = { 'i', 'r', 'a', 'I', 'e', 'n', 't' };
00205 static const symbol s_5_26[8] = { 'i', 's', 's', 'a', 'I', 'e', 'n', 't' };
00206 static const symbol s_5_27[5] = { 'i', 'r', 'e', 'n', 't' };
00207 static const symbol s_5_28[6] = { 'i', 's', 's', 'e', 'n', 't' };
00208 static const symbol s_5_29[5] = { 'i', 'r', 'o', 'n', 't' };
00209 static const symbol s_5_30[3] = { 0xC3, 0xAE, 't' };
00210 static const symbol s_5_31[5] = { 'i', 'r', 'i', 'e', 'z' };
00211 static const symbol s_5_32[6] = { 'i', 's', 's', 'i', 'e', 'z' };
00212 static const symbol s_5_33[4] = { 'i', 'r', 'e', 'z' };
00213 static const symbol s_5_34[5] = { 'i', 's', 's', 'e', 'z' };
00214 
00215 static const struct among a_5[35] =
00216 {
00217 /*  0 */ { 3, s_5_0, -1, 1, 0},
00218 /*  1 */ { 2, s_5_1, -1, 1, 0},
00219 /*  2 */ { 4, s_5_2, -1, 1, 0},
00220 /*  3 */ { 7, s_5_3, -1, 1, 0},
00221 /*  4 */ { 1, s_5_4, -1, 1, 0},
00222 /*  5 */ { 4, s_5_5, 4, 1, 0},
00223 /*  6 */ { 2, s_5_6, -1, 1, 0},
00224 /*  7 */ { 4, s_5_7, -1, 1, 0},
00225 /*  8 */ { 3, s_5_8, -1, 1, 0},
00226 /*  9 */ { 5, s_5_9, -1, 1, 0},
00227 /* 10 */ { 5, s_5_10, -1, 1, 0},
00228 /* 11 */ { 8, s_5_11, -1, 1, 0},
00229 /* 12 */ { 5, s_5_12, -1, 1, 0},
00230 /* 13 */ { 2, s_5_13, -1, 1, 0},
00231 /* 14 */ { 5, s_5_14, 13, 1, 0},
00232 /* 15 */ { 6, s_5_15, 13, 1, 0},
00233 /* 16 */ { 6, s_5_16, -1, 1, 0},
00234 /* 17 */ { 7, s_5_17, -1, 1, 0},
00235 /* 18 */ { 5, s_5_18, -1, 1, 0},
00236 /* 19 */ { 6, s_5_19, -1, 1, 0},
00237 /* 20 */ { 7, s_5_20, -1, 1, 0},
00238 /* 21 */ { 2, s_5_21, -1, 1, 0},
00239 /* 22 */ { 5, s_5_22, 21, 1, 0},
00240 /* 23 */ { 6, s_5_23, 21, 1, 0},
00241 /* 24 */ { 6, s_5_24, -1, 1, 0},
00242 /* 25 */ { 7, s_5_25, -1, 1, 0},
00243 /* 26 */ { 8, s_5_26, -1, 1, 0},
00244 /* 27 */ { 5, s_5_27, -1, 1, 0},
00245 /* 28 */ { 6, s_5_28, -1, 1, 0},
00246 /* 29 */ { 5, s_5_29, -1, 1, 0},
00247 /* 30 */ { 3, s_5_30, -1, 1, 0},
00248 /* 31 */ { 5, s_5_31, -1, 1, 0},
00249 /* 32 */ { 6, s_5_32, -1, 1, 0},
00250 /* 33 */ { 4, s_5_33, -1, 1, 0},
00251 /* 34 */ { 5, s_5_34, -1, 1, 0}
00252 };
00253 
00254 static const symbol s_6_0[1] = { 'a' };
00255 static const symbol s_6_1[3] = { 'e', 'r', 'a' };
00256 static const symbol s_6_2[4] = { 'a', 's', 's', 'e' };
00257 static const symbol s_6_3[4] = { 'a', 'n', 't', 'e' };
00258 static const symbol s_6_4[3] = { 0xC3, 0xA9, 'e' };
00259 static const symbol s_6_5[2] = { 'a', 'i' };
00260 static const symbol s_6_6[4] = { 'e', 'r', 'a', 'i' };
00261 static const symbol s_6_7[2] = { 'e', 'r' };
00262 static const symbol s_6_8[2] = { 'a', 's' };
00263 static const symbol s_6_9[4] = { 'e', 'r', 'a', 's' };
00264 static const symbol s_6_10[5] = { 0xC3, 0xA2, 'm', 'e', 's' };
00265 static const symbol s_6_11[5] = { 'a', 's', 's', 'e', 's' };
00266 static const symbol s_6_12[5] = { 'a', 'n', 't', 'e', 's' };
00267 static const symbol s_6_13[5] = { 0xC3, 0xA2, 't', 'e', 's' };
00268 static const symbol s_6_14[4] = { 0xC3, 0xA9, 'e', 's' };
00269 static const symbol s_6_15[3] = { 'a', 'i', 's' };
00270 static const symbol s_6_16[5] = { 'e', 'r', 'a', 'i', 's' };
00271 static const symbol s_6_17[4] = { 'i', 'o', 'n', 's' };
00272 static const symbol s_6_18[6] = { 'e', 'r', 'i', 'o', 'n', 's' };
00273 static const symbol s_6_19[7] = { 'a', 's', 's', 'i', 'o', 'n', 's' };
00274 static const symbol s_6_20[5] = { 'e', 'r', 'o', 'n', 's' };
00275 static const symbol s_6_21[4] = { 'a', 'n', 't', 's' };
00276 static const symbol s_6_22[3] = { 0xC3, 0xA9, 's' };
00277 static const symbol s_6_23[3] = { 'a', 'i', 't' };
00278 static const symbol s_6_24[5] = { 'e', 'r', 'a', 'i', 't' };
00279 static const symbol s_6_25[3] = { 'a', 'n', 't' };
00280 static const symbol s_6_26[5] = { 'a', 'I', 'e', 'n', 't' };
00281 static const symbol s_6_27[7] = { 'e', 'r', 'a', 'I', 'e', 'n', 't' };
00282 static const symbol s_6_28[6] = { 0xC3, 0xA8, 'r', 'e', 'n', 't' };
00283 static const symbol s_6_29[6] = { 'a', 's', 's', 'e', 'n', 't' };
00284 static const symbol s_6_30[5] = { 'e', 'r', 'o', 'n', 't' };
00285 static const symbol s_6_31[3] = { 0xC3, 0xA2, 't' };
00286 static const symbol s_6_32[2] = { 'e', 'z' };
00287 static const symbol s_6_33[3] = { 'i', 'e', 'z' };
00288 static const symbol s_6_34[5] = { 'e', 'r', 'i', 'e', 'z' };
00289 static const symbol s_6_35[6] = { 'a', 's', 's', 'i', 'e', 'z' };
00290 static const symbol s_6_36[4] = { 'e', 'r', 'e', 'z' };
00291 static const symbol s_6_37[2] = { 0xC3, 0xA9 };
00292 
00293 static const struct among a_6[38] =
00294 {
00295 /*  0 */ { 1, s_6_0, -1, 3, 0},
00296 /*  1 */ { 3, s_6_1, 0, 2, 0},
00297 /*  2 */ { 4, s_6_2, -1, 3, 0},
00298 /*  3 */ { 4, s_6_3, -1, 3, 0},
00299 /*  4 */ { 3, s_6_4, -1, 2, 0},
00300 /*  5 */ { 2, s_6_5, -1, 3, 0},
00301 /*  6 */ { 4, s_6_6, 5, 2, 0},
00302 /*  7 */ { 2, s_6_7, -1, 2, 0},
00303 /*  8 */ { 2, s_6_8, -1, 3, 0},
00304 /*  9 */ { 4, s_6_9, 8, 2, 0},
00305 /* 10 */ { 5, s_6_10, -1, 3, 0},
00306 /* 11 */ { 5, s_6_11, -1, 3, 0},
00307 /* 12 */ { 5, s_6_12, -1, 3, 0},
00308 /* 13 */ { 5, s_6_13, -1, 3, 0},
00309 /* 14 */ { 4, s_6_14, -1, 2, 0},
00310 /* 15 */ { 3, s_6_15, -1, 3, 0},
00311 /* 16 */ { 5, s_6_16, 15, 2, 0},
00312 /* 17 */ { 4, s_6_17, -1, 1, 0},
00313 /* 18 */ { 6, s_6_18, 17, 2, 0},
00314 /* 19 */ { 7, s_6_19, 17, 3, 0},
00315 /* 20 */ { 5, s_6_20, -1, 2, 0},
00316 /* 21 */ { 4, s_6_21, -1, 3, 0},
00317 /* 22 */ { 3, s_6_22, -1, 2, 0},
00318 /* 23 */ { 3, s_6_23, -1, 3, 0},
00319 /* 24 */ { 5, s_6_24, 23, 2, 0},
00320 /* 25 */ { 3, s_6_25, -1, 3, 0},
00321 /* 26 */ { 5, s_6_26, -1, 3, 0},
00322 /* 27 */ { 7, s_6_27, 26, 2, 0},
00323 /* 28 */ { 6, s_6_28, -1, 2, 0},
00324 /* 29 */ { 6, s_6_29, -1, 3, 0},
00325 /* 30 */ { 5, s_6_30, -1, 2, 0},
00326 /* 31 */ { 3, s_6_31, -1, 3, 0},
00327 /* 32 */ { 2, s_6_32, -1, 2, 0},
00328 /* 33 */ { 3, s_6_33, 32, 2, 0},
00329 /* 34 */ { 5, s_6_34, 33, 2, 0},
00330 /* 35 */ { 6, s_6_35, 33, 3, 0},
00331 /* 36 */ { 4, s_6_36, 32, 2, 0},
00332 /* 37 */ { 2, s_6_37, -1, 2, 0}
00333 };
00334 
00335 static const symbol s_7_0[1] = { 'e' };
00336 static const symbol s_7_1[5] = { 'I', 0xC3, 0xA8, 'r', 'e' };
00337 static const symbol s_7_2[5] = { 'i', 0xC3, 0xA8, 'r', 'e' };
00338 static const symbol s_7_3[3] = { 'i', 'o', 'n' };
00339 static const symbol s_7_4[3] = { 'I', 'e', 'r' };
00340 static const symbol s_7_5[3] = { 'i', 'e', 'r' };
00341 static const symbol s_7_6[2] = { 0xC3, 0xAB };
00342 
00343 static const struct among a_7[7] =
00344 {
00345 /*  0 */ { 1, s_7_0, -1, 3, 0},
00346 /*  1 */ { 5, s_7_1, 0, 2, 0},
00347 /*  2 */ { 5, s_7_2, 0, 2, 0},
00348 /*  3 */ { 3, s_7_3, -1, 1, 0},
00349 /*  4 */ { 3, s_7_4, -1, 2, 0},
00350 /*  5 */ { 3, s_7_5, -1, 2, 0},
00351 /*  6 */ { 2, s_7_6, -1, 4, 0}
00352 };
00353 
00354 static const symbol s_8_0[3] = { 'e', 'l', 'l' };
00355 static const symbol s_8_1[4] = { 'e', 'i', 'l', 'l' };
00356 static const symbol s_8_2[3] = { 'e', 'n', 'n' };
00357 static const symbol s_8_3[3] = { 'o', 'n', 'n' };
00358 static const symbol s_8_4[3] = { 'e', 't', 't' };
00359 
00360 static const struct among a_8[5] =
00361 {
00362 /*  0 */ { 3, s_8_0, -1, -1, 0},
00363 /*  1 */ { 4, s_8_1, -1, -1, 0},
00364 /*  2 */ { 3, s_8_2, -1, -1, 0},
00365 /*  3 */ { 3, s_8_3, -1, -1, 0},
00366 /*  4 */ { 3, s_8_4, -1, -1, 0}
00367 };
00368 
00369 static const unsigned char g_v[] = { 17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 130, 103, 8, 5 };
00370 
00371 static const unsigned char g_keep_with_s[] = { 1, 65, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128 };
00372 
00373 static const symbol s_0[] = { 'u' };
00374 static const symbol s_1[] = { 'U' };
00375 static const symbol s_2[] = { 'i' };
00376 static const symbol s_3[] = { 'I' };
00377 static const symbol s_4[] = { 'y' };
00378 static const symbol s_5[] = { 'Y' };
00379 static const symbol s_6[] = { 'y' };
00380 static const symbol s_7[] = { 'Y' };
00381 static const symbol s_8[] = { 'q' };
00382 static const symbol s_9[] = { 'u' };
00383 static const symbol s_10[] = { 'U' };
00384 static const symbol s_11[] = { 'i' };
00385 static const symbol s_12[] = { 'u' };
00386 static const symbol s_13[] = { 'y' };
00387 static const symbol s_14[] = { 'i', 'c' };
00388 static const symbol s_15[] = { 'i', 'q', 'U' };
00389 static const symbol s_16[] = { 'l', 'o', 'g' };
00390 static const symbol s_17[] = { 'u' };
00391 static const symbol s_18[] = { 'e', 'n', 't' };
00392 static const symbol s_19[] = { 'a', 't' };
00393 static const symbol s_20[] = { 'e', 'u', 'x' };
00394 static const symbol s_21[] = { 'i' };
00395 static const symbol s_22[] = { 'a', 'b', 'l' };
00396 static const symbol s_23[] = { 'i', 'q', 'U' };
00397 static const symbol s_24[] = { 'a', 't' };
00398 static const symbol s_25[] = { 'i', 'c' };
00399 static const symbol s_26[] = { 'i', 'q', 'U' };
00400 static const symbol s_27[] = { 'e', 'a', 'u' };
00401 static const symbol s_28[] = { 'a', 'l' };
00402 static const symbol s_29[] = { 'e', 'u', 'x' };
00403 static const symbol s_30[] = { 'a', 'n', 't' };
00404 static const symbol s_31[] = { 'e', 'n', 't' };
00405 static const symbol s_32[] = { 'e' };
00406 static const symbol s_33[] = { 's' };
00407 static const symbol s_34[] = { 's' };
00408 static const symbol s_35[] = { 't' };
00409 static const symbol s_36[] = { 'i' };
00410 static const symbol s_37[] = { 'g', 'u' };
00411 static const symbol s_38[] = { 0xC3, 0xA9 };
00412 static const symbol s_39[] = { 0xC3, 0xA8 };
00413 static const symbol s_40[] = { 'e' };
00414 static const symbol s_41[] = { 'Y' };
00415 static const symbol s_42[] = { 'i' };
00416 static const symbol s_43[] = { 0xC3, 0xA7 };
00417 static const symbol s_44[] = { 'c' };
00418 
00419 static int r_prelude(struct SN_env * z) {
00420     while(1) { /* repeat, line 38 */
00421         int c1 = z->c;
00422         while(1) { /* goto, line 38 */
00423             int c2 = z->c;
00424             {   int c3 = z->c; /* or, line 44 */
00425                 if (in_grouping_U(z, g_v, 97, 251, 0)) goto lab3;
00426                 z->bra = z->c; /* [, line 40 */
00427                 {   int c4 = z->c; /* or, line 40 */
00428                     if (!(eq_s(z, 1, s_0))) goto lab5;
00429                     z->ket = z->c; /* ], line 40 */
00430                     if (in_grouping_U(z, g_v, 97, 251, 0)) goto lab5;
00431                     {   int ret = slice_from_s(z, 1, s_1); /* <-, line 40 */
00432                         if (ret < 0) return ret;
00433                     }
00434                     goto lab4;
00435                 lab5:
00436                     z->c = c4;
00437                     if (!(eq_s(z, 1, s_2))) goto lab6;
00438                     z->ket = z->c; /* ], line 41 */
00439                     if (in_grouping_U(z, g_v, 97, 251, 0)) goto lab6;
00440                     {   int ret = slice_from_s(z, 1, s_3); /* <-, line 41 */
00441                         if (ret < 0) return ret;
00442                     }
00443                     goto lab4;
00444                 lab6:
00445                     z->c = c4;
00446                     if (!(eq_s(z, 1, s_4))) goto lab3;
00447                     z->ket = z->c; /* ], line 42 */
00448                     {   int ret = slice_from_s(z, 1, s_5); /* <-, line 42 */
00449                         if (ret < 0) return ret;
00450                     }
00451                 }
00452             lab4:
00453                 goto lab2;
00454             lab3:
00455                 z->c = c3;
00456                 z->bra = z->c; /* [, line 45 */
00457                 if (!(eq_s(z, 1, s_6))) goto lab7;
00458                 z->ket = z->c; /* ], line 45 */
00459                 if (in_grouping_U(z, g_v, 97, 251, 0)) goto lab7;
00460                 {   int ret = slice_from_s(z, 1, s_7); /* <-, line 45 */
00461                     if (ret < 0) return ret;
00462                 }
00463                 goto lab2;
00464             lab7:
00465                 z->c = c3;
00466                 if (!(eq_s(z, 1, s_8))) goto lab1;
00467                 z->bra = z->c; /* [, line 47 */
00468                 if (!(eq_s(z, 1, s_9))) goto lab1;
00469                 z->ket = z->c; /* ], line 47 */
00470                 {   int ret = slice_from_s(z, 1, s_10); /* <-, line 47 */
00471                     if (ret < 0) return ret;
00472                 }
00473             }
00474         lab2:
00475             z->c = c2;
00476             break;
00477         lab1:
00478             z->c = c2;
00479             {   int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
00480                 if (ret < 0) goto lab0;
00481                 z->c = ret; /* goto, line 38 */
00482             }
00483         }
00484         continue;
00485     lab0:
00486         z->c = c1;
00487         break;
00488     }
00489     return 1;
00490 }
00491 
00492 static int r_mark_regions(struct SN_env * z) {
00493     z->I[0] = z->l;
00494     z->I[1] = z->l;
00495     z->I[2] = z->l;
00496     {   int c1 = z->c; /* do, line 56 */
00497         {   int c2 = z->c; /* or, line 58 */
00498             if (in_grouping_U(z, g_v, 97, 251, 0)) goto lab2;
00499             if (in_grouping_U(z, g_v, 97, 251, 0)) goto lab2;
00500             {   int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
00501                 if (ret < 0) goto lab2;
00502                 z->c = ret; /* next, line 57 */
00503             }
00504             goto lab1;
00505         lab2:
00506             z->c = c2;
00507             if (z->c + 2 >= z->l || z->p[z->c + 2] >> 5 != 3 || !((331776 >> (z->p[z->c + 2] & 0x1f)) & 1)) goto lab3;
00508             if (!(find_among(z, a_0, 3))) goto lab3; /* among, line 59 */
00509             goto lab1;
00510         lab3:
00511             z->c = c2;
00512             {   int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
00513                 if (ret < 0) goto lab0;
00514                 z->c = ret; /* next, line 66 */
00515             }
00516             {    /* gopast */ /* grouping v, line 66 */
00517                 int ret = out_grouping_U(z, g_v, 97, 251, 1);
00518                 if (ret < 0) goto lab0;
00519                 z->c += ret;
00520             }
00521         }
00522     lab1:
00523         z->I[0] = z->c; /* setmark pV, line 67 */
00524     lab0:
00525         z->c = c1;
00526     }
00527     {   int c3 = z->c; /* do, line 69 */
00528         {    /* gopast */ /* grouping v, line 70 */
00529             int ret = out_grouping_U(z, g_v, 97, 251, 1);
00530             if (ret < 0) goto lab4;
00531             z->c += ret;
00532         }
00533         {    /* gopast */ /* non v, line 70 */
00534             int ret = in_grouping_U(z, g_v, 97, 251, 1);
00535             if (ret < 0) goto lab4;
00536             z->c += ret;
00537         }
00538         z->I[1] = z->c; /* setmark p1, line 70 */
00539         {    /* gopast */ /* grouping v, line 71 */
00540             int ret = out_grouping_U(z, g_v, 97, 251, 1);
00541             if (ret < 0) goto lab4;
00542             z->c += ret;
00543         }
00544         {    /* gopast */ /* non v, line 71 */
00545             int ret = in_grouping_U(z, g_v, 97, 251, 1);
00546             if (ret < 0) goto lab4;
00547             z->c += ret;
00548         }
00549         z->I[2] = z->c; /* setmark p2, line 71 */
00550     lab4:
00551         z->c = c3;
00552     }
00553     return 1;
00554 }
00555 
00556 static int r_postlude(struct SN_env * z) {
00557     int among_var;
00558     while(1) { /* repeat, line 75 */
00559         int c1 = z->c;
00560         z->bra = z->c; /* [, line 77 */
00561         if (z->c >= z->l || z->p[z->c + 0] >> 5 != 2 || !((35652096 >> (z->p[z->c + 0] & 0x1f)) & 1)) among_var = 4; else
00562         among_var = find_among(z, a_1, 4); /* substring, line 77 */
00563         if (!(among_var)) goto lab0;
00564         z->ket = z->c; /* ], line 77 */
00565         switch(among_var) {
00566             case 0: goto lab0;
00567             case 1:
00568                 {   int ret = slice_from_s(z, 1, s_11); /* <-, line 78 */
00569                     if (ret < 0) return ret;
00570                 }
00571                 break;
00572             case 2:
00573                 {   int ret = slice_from_s(z, 1, s_12); /* <-, line 79 */
00574                     if (ret < 0) return ret;
00575                 }
00576                 break;
00577             case 3:
00578                 {   int ret = slice_from_s(z, 1, s_13); /* <-, line 80 */
00579                     if (ret < 0) return ret;
00580                 }
00581                 break;
00582             case 4:
00583                 {   int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
00584                     if (ret < 0) goto lab0;
00585                     z->c = ret; /* next, line 81 */
00586                 }
00587                 break;
00588         }
00589         continue;
00590     lab0:
00591         z->c = c1;
00592         break;
00593     }
00594     return 1;
00595 }
00596 
00597 static int r_RV(struct SN_env * z) {
00598     if (!(z->I[0] <= z->c)) return 0;
00599     return 1;
00600 }
00601 
00602 static int r_R1(struct SN_env * z) {
00603     if (!(z->I[1] <= z->c)) return 0;
00604     return 1;
00605 }
00606 
00607 static int r_R2(struct SN_env * z) {
00608     if (!(z->I[2] <= z->c)) return 0;
00609     return 1;
00610 }
00611 
00612 static int r_standard_suffix(struct SN_env * z) {
00613     int among_var;
00614     z->ket = z->c; /* [, line 92 */
00615     among_var = find_among_b(z, a_4, 43); /* substring, line 92 */
00616     if (!(among_var)) return 0;
00617     z->bra = z->c; /* ], line 92 */
00618     switch(among_var) {
00619         case 0: return 0;
00620         case 1:
00621             {   int ret = r_R2(z);
00622                 if (ret == 0) return 0; /* call R2, line 96 */
00623                 if (ret < 0) return ret;
00624             }
00625             {   int ret = slice_del(z); /* delete, line 96 */
00626                 if (ret < 0) return ret;
00627             }
00628             break;
00629         case 2:
00630             {   int ret = r_R2(z);
00631                 if (ret == 0) return 0; /* call R2, line 99 */
00632                 if (ret < 0) return ret;
00633             }
00634             {   int ret = slice_del(z); /* delete, line 99 */
00635                 if (ret < 0) return ret;
00636             }
00637             {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 100 */
00638                 z->ket = z->c; /* [, line 100 */
00639                 if (!(eq_s_b(z, 2, s_14))) { z->c = z->l - m_keep; goto lab0; }
00640                 z->bra = z->c; /* ], line 100 */
00641                 {   int m1 = z->l - z->c; (void)m1; /* or, line 100 */
00642                     {   int ret = r_R2(z);
00643                         if (ret == 0) goto lab2; /* call R2, line 100 */
00644                         if (ret < 0) return ret;
00645                     }
00646                     {   int ret = slice_del(z); /* delete, line 100 */
00647                         if (ret < 0) return ret;
00648                     }
00649                     goto lab1;
00650                 lab2:
00651                     z->c = z->l - m1;
00652                     {   int ret = slice_from_s(z, 3, s_15); /* <-, line 100 */
00653                         if (ret < 0) return ret;
00654                     }
00655                 }
00656             lab1:
00657             lab0:
00658                 ;
00659             }
00660             break;
00661         case 3:
00662             {   int ret = r_R2(z);
00663                 if (ret == 0) return 0; /* call R2, line 104 */
00664                 if (ret < 0) return ret;
00665             }
00666             {   int ret = slice_from_s(z, 3, s_16); /* <-, line 104 */
00667                 if (ret < 0) return ret;
00668             }
00669             break;
00670         case 4:
00671             {   int ret = r_R2(z);
00672                 if (ret == 0) return 0; /* call R2, line 107 */
00673                 if (ret < 0) return ret;
00674             }
00675             {   int ret = slice_from_s(z, 1, s_17); /* <-, line 107 */
00676                 if (ret < 0) return ret;
00677             }
00678             break;
00679         case 5:
00680             {   int ret = r_R2(z);
00681                 if (ret == 0) return 0; /* call R2, line 110 */
00682                 if (ret < 0) return ret;
00683             }
00684             {   int ret = slice_from_s(z, 3, s_18); /* <-, line 110 */
00685                 if (ret < 0) return ret;
00686             }
00687             break;
00688         case 6:
00689             {   int ret = r_RV(z);
00690                 if (ret == 0) return 0; /* call RV, line 114 */
00691                 if (ret < 0) return ret;
00692             }
00693             {   int ret = slice_del(z); /* delete, line 114 */
00694                 if (ret < 0) return ret;
00695             }
00696             {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 115 */
00697                 z->ket = z->c; /* [, line 116 */
00698                 among_var = find_among_b(z, a_2, 6); /* substring, line 116 */
00699                 if (!(among_var)) { z->c = z->l - m_keep; goto lab3; }
00700                 z->bra = z->c; /* ], line 116 */
00701                 switch(among_var) {
00702                     case 0: { z->c = z->l - m_keep; goto lab3; }
00703                     case 1:
00704                         {   int ret = r_R2(z);
00705                             if (ret == 0) { z->c = z->l - m_keep; goto lab3; } /* call R2, line 117 */
00706                             if (ret < 0) return ret;
00707                         }
00708                         {   int ret = slice_del(z); /* delete, line 117 */
00709                             if (ret < 0) return ret;
00710                         }
00711                         z->ket = z->c; /* [, line 117 */
00712                         if (!(eq_s_b(z, 2, s_19))) { z->c = z->l - m_keep; goto lab3; }
00713                         z->bra = z->c; /* ], line 117 */
00714                         {   int ret = r_R2(z);
00715                             if (ret == 0) { z->c = z->l - m_keep; goto lab3; } /* call R2, line 117 */
00716                             if (ret < 0) return ret;
00717                         }
00718                         {   int ret = slice_del(z); /* delete, line 117 */
00719                             if (ret < 0) return ret;
00720                         }
00721                         break;
00722                     case 2:
00723                         {   int m2 = z->l - z->c; (void)m2; /* or, line 118 */
00724                             {   int ret = r_R2(z);
00725                                 if (ret == 0) goto lab5; /* call R2, line 118 */
00726                                 if (ret < 0) return ret;
00727                             }
00728                             {   int ret = slice_del(z); /* delete, line 118 */
00729                                 if (ret < 0) return ret;
00730                             }
00731                             goto lab4;
00732                         lab5:
00733                             z->c = z->l - m2;
00734                             {   int ret = r_R1(z);
00735                                 if (ret == 0) { z->c = z->l - m_keep; goto lab3; } /* call R1, line 118 */
00736                                 if (ret < 0) return ret;
00737                             }
00738                             {   int ret = slice_from_s(z, 3, s_20); /* <-, line 118 */
00739                                 if (ret < 0) return ret;
00740                             }
00741                         }
00742                     lab4:
00743                         break;
00744                     case 3:
00745                         {   int ret = r_R2(z);
00746                             if (ret == 0) { z->c = z->l - m_keep; goto lab3; } /* call R2, line 120 */
00747                             if (ret < 0) return ret;
00748                         }
00749                         {   int ret = slice_del(z); /* delete, line 120 */
00750                             if (ret < 0) return ret;
00751                         }
00752                         break;
00753                     case 4:
00754                         {   int ret = r_RV(z);
00755                             if (ret == 0) { z->c = z->l - m_keep; goto lab3; } /* call RV, line 122 */
00756                             if (ret < 0) return ret;
00757                         }
00758                         {   int ret = slice_from_s(z, 1, s_21); /* <-, line 122 */
00759                             if (ret < 0) return ret;
00760                         }
00761                         break;
00762                 }
00763             lab3:
00764                 ;
00765             }
00766             break;
00767         case 7:
00768             {   int ret = r_R2(z);
00769                 if (ret == 0) return 0; /* call R2, line 129 */
00770                 if (ret < 0) return ret;
00771             }
00772             {   int ret = slice_del(z); /* delete, line 129 */
00773                 if (ret < 0) return ret;
00774             }
00775             {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 130 */
00776                 z->ket = z->c; /* [, line 131 */
00777                 if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((4198408 >> (z->p[z->c - 1] & 0x1f)) & 1)) { z->c = z->l - m_keep; goto lab6; }
00778                 among_var = find_among_b(z, a_3, 3); /* substring, line 131 */
00779                 if (!(among_var)) { z->c = z->l - m_keep; goto lab6; }
00780                 z->bra = z->c; /* ], line 131 */
00781                 switch(among_var) {
00782                     case 0: { z->c = z->l - m_keep; goto lab6; }
00783                     case 1:
00784                         {   int m3 = z->l - z->c; (void)m3; /* or, line 132 */
00785                             {   int ret = r_R2(z);
00786                                 if (ret == 0) goto lab8; /* call R2, line 132 */
00787                                 if (ret < 0) return ret;
00788                             }
00789                             {   int ret = slice_del(z); /* delete, line 132 */
00790                                 if (ret < 0) return ret;
00791                             }
00792                             goto lab7;
00793                         lab8:
00794                             z->c = z->l - m3;
00795                             {   int ret = slice_from_s(z, 3, s_22); /* <-, line 132 */
00796                                 if (ret < 0) return ret;
00797                             }
00798                         }
00799                     lab7:
00800                         break;
00801                     case 2:
00802                         {   int m4 = z->l - z->c; (void)m4; /* or, line 133 */
00803                             {   int ret = r_R2(z);
00804                                 if (ret == 0) goto lab10; /* call R2, line 133 */
00805                                 if (ret < 0) return ret;
00806                             }
00807                             {   int ret = slice_del(z); /* delete, line 133 */
00808                                 if (ret < 0) return ret;
00809                             }
00810                             goto lab9;
00811                         lab10:
00812                             z->c = z->l - m4;
00813                             {   int ret = slice_from_s(z, 3, s_23); /* <-, line 133 */
00814                                 if (ret < 0) return ret;
00815                             }
00816                         }
00817                     lab9:
00818                         break;
00819                     case 3:
00820                         {   int ret = r_R2(z);
00821                             if (ret == 0) { z->c = z->l - m_keep; goto lab6; } /* call R2, line 134 */
00822                             if (ret < 0) return ret;
00823                         }
00824                         {   int ret = slice_del(z); /* delete, line 134 */
00825                             if (ret < 0) return ret;
00826                         }
00827                         break;
00828                 }
00829             lab6:
00830                 ;
00831             }
00832             break;
00833         case 8:
00834             {   int ret = r_R2(z);
00835                 if (ret == 0) return 0; /* call R2, line 141 */
00836                 if (ret < 0) return ret;
00837             }
00838             {   int ret = slice_del(z); /* delete, line 141 */
00839                 if (ret < 0) return ret;
00840             }
00841             {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 142 */
00842                 z->ket = z->c; /* [, line 142 */
00843                 if (!(eq_s_b(z, 2, s_24))) { z->c = z->l - m_keep; goto lab11; }
00844                 z->bra = z->c; /* ], line 142 */
00845                 {   int ret = r_R2(z);
00846                     if (ret == 0) { z->c = z->l - m_keep; goto lab11; } /* call R2, line 142 */
00847                     if (ret < 0) return ret;
00848                 }
00849                 {   int ret = slice_del(z); /* delete, line 142 */
00850                     if (ret < 0) return ret;
00851                 }
00852                 z->ket = z->c; /* [, line 142 */
00853                 if (!(eq_s_b(z, 2, s_25))) { z->c = z->l - m_keep; goto lab11; }
00854                 z->bra = z->c; /* ], line 142 */
00855                 {   int m5 = z->l - z->c; (void)m5; /* or, line 142 */
00856                     {   int ret = r_R2(z);
00857                         if (ret == 0) goto lab13; /* call R2, line 142 */
00858                         if (ret < 0) return ret;
00859                     }
00860                     {   int ret = slice_del(z); /* delete, line 142 */
00861                         if (ret < 0) return ret;
00862                     }
00863                     goto lab12;
00864                 lab13:
00865                     z->c = z->l - m5;
00866                     {   int ret = slice_from_s(z, 3, s_26); /* <-, line 142 */
00867                         if (ret < 0) return ret;
00868                     }
00869                 }
00870             lab12:
00871             lab11:
00872                 ;
00873             }
00874             break;
00875         case 9:
00876             {   int ret = slice_from_s(z, 3, s_27); /* <-, line 144 */
00877                 if (ret < 0) return ret;
00878             }
00879             break;
00880         case 10:
00881             {   int ret = r_R1(z);
00882                 if (ret == 0) return 0; /* call R1, line 145 */
00883                 if (ret < 0) return ret;
00884             }
00885             {   int ret = slice_from_s(z, 2, s_28); /* <-, line 145 */
00886                 if (ret < 0) return ret;
00887             }
00888             break;
00889         case 11:
00890             {   int m6 = z->l - z->c; (void)m6; /* or, line 147 */
00891                 {   int ret = r_R2(z);
00892                     if (ret == 0) goto lab15; /* call R2, line 147 */
00893                     if (ret < 0) return ret;
00894                 }
00895                 {   int ret = slice_del(z); /* delete, line 147 */
00896                     if (ret < 0) return ret;
00897                 }
00898                 goto lab14;
00899             lab15:
00900                 z->c = z->l - m6;
00901                 {   int ret = r_R1(z);
00902                     if (ret == 0) return 0; /* call R1, line 147 */
00903                     if (ret < 0) return ret;
00904                 }
00905                 {   int ret = slice_from_s(z, 3, s_29); /* <-, line 147 */
00906                     if (ret < 0) return ret;
00907                 }
00908             }
00909         lab14:
00910             break;
00911         case 12:
00912             {   int ret = r_R1(z);
00913                 if (ret == 0) return 0; /* call R1, line 150 */
00914                 if (ret < 0) return ret;
00915             }
00916             if (out_grouping_b_U(z, g_v, 97, 251, 0)) return 0;
00917             {   int ret = slice_del(z); /* delete, line 150 */
00918                 if (ret < 0) return ret;
00919             }
00920             break;
00921         case 13:
00922             {   int ret = r_RV(z);
00923                 if (ret == 0) return 0; /* call RV, line 155 */
00924                 if (ret < 0) return ret;
00925             }
00926             {   int ret = slice_from_s(z, 3, s_30); /* <-, line 155 */
00927                 if (ret < 0) return ret;
00928             }
00929             return 0; /* fail, line 155 */
00930             break;
00931         case 14:
00932             {   int ret = r_RV(z);
00933                 if (ret == 0) return 0; /* call RV, line 156 */
00934                 if (ret < 0) return ret;
00935             }
00936             {   int ret = slice_from_s(z, 3, s_31); /* <-, line 156 */
00937                 if (ret < 0) return ret;
00938             }
00939             return 0; /* fail, line 156 */
00940             break;
00941         case 15:
00942             {   int m_test = z->l - z->c; /* test, line 158 */
00943                 if (in_grouping_b_U(z, g_v, 97, 251, 0)) return 0;
00944                 {   int ret = r_RV(z);
00945                     if (ret == 0) return 0; /* call RV, line 158 */
00946                     if (ret < 0) return ret;
00947                 }
00948                 z->c = z->l - m_test;
00949             }
00950             {   int ret = slice_del(z); /* delete, line 158 */
00951                 if (ret < 0) return ret;
00952             }
00953             return 0; /* fail, line 158 */
00954             break;
00955     }
00956     return 1;
00957 }
00958 
00959 static int r_i_verb_suffix(struct SN_env * z) {
00960     int among_var;
00961     {   int mlimit; /* setlimit, line 163 */
00962         int m1 = z->l - z->c; (void)m1;
00963         if (z->c < z->I[0]) return 0;
00964         z->c = z->I[0]; /* tomark, line 163 */
00965         mlimit = z->lb; z->lb = z->c;
00966         z->c = z->l - m1;
00967         z->ket = z->c; /* [, line 164 */
00968         if (z->c <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((68944418 >> (z->p[z->c - 1] & 0x1f)) & 1)) { z->lb = mlimit; return 0; }
00969         among_var = find_among_b(z, a_5, 35); /* substring, line 164 */
00970         if (!(among_var)) { z->lb = mlimit; return 0; }
00971         z->bra = z->c; /* ], line 164 */
00972         switch(among_var) {
00973             case 0: { z->lb = mlimit; return 0; }
00974             case 1:
00975                 if (out_grouping_b_U(z, g_v, 97, 251, 0)) { z->lb = mlimit; return 0; }
00976                 {   int ret = slice_del(z); /* delete, line 170 */
00977                     if (ret < 0) return ret;
00978                 }
00979                 break;
00980         }
00981         z->lb = mlimit;
00982     }
00983     return 1;
00984 }
00985 
00986 static int r_verb_suffix(struct SN_env * z) {
00987     int among_var;
00988     {   int mlimit; /* setlimit, line 174 */
00989         int m1 = z->l - z->c; (void)m1;
00990         if (z->c < z->I[0]) return 0;
00991         z->c = z->I[0]; /* tomark, line 174 */
00992         mlimit = z->lb; z->lb = z->c;
00993         z->c = z->l - m1;
00994         z->ket = z->c; /* [, line 175 */
00995         among_var = find_among_b(z, a_6, 38); /* substring, line 175 */
00996         if (!(among_var)) { z->lb = mlimit; return 0; }
00997         z->bra = z->c; /* ], line 175 */
00998         switch(among_var) {
00999             case 0: { z->lb = mlimit; return 0; }
01000             case 1:
01001                 {   int ret = r_R2(z);
01002                     if (ret == 0) { z->lb = mlimit; return 0; } /* call R2, line 177 */
01003                     if (ret < 0) return ret;
01004                 }
01005                 {   int ret = slice_del(z); /* delete, line 177 */
01006                     if (ret < 0) return ret;
01007                 }
01008                 break;
01009             case 2:
01010                 {   int ret = slice_del(z); /* delete, line 185 */
01011                     if (ret < 0) return ret;
01012                 }
01013                 break;
01014             case 3:
01015                 {   int ret = slice_del(z); /* delete, line 190 */
01016                     if (ret < 0) return ret;
01017                 }
01018                 {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 191 */
01019                     z->ket = z->c; /* [, line 191 */
01020                     if (!(eq_s_b(z, 1, s_32))) { z->c = z->l - m_keep; goto lab0; }
01021                     z->bra = z->c; /* ], line 191 */
01022                     {   int ret = slice_del(z); /* delete, line 191 */
01023                         if (ret < 0) return ret;
01024                     }
01025                 lab0:
01026                     ;
01027                 }
01028                 break;
01029         }
01030         z->lb = mlimit;
01031     }
01032     return 1;
01033 }
01034 
01035 static int r_residual_suffix(struct SN_env * z) {
01036     int among_var;
01037     {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 199 */
01038         z->ket = z->c; /* [, line 199 */
01039         if (!(eq_s_b(z, 1, s_33))) { z->c = z->l - m_keep; goto lab0; }
01040         z->bra = z->c; /* ], line 199 */
01041         {   int m_test = z->l - z->c; /* test, line 199 */
01042             if (out_grouping_b_U(z, g_keep_with_s, 97, 232, 0)) { z->c = z->l - m_keep; goto lab0; }
01043             z->c = z->l - m_test;
01044         }
01045         {   int ret = slice_del(z); /* delete, line 199 */
01046             if (ret < 0) return ret;
01047         }
01048     lab0:
01049         ;
01050     }
01051     {   int mlimit; /* setlimit, line 200 */
01052         int m1 = z->l - z->c; (void)m1;
01053         if (z->c < z->I[0]) return 0;
01054         z->c = z->I[0]; /* tomark, line 200 */
01055         mlimit = z->lb; z->lb = z->c;
01056         z->c = z->l - m1;
01057         z->ket = z->c; /* [, line 201 */
01058         among_var = find_among_b(z, a_7, 7); /* substring, line 201 */
01059         if (!(among_var)) { z->lb = mlimit; return 0; }
01060         z->bra = z->c; /* ], line 201 */
01061         switch(among_var) {
01062             case 0: { z->lb = mlimit; return 0; }
01063             case 1:
01064                 {   int ret = r_R2(z);
01065                     if (ret == 0) { z->lb = mlimit; return 0; } /* call R2, line 202 */
01066                     if (ret < 0) return ret;
01067                 }
01068                 {   int m2 = z->l - z->c; (void)m2; /* or, line 202 */
01069                     if (!(eq_s_b(z, 1, s_34))) goto lab2;
01070                     goto lab1;
01071                 lab2:
01072                     z->c = z->l - m2;
01073                     if (!(eq_s_b(z, 1, s_35))) { z->lb = mlimit; return 0; }
01074                 }
01075             lab1:
01076                 {   int ret = slice_del(z); /* delete, line 202 */
01077                     if (ret < 0) return ret;
01078                 }
01079                 break;
01080             case 2:
01081                 {   int ret = slice_from_s(z, 1, s_36); /* <-, line 204 */
01082                     if (ret < 0) return ret;
01083                 }
01084                 break;
01085             case 3:
01086                 {   int ret = slice_del(z); /* delete, line 205 */
01087                     if (ret < 0) return ret;
01088                 }
01089                 break;
01090             case 4:
01091                 if (!(eq_s_b(z, 2, s_37))) { z->lb = mlimit; return 0; }
01092                 {   int ret = slice_del(z); /* delete, line 206 */
01093                     if (ret < 0) return ret;
01094                 }
01095                 break;
01096         }
01097         z->lb = mlimit;
01098     }
01099     return 1;
01100 }
01101 
01102 static int r_un_double(struct SN_env * z) {
01103     {   int m_test = z->l - z->c; /* test, line 212 */
01104         if (z->c - 2 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((1069056 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0;
01105         if (!(find_among_b(z, a_8, 5))) return 0; /* among, line 212 */
01106         z->c = z->l - m_test;
01107     }
01108     z->ket = z->c; /* [, line 212 */
01109     {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
01110         if (ret < 0) return 0;
01111         z->c = ret; /* next, line 212 */
01112     }
01113     z->bra = z->c; /* ], line 212 */
01114     {   int ret = slice_del(z); /* delete, line 212 */
01115         if (ret < 0) return ret;
01116     }
01117     return 1;
01118 }
01119 
01120 static int r_un_accent(struct SN_env * z) {
01121     {   int i = 1;
01122         while(1) { /* atleast, line 216 */
01123             if (out_grouping_b_U(z, g_v, 97, 251, 0)) goto lab0;
01124             i--;
01125             continue;
01126         lab0:
01127             break;
01128         }
01129         if (i > 0) return 0;
01130     }
01131     z->ket = z->c; /* [, line 217 */
01132     {   int m1 = z->l - z->c; (void)m1; /* or, line 217 */
01133         if (!(eq_s_b(z, 2, s_38))) goto lab2;
01134         goto lab1;
01135     lab2:
01136         z->c = z->l - m1;
01137         if (!(eq_s_b(z, 2, s_39))) return 0;
01138     }
01139 lab1:
01140     z->bra = z->c; /* ], line 217 */
01141     {   int ret = slice_from_s(z, 1, s_40); /* <-, line 217 */
01142         if (ret < 0) return ret;
01143     }
01144     return 1;
01145 }
01146 
01147 extern int french_UTF_8_stem(struct SN_env * z) {
01148     {   int c1 = z->c; /* do, line 223 */
01149         {   int ret = r_prelude(z);
01150             if (ret == 0) goto lab0; /* call prelude, line 223 */
01151             if (ret < 0) return ret;
01152         }
01153     lab0:
01154         z->c = c1;
01155     }
01156     {   int c2 = z->c; /* do, line 224 */
01157         {   int ret = r_mark_regions(z);
01158             if (ret == 0) goto lab1; /* call mark_regions, line 224 */
01159             if (ret < 0) return ret;
01160         }
01161     lab1:
01162         z->c = c2;
01163     }
01164     z->lb = z->c; z->c = z->l; /* backwards, line 225 */
01165 
01166     {   int m3 = z->l - z->c; (void)m3; /* do, line 227 */
01167         {   int m4 = z->l - z->c; (void)m4; /* or, line 237 */
01168             {   int m5 = z->l - z->c; (void)m5; /* and, line 233 */
01169                 {   int m6 = z->l - z->c; (void)m6; /* or, line 229 */
01170                     {   int ret = r_standard_suffix(z);
01171                         if (ret == 0) goto lab6; /* call standard_suffix, line 229 */
01172                         if (ret < 0) return ret;
01173                     }
01174                     goto lab5;
01175                 lab6:
01176                     z->c = z->l - m6;
01177                     {   int ret = r_i_verb_suffix(z);
01178                         if (ret == 0) goto lab7; /* call i_verb_suffix, line 230 */
01179                         if (ret < 0) return ret;
01180                     }
01181                     goto lab5;
01182                 lab7:
01183                     z->c = z->l - m6;
01184                     {   int ret = r_verb_suffix(z);
01185                         if (ret == 0) goto lab4; /* call verb_suffix, line 231 */
01186                         if (ret < 0) return ret;
01187                     }
01188                 }
01189             lab5:
01190                 z->c = z->l - m5;
01191                 {   int m_keep = z->l - z->c;/* (void) m_keep;*/ /* try, line 234 */
01192                     z->ket = z->c; /* [, line 234 */
01193                     {   int m7 = z->l - z->c; (void)m7; /* or, line 234 */
01194                         if (!(eq_s_b(z, 1, s_41))) goto lab10;
01195                         z->bra = z->c; /* ], line 234 */
01196                         {   int ret = slice_from_s(z, 1, s_42); /* <-, line 234 */
01197                             if (ret < 0) return ret;
01198                         }
01199                         goto lab9;
01200                     lab10:
01201                         z->c = z->l - m7;
01202                         if (!(eq_s_b(z, 2, s_43))) { z->c = z->l - m_keep; goto lab8; }
01203                         z->bra = z->c; /* ], line 235 */
01204                         {   int ret = slice_from_s(z, 1, s_44); /* <-, line 235 */
01205                             if (ret < 0) return ret;
01206                         }
01207                     }
01208                 lab9:
01209                 lab8:
01210                     ;
01211                 }
01212             }
01213             goto lab3;
01214         lab4:
01215             z->c = z->l - m4;
01216             {   int ret = r_residual_suffix(z);
01217                 if (ret == 0) goto lab2; /* call residual_suffix, line 238 */
01218                 if (ret < 0) return ret;
01219             }
01220         }
01221     lab3:
01222     lab2:
01223         z->c = z->l - m3;
01224     }
01225     {   int m8 = z->l - z->c; (void)m8; /* do, line 243 */
01226         {   int ret = r_un_double(z);
01227             if (ret == 0) goto lab11; /* call un_double, line 243 */
01228             if (ret < 0) return ret;
01229         }
01230     lab11:
01231         z->c = z->l - m8;
01232     }
01233     {   int m9 = z->l - z->c; (void)m9; /* do, line 244 */
01234         {   int ret = r_un_accent(z);
01235             if (ret == 0) goto lab12; /* call un_accent, line 244 */
01236             if (ret < 0) return ret;
01237         }
01238     lab12:
01239         z->c = z->l - m9;
01240     }
01241     z->c = z->lb;
01242     {   int c10 = z->c; /* do, line 246 */
01243         {   int ret = r_postlude(z);
01244             if (ret == 0) goto lab13; /* call postlude, line 246 */
01245             if (ret < 0) return ret;
01246         }
01247     lab13:
01248         z->c = c10;
01249     }
01250     return 1;
01251 }
01252 
01253 extern struct SN_env * french_UTF_8_create_env(void) { return SN_create_env(0, 3, 0); }
01254 
01255 extern void french_UTF_8_close_env(struct SN_env * z) { SN_close_env(z, 0); }
01256