Mailing-List: contact java-commits-help@lucene.apache.org; run by ezmlm
Precedence: bulk
Reply-To: java-dev@lucene.apache.org
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Subject: svn commit: r688420 [6/12] - in /lucene/java/trunk/contrib: ./
 snowball/
 snowball/src/java/ snowball/src/java/net/sf/snowball/
 snowball/src/java/org/apache/lucene/analysis/snowball/
 snowball/src/java/org/tartarus/ snowball/src/java/org/tartarus/snowbal...
Date: Sat, 23 Aug 2008 22:02:48 -0000
To: java-commits@lucene.apache.org
From: kalle@apache.org
Message-Id: <20080823220250.052552388A55@eris.apache.org>

Added: lucene/java/trunk/contrib/snowball/src/java/org/tartarus/snowball/ext/KpStemmer.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/snowball/src/java/org/tartarus/snowball/ext/KpStemmer.java?rev=688420&view=auto
==============================================================================
--- lucene/java/trunk/contrib/snowball/src/java/org/tartarus/snowball/ext/KpStemmer.java (added)
+++ lucene/java/trunk/contrib/snowball/src/java/org/tartarus/snowball/ext/KpStemmer.java Sat Aug 23 15:02:47 2008
@@ -0,0 +1,2181 @@
+// This file was generated automatically by the Snowball to Java compiler
+
+package org.tartarus.snowball.ext;
+import org.tartarus.snowball.SnowballProgram;
+import org.tartarus.snowball.Among;
+
+/**
+ * Generated class implementing code defined by a snowball script.
+ */
+public class KpStemmer extends SnowballProgram {
+
+        private Among a_0[] = {
+            new Among ( "nde", -1, 7, "", this),
+            new Among ( "en", -1, 6, "", this),
+            new Among ( "s", -1, 2, "", this),
+            new Among ( "'s", 2, 1, "", this),
+            new Among ( "es", 2, 4, "", this),
+            new Among ( "ies", 4, 3, "", this),
+            new Among ( "aus", 2, 5, "", this)
+        };
+
+        private Among a_1[] = {
+            new Among ( "de", -1, 5, "", this),
+            new Among ( "ge", -1, 2, "", this),
+            new Among ( "ische", -1, 4, "", this),
+            new Among ( "je", -1, 1, "", this),
+            new Among ( "lijke", -1, 3, "", this),
+            new Among ( "le", -1, 9, "", this),
+            new Among ( "ene", -1, 10, "", this),
+            new Among ( "re", -1, 8, "", this),
+            new Among ( "se", -1, 7, "", this),
+            new Among ( "te", -1, 6, "", this),
+            new Among ( "ieve", -1, 11, "", this)
+        };
+
+        private Among a_2[] = {
+            new Among ( "heid", -1, 3, "", this),
+            new Among ( "fie", -1, 7, "", this),
+            new Among ( "gie", -1, 8, "", this),
+            new Among ( "atie", -1, 1, "", this),
+            new Among ( "isme", -1, 5, "", this),
+            new Among ( "ing", -1, 5, "", this),
+            new Among ( "arij", -1, 6, "", this),
+            new Among ( "erij", -1, 5, "", this),
+            new Among ( "sel", -1, 3, "", this),
+            new Among ( "rder", -1, 4, "", this),
+            new Among ( "ster", -1, 3, "", this),
+            new Among ( "iteit", -1, 2, "", this),
+            new Among ( "dst", -1, 10, "", this),
+            new Among ( "tst", -1, 9, "", this)
+        };
+
+        private Among a_3[] = {
+            new Among ( "end", -1, 10, "", this),
+            new Among ( "atief", -1, 2, "", this),
+            new Among ( "erig", -1, 10, "", this),
+            new Among ( "achtig", -1, 9, "", this),
+            new Among ( "ioneel", -1, 1, "", this),
+            new Among ( "baar", -1, 3, "", this),
+            new Among ( "laar", -1, 5, "", this),
+            new Among ( "naar", -1, 4, "", this),
+            new Among ( "raar", -1, 6, "", this),
+            new Among ( "eriger", -1, 10, "", this),
+            new Among ( "achtiger", -1, 9, "", this),
+            new Among ( "lijker", -1, 8, "", this),
+            new Among ( "tant", -1, 7, "", this),
+            new Among ( "erigst", -1, 10, "", this),
+            new Among ( "achtigst", -1, 9, "", this),
+            new Among ( "lijkst", -1, 8, "", this)
+        };
+
+        private Among a_4[] = {
+            new Among ( "ig", -1, 1, "", this),
+            new Among ( "iger", -1, 1, "", this),
+            new Among ( "igst", -1, 1, "", this)
+        };
+
+        private Among a_5[] = {
+            new Among ( "ft", -1, 2, "", this),
+            new Among ( "kt", -1, 1, "", this),
+            new Among ( "pt", -1, 3, "", this)
+        };
+
+        private Among a_6[] = {
+            new Among ( "bb", -1, 1, "", this),
+            new Among ( "cc", -1, 2, "", this),
+            new Among ( "dd", -1, 3, "", this),
+            new Among ( "ff", -1, 4, "", this),
+            new Among ( "gg", -1, 5, "", this),
+            new Among ( "hh", -1, 6, "", this),
+            new Among ( "jj", -1, 7, "", this),
+            new Among ( "kk", -1, 8, "", this),
+            new Among ( "ll", -1, 9, "", this),
+            new Among ( "mm", -1, 10, "", this),
+            new Among ( "nn", -1, 11, "", this),
+            new Among ( "pp", -1, 12, "", this),
+            new Among ( "qq", -1, 13, "", this),
+            new Among ( "rr", -1, 14, "", this),
+            new Among ( "ss", -1, 15, "", this),
+            new Among ( "tt", -1, 16, "", this),
+            new Among ( "v", -1, 21, "", this),
+            new Among ( "vv", 16, 17, "", this),
+            new Among ( "ww", -1, 18, "", this),
+            new Among ( "xx", -1, 19, "", this),
+            new Among ( "z", -1, 22, "", this),
+            new Among ( "zz", 20, 20, "", this)
+        };
+
+        private Among a_7[] = {
+            new Among ( "d", -1, 1, "", this),
+            new Among ( "t", -1, 2, "", this)
+        };
+
+        private static final char g_v[] = {17, 65, 16, 1 };
+
+        private static final char g_v_WX[] = {17, 65, 208, 1 };
+
+        private static final char g_AOU[] = {1, 64, 16 };
+
+        private static final char g_AIOU[] = {1, 65, 16 };
+
+        private boolean B_GE_removed;
+        private boolean B_stemmed;
+        private boolean B_Y_found;
+        private int I_p2;
+        private int I_p1;
+        private int I_x;
+        private StringBuffer S_ch = new StringBuffer();
+
+        private void copy_from(KpStemmer other) {
+            B_GE_removed = other.B_GE_removed;
+            B_stemmed = other.B_stemmed;
+            B_Y_found = other.B_Y_found;
+            I_p2 = other.I_p2;
+            I_p1 = other.I_p1;
+            I_x = other.I_x;
+            S_ch = other.S_ch;
+            super.copy_from(other);
+        }
+
+        private boolean r_R1() {
+            // (, line 32
+            // setmark x, line 32
+            I_x = cursor;
+            if (!(I_x >= I_p1))
+            {
+                return false;
+            }
+            return true;
+        }
+
+        private boolean r_R2() {
+            // (, line 33
+            // setmark x, line 33
+            I_x = cursor;
+            if (!(I_x >= I_p2))
+            {
+                return false;
+            }
+            return true;
+        }
+
+        private boolean r_V() {
+            int v_1;
+            int v_2;
+            // test, line 35
+            v_1 = limit - cursor;
+            // (, line 35
+            // or, line 35
+            lab0: do {
+                v_2 = limit - cursor;
+                lab1: do {
+                    if (!(in_grouping_b(g_v, 97, 121)))
+                    {
+                        break lab1;
+                    }
+                    break lab0;
+                } while (false);
+                cursor = limit - v_2;
+                // literal, line 35
+                if (!(eq_s_b(2, "ij")))
+                {
+                    return false;
+                }
+            } while (false);
+            cursor = limit - v_1;
+            return true;
+        }
+
+        private boolean r_VX() {
+            int v_1;
+            int v_2;
+            // test, line 36
+            v_1 = limit - cursor;
+            // (, line 36
+            // next, line 36
+            if (cursor <= limit_backward)
+            {
+                return false;
+            }
+            cursor--;
+            // or, line 36
+            lab0: do {
+                v_2 = limit - cursor;
+                lab1: do {
+                    if (!(in_grouping_b(g_v, 97, 121)))
+                    {
+                        break lab1;
+                    }
+                    break lab0;
+                } while (false);
+                cursor = limit - v_2;
+                // literal, line 36
+                if (!(eq_s_b(2, "ij")))
+                {
+                    return false;
+                }
+            } while (false);
+            cursor = limit - v_1;
+            return true;
+        }
+
+        private boolean r_C() {
+            int v_1;
+            int v_2;
+            // test, line 37
+            v_1 = limit - cursor;
+            // (, line 37
+            // not, line 37
+            {
+                v_2 = limit - cursor;
+                lab0: do {
+                    // literal, line 37
+                    if (!(eq_s_b(2, "ij")))
+                    {
+                        break lab0;
+                    }
+                    return false;
+                } while (false);
+                cursor = limit - v_2;
+            }
+            if (!(out_grouping_b(g_v, 97, 121)))
+            {
+                return false;
+            }
+            cursor = limit - v_1;
+            return true;
+        }
+
+        private boolean r_lengthen_V() {
+            int v_1;
+            int v_2;
+            int v_3;
+            int v_4;
+            int v_5;
+            int v_6;
+            int v_7;
+            int v_8;
+            // do, line 39
+            v_1 = limit - cursor;
+            lab0: do {
+                // (, line 39
+                if (!(out_grouping_b(g_v_WX, 97, 121)))
+                {
+                    break lab0;
+                }
+                // [, line 40
+                ket = cursor;
+                // or, line 40
+                lab1: do {
+                    v_2 = limit - cursor;
+                    lab2: do {
+                        // (, line 40
+                        if (!(in_grouping_b(g_AOU, 97, 117)))
+                        {
+                            break lab2;
+                        }
+                        // ], line 40
+                        bra = cursor;
+                        // test, line 40
+                        v_3 = limit - cursor;
+                        // (, line 40
+                        // or, line 40
+                        lab3: do {
+                            v_4 = limit - cursor;
+                            lab4: do {
+                                if (!(out_grouping_b(g_v, 97, 121)))
+                                {
+                                    break lab4;
+                                }
+                                break lab3;
+                            } while (false);
+                            cursor = limit - v_4;
+                            // atlimit, line 40
+                            if (cursor > limit_backward)
+                            {
+                                break lab2;
+                            }
+                        } while (false);
+                        cursor = limit - v_3;
+                        break lab1;
+                    } while (false);
+                    cursor = limit - v_2;
+                    // (, line 41
+                    // literal, line 41
+                    if (!(eq_s_b(1, "e")))
+                    {
+                        break lab0;
+                    }
+                    // ], line 41
+                    bra = cursor;
+                    // test, line 41
+                    v_5 = limit - cursor;
+                    // (, line 41
+                    // or, line 41
+                    lab5: do {
+                        v_6 = limit - cursor;
+                        lab6: do {
+                            if (!(out_grouping_b(g_v, 97, 121)))
+                            {
+                                break lab6;
+                            }
+                            break lab5;
+                        } while (false);
+                        cursor = limit - v_6;
+                        // atlimit, line 41
+                        if (cursor > limit_backward)
+                        {
+                            break lab0;
+                        }
+                    } while (false);
+                    // not, line 42
+                    {
+                        v_7 = limit - cursor;
+                        lab7: do {
+                            if (!(in_grouping_b(g_AIOU, 97, 117)))
+                            {
+                                break lab7;
+                            }
+                            break lab0;
+                        } while (false);
+                        cursor = limit - v_7;
+                    }
+                    // not, line 43
+                    {
+                        v_8 = limit - cursor;
+                        lab8: do {
+                            // (, line 43
+                            // next, line 43
+                            if (cursor <= limit_backward)
+                            {
+                                break lab8;
+                            }
+                            cursor--;
+                            if (!(in_grouping_b(g_AIOU, 97, 117)))
+                            {
+                                break lab8;
+                            }
+                            if (!(out_grouping_b(g_v, 97, 121)))
+                            {
+                                break lab8;
+                            }
+                            break lab0;
+                        } while (false);
+                        cursor = limit - v_8;
+                    }
+                    cursor = limit - v_5;
+                } while (false);
+                // -> ch, line 44
+                S_ch = slice_to(S_ch);
+                // <+ ch, line 44
+                {
+                    int c = cursor;
+                    insert(cursor, cursor, S_ch);
+                    cursor = c;
+                }
+            } while (false);
+            cursor = limit - v_1;
+            return true;
+        }
+
+        private boolean r_Step_1() {
+            int among_var;
+            int v_1;
+            int v_2;
+            int v_3;
+            int v_4;
+            // (, line 48
+            // [, line 49
+            ket = cursor;
+            // among, line 49
+            among_var = find_among_b(a_0, 7);
+            if (among_var == 0)
+            {
+                return false;
+            }
+            // (, line 49
+            // ], line 49
+            bra = cursor;
+            switch(among_var) {
+                case 0:
+                    return false;
+                case 1:
+                    // (, line 51
+                    // delete, line 51
+                    slice_del();
+                    break;
+                case 2:
+                    // (, line 52
+                    // call R1, line 52
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // not, line 52
+                    {
+                        v_1 = limit - cursor;
+                        lab0: do {
+                            // (, line 52
+                            // literal, line 52
+                            if (!(eq_s_b(1, "t")))
+                            {
+                                break lab0;
+                            }
+                            // call R1, line 52
+                            if (!r_R1())
+                            {
+                                break lab0;
+                            }
+                            return false;
+                        } while (false);
+                        cursor = limit - v_1;
+                    }
+                    // call C, line 52
+                    if (!r_C())
+                    {
+                        return false;
+                    }
+                    // delete, line 52
+                    slice_del();
+                    break;
+                case 3:
+                    // (, line 53
+                    // call R1, line 53
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // <-, line 53
+                    slice_from("ie");
+                    break;
+                case 4:
+                    // (, line 55
+                    // or, line 55
+                    lab1: do {
+                        v_2 = limit - cursor;
+                        lab2: do {
+                            // (, line 55
+                            // literal, line 55
+                            if (!(eq_s_b(2, "ar")))
+                            {
+                                break lab2;
+                            }
+                            // call R1, line 55
+                            if (!r_R1())
+                            {
+                                break lab2;
+                            }
+                            // call C, line 55
+                            if (!r_C())
+                            {
+                                break lab2;
+                            }
+                            // ], line 55
+                            bra = cursor;
+                            // delete, line 55
+                            slice_del();
+                            // call lengthen_V, line 55
+                            if (!r_lengthen_V())
+                            {
+                                break lab2;
+                            }
+                            break lab1;
+                        } while (false);
+                        cursor = limit - v_2;
+                        lab3: do {
+                            // (, line 56
+                            // literal, line 56
+                            if (!(eq_s_b(2, "er")))
+                            {
+                                break lab3;
+                            }
+                            // call R1, line 56
+                            if (!r_R1())
+                            {
+                                break lab3;
+                            }
+                            // call C, line 56
+                            if (!r_C())
+                            {
+                                break lab3;
+                            }
+                            // ], line 56
+                            bra = cursor;
+                            // delete, line 56
+                            slice_del();
+                            break lab1;
+                        } while (false);
+                        cursor = limit - v_2;
+                        // (, line 57
+                        // call R1, line 57
+                        if (!r_R1())
+                        {
+                            return false;
+                        }
+                        // call C, line 57
+                        if (!r_C())
+                        {
+                            return false;
+                        }
+                        // <-, line 57
+                        slice_from("e");
+                    } while (false);
+                    break;
+                case 5:
+                    // (, line 59
+                    // call R1, line 59
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // call V, line 59
+                    if (!r_V())
+                    {
+                        return false;
+                    }
+                    // <-, line 59
+                    slice_from("au");
+                    break;
+                case 6:
+                    // (, line 60
+                    // or, line 60
+                    lab4: do {
+                        v_3 = limit - cursor;
+                        lab5: do {
+                            // (, line 60
+                            // literal, line 60
+                            if (!(eq_s_b(3, "hed")))
+                            {
+                                break lab5;
+                            }
+                            // call R1, line 60
+                            if (!r_R1())
+                            {
+                                break lab5;
+                            }
+                            // ], line 60
+                            bra = cursor;
+                            // <-, line 60
+                            slice_from("heid");
+                            break lab4;
+                        } while (false);
+                        cursor = limit - v_3;
+                        lab6: do {
+                            // (, line 61
+                            // literal, line 61
+                            if (!(eq_s_b(2, "nd")))
+                            {
+                                break lab6;
+                            }
+                            // delete, line 61
+                            slice_del();
+                            break lab4;
+                        } while (false);
+                        cursor = limit - v_3;
+                        lab7: do {
+                            // (, line 62
+                            // literal, line 62
+                            if (!(eq_s_b(1, "d")))
+                            {
+                                break lab7;
+                            }
+                            // call R1, line 62
+                            if (!r_R1())
+                            {
+                                break lab7;
+                            }
+                            // call C, line 62
+                            if (!r_C())
+                            {
+                                break lab7;
+                            }
+                            // ], line 62
+                            bra = cursor;
+                            // delete, line 62
+                            slice_del();
+                            break lab4;
+                        } while (false);
+                        cursor = limit - v_3;
+                        lab8: do {
+                            // (, line 63
+                            // or, line 63
+                            lab9: do {
+                                v_4 = limit - cursor;
+                                lab10: do {
+                                    // literal, line 63
+                                    if (!(eq_s_b(1, "i")))
+                                    {
+                                        break lab10;
+                                    }
+                                    break lab9;
+                                } while (false);
+                                cursor = limit - v_4;
+                                // literal, line 63
+                                if (!(eq_s_b(1, "j")))
+                                {
+                                    break lab8;
+                                }
+                            } while (false);
+                            // call V, line 63
+                            if (!r_V())
+                            {
+                                break lab8;
+                            }
+                            // delete, line 63
+                            slice_del();
+                            break lab4;
+                        } while (false);
+                        cursor = limit - v_3;
+                        // (, line 64
+                        // call R1, line 64
+                        if (!r_R1())
+                        {
+                            return false;
+                        }
+                        // call C, line 64
+                        if (!r_C())
+                        {
+                            return false;
+                        }
+                        // delete, line 64
+                        slice_del();
+                        // call lengthen_V, line 64
+                        if (!r_lengthen_V())
+                        {
+                            return false;
+                        }
+                    } while (false);
+                    break;
+                case 7:
+                    // (, line 65
+                    // <-, line 65
+                    slice_from("nd");
+                    break;
+            }
+            return true;
+        }
+
+        private boolean r_Step_2() {
+            int among_var;
+            int v_1;
+            // (, line 70
+            // [, line 71
+            ket = cursor;
+            // among, line 71
+            among_var = find_among_b(a_1, 11);
+            if (among_var == 0)
+            {
+                return false;
+            }
+            // (, line 71
+            // ], line 71
+            bra = cursor;
+            switch(among_var) {
+                case 0:
+                    return false;
+                case 1:
+                    // (, line 72
+                    // or, line 72
+                    lab0: do {
+                        v_1 = limit - cursor;
+                        lab1: do {
+                            // (, line 72
+                            // literal, line 72
+                            if (!(eq_s_b(2, "'t")))
+                            {
+                                break lab1;
+                            }
+                            // ], line 72
+                            bra = cursor;
+                            // delete, line 72
+                            slice_del();
+                            break lab0;
+                        } while (false);
+                        cursor = limit - v_1;
+                        lab2: do {
+                            // (, line 73
+                            // literal, line 73
+                            if (!(eq_s_b(2, "et")))
+                            {
+                                break lab2;
+                            }
+                            // ], line 73
+                            bra = cursor;
+                            // call R1, line 73
+                            if (!r_R1())
+                            {
+                                break lab2;
+                            }
+                            // call C, line 73
+                            if (!r_C())
+                            {
+                                break lab2;
+                            }
+                            // delete, line 73
+                            slice_del();
+                            break lab0;
+                        } while (false);
+                        cursor = limit - v_1;
+                        lab3: do {
+                            // (, line 74
+                            // literal, line 74
+                            if (!(eq_s_b(3, "rnt")))
+                            {
+                                break lab3;
+                            }
+                            // ], line 74
+                            bra = cursor;
+                            // <-, line 74
+                            slice_from("rn");
+                            break lab0;
+                        } while (false);
+                        cursor = limit - v_1;
+                        lab4: do {
+                            // (, line 75
+                            // literal, line 75
+                            if (!(eq_s_b(1, "t")))
+                            {
+                                break lab4;
+                            }
+                            // ], line 75
+                            bra = cursor;
+                            // call R1, line 75
+                            if (!r_R1())
+                            {
+                                break lab4;
+                            }
+                            // call VX, line 75
+                            if (!r_VX())
+                            {
+                                break lab4;
+                            }
+                            // delete, line 75
+                            slice_del();
+                            break lab0;
+                        } while (false);
+                        cursor = limit - v_1;
+                        lab5: do {
+                            // (, line 76
+                            // literal, line 76
+                            if (!(eq_s_b(3, "ink")))
+                            {
+                                break lab5;
+                            }
+                            // ], line 76
+                            bra = cursor;
+                            // <-, line 76
+                            slice_from("ing");
+                            break lab0;
+                        } while (false);
+                        cursor = limit - v_1;
+                        lab6: do {
+                            // (, line 77
+                            // literal, line 77
+                            if (!(eq_s_b(2, "mp")))
+                            {
+                                break lab6;
+                            }
+                            // ], line 77
+                            bra = cursor;
+                            // <-, line 77
+                            slice_from("m");
+                            break lab0;
+                        } while (false);
+                        cursor = limit - v_1;
+                        lab7: do {
+                            // (, line 78
+                            // literal, line 78
+                            if (!(eq_s_b(1, "'")))
+                            {
+                                break lab7;
+                            }
+                            // ], line 78
+                            bra = cursor;
+                            // call R1, line 78
+                            if (!r_R1())
+                            {
+                                break lab7;
+                            }
+                            // delete, line 78
+                            slice_del();
+                            break lab0;
+                        } while (false);
+                        cursor = limit - v_1;
+                        // (, line 79
+                        // ], line 79
+                        bra = cursor;
+                        // call R1, line 79
+                        if (!r_R1())
+                        {
+                            return false;
+                        }
+                        // call C, line 79
+                        if (!r_C())
+                        {
+                            return false;
+                        }
+                        // delete, line 79
+                        slice_del();
+                    } while (false);
+                    break;
+                case 2:
+                    // (, line 80
+                    // call R1, line 80
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // <-, line 80
+                    slice_from("g");
+                    break;
+                case 3:
+                    // (, line 81
+                    // call R1, line 81
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // <-, line 81
+                    slice_from("lijk");
+                    break;
+                case 4:
+                    // (, line 82
+                    // call R1, line 82
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // <-, line 82
+                    slice_from("isch");
+                    break;
+                case 5:
+                    // (, line 83
+                    // call R1, line 83
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // call C, line 83
+                    if (!r_C())
+                    {
+                        return false;
+                    }
+                    // delete, line 83
+                    slice_del();
+                    break;
+                case 6:
+                    // (, line 84
+                    // call R1, line 84
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // <-, line 84
+                    slice_from("t");
+                    break;
+                case 7:
+                    // (, line 85
+                    // call R1, line 85
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // <-, line 85
+                    slice_from("s");
+                    break;
+                case 8:
+                    // (, line 86
+                    // call R1, line 86
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // <-, line 86
+                    slice_from("r");
+                    break;
+                case 9:
+                    // (, line 87
+                    // call R1, line 87
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // delete, line 87
+                    slice_del();
+                    // attach, line 87
+                    insert(cursor, cursor, "l");
+                    // call lengthen_V, line 87
+                    if (!r_lengthen_V())
+                    {
+                        return false;
+                    }
+                    break;
+                case 10:
+                    // (, line 88
+                    // call R1, line 88
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // call C, line 88
+                    if (!r_C())
+                    {
+                        return false;
+                    }
+                    // delete, line 88
+                    slice_del();
+                    // attach, line 88
+                    insert(cursor, cursor, "en");
+                    // call lengthen_V, line 88
+                    if (!r_lengthen_V())
+                    {
+                        return false;
+                    }
+                    break;
+                case 11:
+                    // (, line 89
+                    // call R1, line 89
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // call C, line 89
+                    if (!r_C())
+                    {
+                        return false;
+                    }
+                    // <-, line 89
+                    slice_from("ief");
+                    break;
+            }
+            return true;
+        }
+
+        private boolean r_Step_3() {
+            int among_var;
+            // (, line 94
+            // [, line 95
+            ket = cursor;
+            // among, line 95
+            among_var = find_among_b(a_2, 14);
+            if (among_var == 0)
+            {
+                return false;
+            }
+            // (, line 95
+            // ], line 95
+            bra = cursor;
+            switch(among_var) {
+                case 0:
+                    return false;
+                case 1:
+                    // (, line 96
+                    // call R1, line 96
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // <-, line 96
+                    slice_from("eer");
+                    break;
+                case 2:
+                    // (, line 97
+                    // call R1, line 97
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // delete, line 97
+                    slice_del();
+                    // call lengthen_V, line 97
+                    if (!r_lengthen_V())
+                    {
+                        return false;
+                    }
+                    break;
+                case 3:
+                    // (, line 100
+                    // call R1, line 100
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // delete, line 100
+                    slice_del();
+                    break;
+                case 4:
+                    // (, line 101
+                    // <-, line 101
+                    slice_from("r");
+                    break;
+                case 5:
+                    // (, line 104
+                    // call R1, line 104
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // delete, line 104
+                    slice_del();
+                    // call lengthen_V, line 104
+                    if (!r_lengthen_V())
+                    {
+                        return false;
+                    }
+                    break;
+                case 6:
+                    // (, line 105
+                    // call R1, line 105
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // call C, line 105
+                    if (!r_C())
+                    {
+                        return false;
+                    }
+                    // <-, line 105
+                    slice_from("aar");
+                    break;
+                case 7:
+                    // (, line 106
+                    // call R2, line 106
+                    if (!r_R2())
+                    {
+                        return false;
+                    }
+                    // delete, line 106
+                    slice_del();
+                    // attach, line 106
+                    insert(cursor, cursor, "f");
+                    // call lengthen_V, line 106
+                    if (!r_lengthen_V())
+                    {
+                        return false;
+                    }
+                    break;
+                case 8:
+                    // (, line 107
+                    // call R2, line 107
+                    if (!r_R2())
+                    {
+                        return false;
+                    }
+                    // delete, line 107
+                    slice_del();
+                    // attach, line 107
+                    insert(cursor, cursor, "g");
+                    // call lengthen_V, line 107
+                    if (!r_lengthen_V())
+                    {
+                        return false;
+                    }
+                    break;
+                case 9:
+                    // (, line 108
+                    // call R1, line 108
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // call C, line 108
+                    if (!r_C())
+                    {
+                        return false;
+                    }
+                    // <-, line 108
+                    slice_from("t");
+                    break;
+                case 10:
+                    // (, line 109
+                    // call R1, line 109
+                    if (!r_R1())
+                    {
+                        return false;
+                    }
+                    // call C, line 109
+                    if (!r_C())
+                    {
+                        return false;
+                    }
+                    // <-, line 109
+                    slice_from("d");
+                    break;
+            }
+            return true;
+        }
+
+        private boolean r_Step_4() {
+            int among_var;
+            int v_1;
+            // (, line 114
+            // or, line 134
+            lab0: do {
+                v_1 = limit - cursor;
+                lab1: do {
+                    // (, line 115
+                    // [, line 115
+                    ket = cursor;
+                    // among, line 115
+                    among_var = find_among_b(a_3, 16);
+                    if (among_var == 0)
+                    {
+                        break lab1;
+                    }
+                    // (, line 115
+                    // ], line 115
+                    bra = cursor;
+                    switch(among_var) {
+                        case 0:
+                            break lab1;
+                        case 1:
+                            // (, line 116
+                            // call R1, line 116
+                            if (!r_R1())
+                            {
+                                break lab1;
+                            }
+                            // <-, line 116
+                            slice_from("ie");
+                            break;
+                        case 2:
+                            // (, line 117
+                            // call R1, line 117
+                            if (!r_R1())
+                            {
+                                break lab1;
+                            }
+                            // <-, line 117
+                            slice_from("eer");
+                            break;
+                        case 3:
+                            // (, line 118
+                            // call R1, line 118
+                            if (!r_R1())
+                            {
+                                break lab1;
+                            }
+                            // delete, line 118
+                            slice_del();
+                            break;
+                        case 4:
+                            // (, line 119
+                            // call R1, line 119
+                            if (!r_R1())
+                            {
+                                break lab1;
+                            }
+                            // call V, line 119
+                            if (!r_V())
+                            {
+                                break lab1;
+                            }
+                            // <-, line 119
+                            slice_from("n");
+                            break;
+                        case 5:
+                            // (, line 120
+                            // call R1, line 120
+                            if (!r_R1())
+                            {
+                                break lab1;
+                            }
+                            // call V, line 120
+                            if (!r_V())
+                            {
+                                break lab1;
+                            }
+                            // <-, line 120
+                            slice_from("l");
+                            break;
+                        case 6:
+                            // (, line 121
+                            // call R1, line 121
+                            if (!r_R1())
+                            {
+                                break lab1;
+                            }
+                            // call V, line 121
+                            if (!r_V())
+                            {
+                                break lab1;
+                            }
+                            // <-, line 121
+                            slice_from("r");
+                            break;
+                        case 7:
+                            // (, line 122
+                            // call R1, line 122
+                            if (!r_R1())
+                            {
+                                break lab1;
+                            }
+                            // <-, line 122
+                            slice_from("teer");
+                            break;
+                        case 8:
+                            // (, line 124
+                            // call R1, line 124
+                            if (!r_R1())
+                            {
+                                break lab1;
+                            }
+                            // <-, line 124
+                            slice_from("lijk");
+                            break;
+                        case 9:
+                            // (, line 127
+                            // call R1, line 127
+                            if (!r_R1())
+                            {
+                                break lab1;
+                            }
+                            // delete, line 127
+                            slice_del();
+                            break;
+                        case 10:
+                            // (, line 131
+                            // call R1, line 131
+                            if (!r_R1())
+                            {
+                                break lab1;
+                            }
+                            // call C, line 131
+                            if (!r_C())
+                            {
+                                break lab1;
+                            }
+                            // delete, line 131
+                            slice_del();
+                            // call lengthen_V, line 131
+                            if (!r_lengthen_V())
+                            {
+                                break lab1;
+                            }
+                            break;
+                    }
+                    break lab0;
+                } while (false);
+                cursor = limit - v_1;
+                // (, line 135
+                // [, line 135
+                ket = cursor;
+                // among, line 135
+                among_var = find_among_b(a_4, 3);
+                if (among_var == 0)
+                {
+                    return false;
+                }
+                // (, line 135
+                // ], line 135
+                bra = cursor;
+                switch(among_var) {
+                    case 0:
+                        return false;
+                    case 1:
+                        // (, line 138
+                        // call R1, line 138
+                        if (!r_R1())
+                        {
+                            return false;
+                        }
+                        // call C, line 138
+                        if (!r_C())
+                        {
+                            return false;
+                        }
+                        // delete, line 138
+                        slice_del();
+                        // call lengthen_V, line 138
+                        if (!r_lengthen_V())
+                        {
+                            return false;
+                        }
+                        break;
+                }
+            } while (false);
+            return true;
+        }
+
+        private boolean r_Step_7() {
+            int among_var;
+            // (, line 144
+            // [, line 145
+            ket = cursor;
+            // among, line 145
+            among_var = find_among_b(a_5, 3);
+            if (among_var == 0)
+            {
+                return false;
+            }
+            // (, line 145
+            // ], line 145
+            bra = cursor;
+            switch(among_var) {
+                case 0:
+                    return false;
+                case 1:
+                    // (, line 146
+                    // <-, line 146
+                    slice_from("k");
+                    break;
+                case 2:
+                    // (, line 147
+                    // <-, line 147
+                    slice_from("f");
+                    break;
+                case 3:
+                    // (, line 148
+                    // <-, line 148
+                    slice_from("p");
+                    break;
+            }
+            return true;
+        }
+
+        private boolean r_Step_6() {
+            int among_var;
+            // (, line 153
+            // [, line 154
+            ket = cursor;
+            // among, line 154
+            among_var = find_among_b(a_6, 22);
+            if (among_var == 0)
+            {
+                return false;
+            }
+            // (, line 154
+            // ], line 154
+            bra = cursor;
+            switch(among_var) {
+                case 0:
+                    return false;
+                case 1:
+                    // (, line 155
+                    // <-, line 155
+                    slice_from("b");
+                    break;
+                case 2:
+                    // (, line 156
+                    // <-, line 156
+                    slice_from("c");
+                    break;
+                case 3:
+                    // (, line 157
+                    // <-, line 157
+                    slice_from("d");
+                    break;
+                case 4:
+                    // (, line 158
+                    // <-, line 158
+                    slice_from("f");
+                    break;
+                case 5:
+                    // (, line 159
+                    // <-, line 159
+                    slice_from("g");
+                    break;
+                case 6:
+                    // (, line 160
+                    // <-, line 160
+                    slice_from("h");
+                    break;
+                case 7:
+                    // (, line 161
+                    // <-, line 161
+                    slice_from("j");
+                    break;
+                case 8:
+                    // (, line 162
+                    // <-, line 162
+                    slice_from("k");
+                    break;
+                case 9:
+                    // (, line 163
+                    // <-, line 163
+                    slice_from("l");
+                    break;
+                case 10:
+                    // (, line 164
+                    // <-, line 164
+                    slice_from("m");
+                    break;
+                case 11:
+                    // (, line 165
+                    // <-, line 165
+                    slice_from("n");
+                    break;
+                case 12:
+                    // (, line 166
+                    // <-, line 166
+                    slice_from("p");
+                    break;
+                case 13:
+                    // (, line 167
+                    // <-, line 167
+                    slice_from("q");
+                    break;
+                case 14:
+                    // (, line 168
+                    // <-, line 168
+                    slice_from("r");
+                    break;
+                case 15:
+                    // (, line 169
+                    // <-, line 169
+                    slice_from("s");
+                    break;
+                case 16:
+                    // (, line 170
+                    // <-, line 170
+                    slice_from("t");
+                    break;
+                case 17:
+                    // (, line 171
+                    // <-, line 171
+                    slice_from("v");
+                    break;
+                case 18:
+                    // (, line 172
+                    // <-, line 172
+                    slice_from("w");
+                    break;
+                case 19:
+                    // (, line 173
+                    // <-, line 173
+                    slice_from("x");
+                    break;
+                case 20:
+                    // (, line 174
+                    // <-, line 174
+                    slice_from("z");
+                    break;
+                case 21:
+                    // (, line 175
+                    // <-, line 175
+                    slice_from("f");
+                    break;
+                case 22:
+                    // (, line 176
+                    // <-, line 176
+                    slice_from("s");
+                    break;
+            }
+            return true;
+        }
+
+        private boolean r_Step_1c() {
+            int among_var;
+            int v_1;
+            int v_2;
+            // (, line 181
+            // [, line 182
+            ket = cursor;
+            // among, line 182
+            among_var = find_among_b(a_7, 2);
+            if (among_var == 0)
+            {
+                return false;
+            }
+            // (, line 182
+            // ], line 182
+            bra = cursor;
+            // call R1, line 182
+            if (!r_R1())
+            {
+                return false;
+            }
+            // call C, line 182
+            if (!r_C())
+            {
+                return false;
+            }
+            switch(among_var) {
+                case 0:
+                    return false;
+                case 1:
+                    // (, line 183
+                    // not, line 183
+                    {
+                        v_1 = limit - cursor;
+                        lab0: do {
+                            // (, line 183
+                            // literal, line 183
+                            if (!(eq_s_b(1, "n")))
+                            {
+                                break lab0;
+                            }
+                            // call R1, line 183
+                            if (!r_R1())
+                            {
+                                break lab0;
+                            }
+                            return false;
+                        } while (false);
+                        cursor = limit - v_1;
+                    }
+                    // delete, line 183
+                    slice_del();
+                    break;
+                case 2:
+                    // (, line 184
+                    // not, line 184
+                    {
+                        v_2 = limit - cursor;
+                        lab1: do {
+                            // (, line 184
+                            // literal, line 184
+                            if (!(eq_s_b(1, "h")))
+                            {
+                                break lab1;
+                            }
+                            // call R1, line 184
+                            if (!r_R1())
+                            {
+                                break lab1;
+                            }
+                            return false;
+                        } while (false);
+                        cursor = limit - v_2;
+                    }
+                    // delete, line 184
+                    slice_del();
+                    break;
+            }
+            return true;
+        }
+
+        private boolean r_Lose_prefix() {
+            int v_1;
+            int v_2;
+            int v_3;
+            // (, line 189
+            // [, line 190
+            bra = cursor;
+            // literal, line 190
+            if (!(eq_s(2, "ge")))
+            {
+                return false;
+            }
+            // ], line 190
+            ket = cursor;
+            // test, line 190
+            v_1 = cursor;
+            // hop, line 190
+            {
+                int c = cursor + 3;
+                if (0 > c || c > limit)
+                {
+                    return false;
+                }
+                cursor = c;
+            }
+            cursor = v_1;
+            // (, line 190
+            // goto, line 190
+            golab0: while(true)
+            {
+                v_2 = cursor;
+                lab1: do {
+                    if (!(in_grouping(g_v, 97, 121)))
+                    {
+                        break lab1;
+                    }
+                    cursor = v_2;
+                    break golab0;
+                } while (false);
+                cursor = v_2;
+                if (cursor >= limit)
+                {
+                    return false;
+                }
+                cursor++;
+            }
+            // goto, line 190
+            golab2: while(true)
+            {
+                v_3 = cursor;
+                lab3: do {
+                    if (!(out_grouping(g_v, 97, 121)))
+                    {
+                        break lab3;
+                    }
+                    cursor = v_3;
+                    break golab2;
+                } while (false);
+                cursor = v_3;
+                if (cursor >= limit)
+                {
+                    return false;
+                }
+                cursor++;
+            }
+            // set GE_removed, line 191
+            B_GE_removed = true;
+            // delete, line 192
+            slice_del();
+            return true;
+        }
+
+        private boolean r_Lose_infix() {
+            int v_2;
+            int v_3;
+            int v_4;
+            // (, line 195
+            // next, line 196
+            if (cursor >= limit)
+            {
+                return false;
+            }
+            cursor++;
+            // gopast, line 197
+            golab0: while(true)
+            {
+                lab1: do {
+                    // (, line 197
+                    // [, line 197
+                    bra = cursor;
+                    // literal, line 197
+                    if (!(eq_s(2, "ge")))
+                    {
+                        break lab1;
+                    }
+                    // ], line 197
+                    ket = cursor;
+                    break golab0;
+                } while (false);
+                if (cursor >= limit)
+                {
+                    return false;
+                }
+                cursor++;
+            }
+            // test, line 197
+            v_2 = cursor;
+            // hop, line 197
+            {
+                int c = cursor + 3;
+                if (0 > c || c > limit)
+                {
+                    return false;
+                }
+                cursor = c;
+            }
+            cursor = v_2;
+            // (, line 197
+            // goto, line 197
+            golab2: while(true)
+            {
+                v_3 = cursor;
+                lab3: do {
+                    if (!(in_grouping(g_v, 97, 121)))
+                    {
+                        break lab3;
+                    }
+                    cursor = v_3;
+                    break golab2;
+                } while (false);
+                cursor = v_3;
+                if (cursor >= limit)
+                {
+                    return false;
+                }
+                cursor++;
+            }
+            // goto, line 197
+            golab4: while(true)
+            {
+                v_4 = cursor;
+                lab5: do {
+                    if (!(out_grouping(g_v, 97, 121)))
+                    {
+                        break lab5;
+                    }
+                    cursor = v_4;
+                    break golab4;
+                } while (false);
+                cursor = v_4;
+                if (cursor >= limit)
+                {
+                    return false;
+                }
+                cursor++;
+            }
+            // set GE_removed, line 198
+            B_GE_removed = true;
+            // delete, line 199
+            slice_del();
+            return true;
+        }
+
+        private boolean r_measure() {
+            int v_1;
+            int v_2;
+            int v_5;
+            int v_6;
+            int v_9;
+            int v_10;
+            // (, line 202
+            // do, line 203
+            v_1 = cursor;
+            lab0: do {
+                // (, line 203
+                // tolimit, line 204
+                cursor = limit;
+                // setmark p1, line 205
+                I_p1 = cursor;
+                // setmark p2, line 206
+                I_p2 = cursor;
+            } while (false);
+            cursor = v_1;
+            // do, line 208
+            v_2 = cursor;
+            lab1: do {
+                // (, line 208
+                // repeat, line 209
+                replab2: while(true)
+                {
+                    lab3: do {
+                        if (!(out_grouping(g_v, 97, 121)))
+                        {
+                            break lab3;
+                        }
+                        continue replab2;
+                    } while (false);
+                    break replab2;
+                }
+                // atleast, line 209
+                {
+                    int v_4 = 1;
+                    // atleast, line 209
+                    replab4: while(true)
+                    {
+                        v_5 = cursor;
+                        lab5: do {
+                            // (, line 209
+                            // or, line 209
+                            lab6: do {
+                                v_6 = cursor;
+                                lab7: do {
+                                    // literal, line 209
+                                    if (!(eq_s(2, "ij")))
+                                    {
+                                        break lab7;
+                                    }
+                                    break lab6;
+                                } while (false);
+                                cursor = v_6;
+                                if (!(in_grouping(g_v, 97, 121)))
+                                {
+                                    break lab5;
+                                }
+                            } while (false);
+                            v_4--;
+                            continue replab4;
+                        } while (false);
+                        cursor = v_5;
+                        break replab4;
+                    }
+                    if (v_4 > 0)
+                    {
+                        break lab1;
+                    }
+                }
+                if (!(out_grouping(g_v, 97, 121)))
+                {
+                    break lab1;
+                }
+                // setmark p1, line 209
+                I_p1 = cursor;
+                // repeat, line 210
+                replab8: while(true)
+                {
+                    lab9: do {
+                        if (!(out_grouping(g_v, 97, 121)))
+                        {
+                            break lab9;
+                        }
+                        continue replab8;
+                    } while (false);
+                    break replab8;
+                }
+                // atleast, line 210
+                {
+                    int v_8 = 1;
+                    // atleast, line 210
+                    replab10: while(true)
+                    {
+                        v_9 = cursor;
+                        lab11: do {
+                            // (, line 210
+                            // or, line 210
+                            lab12: do {
+                                v_10 = cursor;
+                                lab13: do {
+                                    // literal, line 210
+                                    if (!(eq_s(2, "ij")))
+                                    {
+                                        break lab13;
+                                    }
+                                    break lab12;
+                                } while (false);
+                                cursor = v_10;
+                                if (!(in_grouping(g_v, 97, 121)))
+                                {
+                                    break lab11;
+                                }
+                            } while (false);
+                            v_8--;
+                            continue replab10;
+                        } while (false);
+                        cursor = v_9;
+                        break replab10;
+                    }
+                    if (v_8 > 0)
+                    {
+                        break lab1;
+                    }
+                }
+                if (!(out_grouping(g_v, 97, 121)))
+                {
+                    break lab1;
+                }
+                // setmark p2, line 210
+                I_p2 = cursor;
+            } while (false);
+            cursor = v_2;
+            return true;
+        }
+
+        public boolean stem() {
+            int v_1;
+            int v_2;
+            int v_3;
+            int v_4;
+            int v_5;
+            int v_6;
+            int v_7;
+            int v_8;
+            int v_9;
+            int v_10;
+            int v_11;
+            int v_12;
+            int v_13;
+            int v_14;
+            int v_15;
+            int v_16;
+            int v_18;
+            int v_19;
+            int v_20;
+            // (, line 214
+            // unset Y_found, line 216
+            B_Y_found = false;
+            // unset stemmed, line 217
+            B_stemmed = false;
+            // do, line 218
+            v_1 = cursor;
+            lab0: do {
+                // (, line 218
+                // [, line 218
+                bra = cursor;
+                // literal, line 218
+                if (!(eq_s(1, "y")))
+                {
+                    break lab0;
+                }
+                // ], line 218
+                ket = cursor;
+                // <-, line 218
+                slice_from("Y");
+                // set Y_found, line 218
+                B_Y_found = true;
+            } while (false);
+            cursor = v_1;
+            // do, line 219
+            v_2 = cursor;
+            lab1: do {
+                // repeat, line 219
+                replab2: while(true)
+                {
+                    v_3 = cursor;
+                    lab3: do {
+                        // (, line 219
+                        // goto, line 219
+                        golab4: while(true)
+                        {
+                            v_4 = cursor;
+                            lab5: do {
+                                // (, line 219
+                                if (!(in_grouping(g_v, 97, 121)))
+                                {
+                                    break lab5;
+                                }
+                                // [, line 219
+                                bra = cursor;
+                                // literal, line 219
+                                if (!(eq_s(1, "y")))
+                                {
+                                    break lab5;
+                                }
+                                // ], line 219
+                                ket = cursor;
+                                cursor = v_4;
+                                break golab4;
+                            } while (false);
+                            cursor = v_4;
+                            if (cursor >= limit)
+                            {
+                                break lab3;
+                            }
+                            cursor++;
+                        }
+                        // <-, line 219
+                        slice_from("Y");
+                        // set Y_found, line 219
+                        B_Y_found = true;
+                        continue replab2;
+                    } while (false);
+                    cursor = v_3;
+                    break replab2;
+                }
+            } while (false);
+            cursor = v_2;
+            // call measure, line 221
+            if (!r_measure())
+            {
+                return false;
+            }
+            // backwards, line 223
+            limit_backward = cursor; cursor = limit;
+            // (, line 223
+            // do, line 224
+            v_5 = limit - cursor;
+            lab6: do {
+                // (, line 224
+                // call Step_1, line 224
+                if (!r_Step_1())
+                {
+                    break lab6;
+                }
+                // set stemmed, line 224
+                B_stemmed = true;
+            } while (false);
+            cursor = limit - v_5;
+            // do, line 225
+            v_6 = limit - cursor;
+            lab7: do {
+                // (, line 225
+                // call Step_2, line 225
+                if (!r_Step_2())
+                {
+                    break lab7;
+                }
+                // set stemmed, line 225
+                B_stemmed = true;
+            } while (false);
+            cursor = limit - v_6;
+            // do, line 226
+            v_7 = limit - cursor;
+            lab8: do {
+                // (, line 226
+                // call Step_3, line 226
+                if (!r_Step_3())
+                {
+                    break lab8;
+                }
+                // set stemmed, line 226
+                B_stemmed = true;
+            } while (false);
+            cursor = limit - v_7;
+            // do, line 227
+            v_8 = limit - cursor;
+            lab9: do {
+                // (, line 227
+                // call Step_4, line 227
+                if (!r_Step_4())
+                {
+                    break lab9;
+                }
+                // set stemmed, line 227
+                B_stemmed = true;
+            } while (false);
+            cursor = limit - v_8;
+            cursor = limit_backward;            // unset GE_removed, line 229
+            B_GE_removed = false;
+            // do, line 230
+            v_9 = cursor;
+            lab10: do {
+                // (, line 230
+                // and, line 230
+                v_10 = cursor;
+                // call Lose_prefix, line 230
+                if (!r_Lose_prefix())
+                {
+                    break lab10;
+                }
+                cursor = v_10;
+                // call measure, line 230
+                if (!r_measure())
+                {
+                    break lab10;
+                }
+            } while (false);
+            cursor = v_9;
+            // backwards, line 231
+            limit_backward = cursor; cursor = limit;
+            // (, line 231
+            // do, line 232
+            v_11 = limit - cursor;
+            lab11: do {
+                // (, line 232
+                // Boolean test GE_removed, line 232
+                if (!(B_GE_removed))
+                {
+                    break lab11;
+                }
+                // call Step_1c, line 232
+                if (!r_Step_1c())
+                {
+                    break lab11;
+                }
+            } while (false);
+            cursor = limit - v_11;
+            cursor = limit_backward;            // unset GE_removed, line 234
+            B_GE_removed = false;
+            // do, line 235
+            v_12 = cursor;
+            lab12: do {
+                // (, line 235
+                // and, line 235
+                v_13 = cursor;
+                // call Lose_infix, line 235
+                if (!r_Lose_infix())
+                {
+                    break lab12;
+                }
+                cursor = v_13;
+                // call measure, line 235
+                if (!r_measure())
+                {
+                    break lab12;
+                }
+            } while (false);
+            cursor = v_12;
+            // backwards, line 236
+            limit_backward = cursor; cursor = limit;
+            // (, line 236
+            // do, line 237
+            v_14 = limit - cursor;
+            lab13: do {
+                // (, line 237
+                // Boolean test GE_removed, line 237
+                if (!(B_GE_removed))
+                {
+                    break lab13;
+                }
+                // call Step_1c, line 237
+                if (!r_Step_1c())
+                {
+                    break lab13;
+                }
+            } while (false);
+            cursor = limit - v_14;
+            cursor = limit_backward;            // backwards, line 239
+            limit_backward = cursor; cursor = limit;
+            // (, line 239
+            // do, line 240
+            v_15 = limit - cursor;
+            lab14: do {
+                // (, line 240
+                // call Step_7, line 240
+                if (!r_Step_7())
+                {
+                    break lab14;
+                }
+                // set stemmed, line 240
+                B_stemmed = true;
+            } while (false);
+            cursor = limit - v_15;
+            // do, line 241
+            v_16 = limit - cursor;
+            lab15: do {
+                // (, line 241
+                // or, line 241
+                lab16: do {
+                    lab17: do {
+                        // Boolean test stemmed, line 241
+                        if (!(B_stemmed))
+                        {
+                            break lab17;
+                        }
+                        break lab16;
+                    } while (false);
+                    // Boolean test GE_removed, line 241
+                    if (!(B_GE_removed))
+                    {
+                        break lab15;
+                    }
+                } while (false);
+                // call Step_6, line 241
+                if (!r_Step_6())
+                {
+                    break lab15;
+                }
+            } while (false);
+            cursor = limit - v_16;
+            cursor = limit_backward;            // do, line 243
+            v_18 = cursor;
+            lab18: do {
+                // (, line 243
+                // Boolean test Y_found, line 243
+                if (!(B_Y_found))
+                {
+                    break lab18;
+                }
+                // repeat, line 243
+                replab19: while(true)
+                {
+                    v_19 = cursor;
+                    lab20: do {
+                        // (, line 243
+                        // goto, line 243
+                        golab21: while(true)
+                        {
+                            v_20 = cursor;
+                            lab22: do {
+                                // (, line 243
+                                // [, line 243
+                                bra = cursor;
+                                // literal, line 243
+                                if (!(eq_s(1, "Y")))
+                                {
+                                    break lab22;
+                                }
+                                // ], line 243
+                                ket = cursor;
+                                cursor = v_20;
+                                break golab21;
+                            } while (false);
+                            cursor = v_20;
+                            if (cursor >= limit)
+                            {
+                                break lab20;
+                            }
+                            cursor++;
+                        }
+                        // <-, line 243
+                        slice_from("y");
+                        continue replab19;
+                    } while (false);
+                    cursor = v_19;
+                    break replab19;
+                }
+            } while (false);
+            cursor = v_18;
+            return true;
+        }
+
+}
+