LCOV - code coverage report
Current view: top level - src/backend/snowball/libstemmer - stem_UTF_8_english.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 324 475 68.2 %
Date: 2019-11-21 15:06:52 Functions: 17 18 94.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* This file was generated automatically by the Snowball to ISO C compiler */
       2             : /* http://snowballstem.org/ */
       3             : 
       4             : #include "header.h"
       5             : 
       6             : #ifdef __cplusplus
       7             : extern "C" {
       8             : #endif
       9             : extern int english_UTF_8_stem(struct SN_env * z);
      10             : #ifdef __cplusplus
      11             : }
      12             : #endif
      13             : static int r_exception2(struct SN_env * z);
      14             : static int r_exception1(struct SN_env * z);
      15             : static int r_Step_5(struct SN_env * z);
      16             : static int r_Step_4(struct SN_env * z);
      17             : static int r_Step_3(struct SN_env * z);
      18             : static int r_Step_2(struct SN_env * z);
      19             : static int r_Step_1c(struct SN_env * z);
      20             : static int r_Step_1b(struct SN_env * z);
      21             : static int r_Step_1a(struct SN_env * z);
      22             : static int r_R2(struct SN_env * z);
      23             : static int r_R1(struct SN_env * z);
      24             : static int r_shortv(struct SN_env * z);
      25             : static int r_mark_regions(struct SN_env * z);
      26             : static int r_postlude(struct SN_env * z);
      27             : static int r_prelude(struct SN_env * z);
      28             : #ifdef __cplusplus
      29             : extern "C" {
      30             : #endif
      31             : 
      32             : 
      33             : extern struct SN_env * english_UTF_8_create_env(void);
      34             : extern void english_UTF_8_close_env(struct SN_env * z);
      35             : 
      36             : 
      37             : #ifdef __cplusplus
      38             : }
      39             : #endif
      40             : static const symbol s_0_0[5] = { 'a', 'r', 's', 'e', 'n' };
      41             : static const symbol s_0_1[6] = { 'c', 'o', 'm', 'm', 'u', 'n' };
      42             : static const symbol s_0_2[5] = { 'g', 'e', 'n', 'e', 'r' };
      43             : 
      44             : static const struct among a_0[3] =
      45             : {
      46             : /*  0 */ { 5, s_0_0, -1, -1, 0},
      47             : /*  1 */ { 6, s_0_1, -1, -1, 0},
      48             : /*  2 */ { 5, s_0_2, -1, -1, 0}
      49             : };
      50             : 
      51             : static const symbol s_1_0[1] = { '\'' };
      52             : static const symbol s_1_1[3] = { '\'', 's', '\'' };
      53             : static const symbol s_1_2[2] = { '\'', 's' };
      54             : 
      55             : static const struct among a_1[3] =
      56             : {
      57             : /*  0 */ { 1, s_1_0, -1, 1, 0},
      58             : /*  1 */ { 3, s_1_1, 0, 1, 0},
      59             : /*  2 */ { 2, s_1_2, -1, 1, 0}
      60             : };
      61             : 
      62             : static const symbol s_2_0[3] = { 'i', 'e', 'd' };
      63             : static const symbol s_2_1[1] = { 's' };
      64             : static const symbol s_2_2[3] = { 'i', 'e', 's' };
      65             : static const symbol s_2_3[4] = { 's', 's', 'e', 's' };
      66             : static const symbol s_2_4[2] = { 's', 's' };
      67             : static const symbol s_2_5[2] = { 'u', 's' };
      68             : 
      69             : static const struct among a_2[6] =
      70             : {
      71             : /*  0 */ { 3, s_2_0, -1, 2, 0},
      72             : /*  1 */ { 1, s_2_1, -1, 3, 0},
      73             : /*  2 */ { 3, s_2_2, 1, 2, 0},
      74             : /*  3 */ { 4, s_2_3, 1, 1, 0},
      75             : /*  4 */ { 2, s_2_4, 1, -1, 0},
      76             : /*  5 */ { 2, s_2_5, 1, -1, 0}
      77             : };
      78             : 
      79             : static const symbol s_3_1[2] = { 'b', 'b' };
      80             : static const symbol s_3_2[2] = { 'd', 'd' };
      81             : static const symbol s_3_3[2] = { 'f', 'f' };
      82             : static const symbol s_3_4[2] = { 'g', 'g' };
      83             : static const symbol s_3_5[2] = { 'b', 'l' };
      84             : static const symbol s_3_6[2] = { 'm', 'm' };
      85             : static const symbol s_3_7[2] = { 'n', 'n' };
      86             : static const symbol s_3_8[2] = { 'p', 'p' };
      87             : static const symbol s_3_9[2] = { 'r', 'r' };
      88             : static const symbol s_3_10[2] = { 'a', 't' };
      89             : static const symbol s_3_11[2] = { 't', 't' };
      90             : static const symbol s_3_12[2] = { 'i', 'z' };
      91             : 
      92             : static const struct among a_3[13] =
      93             : {
      94             : /*  0 */ { 0, 0, -1, 3, 0},
      95             : /*  1 */ { 2, s_3_1, 0, 2, 0},
      96             : /*  2 */ { 2, s_3_2, 0, 2, 0},
      97             : /*  3 */ { 2, s_3_3, 0, 2, 0},
      98             : /*  4 */ { 2, s_3_4, 0, 2, 0},
      99             : /*  5 */ { 2, s_3_5, 0, 1, 0},
     100             : /*  6 */ { 2, s_3_6, 0, 2, 0},
     101             : /*  7 */ { 2, s_3_7, 0, 2, 0},
     102             : /*  8 */ { 2, s_3_8, 0, 2, 0},
     103             : /*  9 */ { 2, s_3_9, 0, 2, 0},
     104             : /* 10 */ { 2, s_3_10, 0, 1, 0},
     105             : /* 11 */ { 2, s_3_11, 0, 2, 0},
     106             : /* 12 */ { 2, s_3_12, 0, 1, 0}
     107             : };
     108             : 
     109             : static const symbol s_4_0[2] = { 'e', 'd' };
     110             : static const symbol s_4_1[3] = { 'e', 'e', 'd' };
     111             : static const symbol s_4_2[3] = { 'i', 'n', 'g' };
     112             : static const symbol s_4_3[4] = { 'e', 'd', 'l', 'y' };
     113             : static const symbol s_4_4[5] = { 'e', 'e', 'd', 'l', 'y' };
     114             : static const symbol s_4_5[5] = { 'i', 'n', 'g', 'l', 'y' };
     115             : 
     116             : static const struct among a_4[6] =
     117             : {
     118             : /*  0 */ { 2, s_4_0, -1, 2, 0},
     119             : /*  1 */ { 3, s_4_1, 0, 1, 0},
     120             : /*  2 */ { 3, s_4_2, -1, 2, 0},
     121             : /*  3 */ { 4, s_4_3, -1, 2, 0},
     122             : /*  4 */ { 5, s_4_4, 3, 1, 0},
     123             : /*  5 */ { 5, s_4_5, -1, 2, 0}
     124             : };
     125             : 
     126             : static const symbol s_5_0[4] = { 'a', 'n', 'c', 'i' };
     127             : static const symbol s_5_1[4] = { 'e', 'n', 'c', 'i' };
     128             : static const symbol s_5_2[3] = { 'o', 'g', 'i' };
     129             : static const symbol s_5_3[2] = { 'l', 'i' };
     130             : static const symbol s_5_4[3] = { 'b', 'l', 'i' };
     131             : static const symbol s_5_5[4] = { 'a', 'b', 'l', 'i' };
     132             : static const symbol s_5_6[4] = { 'a', 'l', 'l', 'i' };
     133             : static const symbol s_5_7[5] = { 'f', 'u', 'l', 'l', 'i' };
     134             : static const symbol s_5_8[6] = { 'l', 'e', 's', 's', 'l', 'i' };
     135             : static const symbol s_5_9[5] = { 'o', 'u', 's', 'l', 'i' };
     136             : static const symbol s_5_10[5] = { 'e', 'n', 't', 'l', 'i' };
     137             : static const symbol s_5_11[5] = { 'a', 'l', 'i', 't', 'i' };
     138             : static const symbol s_5_12[6] = { 'b', 'i', 'l', 'i', 't', 'i' };
     139             : static const symbol s_5_13[5] = { 'i', 'v', 'i', 't', 'i' };
     140             : static const symbol s_5_14[6] = { 't', 'i', 'o', 'n', 'a', 'l' };
     141             : static const symbol s_5_15[7] = { 'a', 't', 'i', 'o', 'n', 'a', 'l' };
     142             : static const symbol s_5_16[5] = { 'a', 'l', 'i', 's', 'm' };
     143             : static const symbol s_5_17[5] = { 'a', 't', 'i', 'o', 'n' };
     144             : static const symbol s_5_18[7] = { 'i', 'z', 'a', 't', 'i', 'o', 'n' };
     145             : static const symbol s_5_19[4] = { 'i', 'z', 'e', 'r' };
     146             : static const symbol s_5_20[4] = { 'a', 't', 'o', 'r' };
     147             : static const symbol s_5_21[7] = { 'i', 'v', 'e', 'n', 'e', 's', 's' };
     148             : static const symbol s_5_22[7] = { 'f', 'u', 'l', 'n', 'e', 's', 's' };
     149             : static const symbol s_5_23[7] = { 'o', 'u', 's', 'n', 'e', 's', 's' };
     150             : 
     151             : static const struct among a_5[24] =
     152             : {
     153             : /*  0 */ { 4, s_5_0, -1, 3, 0},
     154             : /*  1 */ { 4, s_5_1, -1, 2, 0},
     155             : /*  2 */ { 3, s_5_2, -1, 13, 0},
     156             : /*  3 */ { 2, s_5_3, -1, 15, 0},
     157             : /*  4 */ { 3, s_5_4, 3, 12, 0},
     158             : /*  5 */ { 4, s_5_5, 4, 4, 0},
     159             : /*  6 */ { 4, s_5_6, 3, 8, 0},
     160             : /*  7 */ { 5, s_5_7, 3, 9, 0},
     161             : /*  8 */ { 6, s_5_8, 3, 14, 0},
     162             : /*  9 */ { 5, s_5_9, 3, 10, 0},
     163             : /* 10 */ { 5, s_5_10, 3, 5, 0},
     164             : /* 11 */ { 5, s_5_11, -1, 8, 0},
     165             : /* 12 */ { 6, s_5_12, -1, 12, 0},
     166             : /* 13 */ { 5, s_5_13, -1, 11, 0},
     167             : /* 14 */ { 6, s_5_14, -1, 1, 0},
     168             : /* 15 */ { 7, s_5_15, 14, 7, 0},
     169             : /* 16 */ { 5, s_5_16, -1, 8, 0},
     170             : /* 17 */ { 5, s_5_17, -1, 7, 0},
     171             : /* 18 */ { 7, s_5_18, 17, 6, 0},
     172             : /* 19 */ { 4, s_5_19, -1, 6, 0},
     173             : /* 20 */ { 4, s_5_20, -1, 7, 0},
     174             : /* 21 */ { 7, s_5_21, -1, 11, 0},
     175             : /* 22 */ { 7, s_5_22, -1, 9, 0},
     176             : /* 23 */ { 7, s_5_23, -1, 10, 0}
     177             : };
     178             : 
     179             : static const symbol s_6_0[5] = { 'i', 'c', 'a', 't', 'e' };
     180             : static const symbol s_6_1[5] = { 'a', 't', 'i', 'v', 'e' };
     181             : static const symbol s_6_2[5] = { 'a', 'l', 'i', 'z', 'e' };
     182             : static const symbol s_6_3[5] = { 'i', 'c', 'i', 't', 'i' };
     183             : static const symbol s_6_4[4] = { 'i', 'c', 'a', 'l' };
     184             : static const symbol s_6_5[6] = { 't', 'i', 'o', 'n', 'a', 'l' };
     185             : static const symbol s_6_6[7] = { 'a', 't', 'i', 'o', 'n', 'a', 'l' };
     186             : static const symbol s_6_7[3] = { 'f', 'u', 'l' };
     187             : static const symbol s_6_8[4] = { 'n', 'e', 's', 's' };
     188             : 
     189             : static const struct among a_6[9] =
     190             : {
     191             : /*  0 */ { 5, s_6_0, -1, 4, 0},
     192             : /*  1 */ { 5, s_6_1, -1, 6, 0},
     193             : /*  2 */ { 5, s_6_2, -1, 3, 0},
     194             : /*  3 */ { 5, s_6_3, -1, 4, 0},
     195             : /*  4 */ { 4, s_6_4, -1, 4, 0},
     196             : /*  5 */ { 6, s_6_5, -1, 1, 0},
     197             : /*  6 */ { 7, s_6_6, 5, 2, 0},
     198             : /*  7 */ { 3, s_6_7, -1, 5, 0},
     199             : /*  8 */ { 4, s_6_8, -1, 5, 0}
     200             : };
     201             : 
     202             : static const symbol s_7_0[2] = { 'i', 'c' };
     203             : static const symbol s_7_1[4] = { 'a', 'n', 'c', 'e' };
     204             : static const symbol s_7_2[4] = { 'e', 'n', 'c', 'e' };
     205             : static const symbol s_7_3[4] = { 'a', 'b', 'l', 'e' };
     206             : static const symbol s_7_4[4] = { 'i', 'b', 'l', 'e' };
     207             : static const symbol s_7_5[3] = { 'a', 't', 'e' };
     208             : static const symbol s_7_6[3] = { 'i', 'v', 'e' };
     209             : static const symbol s_7_7[3] = { 'i', 'z', 'e' };
     210             : static const symbol s_7_8[3] = { 'i', 't', 'i' };
     211             : static const symbol s_7_9[2] = { 'a', 'l' };
     212             : static const symbol s_7_10[3] = { 'i', 's', 'm' };
     213             : static const symbol s_7_11[3] = { 'i', 'o', 'n' };
     214             : static const symbol s_7_12[2] = { 'e', 'r' };
     215             : static const symbol s_7_13[3] = { 'o', 'u', 's' };
     216             : static const symbol s_7_14[3] = { 'a', 'n', 't' };
     217             : static const symbol s_7_15[3] = { 'e', 'n', 't' };
     218             : static const symbol s_7_16[4] = { 'm', 'e', 'n', 't' };
     219             : static const symbol s_7_17[5] = { 'e', 'm', 'e', 'n', 't' };
     220             : 
     221             : static const struct among a_7[18] =
     222             : {
     223             : /*  0 */ { 2, s_7_0, -1, 1, 0},
     224             : /*  1 */ { 4, s_7_1, -1, 1, 0},
     225             : /*  2 */ { 4, s_7_2, -1, 1, 0},
     226             : /*  3 */ { 4, s_7_3, -1, 1, 0},
     227             : /*  4 */ { 4, s_7_4, -1, 1, 0},
     228             : /*  5 */ { 3, s_7_5, -1, 1, 0},
     229             : /*  6 */ { 3, s_7_6, -1, 1, 0},
     230             : /*  7 */ { 3, s_7_7, -1, 1, 0},
     231             : /*  8 */ { 3, s_7_8, -1, 1, 0},
     232             : /*  9 */ { 2, s_7_9, -1, 1, 0},
     233             : /* 10 */ { 3, s_7_10, -1, 1, 0},
     234             : /* 11 */ { 3, s_7_11, -1, 2, 0},
     235             : /* 12 */ { 2, s_7_12, -1, 1, 0},
     236             : /* 13 */ { 3, s_7_13, -1, 1, 0},
     237             : /* 14 */ { 3, s_7_14, -1, 1, 0},
     238             : /* 15 */ { 3, s_7_15, -1, 1, 0},
     239             : /* 16 */ { 4, s_7_16, 15, 1, 0},
     240             : /* 17 */ { 5, s_7_17, 16, 1, 0}
     241             : };
     242             : 
     243             : static const symbol s_8_0[1] = { 'e' };
     244             : static const symbol s_8_1[1] = { 'l' };
     245             : 
     246             : static const struct among a_8[2] =
     247             : {
     248             : /*  0 */ { 1, s_8_0, -1, 1, 0},
     249             : /*  1 */ { 1, s_8_1, -1, 2, 0}
     250             : };
     251             : 
     252             : static const symbol s_9_0[7] = { 's', 'u', 'c', 'c', 'e', 'e', 'd' };
     253             : static const symbol s_9_1[7] = { 'p', 'r', 'o', 'c', 'e', 'e', 'd' };
     254             : static const symbol s_9_2[6] = { 'e', 'x', 'c', 'e', 'e', 'd' };
     255             : static const symbol s_9_3[7] = { 'c', 'a', 'n', 'n', 'i', 'n', 'g' };
     256             : static const symbol s_9_4[6] = { 'i', 'n', 'n', 'i', 'n', 'g' };
     257             : static const symbol s_9_5[7] = { 'e', 'a', 'r', 'r', 'i', 'n', 'g' };
     258             : static const symbol s_9_6[7] = { 'h', 'e', 'r', 'r', 'i', 'n', 'g' };
     259             : static const symbol s_9_7[6] = { 'o', 'u', 't', 'i', 'n', 'g' };
     260             : 
     261             : static const struct among a_9[8] =
     262             : {
     263             : /*  0 */ { 7, s_9_0, -1, -1, 0},
     264             : /*  1 */ { 7, s_9_1, -1, -1, 0},
     265             : /*  2 */ { 6, s_9_2, -1, -1, 0},
     266             : /*  3 */ { 7, s_9_3, -1, -1, 0},
     267             : /*  4 */ { 6, s_9_4, -1, -1, 0},
     268             : /*  5 */ { 7, s_9_5, -1, -1, 0},
     269             : /*  6 */ { 7, s_9_6, -1, -1, 0},
     270             : /*  7 */ { 6, s_9_7, -1, -1, 0}
     271             : };
     272             : 
     273             : static const symbol s_10_0[5] = { 'a', 'n', 'd', 'e', 's' };
     274             : static const symbol s_10_1[5] = { 'a', 't', 'l', 'a', 's' };
     275             : static const symbol s_10_2[4] = { 'b', 'i', 'a', 's' };
     276             : static const symbol s_10_3[6] = { 'c', 'o', 's', 'm', 'o', 's' };
     277             : static const symbol s_10_4[5] = { 'd', 'y', 'i', 'n', 'g' };
     278             : static const symbol s_10_5[5] = { 'e', 'a', 'r', 'l', 'y' };
     279             : static const symbol s_10_6[6] = { 'g', 'e', 'n', 't', 'l', 'y' };
     280             : static const symbol s_10_7[4] = { 'h', 'o', 'w', 'e' };
     281             : static const symbol s_10_8[4] = { 'i', 'd', 'l', 'y' };
     282             : static const symbol s_10_9[5] = { 'l', 'y', 'i', 'n', 'g' };
     283             : static const symbol s_10_10[4] = { 'n', 'e', 'w', 's' };
     284             : static const symbol s_10_11[4] = { 'o', 'n', 'l', 'y' };
     285             : static const symbol s_10_12[6] = { 's', 'i', 'n', 'g', 'l', 'y' };
     286             : static const symbol s_10_13[5] = { 's', 'k', 'i', 'e', 's' };
     287             : static const symbol s_10_14[4] = { 's', 'k', 'i', 's' };
     288             : static const symbol s_10_15[3] = { 's', 'k', 'y' };
     289             : static const symbol s_10_16[5] = { 't', 'y', 'i', 'n', 'g' };
     290             : static const symbol s_10_17[4] = { 'u', 'g', 'l', 'y' };
     291             : 
     292             : static const struct among a_10[18] =
     293             : {
     294             : /*  0 */ { 5, s_10_0, -1, -1, 0},
     295             : /*  1 */ { 5, s_10_1, -1, -1, 0},
     296             : /*  2 */ { 4, s_10_2, -1, -1, 0},
     297             : /*  3 */ { 6, s_10_3, -1, -1, 0},
     298             : /*  4 */ { 5, s_10_4, -1, 3, 0},
     299             : /*  5 */ { 5, s_10_5, -1, 9, 0},
     300             : /*  6 */ { 6, s_10_6, -1, 7, 0},
     301             : /*  7 */ { 4, s_10_7, -1, -1, 0},
     302             : /*  8 */ { 4, s_10_8, -1, 6, 0},
     303             : /*  9 */ { 5, s_10_9, -1, 4, 0},
     304             : /* 10 */ { 4, s_10_10, -1, -1, 0},
     305             : /* 11 */ { 4, s_10_11, -1, 10, 0},
     306             : /* 12 */ { 6, s_10_12, -1, 11, 0},
     307             : /* 13 */ { 5, s_10_13, -1, 2, 0},
     308             : /* 14 */ { 4, s_10_14, -1, 1, 0},
     309             : /* 15 */ { 3, s_10_15, -1, -1, 0},
     310             : /* 16 */ { 5, s_10_16, -1, 5, 0},
     311             : /* 17 */ { 4, s_10_17, -1, 8, 0}
     312             : };
     313             : 
     314             : static const unsigned char g_v[] = { 17, 65, 16, 1 };
     315             : 
     316             : static const unsigned char g_v_WXY[] = { 1, 17, 65, 208, 1 };
     317             : 
     318             : static const unsigned char g_valid_LI[] = { 55, 141, 2 };
     319             : 
     320             : static const symbol s_0[] = { 'Y' };
     321             : static const symbol s_1[] = { 'Y' };
     322             : static const symbol s_2[] = { 's', 's' };
     323             : static const symbol s_3[] = { 'i' };
     324             : static const symbol s_4[] = { 'i', 'e' };
     325             : static const symbol s_5[] = { 'e', 'e' };
     326             : static const symbol s_6[] = { 'e' };
     327             : static const symbol s_7[] = { 'e' };
     328             : static const symbol s_8[] = { 'i' };
     329             : static const symbol s_9[] = { 't', 'i', 'o', 'n' };
     330             : static const symbol s_10[] = { 'e', 'n', 'c', 'e' };
     331             : static const symbol s_11[] = { 'a', 'n', 'c', 'e' };
     332             : static const symbol s_12[] = { 'a', 'b', 'l', 'e' };
     333             : static const symbol s_13[] = { 'e', 'n', 't' };
     334             : static const symbol s_14[] = { 'i', 'z', 'e' };
     335             : static const symbol s_15[] = { 'a', 't', 'e' };
     336             : static const symbol s_16[] = { 'a', 'l' };
     337             : static const symbol s_17[] = { 'f', 'u', 'l' };
     338             : static const symbol s_18[] = { 'o', 'u', 's' };
     339             : static const symbol s_19[] = { 'i', 'v', 'e' };
     340             : static const symbol s_20[] = { 'b', 'l', 'e' };
     341             : static const symbol s_21[] = { 'o', 'g' };
     342             : static const symbol s_22[] = { 'l', 'e', 's', 's' };
     343             : static const symbol s_23[] = { 't', 'i', 'o', 'n' };
     344             : static const symbol s_24[] = { 'a', 't', 'e' };
     345             : static const symbol s_25[] = { 'a', 'l' };
     346             : static const symbol s_26[] = { 'i', 'c' };
     347             : static const symbol s_27[] = { 's', 'k', 'i' };
     348             : static const symbol s_28[] = { 's', 'k', 'y' };
     349             : static const symbol s_29[] = { 'd', 'i', 'e' };
     350             : static const symbol s_30[] = { 'l', 'i', 'e' };
     351             : static const symbol s_31[] = { 't', 'i', 'e' };
     352             : static const symbol s_32[] = { 'i', 'd', 'l' };
     353             : static const symbol s_33[] = { 'g', 'e', 'n', 't', 'l' };
     354             : static const symbol s_34[] = { 'u', 'g', 'l', 'i' };
     355             : static const symbol s_35[] = { 'e', 'a', 'r', 'l', 'i' };
     356             : static const symbol s_36[] = { 'o', 'n', 'l', 'i' };
     357             : static const symbol s_37[] = { 's', 'i', 'n', 'g', 'l' };
     358             : static const symbol s_38[] = { 'y' };
     359             : 
     360        3424 : static int r_prelude(struct SN_env * z) { /* forwardmode */
     361        3424 :     z->B[0] = 0; /* unset Y_found, line 26 */
     362        3424 :     {   int c1 = z->c; /* do, line 27 */
     363        3424 :         z->bra = z->c; /* [, line 27 */
     364        3424 :         if (z->c == z->l || z->p[z->c] != '\'') goto lab0; /* literal, line 27 */
     365           0 :         z->c++;
     366           0 :         z->ket = z->c; /* ], line 27 */
     367           0 :         {   int ret = slice_del(z); /* delete, line 27 */
     368           0 :             if (ret < 0) return ret;
     369             :         }
     370             :     lab0:
     371        3424 :         z->c = c1;
     372             :     }
     373        3424 :     {   int c2 = z->c; /* do, line 28 */
     374        3424 :         z->bra = z->c; /* [, line 28 */
     375        3424 :         if (z->c == z->l || z->p[z->c] != 'y') goto lab1; /* literal, line 28 */
     376          28 :         z->c++;
     377          28 :         z->ket = z->c; /* ], line 28 */
     378          28 :         {   int ret = slice_from_s(z, 1, s_0); /* <-, line 28 */
     379          28 :             if (ret < 0) return ret;
     380             :         }
     381          28 :         z->B[0] = 1; /* set Y_found, line 28 */
     382             :     lab1:
     383        3424 :         z->c = c2;
     384             :     }
     385        3424 :     {   int c3 = z->c; /* do, line 29 */
     386         216 :         while(1) { /* repeat, line 29 */
     387        3640 :             int c4 = z->c;
     388       15596 :             while(1) { /* goto, line 29 */
     389       19236 :                 int c5 = z->c;
     390       19236 :                 if (in_grouping_U(z, g_v, 97, 121, 0)) goto lab4; /* grouping v, line 29 */
     391        6048 :                 z->bra = z->c; /* [, line 29 */
     392        6048 :                 if (z->c == z->l || z->p[z->c] != 'y') goto lab4; /* literal, line 29 */
     393         216 :                 z->c++;
     394         216 :                 z->ket = z->c; /* ], line 29 */
     395         216 :                 z->c = c5;
     396         216 :                 break;
     397             :             lab4:
     398       19020 :                 z->c = c5;
     399       19020 :                 {   int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
     400       19020 :                     if (ret < 0) goto lab3;
     401       15596 :                     z->c = ret; /* goto, line 29 */
     402             :                 }
     403             :             }
     404         216 :             {   int ret = slice_from_s(z, 1, s_1); /* <-, line 29 */
     405         216 :                 if (ret < 0) return ret;
     406             :             }
     407         216 :             z->B[0] = 1; /* set Y_found, line 29 */
     408         216 :             continue;
     409             :         lab3:
     410        3424 :             z->c = c4;
     411        3424 :             break;
     412             :         }
     413        3424 :         z->c = c3;
     414             :     }
     415        3424 :     return 1;
     416             : }
     417             : 
     418        3424 : static int r_mark_regions(struct SN_env * z) { /* forwardmode */
     419        3424 :     z->I[0] = z->l; /* $p1 = <integer expression>, line 33 */
     420        3424 :     z->I[1] = z->l; /* $p2 = <integer expression>, line 34 */
     421        3424 :     {   int c1 = z->c; /* do, line 35 */
     422        3424 :         {   int c2 = z->c; /* or, line 41 */
     423        3424 :             if (z->c + 4 >= z->l || z->p[z->c + 4] >> 5 != 3 || !((2375680 >> (z->p[z->c + 4] & 0x1f)) & 1)) goto lab2; /* among, line 36 */
     424         524 :             if (!(find_among(z, a_0, 3))) goto lab2;
     425           0 :             goto lab1;
     426             :         lab2:
     427        3424 :             z->c = c2;
     428             :             {    /* gopast */ /* grouping v, line 41 */
     429        3424 :                 int ret = out_grouping_U(z, g_v, 97, 121, 1);
     430        3424 :                 if (ret < 0) goto lab0;
     431        2976 :                 z->c += ret;
     432             :             }
     433             :             {    /* gopast */ /* non v, line 41 */
     434        2976 :                 int ret = in_grouping_U(z, g_v, 97, 121, 1);
     435        2976 :                 if (ret < 0) goto lab0;
     436        2588 :                 z->c += ret;
     437             :             }
     438             :         }
     439             :     lab1:
     440        2588 :         z->I[0] = z->c; /* setmark p1, line 42 */
     441             :         {    /* gopast */ /* grouping v, line 43 */
     442        2588 :             int ret = out_grouping_U(z, g_v, 97, 121, 1);
     443        2588 :             if (ret < 0) goto lab0;
     444        1394 :             z->c += ret;
     445             :         }
     446             :         {    /* gopast */ /* non v, line 43 */
     447        1394 :             int ret = in_grouping_U(z, g_v, 97, 121, 1);
     448        1394 :             if (ret < 0) goto lab0;
     449        1096 :             z->c += ret;
     450             :         }
     451        1096 :         z->I[1] = z->c; /* setmark p2, line 43 */
     452             :     lab0:
     453        3424 :         z->c = c1;
     454             :     }
     455        3424 :     return 1;
     456             : }
     457             : 
     458         270 : static int r_shortv(struct SN_env * z) { /* backwardmode */
     459         270 :     {   int m1 = z->l - z->c; (void)m1; /* or, line 51 */
     460         270 :         if (out_grouping_b_U(z, g_v_WXY, 89, 121, 0)) goto lab1; /* non v_WXY, line 50 */
     461         270 :         if (in_grouping_b_U(z, g_v, 97, 121, 0)) goto lab1; /* grouping v, line 50 */
     462         158 :         if (out_grouping_b_U(z, g_v, 97, 121, 0)) goto lab1; /* non v, line 50 */
     463          44 :         goto lab0;
     464             :     lab1:
     465         226 :         z->c = z->l - m1;
     466         226 :         if (out_grouping_b_U(z, g_v, 97, 121, 0)) return 0; /* non v, line 52 */
     467         226 :         if (in_grouping_b_U(z, g_v, 97, 121, 0)) return 0; /* grouping v, line 52 */
     468         114 :         if (z->c > z->lb) return 0; /* atlimit, line 52 */
     469             :     }
     470             : lab0:
     471         118 :     return 1;
     472             : }
     473             : 
     474         384 : static int r_R1(struct SN_env * z) { /* backwardmode */
     475         384 :     if (!(z->I[0] <= z->c)) return 0; /* $(<integer expression> <= <integer expression>), line 55 */
     476         270 :     return 1;
     477             : }
     478             : 
     479         968 : static int r_R2(struct SN_env * z) { /* backwardmode */
     480         968 :     if (!(z->I[1] <= z->c)) return 0; /* $(<integer expression> <= <integer expression>), line 56 */
     481         176 :     return 1;
     482             : }
     483             : 
     484        3424 : static int r_Step_1a(struct SN_env * z) { /* backwardmode */
     485             :     int among_var;
     486        3424 :     {   int m1 = z->l - z->c; (void)m1; /* try, line 59 */
     487        3424 :         z->ket = z->c; /* [, line 60 */
     488        3424 :         if (z->c <= z->lb || (z->p[z->c - 1] != 39 && z->p[z->c - 1] != 115)) { z->c = z->l - m1; goto lab0; } /* substring, line 60 */
     489         174 :         if (!(find_among_b(z, a_1, 3))) { z->c = z->l - m1; goto lab0; }
     490           0 :         z->bra = z->c; /* ], line 60 */
     491           0 :         {   int ret = slice_del(z); /* delete, line 62 */
     492           0 :             if (ret < 0) return ret;
     493             :         }
     494             :     lab0:
     495             :         ;
     496             :     }
     497        3424 :     z->ket = z->c; /* [, line 65 */
     498        3424 :     if (z->c <= z->lb || (z->p[z->c - 1] != 100 && z->p[z->c - 1] != 115)) return 0; /* substring, line 65 */
     499         442 :     among_var = find_among_b(z, a_2, 6);
     500         442 :     if (!(among_var)) return 0;
     501         174 :     z->bra = z->c; /* ], line 65 */
     502         174 :     switch (among_var) { /* among, line 65 */
     503             :         case 1:
     504           0 :             {   int ret = slice_from_s(z, 2, s_2); /* <-, line 66 */
     505           0 :                 if (ret < 0) return ret;
     506             :             }
     507           0 :             break;
     508             :         case 2:
     509           0 :             {   int m2 = z->l - z->c; (void)m2; /* or, line 68 */
     510           0 :                 {   int ret = skip_utf8(z->p, z->c, z->lb, z->l, - 2); /* hop, line 68 */
     511           0 :                     if (ret < 0) goto lab2;
     512           0 :                     z->c = ret;
     513             :                 }
     514           0 :                 {   int ret = slice_from_s(z, 1, s_3); /* <-, line 68 */
     515           0 :                     if (ret < 0) return ret;
     516             :                 }
     517           0 :                 goto lab1;
     518             :             lab2:
     519           0 :                 z->c = z->l - m2;
     520           0 :                 {   int ret = slice_from_s(z, 2, s_4); /* <-, line 68 */
     521           0 :                     if (ret < 0) return ret;
     522             :                 }
     523             :             }
     524             :         lab1:
     525           0 :             break;
     526             :         case 3:
     527         142 :             {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
     528         142 :                 if (ret < 0) return 0;
     529         142 :                 z->c = ret; /* next, line 69 */
     530             :             }
     531             :             {    /* gopast */ /* grouping v, line 69 */
     532         142 :                 int ret = out_grouping_b_U(z, g_v, 97, 121, 1);
     533         142 :                 if (ret < 0) return 0;
     534         138 :                 z->c -= ret;
     535             :             }
     536         138 :             {   int ret = slice_del(z); /* delete, line 69 */
     537         138 :                 if (ret < 0) return ret;
     538             :             }
     539         138 :             break;
     540             :     }
     541         170 :     return 1;
     542             : }
     543             : 
     544        3424 : static int r_Step_1b(struct SN_env * z) { /* backwardmode */
     545             :     int among_var;
     546        3424 :     z->ket = z->c; /* [, line 75 */
     547        3424 :     if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((33554576 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0; /* substring, line 75 */
     548         632 :     among_var = find_among_b(z, a_4, 6);
     549         632 :     if (!(among_var)) return 0;
     550         200 :     z->bra = z->c; /* ], line 75 */
     551         200 :     switch (among_var) { /* among, line 75 */
     552             :         case 1:
     553           0 :             {   int ret = r_R1(z); /* call R1, line 77 */
     554           0 :                 if (ret <= 0) return ret;
     555             :             }
     556           0 :             {   int ret = slice_from_s(z, 2, s_5); /* <-, line 77 */
     557           0 :                 if (ret < 0) return ret;
     558             :             }
     559           0 :             break;
     560             :         case 2:
     561         200 :             {   int m_test1 = z->l - z->c; /* test, line 80 */
     562             :                 {    /* gopast */ /* grouping v, line 80 */
     563         200 :                     int ret = out_grouping_b_U(z, g_v, 97, 121, 1);
     564         200 :                     if (ret < 0) return 0;
     565         200 :                     z->c -= ret;
     566             :                 }
     567         200 :                 z->c = z->l - m_test1;
     568             :             }
     569         200 :             {   int ret = slice_del(z); /* delete, line 80 */
     570         200 :                 if (ret < 0) return ret;
     571             :             }
     572         200 :             {   int m_test2 = z->l - z->c; /* test, line 81 */
     573         200 :                 if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((68514004 >> (z->p[z->c - 1] & 0x1f)) & 1)) among_var = 3; else /* substring, line 81 */
     574         156 :                 among_var = find_among_b(z, a_3, 13);
     575         200 :                 if (!(among_var)) return 0;
     576         200 :                 z->c = z->l - m_test2;
     577             :             }
     578         200 :             switch (among_var) { /* among, line 81 */
     579             :                 case 1:
     580             :                     {   int ret;
     581           0 :                         {   int saved_c = z->c;
     582           0 :                             ret = insert_s(z, z->c, z->c, 1, s_6); /* <+, line 83 */
     583           0 :                             z->c = saved_c;
     584             :                         }
     585           0 :                         if (ret < 0) return ret;
     586             :                     }
     587           0 :                     break;
     588             :                 case 2:
     589          24 :                     z->ket = z->c; /* [, line 86 */
     590          24 :                     {   int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
     591          24 :                         if (ret < 0) return 0;
     592          24 :                         z->c = ret; /* next, line 86 */
     593             :                     }
     594          24 :                     z->bra = z->c; /* ], line 86 */
     595          24 :                     {   int ret = slice_del(z); /* delete, line 86 */
     596          24 :                         if (ret < 0) return ret;
     597             :                     }
     598          24 :                     break;
     599             :                 case 3:
     600         176 :                     if (z->c != z->I[0]) return 0; /* atmark, line 87 */
     601          40 :                     {   int m_test3 = z->l - z->c; /* test, line 87 */
     602          40 :                         {   int ret = r_shortv(z); /* call shortv, line 87 */
     603          40 :                             if (ret <= 0) return ret;
     604             :                         }
     605           4 :                         z->c = z->l - m_test3;
     606             :                     }
     607             :                     {   int ret;
     608           4 :                         {   int saved_c = z->c;
     609           4 :                             ret = insert_s(z, z->c, z->c, 1, s_7); /* <+, line 87 */
     610           4 :                             z->c = saved_c;
     611             :                         }
     612           4 :                         if (ret < 0) return ret;
     613             :                     }
     614           4 :                     break;
     615             :             }
     616          28 :             break;
     617             :     }
     618          28 :     return 1;
     619             : }
     620             : 
     621        3424 : static int r_Step_1c(struct SN_env * z) { /* backwardmode */
     622        3424 :     z->ket = z->c; /* [, line 94 */
     623        3424 :     {   int m1 = z->l - z->c; (void)m1; /* or, line 94 */
     624        3424 :         if (z->c <= z->lb || z->p[z->c - 1] != 'y') goto lab1; /* literal, line 94 */
     625         188 :         z->c--;
     626         188 :         goto lab0;
     627             :     lab1:
     628        3236 :         z->c = z->l - m1;
     629        3236 :         if (z->c <= z->lb || z->p[z->c - 1] != 'Y') return 0; /* literal, line 94 */
     630         216 :         z->c--;
     631             :     }
     632             : lab0:
     633         404 :     z->bra = z->c; /* ], line 94 */
     634         404 :     if (out_grouping_b_U(z, g_v, 97, 121, 0)) return 0; /* non v, line 95 */
     635             :     /* not, line 95 */
     636         188 :     if (z->c > z->lb) goto lab2; /* atlimit, line 95 */
     637           0 :     return 0;
     638             : lab2:
     639         188 :     {   int ret = slice_from_s(z, 1, s_8); /* <-, line 96 */
     640         188 :         if (ret < 0) return ret;
     641             :     }
     642         188 :     return 1;
     643             : }
     644             : 
     645        3424 : static int r_Step_2(struct SN_env * z) { /* backwardmode */
     646             :     int among_var;
     647        3424 :     z->ket = z->c; /* [, line 100 */
     648        3424 :     if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((815616 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0; /* substring, line 100 */
     649         986 :     among_var = find_among_b(z, a_5, 24);
     650         986 :     if (!(among_var)) return 0;
     651          40 :     z->bra = z->c; /* ], line 100 */
     652          40 :     {   int ret = r_R1(z); /* call R1, line 100 */
     653          40 :         if (ret <= 0) return ret;
     654             :     }
     655          40 :     switch (among_var) { /* among, line 100 */
     656             :         case 1:
     657           0 :             {   int ret = slice_from_s(z, 4, s_9); /* <-, line 101 */
     658           0 :                 if (ret < 0) return ret;
     659             :             }
     660           0 :             break;
     661             :         case 2:
     662           0 :             {   int ret = slice_from_s(z, 4, s_10); /* <-, line 102 */
     663           0 :                 if (ret < 0) return ret;
     664             :             }
     665           0 :             break;
     666             :         case 3:
     667           0 :             {   int ret = slice_from_s(z, 4, s_11); /* <-, line 103 */
     668           0 :                 if (ret < 0) return ret;
     669             :             }
     670           0 :             break;
     671             :         case 4:
     672           0 :             {   int ret = slice_from_s(z, 4, s_12); /* <-, line 104 */
     673           0 :                 if (ret < 0) return ret;
     674             :             }
     675           0 :             break;
     676             :         case 5:
     677           0 :             {   int ret = slice_from_s(z, 3, s_13); /* <-, line 105 */
     678           0 :                 if (ret < 0) return ret;
     679             :             }
     680           0 :             break;
     681             :         case 6:
     682           0 :             {   int ret = slice_from_s(z, 3, s_14); /* <-, line 107 */
     683           0 :                 if (ret < 0) return ret;
     684             :             }
     685           0 :             break;
     686             :         case 7:
     687          32 :             {   int ret = slice_from_s(z, 3, s_15); /* <-, line 109 */
     688          32 :                 if (ret < 0) return ret;
     689             :             }
     690          32 :             break;
     691             :         case 8:
     692           8 :             {   int ret = slice_from_s(z, 2, s_16); /* <-, line 111 */
     693           8 :                 if (ret < 0) return ret;
     694             :             }
     695           8 :             break;
     696             :         case 9:
     697           0 :             {   int ret = slice_from_s(z, 3, s_17); /* <-, line 112 */
     698           0 :                 if (ret < 0) return ret;
     699             :             }
     700           0 :             break;
     701             :         case 10:
     702           0 :             {   int ret = slice_from_s(z, 3, s_18); /* <-, line 114 */
     703           0 :                 if (ret < 0) return ret;
     704             :             }
     705           0 :             break;
     706             :         case 11:
     707           0 :             {   int ret = slice_from_s(z, 3, s_19); /* <-, line 116 */
     708           0 :                 if (ret < 0) return ret;
     709             :             }
     710           0 :             break;
     711             :         case 12:
     712           0 :             {   int ret = slice_from_s(z, 3, s_20); /* <-, line 118 */
     713           0 :                 if (ret < 0) return ret;
     714             :             }
     715           0 :             break;
     716             :         case 13:
     717           0 :             if (z->c <= z->lb || z->p[z->c - 1] != 'l') return 0; /* literal, line 119 */
     718           0 :             z->c--;
     719           0 :             {   int ret = slice_from_s(z, 2, s_21); /* <-, line 119 */
     720           0 :                 if (ret < 0) return ret;
     721             :             }
     722           0 :             break;
     723             :         case 14:
     724           0 :             {   int ret = slice_from_s(z, 4, s_22); /* <-, line 121 */
     725           0 :                 if (ret < 0) return ret;
     726             :             }
     727           0 :             break;
     728             :         case 15:
     729           0 :             if (in_grouping_b_U(z, g_valid_LI, 99, 116, 0)) return 0; /* grouping valid_LI, line 122 */
     730           0 :             {   int ret = slice_del(z); /* delete, line 122 */
     731           0 :                 if (ret < 0) return ret;
     732             :             }
     733           0 :             break;
     734             :     }
     735          40 :     return 1;
     736             : }
     737             : 
     738        3424 : static int r_Step_3(struct SN_env * z) { /* backwardmode */
     739             :     int among_var;
     740        3424 :     z->ket = z->c; /* [, line 127 */
     741        3424 :     if (z->c - 2 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((528928 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0; /* substring, line 127 */
     742         852 :     among_var = find_among_b(z, a_6, 9);
     743         852 :     if (!(among_var)) return 0;
     744           0 :     z->bra = z->c; /* ], line 127 */
     745           0 :     {   int ret = r_R1(z); /* call R1, line 127 */
     746           0 :         if (ret <= 0) return ret;
     747             :     }
     748           0 :     switch (among_var) { /* among, line 127 */
     749             :         case 1:
     750           0 :             {   int ret = slice_from_s(z, 4, s_23); /* <-, line 128 */
     751           0 :                 if (ret < 0) return ret;
     752             :             }
     753           0 :             break;
     754             :         case 2:
     755           0 :             {   int ret = slice_from_s(z, 3, s_24); /* <-, line 129 */
     756           0 :                 if (ret < 0) return ret;
     757             :             }
     758           0 :             break;
     759             :         case 3:
     760           0 :             {   int ret = slice_from_s(z, 2, s_25); /* <-, line 130 */
     761           0 :                 if (ret < 0) return ret;
     762             :             }
     763           0 :             break;
     764             :         case 4:
     765           0 :             {   int ret = slice_from_s(z, 2, s_26); /* <-, line 132 */
     766           0 :                 if (ret < 0) return ret;
     767             :             }
     768           0 :             break;
     769             :         case 5:
     770           0 :             {   int ret = slice_del(z); /* delete, line 134 */
     771           0 :                 if (ret < 0) return ret;
     772             :             }
     773           0 :             break;
     774             :         case 6:
     775           0 :             {   int ret = r_R2(z); /* call R2, line 136 */
     776           0 :                 if (ret <= 0) return ret;
     777             :             }
     778           0 :             {   int ret = slice_del(z); /* delete, line 136 */
     779           0 :                 if (ret < 0) return ret;
     780             :             }
     781           0 :             break;
     782             :     }
     783           0 :     return 1;
     784             : }
     785             : 
     786        3424 : static int r_Step_4(struct SN_env * z) { /* backwardmode */
     787             :     int among_var;
     788        3424 :     z->ket = z->c; /* [, line 141 */
     789        3424 :     if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((1864232 >> (z->p[z->c - 1] & 0x1f)) & 1)) return 0; /* substring, line 141 */
     790        1878 :     among_var = find_among_b(z, a_7, 18);
     791        1878 :     if (!(among_var)) return 0;
     792         424 :     z->bra = z->c; /* ], line 141 */
     793         424 :     {   int ret = r_R2(z); /* call R2, line 141 */
     794         424 :         if (ret <= 0) return ret;
     795             :     }
     796          36 :     switch (among_var) { /* among, line 141 */
     797             :         case 1:
     798          36 :             {   int ret = slice_del(z); /* delete, line 144 */
     799          36 :                 if (ret < 0) return ret;
     800             :             }
     801          36 :             break;
     802             :         case 2:
     803           0 :             {   int m1 = z->l - z->c; (void)m1; /* or, line 145 */
     804           0 :                 if (z->c <= z->lb || z->p[z->c - 1] != 's') goto lab1; /* literal, line 145 */
     805           0 :                 z->c--;
     806           0 :                 goto lab0;
     807             :             lab1:
     808           0 :                 z->c = z->l - m1;
     809           0 :                 if (z->c <= z->lb || z->p[z->c - 1] != 't') return 0; /* literal, line 145 */
     810           0 :                 z->c--;
     811             :             }
     812             :         lab0:
     813           0 :             {   int ret = slice_del(z); /* delete, line 145 */
     814           0 :                 if (ret < 0) return ret;
     815             :             }
     816           0 :             break;
     817             :     }
     818          36 :     return 1;
     819             : }
     820             : 
     821        3424 : static int r_Step_5(struct SN_env * z) { /* backwardmode */
     822             :     int among_var;
     823        3424 :     z->ket = z->c; /* [, line 150 */
     824        3424 :     if (z->c <= z->lb || (z->p[z->c - 1] != 101 && z->p[z->c - 1] != 108)) return 0; /* substring, line 150 */
     825         544 :     among_var = find_among_b(z, a_8, 2);
     826         544 :     if (!(among_var)) return 0;
     827         544 :     z->bra = z->c; /* ], line 150 */
     828         544 :     switch (among_var) { /* among, line 150 */
     829             :         case 1:
     830         480 :             {   int m1 = z->l - z->c; (void)m1; /* or, line 151 */
     831         480 :                 {   int ret = r_R2(z); /* call R2, line 151 */
     832         480 :                     if (ret == 0) goto lab1;
     833         136 :                     if (ret < 0) return ret;
     834             :                 }
     835         136 :                 goto lab0;
     836             :             lab1:
     837         344 :                 z->c = z->l - m1;
     838         344 :                 {   int ret = r_R1(z); /* call R1, line 151 */
     839         344 :                     if (ret <= 0) return ret;
     840             :                 }
     841         230 :                 {   int m2 = z->l - z->c; (void)m2; /* not, line 151 */
     842         230 :                     {   int ret = r_shortv(z); /* call shortv, line 151 */
     843         230 :                         if (ret == 0) goto lab2;
     844         114 :                         if (ret < 0) return ret;
     845             :                     }
     846         114 :                     return 0;
     847             :                 lab2:
     848         116 :                     z->c = z->l - m2;
     849             :                 }
     850             :             }
     851             :         lab0:
     852         252 :             {   int ret = slice_del(z); /* delete, line 151 */
     853         252 :                 if (ret < 0) return ret;
     854             :             }
     855         252 :             break;
     856             :         case 2:
     857          64 :             {   int ret = r_R2(z); /* call R2, line 152 */
     858          64 :                 if (ret <= 0) return ret;
     859             :             }
     860           4 :             if (z->c <= z->lb || z->p[z->c - 1] != 'l') return 0; /* literal, line 152 */
     861           0 :             z->c--;
     862           0 :             {   int ret = slice_del(z); /* delete, line 152 */
     863           0 :                 if (ret < 0) return ret;
     864             :             }
     865           0 :             break;
     866             :     }
     867         252 :     return 1;
     868             : }
     869             : 
     870        3424 : static int r_exception2(struct SN_env * z) { /* backwardmode */
     871        3424 :     z->ket = z->c; /* [, line 158 */
     872        3424 :     if (z->c - 5 <= z->lb || (z->p[z->c - 1] != 100 && z->p[z->c - 1] != 103)) return 0; /* substring, line 158 */
     873         216 :     if (!(find_among_b(z, a_9, 8))) return 0;
     874           0 :     z->bra = z->c; /* ], line 158 */
     875           0 :     if (z->c > z->lb) return 0; /* atlimit, line 158 */
     876           0 :     return 1;
     877             : }
     878             : 
     879        3776 : static int r_exception1(struct SN_env * z) { /* forwardmode */
     880             :     int among_var;
     881        3776 :     z->bra = z->c; /* [, line 170 */
     882        3776 :     if (z->c + 2 >= z->l || z->p[z->c + 2] >> 5 != 3 || !((42750482 >> (z->p[z->c + 2] & 0x1f)) & 1)) return 0; /* substring, line 170 */
     883        1520 :     among_var = find_among(z, a_10, 18);
     884        1520 :     if (!(among_var)) return 0;
     885          24 :     z->ket = z->c; /* ], line 170 */
     886          24 :     if (z->c < z->l) return 0; /* atlimit, line 170 */
     887          24 :     switch (among_var) { /* among, line 170 */
     888             :         case 1:
     889           0 :             {   int ret = slice_from_s(z, 3, s_27); /* <-, line 174 */
     890           0 :                 if (ret < 0) return ret;
     891             :             }
     892           0 :             break;
     893             :         case 2:
     894          24 :             {   int ret = slice_from_s(z, 3, s_28); /* <-, line 175 */
     895          24 :                 if (ret < 0) return ret;
     896             :             }
     897          24 :             break;
     898             :         case 3:
     899           0 :             {   int ret = slice_from_s(z, 3, s_29); /* <-, line 176 */
     900           0 :                 if (ret < 0) return ret;
     901             :             }
     902           0 :             break;
     903             :         case 4:
     904           0 :             {   int ret = slice_from_s(z, 3, s_30); /* <-, line 177 */
     905           0 :                 if (ret < 0) return ret;
     906             :             }
     907           0 :             break;
     908             :         case 5:
     909           0 :             {   int ret = slice_from_s(z, 3, s_31); /* <-, line 178 */
     910           0 :                 if (ret < 0) return ret;
     911             :             }
     912           0 :             break;
     913             :         case 6:
     914           0 :             {   int ret = slice_from_s(z, 3, s_32); /* <-, line 182 */
     915           0 :                 if (ret < 0) return ret;
     916             :             }
     917           0 :             break;
     918             :         case 7:
     919           0 :             {   int ret = slice_from_s(z, 5, s_33); /* <-, line 183 */
     920           0 :                 if (ret < 0) return ret;
     921             :             }
     922           0 :             break;
     923             :         case 8:
     924           0 :             {   int ret = slice_from_s(z, 4, s_34); /* <-, line 184 */
     925           0 :                 if (ret < 0) return ret;
     926             :             }
     927           0 :             break;
     928             :         case 9:
     929           0 :             {   int ret = slice_from_s(z, 5, s_35); /* <-, line 185 */
     930           0 :                 if (ret < 0) return ret;
     931             :             }
     932           0 :             break;
     933             :         case 10:
     934           0 :             {   int ret = slice_from_s(z, 4, s_36); /* <-, line 186 */
     935           0 :                 if (ret < 0) return ret;
     936             :             }
     937           0 :             break;
     938             :         case 11:
     939           0 :             {   int ret = slice_from_s(z, 5, s_37); /* <-, line 187 */
     940           0 :                 if (ret < 0) return ret;
     941             :             }
     942           0 :             break;
     943             :     }
     944          24 :     return 1;
     945             : }
     946             : 
     947        3424 : static int r_postlude(struct SN_env * z) { /* forwardmode */
     948        3424 :     if (!(z->B[0])) return 0; /* Boolean test Y_found, line 203 */
     949         244 :     while(1) { /* repeat, line 203 */
     950         488 :         int c1 = z->c;
     951         760 :         while(1) { /* goto, line 203 */
     952        1248 :             int c2 = z->c;
     953        1248 :             z->bra = z->c; /* [, line 203 */
     954        1248 :             if (z->c == z->l || z->p[z->c] != 'Y') goto lab1; /* literal, line 203 */
     955         244 :             z->c++;
     956         244 :             z->ket = z->c; /* ], line 203 */
     957         244 :             z->c = c2;
     958         244 :             break;
     959             :         lab1:
     960        1004 :             z->c = c2;
     961        1004 :             {   int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
     962        1004 :                 if (ret < 0) goto lab0;
     963         760 :                 z->c = ret; /* goto, line 203 */
     964             :             }
     965             :         }
     966         244 :         {   int ret = slice_from_s(z, 1, s_38); /* <-, line 203 */
     967         244 :             if (ret < 0) return ret;
     968             :         }
     969         244 :         continue;
     970             :     lab0:
     971         244 :         z->c = c1;
     972         244 :         break;
     973             :     }
     974         244 :     return 1;
     975             : }
     976             : 
     977        3776 : extern int english_UTF_8_stem(struct SN_env * z) { /* forwardmode */
     978        3776 :     {   int c1 = z->c; /* or, line 207 */
     979        3776 :         {   int ret = r_exception1(z); /* call exception1, line 207 */
     980        3776 :             if (ret == 0) goto lab1;
     981          24 :             if (ret < 0) return ret;
     982             :         }
     983          24 :         goto lab0;
     984             :     lab1:
     985        3752 :         z->c = c1;
     986        3752 :         {   int c2 = z->c; /* not, line 208 */
     987        3752 :             {   int ret = skip_utf8(z->p, z->c, 0, z->l, + 3); /* hop, line 208 */
     988        3752 :                 if (ret < 0) goto lab3;
     989        3424 :                 z->c = ret;
     990             :             }
     991        3424 :             goto lab2;
     992             :         lab3:
     993         328 :             z->c = c2;
     994             :         }
     995         328 :         goto lab0;
     996             :     lab2:
     997        3424 :         z->c = c1;
     998             :         /* do, line 209 */
     999        3424 :         {   int ret = r_prelude(z); /* call prelude, line 209 */
    1000        3424 :             if (ret == 0) goto lab4;
    1001        3424 :             if (ret < 0) return ret;
    1002             :         }
    1003             :     lab4:
    1004             :         /* do, line 210 */
    1005        3424 :         {   int ret = r_mark_regions(z); /* call mark_regions, line 210 */
    1006        3424 :             if (ret == 0) goto lab5;
    1007        3424 :             if (ret < 0) return ret;
    1008             :         }
    1009             :     lab5:
    1010        3424 :         z->lb = z->c; z->c = z->l; /* backwards, line 211 */
    1011             : 
    1012        3424 :         {   int m3 = z->l - z->c; (void)m3; /* do, line 213 */
    1013        3424 :             {   int ret = r_Step_1a(z); /* call Step_1a, line 213 */
    1014        3424 :                 if (ret == 0) goto lab6;
    1015         170 :                 if (ret < 0) return ret;
    1016             :             }
    1017             :         lab6:
    1018        3424 :             z->c = z->l - m3;
    1019             :         }
    1020        3424 :         {   int m4 = z->l - z->c; (void)m4; /* or, line 215 */
    1021        3424 :             {   int ret = r_exception2(z); /* call exception2, line 215 */
    1022        3424 :                 if (ret == 0) goto lab8;
    1023           0 :                 if (ret < 0) return ret;
    1024             :             }
    1025           0 :             goto lab7;
    1026             :         lab8:
    1027        3424 :             z->c = z->l - m4;
    1028        3424 :             {   int m5 = z->l - z->c; (void)m5; /* do, line 217 */
    1029        3424 :                 {   int ret = r_Step_1b(z); /* call Step_1b, line 217 */
    1030        3424 :                     if (ret == 0) goto lab9;
    1031          28 :                     if (ret < 0) return ret;
    1032             :                 }
    1033             :             lab9:
    1034        3424 :                 z->c = z->l - m5;
    1035             :             }
    1036        3424 :             {   int m6 = z->l - z->c; (void)m6; /* do, line 218 */
    1037        3424 :                 {   int ret = r_Step_1c(z); /* call Step_1c, line 218 */
    1038        3424 :                     if (ret == 0) goto lab10;
    1039         188 :                     if (ret < 0) return ret;
    1040             :                 }
    1041             :             lab10:
    1042        3424 :                 z->c = z->l - m6;
    1043             :             }
    1044        3424 :             {   int m7 = z->l - z->c; (void)m7; /* do, line 220 */
    1045        3424 :                 {   int ret = r_Step_2(z); /* call Step_2, line 220 */
    1046        3424 :                     if (ret == 0) goto lab11;
    1047          40 :                     if (ret < 0) return ret;
    1048             :                 }
    1049             :             lab11:
    1050        3424 :                 z->c = z->l - m7;
    1051             :             }
    1052        3424 :             {   int m8 = z->l - z->c; (void)m8; /* do, line 221 */
    1053        3424 :                 {   int ret = r_Step_3(z); /* call Step_3, line 221 */
    1054        3424 :                     if (ret == 0) goto lab12;
    1055           0 :                     if (ret < 0) return ret;
    1056             :                 }
    1057             :             lab12:
    1058        3424 :                 z->c = z->l - m8;
    1059             :             }
    1060        3424 :             {   int m9 = z->l - z->c; (void)m9; /* do, line 222 */
    1061        3424 :                 {   int ret = r_Step_4(z); /* call Step_4, line 222 */
    1062        3424 :                     if (ret == 0) goto lab13;
    1063          36 :                     if (ret < 0) return ret;
    1064             :                 }
    1065             :             lab13:
    1066        3424 :                 z->c = z->l - m9;
    1067             :             }
    1068        3424 :             {   int m10 = z->l - z->c; (void)m10; /* do, line 224 */
    1069        3424 :                 {   int ret = r_Step_5(z); /* call Step_5, line 224 */
    1070        3424 :                     if (ret == 0) goto lab14;
    1071         252 :                     if (ret < 0) return ret;
    1072             :                 }
    1073             :             lab14:
    1074        3424 :                 z->c = z->l - m10;
    1075             :             }
    1076             :         }
    1077             :     lab7:
    1078        3424 :         z->c = z->lb;
    1079        3424 :         {   int c11 = z->c; /* do, line 227 */
    1080        3424 :             {   int ret = r_postlude(z); /* call postlude, line 227 */
    1081        3424 :                 if (ret == 0) goto lab15;
    1082         244 :                 if (ret < 0) return ret;
    1083             :             }
    1084             :         lab15:
    1085        3424 :             z->c = c11;
    1086             :         }
    1087             :     }
    1088             : lab0:
    1089        3776 :     return 1;
    1090             : }
    1091             : 
    1092          26 : extern struct SN_env * english_UTF_8_create_env(void) { return SN_create_env(0, 2, 1); }
    1093             : 
    1094           0 : extern void english_UTF_8_close_env(struct SN_env * z) { SN_close_env(z, 0); }
    1095             : 

Generated by: LCOV version 1.13