Go: refactor (#16602)

### Summary

1. update doc
2. refactor route code

---------

Signed-off-by: Jin Hai <haijin.chn@gmail.com>

internal/binding/cpp/stemmer/api.cpp

@@ -0,0 +1,78 @@
+// Copyright(C) 2023 InfiniFlow, Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "header.h"
+
+#include <stdlib.h> /* for calloc, free */
+
+extern struct SN_env *SN_create_env(int S_size, int I_size, int B_size) {
+    struct SN_env *z = (struct SN_env *)calloc(1, sizeof(struct SN_env));
+    if (z == NULL)
+        return NULL;
+    z->p = create_s();
+    if (z->p == NULL)
+        goto error;
+    if (S_size) {
+        int i;
+        z->S = (symbol **)calloc(S_size, sizeof(symbol *));
+        if (z->S == NULL)
+            goto error;
+
+        for (i = 0; i < S_size; i++) {
+            z->S[i] = create_s();
+            if (z->S[i] == NULL)
+                goto error;
+        }
+    }
+
+    if (I_size) {
+        z->I = (int *)calloc(I_size, sizeof(int));
+        if (z->I == NULL)
+            goto error;
+    }
+
+    if (B_size) {
+        z->B = (unsigned char *)calloc(B_size, sizeof(unsigned char));
+        if (z->B == NULL)
+            goto error;
+    }
+
+    return z;
+error:
+    SN_close_env(z, S_size);
+    return NULL;
+}
+
+extern void SN_close_env(struct SN_env *z, int S_size) {
+    if (z == NULL)
+        return;
+    if (S_size) {
+        int i;
+        for (i = 0; i < S_size; i++) {
+            lose_s(z->S[i]);
+        }
+        free(z->S);
+    }
+    free(z->I);
+    free(z->B);
+    if (z->p)
+        lose_s(z->p);
+    free(z);
+}
+
+extern int SN_set_current(struct SN_env *z, int size, const symbol *s) {
+    int err = replace_s(z, 0, z->l, size, s, NULL);
+    z->c = 0;
+    return err;
+}

internal/binding/cpp/stemmer/api.h

@@ -0,0 +1,31 @@
+
+#pragma once
+
+typedef unsigned char symbol;
+
+/* Or replace 'char' above with 'short' for 16 bit characters.
+
+   More precisely, replace 'char' with whatever type guarantees the
+   character width you need. Note however that sizeof(symbol) should divide
+   HEAD, defined in header.h as 2*sizeof(int), without remainder, otherwise
+   there is an alignment problem. In the unlikely event of a problem here,
+   consult Martin Porter.
+
+*/
+
+struct SN_env {
+    symbol *p;
+    int c;
+    int l;
+    int lb;
+    int bra;
+    int ket;
+    symbol **S;
+    int *I;
+    unsigned char *B;
+};
+
+extern struct SN_env *SN_create_env(int S_size, int I_size, int B_size);
+extern void SN_close_env(struct SN_env *z, int S_size);
+
+extern int SN_set_current(struct SN_env *z, int size, const symbol *s);

internal/binding/cpp/stemmer/header.h

@@ -0,0 +1,59 @@
+
+#pragma once
+
+#include <limits.h>
+
+#include "api.h"
+
+#define MAXINT INT_MAX
+#define MININT INT_MIN
+
+#define HEAD 2 * sizeof(int)
+
+#define SIZE(p) ((int *)(p))[-1]
+#define SET_SIZE(p, n) ((int *)(p))[-1] = n
+#define CAPACITY(p) ((int *)(p))[-2]
+
+struct among {
+    int s_size;      /* number of chars in string */
+    const symbol *s; /* search string */
+    int substring_i; /* index to longest matching substring */
+    int result;      /* result of the lookup */
+    int (*function)(struct SN_env *);
+};
+
+extern symbol *create_s(void);
+extern void lose_s(symbol *p);
+
+extern int skip_utf8(const symbol *p, int c, int lb, int l, int n);
+
+extern int in_grouping_U(struct SN_env *z, const unsigned char *s, int min, int max, int repeat);
+extern int in_grouping_b_U(struct SN_env *z, const unsigned char *s, int min, int max, int repeat);
+extern int out_grouping_U(struct SN_env *z, const unsigned char *s, int min, int max, int repeat);
+extern int out_grouping_b_U(struct SN_env *z, const unsigned char *s, int min, int max, int repeat);
+
+extern int in_grouping(struct SN_env *z, const unsigned char *s, int min, int max, int repeat);
+extern int in_grouping_b(struct SN_env *z, const unsigned char *s, int min, int max, int repeat);
+extern int out_grouping(struct SN_env *z, const unsigned char *s, int min, int max, int repeat);
+extern int out_grouping_b(struct SN_env *z, const unsigned char *s, int min, int max, int repeat);
+
+extern int eq_s(struct SN_env *z, int s_size, const symbol *s);
+extern int eq_s_b(struct SN_env *z, int s_size, const symbol *s);
+extern int eq_v(struct SN_env *z, const symbol *p);
+extern int eq_v_b(struct SN_env *z, const symbol *p);
+
+extern int find_among(struct SN_env *z, const struct among *v, int v_size);
+extern int find_among_b(struct SN_env *z, const struct among *v, int v_size);
+
+extern int replace_s(struct SN_env *z, int c_bra, int c_ket, int s_size, const symbol *s, int *adjustment);
+extern int slice_from_s(struct SN_env *z, int s_size, const symbol *s);
+extern int slice_from_v(struct SN_env *z, const symbol *p);
+extern int slice_del(struct SN_env *z);
+
+extern int insert_s(struct SN_env *z, int bra, int ket, int s_size, const symbol *s);
+extern int insert_v(struct SN_env *z, int bra, int ket, const symbol *p);
+
+extern symbol *slice_to(struct SN_env *z, symbol *p);
+extern symbol *assign_to(struct SN_env *z, symbol *p);
+
+extern void debug(struct SN_env *z, int number, int line_count);

internal/binding/cpp/stemmer/stem_UTF_8_danish.cpp

@@ -0,0 +1,424 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#include "header.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern int danish_UTF_8_stem(struct SN_env *z);
+#ifdef __cplusplus
+}
+#endif
+static int r_undouble(struct SN_env *z);
+static int r_other_suffix(struct SN_env *z);
+static int r_consonant_pair(struct SN_env *z);
+static int r_main_suffix(struct SN_env *z);
+static int r_mark_regions(struct SN_env *z);
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *danish_UTF_8_create_env(void);
+extern void danish_UTF_8_close_env(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif
+static const symbol s_0_0[3] = {'h', 'e', 'd'};
+static const symbol s_0_1[5] = {'e', 't', 'h', 'e', 'd'};
+static const symbol s_0_2[4] = {'e', 'r', 'e', 'd'};
+static const symbol s_0_3[1] = {'e'};
+static const symbol s_0_4[5] = {'e', 'r', 'e', 'd', 'e'};
+static const symbol s_0_5[4] = {'e', 'n', 'd', 'e'};
+static const symbol s_0_6[6] = {'e', 'r', 'e', 'n', 'd', 'e'};
+static const symbol s_0_7[3] = {'e', 'n', 'e'};
+static const symbol s_0_8[4] = {'e', 'r', 'n', 'e'};
+static const symbol s_0_9[3] = {'e', 'r', 'e'};
+static const symbol s_0_10[2] = {'e', 'n'};
+static const symbol s_0_11[5] = {'h', 'e', 'd', 'e', 'n'};
+static const symbol s_0_12[4] = {'e', 'r', 'e', 'n'};
+static const symbol s_0_13[2] = {'e', 'r'};
+static const symbol s_0_14[5] = {'h', 'e', 'd', 'e', 'r'};
+static const symbol s_0_15[4] = {'e', 'r', 'e', 'r'};
+static const symbol s_0_16[1] = {'s'};
+static const symbol s_0_17[4] = {'h', 'e', 'd', 's'};
+static const symbol s_0_18[2] = {'e', 's'};
+static const symbol s_0_19[5] = {'e', 'n', 'd', 'e', 's'};
+static const symbol s_0_20[7] = {'e', 'r', 'e', 'n', 'd', 'e', 's'};
+static const symbol s_0_21[4] = {'e', 'n', 'e', 's'};
+static const symbol s_0_22[5] = {'e', 'r', 'n', 'e', 's'};
+static const symbol s_0_23[4] = {'e', 'r', 'e', 's'};
+static const symbol s_0_24[3] = {'e', 'n', 's'};
+static const symbol s_0_25[6] = {'h', 'e', 'd', 'e', 'n', 's'};
+static const symbol s_0_26[5] = {'e', 'r', 'e', 'n', 's'};
+static const symbol s_0_27[3] = {'e', 'r', 's'};
+static const symbol s_0_28[3] = {'e', 't', 's'};
+static const symbol s_0_29[5] = {'e', 'r', 'e', 't', 's'};
+static const symbol s_0_30[2] = {'e', 't'};
+static const symbol s_0_31[4] = {'e', 'r', 'e', 't'};
+
+static const struct among a_0[32] = {
+    /*  0 */ {3, s_0_0, -1, 1, 0},
+    /*  1 */ {5, s_0_1, 0, 1, 0},
+    /*  2 */ {4, s_0_2, -1, 1, 0},
+    /*  3 */ {1, s_0_3, -1, 1, 0},
+    /*  4 */ {5, s_0_4, 3, 1, 0},
+    /*  5 */ {4, s_0_5, 3, 1, 0},
+    /*  6 */ {6, s_0_6, 5, 1, 0},
+    /*  7 */ {3, s_0_7, 3, 1, 0},
+    /*  8 */ {4, s_0_8, 3, 1, 0},
+    /*  9 */ {3, s_0_9, 3, 1, 0},
+    /* 10 */ {2, s_0_10, -1, 1, 0},
+    /* 11 */ {5, s_0_11, 10, 1, 0},
+    /* 12 */ {4, s_0_12, 10, 1, 0},
+    /* 13 */ {2, s_0_13, -1, 1, 0},
+    /* 14 */ {5, s_0_14, 13, 1, 0},
+    /* 15 */ {4, s_0_15, 13, 1, 0},
+    /* 16 */ {1, s_0_16, -1, 2, 0},
+    /* 17 */ {4, s_0_17, 16, 1, 0},
+    /* 18 */ {2, s_0_18, 16, 1, 0},
+    /* 19 */ {5, s_0_19, 18, 1, 0},
+    /* 20 */ {7, s_0_20, 19, 1, 0},
+    /* 21 */ {4, s_0_21, 18, 1, 0},
+    /* 22 */ {5, s_0_22, 18, 1, 0},
+    /* 23 */ {4, s_0_23, 18, 1, 0},
+    /* 24 */ {3, s_0_24, 16, 1, 0},
+    /* 25 */ {6, s_0_25, 24, 1, 0},
+    /* 26 */ {5, s_0_26, 24, 1, 0},
+    /* 27 */ {3, s_0_27, 16, 1, 0},
+    /* 28 */ {3, s_0_28, 16, 1, 0},
+    /* 29 */ {5, s_0_29, 28, 1, 0},
+    /* 30 */ {2, s_0_30, -1, 1, 0},
+    /* 31 */ {4, s_0_31, 30, 1, 0}};
+
+static const symbol s_1_0[2] = {'g', 'd'};
+static const symbol s_1_1[2] = {'d', 't'};
+static const symbol s_1_2[2] = {'g', 't'};
+static const symbol s_1_3[2] = {'k', 't'};
+
+static const struct among a_1[4] = {
+    /*  0 */ {2, s_1_0, -1, -1, 0},
+    /*  1 */ {2, s_1_1, -1, -1, 0},
+    /*  2 */ {2, s_1_2, -1, -1, 0},
+    /*  3 */ {2, s_1_3, -1, -1, 0}};
+
+static const symbol s_2_0[2] = {'i', 'g'};
+static const symbol s_2_1[3] = {'l', 'i', 'g'};
+static const symbol s_2_2[4] = {'e', 'l', 'i', 'g'};
+static const symbol s_2_3[3] = {'e', 'l', 's'};
+static const symbol s_2_4[5] = {'l', 0xC3, 0xB8, 's', 't'};
+
+static const struct among a_2[5] = {
+    /*  0 */ {2, s_2_0, -1, 1, 0},
+    /*  1 */ {3, s_2_1, 0, 1, 0},
+    /*  2 */ {4, s_2_2, 1, 1, 0},
+    /*  3 */ {3, s_2_3, -1, 1, 0},
+    /*  4 */ {5, s_2_4, -1, 2, 0}};
+
+static const unsigned char g_v[] = {17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 128};
+
+static const unsigned char g_s_ending[] = {239, 254, 42, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16};
+
+static const symbol s_0[] = {'s', 't'};
+static const symbol s_1[] = {'i', 'g'};
+static const symbol s_2[] = {'l', 0xC3, 0xB8, 's'};
+
+static int r_mark_regions(struct SN_env *z) {
+    z->I[0] = z->l;
+    {
+        int c_test = z->c; /* test, line 33 */
+        {
+            int ret = skip_utf8(z->p, z->c, 0, z->l, +3);
+            if (ret < 0)
+                return 0;
+            z->c = ret; /* hop, line 33 */
+        }
+        z->I[1] = z->c; /* setmark x, line 33 */
+        z->c = c_test;
+    }
+    if (out_grouping_U(z, g_v, 97, 248, 1) < 0)
+        return 0; /* goto */ /* grouping v, line 34 */
+    { /* gopast */           /* non v, line 34 */
+        int ret = in_grouping_U(z, g_v, 97, 248, 1);
+        if (ret < 0)
+            return 0;
+        z->c += ret;
+    }
+    z->I[0] = z->c; /* setmark p1, line 34 */
+                    /* try, line 35 */
+    if (!(z->I[0] < z->I[1]))
+        goto lab0;
+    z->I[0] = z->I[1];
+lab0:
+    return 1;
+}
+
+static int r_main_suffix(struct SN_env *z) {
+    int among_var;
+    {
+        int mlimit; /* setlimit, line 41 */
+        int m1 = z->l - z->c;
+        (void)m1;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 41 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m1;
+        z->ket = z->c; /* [, line 41 */
+        if (z->c <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((1851440 >> (z->p[z->c - 1] & 0x1f)) & 1)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        among_var = find_among_b(z, a_0, 32); /* substring, line 41 */
+        if (!(among_var)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        z->bra = z->c; /* ], line 41 */
+        z->lb = mlimit;
+    }
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = slice_del(z); /* delete, line 48 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 2:
+            if (in_grouping_b_U(z, g_s_ending, 97, 229, 0))
+                return 0;
+            {
+                int ret = slice_del(z); /* delete, line 50 */
+                if (ret < 0)
+                    return ret;
+            }
+            break;
+    }
+    return 1;
+}
+
+static int r_consonant_pair(struct SN_env *z) {
+    {
+        int m_test = z->l - z->c; /* test, line 55 */
+        {
+            int mlimit; /* setlimit, line 56 */
+            int m1 = z->l - z->c;
+            (void)m1;
+            if (z->c < z->I[0])
+                return 0;
+            z->c = z->I[0]; /* tomark, line 56 */
+            mlimit = z->lb;
+            z->lb = z->c;
+            z->c = z->l - m1;
+            z->ket = z->c; /* [, line 56 */
+            if (z->c - 1 <= z->lb || (z->p[z->c - 1] != 100 && z->p[z->c - 1] != 116)) {
+                z->lb = mlimit;
+                return 0;
+            }
+            if (!(find_among_b(z, a_1, 4))) {
+                z->lb = mlimit;
+                return 0;
+            } /* substring, line 56 */
+            z->bra = z->c; /* ], line 56 */
+            z->lb = mlimit;
+        }
+        z->c = z->l - m_test;
+    }
+    {
+        int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
+        if (ret < 0)
+            return 0;
+        z->c = ret; /* next, line 62 */
+    }
+    z->bra = z->c; /* ], line 62 */
+    {
+        int ret = slice_del(z); /* delete, line 62 */
+        if (ret < 0)
+            return ret;
+    }
+    return 1;
+}
+
+static int r_other_suffix(struct SN_env *z) {
+    int among_var;
+    {
+        int m1 = z->l - z->c;
+        (void)m1;      /* do, line 66 */
+        z->ket = z->c; /* [, line 66 */
+        if (!(eq_s_b(z, 2, s_0)))
+            goto lab0;
+        z->bra = z->c; /* ], line 66 */
+        if (!(eq_s_b(z, 2, s_1)))
+            goto lab0;
+        {
+            int ret = slice_del(z); /* delete, line 66 */
+            if (ret < 0)
+                return ret;
+        }
+    lab0:
+        z->c = z->l - m1;
+    }
+    {
+        int mlimit; /* setlimit, line 67 */
+        int m2 = z->l - z->c;
+        (void)m2;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 67 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m2;
+        z->ket = z->c; /* [, line 67 */
+        if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((1572992 >> (z->p[z->c - 1] & 0x1f)) & 1)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        among_var = find_among_b(z, a_2, 5); /* substring, line 67 */
+        if (!(among_var)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        z->bra = z->c; /* ], line 67 */
+        z->lb = mlimit;
+    }
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = slice_del(z); /* delete, line 70 */
+            if (ret < 0)
+                return ret;
+        }
+            {
+                int m3 = z->l - z->c;
+                (void)m3; /* do, line 70 */
+                {
+                    int ret = r_consonant_pair(z);
+                    if (ret == 0)
+                        goto lab1; /* call consonant_pair, line 70 */
+                    if (ret < 0)
+                        return ret;
+                }
+            lab1:
+                z->c = z->l - m3;
+            }
+            break;
+        case 2: {
+            int ret = slice_from_s(z, 4, s_2); /* <-, line 72 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    return 1;
+}
+
+static int r_undouble(struct SN_env *z) {
+    {
+        int mlimit; /* setlimit, line 76 */
+        int m1 = z->l - z->c;
+        (void)m1;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 76 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m1;
+        z->ket = z->c; /* [, line 76 */
+        if (out_grouping_b_U(z, g_v, 97, 248, 0)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        z->bra = z->c;                  /* ], line 76 */
+        z->S[0] = slice_to(z, z->S[0]); /* -> ch, line 76 */
+        if (z->S[0] == 0)
+            return -1; /* -> ch, line 76 */
+        z->lb = mlimit;
+    }
+    if (!(eq_v_b(z, z->S[0])))
+        return 0; /* name ch, line 77 */
+    {
+        int ret = slice_del(z); /* delete, line 78 */
+        if (ret < 0)
+            return ret;
+    }
+    return 1;
+}
+
+extern int danish_UTF_8_stem(struct SN_env *z) {
+    {
+        int c1 = z->c; /* do, line 84 */
+        {
+            int ret = r_mark_regions(z);
+            if (ret == 0)
+                goto lab0; /* call mark_regions, line 84 */
+            if (ret < 0)
+                return ret;
+        }
+    lab0:
+        z->c = c1;
+    }
+    z->lb = z->c;
+    z->c = z->l; /* backwards, line 85 */
+
+    {
+        int m2 = z->l - z->c;
+        (void)m2; /* do, line 86 */
+        {
+            int ret = r_main_suffix(z);
+            if (ret == 0)
+                goto lab1; /* call main_suffix, line 86 */
+            if (ret < 0)
+                return ret;
+        }
+    lab1:
+        z->c = z->l - m2;
+    }
+    {
+        int m3 = z->l - z->c;
+        (void)m3; /* do, line 87 */
+        {
+            int ret = r_consonant_pair(z);
+            if (ret == 0)
+                goto lab2; /* call consonant_pair, line 87 */
+            if (ret < 0)
+                return ret;
+        }
+    lab2:
+        z->c = z->l - m3;
+    }
+    {
+        int m4 = z->l - z->c;
+        (void)m4; /* do, line 88 */
+        {
+            int ret = r_other_suffix(z);
+            if (ret == 0)
+                goto lab3; /* call other_suffix, line 88 */
+            if (ret < 0)
+                return ret;
+        }
+    lab3:
+        z->c = z->l - m4;
+    }
+    {
+        int m5 = z->l - z->c;
+        (void)m5; /* do, line 89 */
+        {
+            int ret = r_undouble(z);
+            if (ret == 0)
+                goto lab4; /* call undouble, line 89 */
+            if (ret < 0)
+                return ret;
+        }
+    lab4:
+        z->c = z->l - m5;
+    }
+    z->c = z->lb;
+    return 1;
+}
+
+extern struct SN_env *danish_UTF_8_create_env(void) { return SN_create_env(1, 2, 0); }
+
+extern void danish_UTF_8_close_env(struct SN_env *z) { SN_close_env(z, 1); }

internal/binding/cpp/stemmer/stem_UTF_8_danish.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *danish_UTF_8_create_env(void);
+extern void danish_UTF_8_close_env(struct SN_env *z);
+
+extern int danish_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_dutch.cpp

@@ -0,0 +1,792 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#include "header.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern int dutch_UTF_8_stem(struct SN_env *z);
+#ifdef __cplusplus
+}
+#endif
+static int r_standard_suffix(struct SN_env *z);
+static int r_undouble(struct SN_env *z);
+static int r_R2(struct SN_env *z);
+static int r_R1(struct SN_env *z);
+static int r_mark_regions(struct SN_env *z);
+static int r_en_ending(struct SN_env *z);
+static int r_e_ending(struct SN_env *z);
+static int r_postlude(struct SN_env *z);
+static int r_prelude(struct SN_env *z);
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *dutch_UTF_8_create_env(void);
+extern void dutch_UTF_8_close_env(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif
+static const symbol s_0_1[2] = {0xC3, 0xA1};
+static const symbol s_0_2[2] = {0xC3, 0xA4};
+static const symbol s_0_3[2] = {0xC3, 0xA9};
+static const symbol s_0_4[2] = {0xC3, 0xAB};
+static const symbol s_0_5[2] = {0xC3, 0xAD};
+static const symbol s_0_6[2] = {0xC3, 0xAF};
+static const symbol s_0_7[2] = {0xC3, 0xB3};
+static const symbol s_0_8[2] = {0xC3, 0xB6};
+static const symbol s_0_9[2] = {0xC3, 0xBA};
+static const symbol s_0_10[2] = {0xC3, 0xBC};
+
+static const struct among a_0[11] = {
+    /*  0 */ {0, 0, -1, 6, 0},
+    /*  1 */ {2, s_0_1, 0, 1, 0},
+    /*  2 */ {2, s_0_2, 0, 1, 0},
+    /*  3 */ {2, s_0_3, 0, 2, 0},
+    /*  4 */ {2, s_0_4, 0, 2, 0},
+    /*  5 */ {2, s_0_5, 0, 3, 0},
+    /*  6 */ {2, s_0_6, 0, 3, 0},
+    /*  7 */ {2, s_0_7, 0, 4, 0},
+    /*  8 */ {2, s_0_8, 0, 4, 0},
+    /*  9 */ {2, s_0_9, 0, 5, 0},
+    /* 10 */ {2, s_0_10, 0, 5, 0}};
+
+static const symbol s_1_1[1] = {'I'};
+static const symbol s_1_2[1] = {'Y'};
+
+static const struct among a_1[3] = {
+    /*  0 */ {0, 0, -1, 3, 0},
+    /*  1 */ {1, s_1_1, 0, 2, 0},
+    /*  2 */ {1, s_1_2, 0, 1, 0}};
+
+static const symbol s_2_0[2] = {'d', 'd'};
+static const symbol s_2_1[2] = {'k', 'k'};
+static const symbol s_2_2[2] = {'t', 't'};
+
+static const struct among a_2[3] = {
+    /*  0 */ {2, s_2_0, -1, -1, 0},
+    /*  1 */ {2, s_2_1, -1, -1, 0},
+    /*  2 */ {2, s_2_2, -1, -1, 0}};
+
+static const symbol s_3_0[3] = {'e', 'n', 'e'};
+static const symbol s_3_1[2] = {'s', 'e'};
+static const symbol s_3_2[2] = {'e', 'n'};
+static const symbol s_3_3[5] = {'h', 'e', 'd', 'e', 'n'};
+static const symbol s_3_4[1] = {'s'};
+
+static const struct among a_3[5] = {
+    /*  0 */ {3, s_3_0, -1, 2, 0},
+    /*  1 */ {2, s_3_1, -1, 3, 0},
+    /*  2 */ {2, s_3_2, -1, 2, 0},
+    /*  3 */ {5, s_3_3, 2, 1, 0},
+    /*  4 */ {1, s_3_4, -1, 3, 0}};
+
+static const symbol s_4_0[3] = {'e', 'n', 'd'};
+static const symbol s_4_1[2] = {'i', 'g'};
+static const symbol s_4_2[3] = {'i', 'n', 'g'};
+static const symbol s_4_3[4] = {'l', 'i', 'j', 'k'};
+static const symbol s_4_4[4] = {'b', 'a', 'a', 'r'};
+static const symbol s_4_5[3] = {'b', 'a', 'r'};
+
+static const struct among a_4[6] = {
+    /*  0 */ {3, s_4_0, -1, 1, 0},
+    /*  1 */ {2, s_4_1, -1, 2, 0},
+    /*  2 */ {3, s_4_2, -1, 1, 0},
+    /*  3 */ {4, s_4_3, -1, 3, 0},
+    /*  4 */ {4, s_4_4, -1, 4, 0},
+    /*  5 */ {3, s_4_5, -1, 5, 0}};
+
+static const symbol s_5_0[2] = {'a', 'a'};
+static const symbol s_5_1[2] = {'e', 'e'};
+static const symbol s_5_2[2] = {'o', 'o'};
+static const symbol s_5_3[2] = {'u', 'u'};
+
+static const struct among a_5[4] = {
+    /*  0 */ {2, s_5_0, -1, -1, 0},
+    /*  1 */ {2, s_5_1, -1, -1, 0},
+    /*  2 */ {2, s_5_2, -1, -1, 0},
+    /*  3 */ {2, s_5_3, -1, -1, 0}};
+
+static const unsigned char g_v[] = {17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128};
+
+static const unsigned char g_v_I[] = {1, 0, 0, 17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128};
+
+static const unsigned char g_v_j[] = {17, 67, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128};
+
+static const symbol s_0[] = {'a'};
+static const symbol s_1[] = {'e'};
+static const symbol s_2[] = {'i'};
+static const symbol s_3[] = {'o'};
+static const symbol s_4[] = {'u'};
+static const symbol s_5[] = {'y'};
+static const symbol s_6[] = {'Y'};
+static const symbol s_7[] = {'i'};
+static const symbol s_8[] = {'I'};
+static const symbol s_9[] = {'y'};
+static const symbol s_10[] = {'Y'};
+static const symbol s_11[] = {'y'};
+static const symbol s_12[] = {'i'};
+static const symbol s_13[] = {'e'};
+static const symbol s_14[] = {'g', 'e', 'm'};
+static const symbol s_15[] = {'h', 'e', 'i', 'd'};
+static const symbol s_16[] = {'h', 'e', 'i', 'd'};
+static const symbol s_17[] = {'c'};
+static const symbol s_18[] = {'e', 'n'};
+static const symbol s_19[] = {'i', 'g'};
+static const symbol s_20[] = {'e'};
+static const symbol s_21[] = {'e'};
+
+static int r_prelude(struct SN_env *z) {
+    int among_var;
+    {
+        int c_test = z->c; /* test, line 42 */
+        while (1) {        /* repeat, line 42 */
+            int c1 = z->c;
+            z->bra = z->c; /* [, line 43 */
+            if (z->c + 1 >= z->l || z->p[z->c + 1] >> 5 != 5 || !((340306450 >> (z->p[z->c + 1] & 0x1f)) & 1))
+                among_var = 6;
+            else
+                among_var = find_among(z, a_0, 11); /* substring, line 43 */
+            if (!(among_var))
+                goto lab0;
+            z->ket = z->c; /* ], line 43 */
+            switch (among_var) {
+                case 0:
+                    goto lab0;
+                case 1: {
+                    int ret = slice_from_s(z, 1, s_0); /* <-, line 45 */
+                    if (ret < 0)
+                        return ret;
+                } break;
+                case 2: {
+                    int ret = slice_from_s(z, 1, s_1); /* <-, line 47 */
+                    if (ret < 0)
+                        return ret;
+                } break;
+                case 3: {
+                    int ret = slice_from_s(z, 1, s_2); /* <-, line 49 */
+                    if (ret < 0)
+                        return ret;
+                } break;
+                case 4: {
+                    int ret = slice_from_s(z, 1, s_3); /* <-, line 51 */
+                    if (ret < 0)
+                        return ret;
+                } break;
+                case 5: {
+                    int ret = slice_from_s(z, 1, s_4); /* <-, line 53 */
+                    if (ret < 0)
+                        return ret;
+                } break;
+                case 6: {
+                    int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
+                    if (ret < 0)
+                        goto lab0;
+                    z->c = ret; /* next, line 54 */
+                } break;
+            }
+            continue;
+        lab0:
+            z->c = c1;
+            break;
+        }
+        z->c = c_test;
+    }
+    {
+        int c_keep = z->c; /* try, line 57 */
+        z->bra = z->c;     /* [, line 57 */
+        if (!(eq_s(z, 1, s_5))) {
+            z->c = c_keep;
+            goto lab1;
+        }
+        z->ket = z->c; /* ], line 57 */
+        {
+            int ret = slice_from_s(z, 1, s_6); /* <-, line 57 */
+            if (ret < 0)
+                return ret;
+        }
+    lab1:;
+    }
+    while (1) { /* repeat, line 58 */
+        int c2 = z->c;
+        while (1) { /* goto, line 58 */
+            int c3 = z->c;
+            if (in_grouping_U(z, g_v, 97, 232, 0))
+                goto lab3;
+            z->bra = z->c; /* [, line 59 */
+            {
+                int c4 = z->c; /* or, line 59 */
+                if (!(eq_s(z, 1, s_7)))
+                    goto lab5;
+                z->ket = z->c; /* ], line 59 */
+                if (in_grouping_U(z, g_v, 97, 232, 0))
+                    goto lab5;
+                {
+                    int ret = slice_from_s(z, 1, s_8); /* <-, line 59 */
+                    if (ret < 0)
+                        return ret;
+                }
+                goto lab4;
+            lab5:
+                z->c = c4;
+                if (!(eq_s(z, 1, s_9)))
+                    goto lab3;
+                z->ket = z->c; /* ], line 60 */
+                {
+                    int ret = slice_from_s(z, 1, s_10); /* <-, line 60 */
+                    if (ret < 0)
+                        return ret;
+                }
+            }
+        lab4:
+            z->c = c3;
+            break;
+        lab3:
+            z->c = c3;
+            {
+                int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
+                if (ret < 0)
+                    goto lab2;
+                z->c = ret; /* goto, line 58 */
+            }
+        }
+        continue;
+    lab2:
+        z->c = c2;
+        break;
+    }
+    return 1;
+}
+
+static int r_mark_regions(struct SN_env *z) {
+    z->I[0] = z->l;
+    z->I[1] = z->l;
+    { /* gopast */ /* grouping v, line 69 */
+        int ret = out_grouping_U(z, g_v, 97, 232, 1);
+        if (ret < 0)
+            return 0;
+        z->c += ret;
+    }
+    { /* gopast */ /* non v, line 69 */
+        int ret = in_grouping_U(z, g_v, 97, 232, 1);
+        if (ret < 0)
+            return 0;
+        z->c += ret;
+    }
+    z->I[0] = z->c; /* setmark p1, line 69 */
+                    /* try, line 70 */
+    if (!(z->I[0] < 3))
+        goto lab0;
+    z->I[0] = 3;
+lab0: { /* gopast */ /* grouping v, line 71 */
+    int ret = out_grouping_U(z, g_v, 97, 232, 1);
+    if (ret < 0)
+        return 0;
+    z->c += ret;
+}
+    { /* gopast */ /* non v, line 71 */
+        int ret = in_grouping_U(z, g_v, 97, 232, 1);
+        if (ret < 0)
+            return 0;
+        z->c += ret;
+    }
+    z->I[1] = z->c; /* setmark p2, line 71 */
+    return 1;
+}
+
+static int r_postlude(struct SN_env *z) {
+    int among_var;
+    while (1) { /* repeat, line 75 */
+        int c1 = z->c;
+        z->bra = z->c; /* [, line 77 */
+        if (z->c >= z->l || (z->p[z->c + 0] != 73 && z->p[z->c + 0] != 89))
+            among_var = 3;
+        else
+            among_var = find_among(z, a_1, 3); /* substring, line 77 */
+        if (!(among_var))
+            goto lab0;
+        z->ket = z->c; /* ], line 77 */
+        switch (among_var) {
+            case 0:
+                goto lab0;
+            case 1: {
+                int ret = slice_from_s(z, 1, s_11); /* <-, line 78 */
+                if (ret < 0)
+                    return ret;
+            } break;
+            case 2: {
+                int ret = slice_from_s(z, 1, s_12); /* <-, line 79 */
+                if (ret < 0)
+                    return ret;
+            } break;
+            case 3: {
+                int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
+                if (ret < 0)
+                    goto lab0;
+                z->c = ret; /* next, line 80 */
+            } break;
+        }
+        continue;
+    lab0:
+        z->c = c1;
+        break;
+    }
+    return 1;
+}
+
+static int r_R1(struct SN_env *z) {
+    if (!(z->I[0] <= z->c))
+        return 0;
+    return 1;
+}
+
+static int r_R2(struct SN_env *z) {
+    if (!(z->I[1] <= z->c))
+        return 0;
+    return 1;
+}
+
+static int r_undouble(struct SN_env *z) {
+    {
+        int m_test = z->l - z->c; /* test, line 91 */
+        if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((1050640 >> (z->p[z->c - 1] & 0x1f)) & 1))
+            return 0;
+        if (!(find_among_b(z, a_2, 3)))
+            return 0; /* among, line 91 */
+        z->c = z->l - m_test;
+    }
+    z->ket = z->c; /* [, line 91 */
+    {
+        int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
+        if (ret < 0)
+            return 0;
+        z->c = ret; /* next, line 91 */
+    }
+    z->bra = z->c; /* ], line 91 */
+    {
+        int ret = slice_del(z); /* delete, line 91 */
+        if (ret < 0)
+            return ret;
+    }
+    return 1;
+}
+
+static int r_e_ending(struct SN_env *z) {
+    z->B[0] = 0;   /* unset e_found, line 95 */
+    z->ket = z->c; /* [, line 96 */
+    if (!(eq_s_b(z, 1, s_13)))
+        return 0;
+    z->bra = z->c; /* ], line 96 */
+    {
+        int ret = r_R1(z);
+        if (ret == 0)
+            return 0; /* call R1, line 96 */
+        if (ret < 0)
+            return ret;
+    }
+    {
+        int m_test = z->l - z->c; /* test, line 96 */
+        if (out_grouping_b_U(z, g_v, 97, 232, 0))
+            return 0;
+        z->c = z->l - m_test;
+    }
+    {
+        int ret = slice_del(z); /* delete, line 96 */
+        if (ret < 0)
+            return ret;
+    }
+    z->B[0] = 1; /* set e_found, line 97 */
+    {
+        int ret = r_undouble(z);
+        if (ret == 0)
+            return 0; /* call undouble, line 98 */
+        if (ret < 0)
+            return ret;
+    }
+    return 1;
+}
+
+static int r_en_ending(struct SN_env *z) {
+    {
+        int ret = r_R1(z);
+        if (ret == 0)
+            return 0; /* call R1, line 102 */
+        if (ret < 0)
+            return ret;
+    }
+    {
+        int m1 = z->l - z->c;
+        (void)m1; /* and, line 102 */
+        if (out_grouping_b_U(z, g_v, 97, 232, 0))
+            return 0;
+        z->c = z->l - m1;
+        {
+            int m2 = z->l - z->c;
+            (void)m2; /* not, line 102 */
+            if (!(eq_s_b(z, 3, s_14)))
+                goto lab0;
+            return 0;
+        lab0:
+            z->c = z->l - m2;
+        }
+    }
+    {
+        int ret = slice_del(z); /* delete, line 102 */
+        if (ret < 0)
+            return ret;
+    }
+    {
+        int ret = r_undouble(z);
+        if (ret == 0)
+            return 0; /* call undouble, line 103 */
+        if (ret < 0)
+            return ret;
+    }
+    return 1;
+}
+
+static int r_standard_suffix(struct SN_env *z) {
+    int among_var;
+    {
+        int m1 = z->l - z->c;
+        (void)m1;      /* do, line 107 */
+        z->ket = z->c; /* [, line 108 */
+        if (z->c <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((540704 >> (z->p[z->c - 1] & 0x1f)) & 1))
+            goto lab0;
+        among_var = find_among_b(z, a_3, 5); /* substring, line 108 */
+        if (!(among_var))
+            goto lab0;
+        z->bra = z->c; /* ], line 108 */
+        switch (among_var) {
+            case 0:
+                goto lab0;
+            case 1: {
+                int ret = r_R1(z);
+                if (ret == 0)
+                    goto lab0; /* call R1, line 110 */
+                if (ret < 0)
+                    return ret;
+            }
+                {
+                    int ret = slice_from_s(z, 4, s_15); /* <-, line 110 */
+                    if (ret < 0)
+                        return ret;
+                }
+                break;
+            case 2: {
+                int ret = r_en_ending(z);
+                if (ret == 0)
+                    goto lab0; /* call en_ending, line 113 */
+                if (ret < 0)
+                    return ret;
+            } break;
+            case 3: {
+                int ret = r_R1(z);
+                if (ret == 0)
+                    goto lab0; /* call R1, line 116 */
+                if (ret < 0)
+                    return ret;
+            }
+                if (out_grouping_b_U(z, g_v_j, 97, 232, 0))
+                    goto lab0;
+                {
+                    int ret = slice_del(z); /* delete, line 116 */
+                    if (ret < 0)
+                        return ret;
+                }
+                break;
+        }
+    lab0:
+        z->c = z->l - m1;
+    }
+    {
+        int m2 = z->l - z->c;
+        (void)m2; /* do, line 120 */
+        {
+            int ret = r_e_ending(z);
+            if (ret == 0)
+                goto lab1; /* call e_ending, line 120 */
+            if (ret < 0)
+                return ret;
+        }
+    lab1:
+        z->c = z->l - m2;
+    }
+    {
+        int m3 = z->l - z->c;
+        (void)m3;      /* do, line 122 */
+        z->ket = z->c; /* [, line 122 */
+        if (!(eq_s_b(z, 4, s_16)))
+            goto lab2;
+        z->bra = z->c; /* ], line 122 */
+        {
+            int ret = r_R2(z);
+            if (ret == 0)
+                goto lab2; /* call R2, line 122 */
+            if (ret < 0)
+                return ret;
+        }
+        {
+            int m4 = z->l - z->c;
+            (void)m4; /* not, line 122 */
+            if (!(eq_s_b(z, 1, s_17)))
+                goto lab3;
+            goto lab2;
+        lab3:
+            z->c = z->l - m4;
+        }
+        {
+            int ret = slice_del(z); /* delete, line 122 */
+            if (ret < 0)
+                return ret;
+        }
+        z->ket = z->c; /* [, line 123 */
+        if (!(eq_s_b(z, 2, s_18)))
+            goto lab2;
+        z->bra = z->c; /* ], line 123 */
+        {
+            int ret = r_en_ending(z);
+            if (ret == 0)
+                goto lab2; /* call en_ending, line 123 */
+            if (ret < 0)
+                return ret;
+        }
+    lab2:
+        z->c = z->l - m3;
+    }
+    {
+        int m5 = z->l - z->c;
+        (void)m5;      /* do, line 126 */
+        z->ket = z->c; /* [, line 127 */
+        if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((264336 >> (z->p[z->c - 1] & 0x1f)) & 1))
+            goto lab4;
+        among_var = find_among_b(z, a_4, 6); /* substring, line 127 */
+        if (!(among_var))
+            goto lab4;
+        z->bra = z->c; /* ], line 127 */
+        switch (among_var) {
+            case 0:
+                goto lab4;
+            case 1: {
+                int ret = r_R2(z);
+                if (ret == 0)
+                    goto lab4; /* call R2, line 129 */
+                if (ret < 0)
+                    return ret;
+            }
+                {
+                    int ret = slice_del(z); /* delete, line 129 */
+                    if (ret < 0)
+                        return ret;
+                }
+                {
+                    int m6 = z->l - z->c;
+                    (void)m6;      /* or, line 130 */
+                    z->ket = z->c; /* [, line 130 */
+                    if (!(eq_s_b(z, 2, s_19)))
+                        goto lab6;
+                    z->bra = z->c; /* ], line 130 */
+                    {
+                        int ret = r_R2(z);
+                        if (ret == 0)
+                            goto lab6; /* call R2, line 130 */
+                        if (ret < 0)
+                            return ret;
+                    }
+                    {
+                        int m7 = z->l - z->c;
+                        (void)m7; /* not, line 130 */
+                        if (!(eq_s_b(z, 1, s_20)))
+                            goto lab7;
+                        goto lab6;
+                    lab7:
+                        z->c = z->l - m7;
+                    }
+                    {
+                        int ret = slice_del(z); /* delete, line 130 */
+                        if (ret < 0)
+                            return ret;
+                    }
+                    goto lab5;
+                lab6:
+                    z->c = z->l - m6;
+                    {
+                        int ret = r_undouble(z);
+                        if (ret == 0)
+                            goto lab4; /* call undouble, line 130 */
+                        if (ret < 0)
+                            return ret;
+                    }
+                }
+            lab5:
+                break;
+            case 2: {
+                int ret = r_R2(z);
+                if (ret == 0)
+                    goto lab4; /* call R2, line 133 */
+                if (ret < 0)
+                    return ret;
+            }
+                {
+                    int m8 = z->l - z->c;
+                    (void)m8; /* not, line 133 */
+                    if (!(eq_s_b(z, 1, s_21)))
+                        goto lab8;
+                    goto lab4;
+                lab8:
+                    z->c = z->l - m8;
+                }
+                {
+                    int ret = slice_del(z); /* delete, line 133 */
+                    if (ret < 0)
+                        return ret;
+                }
+                break;
+            case 3: {
+                int ret = r_R2(z);
+                if (ret == 0)
+                    goto lab4; /* call R2, line 136 */
+                if (ret < 0)
+                    return ret;
+            }
+                {
+                    int ret = slice_del(z); /* delete, line 136 */
+                    if (ret < 0)
+                        return ret;
+                }
+                {
+                    int ret = r_e_ending(z);
+                    if (ret == 0)
+                        goto lab4; /* call e_ending, line 136 */
+                    if (ret < 0)
+                        return ret;
+                }
+                break;
+            case 4: {
+                int ret = r_R2(z);
+                if (ret == 0)
+                    goto lab4; /* call R2, line 139 */
+                if (ret < 0)
+                    return ret;
+            }
+                {
+                    int ret = slice_del(z); /* delete, line 139 */
+                    if (ret < 0)
+                        return ret;
+                }
+                break;
+            case 5: {
+                int ret = r_R2(z);
+                if (ret == 0)
+                    goto lab4; /* call R2, line 142 */
+                if (ret < 0)
+                    return ret;
+            }
+                if (!(z->B[0]))
+                    goto lab4; /* Boolean test e_found, line 142 */
+                {
+                    int ret = slice_del(z); /* delete, line 142 */
+                    if (ret < 0)
+                        return ret;
+                }
+                break;
+        }
+    lab4:
+        z->c = z->l - m5;
+    }
+    {
+        int m9 = z->l - z->c;
+        (void)m9; /* do, line 146 */
+        if (out_grouping_b_U(z, g_v_I, 73, 232, 0))
+            goto lab9;
+        {
+            int m_test = z->l - z->c; /* test, line 148 */
+            if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((2129954 >> (z->p[z->c - 1] & 0x1f)) & 1))
+                goto lab9;
+            if (!(find_among_b(z, a_5, 4)))
+                goto lab9; /* among, line 149 */
+            if (out_grouping_b_U(z, g_v, 97, 232, 0))
+                goto lab9;
+            z->c = z->l - m_test;
+        }
+        z->ket = z->c; /* [, line 152 */
+        {
+            int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
+            if (ret < 0)
+                goto lab9;
+            z->c = ret; /* next, line 152 */
+        }
+        z->bra = z->c; /* ], line 152 */
+        {
+            int ret = slice_del(z); /* delete, line 152 */
+            if (ret < 0)
+                return ret;
+        }
+    lab9:
+        z->c = z->l - m9;
+    }
+    return 1;
+}
+
+extern int dutch_UTF_8_stem(struct SN_env *z) {
+    {
+        int c1 = z->c; /* do, line 159 */
+        {
+            int ret = r_prelude(z);
+            if (ret == 0)
+                goto lab0; /* call prelude, line 159 */
+            if (ret < 0)
+                return ret;
+        }
+    lab0:
+        z->c = c1;
+    }
+    {
+        int c2 = z->c; /* do, line 160 */
+        {
+            int ret = r_mark_regions(z);
+            if (ret == 0)
+                goto lab1; /* call mark_regions, line 160 */
+            if (ret < 0)
+                return ret;
+        }
+    lab1:
+        z->c = c2;
+    }
+    z->lb = z->c;
+    z->c = z->l; /* backwards, line 161 */
+
+    {
+        int m3 = z->l - z->c;
+        (void)m3; /* do, line 162 */
+        {
+            int ret = r_standard_suffix(z);
+            if (ret == 0)
+                goto lab2; /* call standard_suffix, line 162 */
+            if (ret < 0)
+                return ret;
+        }
+    lab2:
+        z->c = z->l - m3;
+    }
+    z->c = z->lb;
+    {
+        int c4 = z->c; /* do, line 163 */
+        {
+            int ret = r_postlude(z);
+            if (ret == 0)
+                goto lab3; /* call postlude, line 163 */
+            if (ret < 0)
+                return ret;
+        }
+    lab3:
+        z->c = c4;
+    }
+    return 1;
+}
+
+extern struct SN_env *dutch_UTF_8_create_env(void) { return SN_create_env(0, 2, 1); }
+
+extern void dutch_UTF_8_close_env(struct SN_env *z) { SN_close_env(z, 0); }

internal/binding/cpp/stemmer/stem_UTF_8_dutch.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *dutch_UTF_8_create_env(void);
+extern void dutch_UTF_8_close_env(struct SN_env *z);
+
+extern int dutch_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_english.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *english_UTF_8_create_env(void);
+extern void english_UTF_8_close_env(struct SN_env *z);
+
+extern int english_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_finnish.cpp

@@ -0,0 +1,958 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#include "header.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern int finnish_UTF_8_stem(struct SN_env *z);
+#ifdef __cplusplus
+}
+#endif
+static int r_tidy(struct SN_env *z);
+static int r_other_endings(struct SN_env *z);
+static int r_t_plural(struct SN_env *z);
+static int r_i_plural(struct SN_env *z);
+static int r_case_ending(struct SN_env *z);
+static int r_VI(struct SN_env *z);
+static int r_LONG(struct SN_env *z);
+static int r_possessive(struct SN_env *z);
+static int r_particle_etc(struct SN_env *z);
+static int r_R2(struct SN_env *z);
+static int r_mark_regions(struct SN_env *z);
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *finnish_UTF_8_create_env(void);
+extern void finnish_UTF_8_close_env(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif
+static const symbol s_0_0[2] = {'p', 'a'};
+static const symbol s_0_1[3] = {'s', 't', 'i'};
+static const symbol s_0_2[4] = {'k', 'a', 'a', 'n'};
+static const symbol s_0_3[3] = {'h', 'a', 'n'};
+static const symbol s_0_4[3] = {'k', 'i', 'n'};
+static const symbol s_0_5[4] = {'h', 0xC3, 0xA4, 'n'};
+static const symbol s_0_6[6] = {'k', 0xC3, 0xA4, 0xC3, 0xA4, 'n'};
+static const symbol s_0_7[2] = {'k', 'o'};
+static const symbol s_0_8[3] = {'p', 0xC3, 0xA4};
+static const symbol s_0_9[3] = {'k', 0xC3, 0xB6};
+
+static const struct among a_0[10] = {
+    /*  0 */ {2, s_0_0, -1, 1, 0},
+    /*  1 */ {3, s_0_1, -1, 2, 0},
+    /*  2 */ {4, s_0_2, -1, 1, 0},
+    /*  3 */ {3, s_0_3, -1, 1, 0},
+    /*  4 */ {3, s_0_4, -1, 1, 0},
+    /*  5 */ {4, s_0_5, -1, 1, 0},
+    /*  6 */ {6, s_0_6, -1, 1, 0},
+    /*  7 */ {2, s_0_7, -1, 1, 0},
+    /*  8 */ {3, s_0_8, -1, 1, 0},
+    /*  9 */ {3, s_0_9, -1, 1, 0}};
+
+static const symbol s_1_0[3] = {'l', 'l', 'a'};
+static const symbol s_1_1[2] = {'n', 'a'};
+static const symbol s_1_2[3] = {'s', 's', 'a'};
+static const symbol s_1_3[2] = {'t', 'a'};
+static const symbol s_1_4[3] = {'l', 't', 'a'};
+static const symbol s_1_5[3] = {'s', 't', 'a'};
+
+static const struct among a_1[6] = {
+    /*  0 */ {3, s_1_0, -1, -1, 0},
+    /*  1 */ {2, s_1_1, -1, -1, 0},
+    /*  2 */ {3, s_1_2, -1, -1, 0},
+    /*  3 */ {2, s_1_3, -1, -1, 0},
+    /*  4 */ {3, s_1_4, 3, -1, 0},
+    /*  5 */ {3, s_1_5, 3, -1, 0}};
+
+static const symbol s_2_0[4] = {'l', 'l', 0xC3, 0xA4};
+static const symbol s_2_1[3] = {'n', 0xC3, 0xA4};
+static const symbol s_2_2[4] = {'s', 's', 0xC3, 0xA4};
+static const symbol s_2_3[3] = {'t', 0xC3, 0xA4};
+static const symbol s_2_4[4] = {'l', 't', 0xC3, 0xA4};
+static const symbol s_2_5[4] = {'s', 't', 0xC3, 0xA4};
+
+static const struct among a_2[6] = {
+    /*  0 */ {4, s_2_0, -1, -1, 0},
+    /*  1 */ {3, s_2_1, -1, -1, 0},
+    /*  2 */ {4, s_2_2, -1, -1, 0},
+    /*  3 */ {3, s_2_3, -1, -1, 0},
+    /*  4 */ {4, s_2_4, 3, -1, 0},
+    /*  5 */ {4, s_2_5, 3, -1, 0}};
+
+static const symbol s_3_0[3] = {'l', 'l', 'e'};
+static const symbol s_3_1[3] = {'i', 'n', 'e'};
+
+static const struct among a_3[2] = {
+    /*  0 */ {3, s_3_0, -1, -1, 0},
+    /*  1 */ {3, s_3_1, -1, -1, 0}};
+
+static const symbol s_4_0[3] = {'n', 's', 'a'};
+static const symbol s_4_1[3] = {'m', 'm', 'e'};
+static const symbol s_4_2[3] = {'n', 'n', 'e'};
+static const symbol s_4_3[2] = {'n', 'i'};
+static const symbol s_4_4[2] = {'s', 'i'};
+static const symbol s_4_5[2] = {'a', 'n'};
+static const symbol s_4_6[2] = {'e', 'n'};
+static const symbol s_4_7[3] = {0xC3, 0xA4, 'n'};
+static const symbol s_4_8[4] = {'n', 's', 0xC3, 0xA4};
+
+static const struct among a_4[9] = {
+    /*  0 */ {3, s_4_0, -1, 3, 0},
+    /*  1 */ {3, s_4_1, -1, 3, 0},
+    /*  2 */ {3, s_4_2, -1, 3, 0},
+    /*  3 */ {2, s_4_3, -1, 2, 0},
+    /*  4 */ {2, s_4_4, -1, 1, 0},
+    /*  5 */ {2, s_4_5, -1, 4, 0},
+    /*  6 */ {2, s_4_6, -1, 6, 0},
+    /*  7 */ {3, s_4_7, -1, 5, 0},
+    /*  8 */ {4, s_4_8, -1, 3, 0}};
+
+static const symbol s_5_0[2] = {'a', 'a'};
+static const symbol s_5_1[2] = {'e', 'e'};
+static const symbol s_5_2[2] = {'i', 'i'};
+static const symbol s_5_3[2] = {'o', 'o'};
+static const symbol s_5_4[2] = {'u', 'u'};
+static const symbol s_5_5[4] = {0xC3, 0xA4, 0xC3, 0xA4};
+static const symbol s_5_6[4] = {0xC3, 0xB6, 0xC3, 0xB6};
+
+static const struct among a_5[7] = {
+    /*  0 */ {2, s_5_0, -1, -1, 0},
+    /*  1 */ {2, s_5_1, -1, -1, 0},
+    /*  2 */ {2, s_5_2, -1, -1, 0},
+    /*  3 */ {2, s_5_3, -1, -1, 0},
+    /*  4 */ {2, s_5_4, -1, -1, 0},
+    /*  5 */ {4, s_5_5, -1, -1, 0},
+    /*  6 */ {4, s_5_6, -1, -1, 0}};
+
+static const symbol s_6_0[1] = {'a'};
+static const symbol s_6_1[3] = {'l', 'l', 'a'};
+static const symbol s_6_2[2] = {'n', 'a'};
+static const symbol s_6_3[3] = {'s', 's', 'a'};
+static const symbol s_6_4[2] = {'t', 'a'};
+static const symbol s_6_5[3] = {'l', 't', 'a'};
+static const symbol s_6_6[3] = {'s', 't', 'a'};
+static const symbol s_6_7[3] = {'t', 't', 'a'};
+static const symbol s_6_8[3] = {'l', 'l', 'e'};
+static const symbol s_6_9[3] = {'i', 'n', 'e'};
+static const symbol s_6_10[3] = {'k', 's', 'i'};
+static const symbol s_6_11[1] = {'n'};
+static const symbol s_6_12[3] = {'h', 'a', 'n'};
+static const symbol s_6_13[3] = {'d', 'e', 'n'};
+static const symbol s_6_14[4] = {'s', 'e', 'e', 'n'};
+static const symbol s_6_15[3] = {'h', 'e', 'n'};
+static const symbol s_6_16[4] = {'t', 't', 'e', 'n'};
+static const symbol s_6_17[3] = {'h', 'i', 'n'};
+static const symbol s_6_18[4] = {'s', 'i', 'i', 'n'};
+static const symbol s_6_19[3] = {'h', 'o', 'n'};
+static const symbol s_6_20[4] = {'h', 0xC3, 0xA4, 'n'};
+static const symbol s_6_21[4] = {'h', 0xC3, 0xB6, 'n'};
+static const symbol s_6_22[2] = {0xC3, 0xA4};
+static const symbol s_6_23[4] = {'l', 'l', 0xC3, 0xA4};
+static const symbol s_6_24[3] = {'n', 0xC3, 0xA4};
+static const symbol s_6_25[4] = {'s', 's', 0xC3, 0xA4};
+static const symbol s_6_26[3] = {'t', 0xC3, 0xA4};
+static const symbol s_6_27[4] = {'l', 't', 0xC3, 0xA4};
+static const symbol s_6_28[4] = {'s', 't', 0xC3, 0xA4};
+static const symbol s_6_29[4] = {'t', 't', 0xC3, 0xA4};
+
+static const struct among a_6[30] = {
+    /*  0 */ {1, s_6_0, -1, 8, 0},
+    /*  1 */ {3, s_6_1, 0, -1, 0},
+    /*  2 */ {2, s_6_2, 0, -1, 0},
+    /*  3 */ {3, s_6_3, 0, -1, 0},
+    /*  4 */ {2, s_6_4, 0, -1, 0},
+    /*  5 */ {3, s_6_5, 4, -1, 0},
+    /*  6 */ {3, s_6_6, 4, -1, 0},
+    /*  7 */ {3, s_6_7, 4, 9, 0},
+    /*  8 */ {3, s_6_8, -1, -1, 0},
+    /*  9 */ {3, s_6_9, -1, -1, 0},
+    /* 10 */ {3, s_6_10, -1, -1, 0},
+    /* 11 */ {1, s_6_11, -1, 7, 0},
+    /* 12 */ {3, s_6_12, 11, 1, 0},
+    /* 13 */ {3, s_6_13, 11, -1, r_VI},
+    /* 14 */ {4, s_6_14, 11, -1, r_LONG},
+    /* 15 */ {3, s_6_15, 11, 2, 0},
+    /* 16 */ {4, s_6_16, 11, -1, r_VI},
+    /* 17 */ {3, s_6_17, 11, 3, 0},
+    /* 18 */ {4, s_6_18, 11, -1, r_VI},
+    /* 19 */ {3, s_6_19, 11, 4, 0},
+    /* 20 */ {4, s_6_20, 11, 5, 0},
+    /* 21 */ {4, s_6_21, 11, 6, 0},
+    /* 22 */ {2, s_6_22, -1, 8, 0},
+    /* 23 */ {4, s_6_23, 22, -1, 0},
+    /* 24 */ {3, s_6_24, 22, -1, 0},
+    /* 25 */ {4, s_6_25, 22, -1, 0},
+    /* 26 */ {3, s_6_26, 22, -1, 0},
+    /* 27 */ {4, s_6_27, 26, -1, 0},
+    /* 28 */ {4, s_6_28, 26, -1, 0},
+    /* 29 */ {4, s_6_29, 26, 9, 0}};
+
+static const symbol s_7_0[3] = {'e', 'j', 'a'};
+static const symbol s_7_1[3] = {'m', 'm', 'a'};
+static const symbol s_7_2[4] = {'i', 'm', 'm', 'a'};
+static const symbol s_7_3[3] = {'m', 'p', 'a'};
+static const symbol s_7_4[4] = {'i', 'm', 'p', 'a'};
+static const symbol s_7_5[3] = {'m', 'm', 'i'};
+static const symbol s_7_6[4] = {'i', 'm', 'm', 'i'};
+static const symbol s_7_7[3] = {'m', 'p', 'i'};
+static const symbol s_7_8[4] = {'i', 'm', 'p', 'i'};
+static const symbol s_7_9[4] = {'e', 'j', 0xC3, 0xA4};
+static const symbol s_7_10[4] = {'m', 'm', 0xC3, 0xA4};
+static const symbol s_7_11[5] = {'i', 'm', 'm', 0xC3, 0xA4};
+static const symbol s_7_12[4] = {'m', 'p', 0xC3, 0xA4};
+static const symbol s_7_13[5] = {'i', 'm', 'p', 0xC3, 0xA4};
+
+static const struct among a_7[14] = {
+    /*  0 */ {3, s_7_0, -1, -1, 0},
+    /*  1 */ {3, s_7_1, -1, 1, 0},
+    /*  2 */ {4, s_7_2, 1, -1, 0},
+    /*  3 */ {3, s_7_3, -1, 1, 0},
+    /*  4 */ {4, s_7_4, 3, -1, 0},
+    /*  5 */ {3, s_7_5, -1, 1, 0},
+    /*  6 */ {4, s_7_6, 5, -1, 0},
+    /*  7 */ {3, s_7_7, -1, 1, 0},
+    /*  8 */ {4, s_7_8, 7, -1, 0},
+    /*  9 */ {4, s_7_9, -1, -1, 0},
+    /* 10 */ {4, s_7_10, -1, 1, 0},
+    /* 11 */ {5, s_7_11, 10, -1, 0},
+    /* 12 */ {4, s_7_12, -1, 1, 0},
+    /* 13 */ {5, s_7_13, 12, -1, 0}};
+
+static const symbol s_8_0[1] = {'i'};
+static const symbol s_8_1[1] = {'j'};
+
+static const struct among a_8[2] = {
+    /*  0 */ {1, s_8_0, -1, -1, 0},
+    /*  1 */ {1, s_8_1, -1, -1, 0}};
+
+static const symbol s_9_0[3] = {'m', 'm', 'a'};
+static const symbol s_9_1[4] = {'i', 'm', 'm', 'a'};
+
+static const struct among a_9[2] = {
+    /*  0 */ {3, s_9_0, -1, 1, 0},
+    /*  1 */ {4, s_9_1, 0, -1, 0}};
+
+static const unsigned char g_AEI[] = {17, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8};
+
+static const unsigned char g_V1[] = {17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32};
+
+static const unsigned char g_V2[] = {17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32};
+
+static const unsigned char g_particle_end[] = {17, 97, 24, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32};
+
+static const symbol s_0[] = {'k'};
+static const symbol s_1[] = {'k', 's', 'e'};
+static const symbol s_2[] = {'k', 's', 'i'};
+static const symbol s_3[] = {'i'};
+static const symbol s_4[] = {'a'};
+static const symbol s_5[] = {'e'};
+static const symbol s_6[] = {'i'};
+static const symbol s_7[] = {'o'};
+static const symbol s_8[] = {0xC3, 0xA4};
+static const symbol s_9[] = {0xC3, 0xB6};
+static const symbol s_10[] = {'i', 'e'};
+static const symbol s_11[] = {'e'};
+static const symbol s_12[] = {'p', 'o'};
+static const symbol s_13[] = {'t'};
+static const symbol s_14[] = {'p', 'o'};
+static const symbol s_15[] = {'j'};
+static const symbol s_16[] = {'o'};
+static const symbol s_17[] = {'u'};
+static const symbol s_18[] = {'o'};
+static const symbol s_19[] = {'j'};
+
+static int r_mark_regions(struct SN_env *z) {
+    z->I[0] = z->l;
+    z->I[1] = z->l;
+    if (out_grouping_U(z, g_V1, 97, 246, 1) < 0)
+        return 0; /* goto */ /* grouping V1, line 46 */
+    { /* gopast */           /* non V1, line 46 */
+        int ret = in_grouping_U(z, g_V1, 97, 246, 1);
+        if (ret < 0)
+            return 0;
+        z->c += ret;
+    }
+    z->I[0] = z->c; /* setmark p1, line 46 */
+    if (out_grouping_U(z, g_V1, 97, 246, 1) < 0)
+        return 0; /* goto */ /* grouping V1, line 47 */
+    { /* gopast */           /* non V1, line 47 */
+        int ret = in_grouping_U(z, g_V1, 97, 246, 1);
+        if (ret < 0)
+            return 0;
+        z->c += ret;
+    }
+    z->I[1] = z->c; /* setmark p2, line 47 */
+    return 1;
+}
+
+static int r_R2(struct SN_env *z) {
+    if (!(z->I[1] <= z->c))
+        return 0;
+    return 1;
+}
+
+static int r_particle_etc(struct SN_env *z) {
+    int among_var;
+    {
+        int mlimit; /* setlimit, line 55 */
+        int m1 = z->l - z->c;
+        (void)m1;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 55 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m1;
+        z->ket = z->c;                        /* [, line 55 */
+        among_var = find_among_b(z, a_0, 10); /* substring, line 55 */
+        if (!(among_var)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        z->bra = z->c; /* ], line 55 */
+        z->lb = mlimit;
+    }
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1:
+            if (in_grouping_b_U(z, g_particle_end, 97, 246, 0))
+                return 0;
+            break;
+        case 2: {
+            int ret = r_R2(z);
+            if (ret == 0)
+                return 0; /* call R2, line 64 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    {
+        int ret = slice_del(z); /* delete, line 66 */
+        if (ret < 0)
+            return ret;
+    }
+    return 1;
+}
+
+static int r_possessive(struct SN_env *z) {
+    int among_var;
+    {
+        int mlimit; /* setlimit, line 69 */
+        int m1 = z->l - z->c;
+        (void)m1;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 69 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m1;
+        z->ket = z->c;                       /* [, line 69 */
+        among_var = find_among_b(z, a_4, 9); /* substring, line 69 */
+        if (!(among_var)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        z->bra = z->c; /* ], line 69 */
+        z->lb = mlimit;
+    }
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int m2 = z->l - z->c;
+            (void)m2; /* not, line 72 */
+            if (!(eq_s_b(z, 1, s_0)))
+                goto lab0;
+            return 0;
+        lab0:
+            z->c = z->l - m2;
+        }
+            {
+                int ret = slice_del(z); /* delete, line 72 */
+                if (ret < 0)
+                    return ret;
+            }
+            break;
+        case 2: {
+            int ret = slice_del(z); /* delete, line 74 */
+            if (ret < 0)
+                return ret;
+        }
+            z->ket = z->c; /* [, line 74 */
+            if (!(eq_s_b(z, 3, s_1)))
+                return 0;
+            z->bra = z->c; /* ], line 74 */
+            {
+                int ret = slice_from_s(z, 3, s_2); /* <-, line 74 */
+                if (ret < 0)
+                    return ret;
+            }
+            break;
+        case 3: {
+            int ret = slice_del(z); /* delete, line 78 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 4:
+            if (z->c - 1 <= z->lb || z->p[z->c - 1] != 97)
+                return 0;
+            if (!(find_among_b(z, a_1, 6)))
+                return 0; /* among, line 81 */
+            {
+                int ret = slice_del(z); /* delete, line 81 */
+                if (ret < 0)
+                    return ret;
+            }
+            break;
+        case 5:
+            if (z->c - 2 <= z->lb || z->p[z->c - 1] != 164)
+                return 0;
+            if (!(find_among_b(z, a_2, 6)))
+                return 0; /* among, line 83 */
+            {
+                int ret = slice_del(z); /* delete, line 84 */
+                if (ret < 0)
+                    return ret;
+            }
+            break;
+        case 6:
+            if (z->c - 2 <= z->lb || z->p[z->c - 1] != 101)
+                return 0;
+            if (!(find_among_b(z, a_3, 2)))
+                return 0; /* among, line 86 */
+            {
+                int ret = slice_del(z); /* delete, line 86 */
+                if (ret < 0)
+                    return ret;
+            }
+            break;
+    }
+    return 1;
+}
+
+static int r_LONG(struct SN_env *z) {
+    if (!(find_among_b(z, a_5, 7)))
+        return 0; /* among, line 91 */
+    return 1;
+}
+
+static int r_VI(struct SN_env *z) {
+    if (!(eq_s_b(z, 1, s_3)))
+        return 0;
+    if (in_grouping_b_U(z, g_V2, 97, 246, 0))
+        return 0;
+    return 1;
+}
+
+static int r_case_ending(struct SN_env *z) {
+    int among_var;
+    {
+        int mlimit; /* setlimit, line 96 */
+        int m1 = z->l - z->c;
+        (void)m1;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 96 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m1;
+        z->ket = z->c;                        /* [, line 96 */
+        among_var = find_among_b(z, a_6, 30); /* substring, line 96 */
+        if (!(among_var)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        z->bra = z->c; /* ], line 96 */
+        z->lb = mlimit;
+    }
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1:
+            if (!(eq_s_b(z, 1, s_4)))
+                return 0;
+            break;
+        case 2:
+            if (!(eq_s_b(z, 1, s_5)))
+                return 0;
+            break;
+        case 3:
+            if (!(eq_s_b(z, 1, s_6)))
+                return 0;
+            break;
+        case 4:
+            if (!(eq_s_b(z, 1, s_7)))
+                return 0;
+            break;
+        case 5:
+            if (!(eq_s_b(z, 2, s_8)))
+                return 0;
+            break;
+        case 6:
+            if (!(eq_s_b(z, 2, s_9)))
+                return 0;
+            break;
+        case 7: {
+            int m_keep = z->l - z->c; /* (void) m_keep;*/ /* try, line 111 */
+            {
+                int m2 = z->l - z->c;
+                (void)m2; /* and, line 113 */
+                {
+                    int m3 = z->l - z->c;
+                    (void)m3; /* or, line 112 */
+                    {
+                        int ret = r_LONG(z);
+                        if (ret == 0)
+                            goto lab2; /* call LONG, line 111 */
+                        if (ret < 0)
+                            return ret;
+                    }
+                    goto lab1;
+                lab2:
+                    z->c = z->l - m3;
+                    if (!(eq_s_b(z, 2, s_10))) {
+                        z->c = z->l - m_keep;
+                        goto lab0;
+                    }
+                }
+            lab1:
+                z->c = z->l - m2;
+                {
+                    int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
+                    if (ret < 0) {
+                        z->c = z->l - m_keep;
+                        goto lab0;
+                    }
+                    z->c = ret; /* next, line 113 */
+                }
+            }
+            z->bra = z->c; /* ], line 113 */
+        lab0:;
+        } break;
+        case 8:
+            if (in_grouping_b_U(z, g_V1, 97, 246, 0))
+                return 0;
+            if (out_grouping_b_U(z, g_V1, 97, 246, 0))
+                return 0;
+            break;
+        case 9:
+            if (!(eq_s_b(z, 1, s_11)))
+                return 0;
+            break;
+    }
+    {
+        int ret = slice_del(z); /* delete, line 138 */
+        if (ret < 0)
+            return ret;
+    }
+    z->B[0] = 1; /* set ending_removed, line 139 */
+    return 1;
+}
+
+static int r_other_endings(struct SN_env *z) {
+    int among_var;
+    {
+        int mlimit; /* setlimit, line 142 */
+        int m1 = z->l - z->c;
+        (void)m1;
+        if (z->c < z->I[1])
+            return 0;
+        z->c = z->I[1]; /* tomark, line 142 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m1;
+        z->ket = z->c;                        /* [, line 142 */
+        among_var = find_among_b(z, a_7, 14); /* substring, line 142 */
+        if (!(among_var)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        z->bra = z->c; /* ], line 142 */
+        z->lb = mlimit;
+    }
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int m2 = z->l - z->c;
+            (void)m2; /* not, line 146 */
+            if (!(eq_s_b(z, 2, s_12)))
+                goto lab0;
+            return 0;
+        lab0:
+            z->c = z->l - m2;
+        } break;
+    }
+    {
+        int ret = slice_del(z); /* delete, line 151 */
+        if (ret < 0)
+            return ret;
+    }
+    return 1;
+}
+
+static int r_i_plural(struct SN_env *z) {
+    {
+        int mlimit; /* setlimit, line 154 */
+        int m1 = z->l - z->c;
+        (void)m1;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 154 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m1;
+        z->ket = z->c; /* [, line 154 */
+        if (z->c <= z->lb || (z->p[z->c - 1] != 105 && z->p[z->c - 1] != 106)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        if (!(find_among_b(z, a_8, 2))) {
+            z->lb = mlimit;
+            return 0;
+        } /* substring, line 154 */
+        z->bra = z->c; /* ], line 154 */
+        z->lb = mlimit;
+    }
+    {
+        int ret = slice_del(z); /* delete, line 158 */
+        if (ret < 0)
+            return ret;
+    }
+    return 1;
+}
+
+static int r_t_plural(struct SN_env *z) {
+    int among_var;
+    {
+        int mlimit; /* setlimit, line 161 */
+        int m1 = z->l - z->c;
+        (void)m1;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 161 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m1;
+        z->ket = z->c; /* [, line 162 */
+        if (!(eq_s_b(z, 1, s_13))) {
+            z->lb = mlimit;
+            return 0;
+        }
+        z->bra = z->c; /* ], line 162 */
+        {
+            int m_test = z->l - z->c; /* test, line 162 */
+            if (in_grouping_b_U(z, g_V1, 97, 246, 0)) {
+                z->lb = mlimit;
+                return 0;
+            }
+            z->c = z->l - m_test;
+        }
+        {
+            int ret = slice_del(z); /* delete, line 163 */
+            if (ret < 0)
+                return ret;
+        }
+        z->lb = mlimit;
+    }
+    {
+        int mlimit; /* setlimit, line 165 */
+        int m2 = z->l - z->c;
+        (void)m2;
+        if (z->c < z->I[1])
+            return 0;
+        z->c = z->I[1]; /* tomark, line 165 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m2;
+        z->ket = z->c; /* [, line 165 */
+        if (z->c - 2 <= z->lb || z->p[z->c - 1] != 97) {
+            z->lb = mlimit;
+            return 0;
+        }
+        among_var = find_among_b(z, a_9, 2); /* substring, line 165 */
+        if (!(among_var)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        z->bra = z->c; /* ], line 165 */
+        z->lb = mlimit;
+    }
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int m3 = z->l - z->c;
+            (void)m3; /* not, line 167 */
+            if (!(eq_s_b(z, 2, s_14)))
+                goto lab0;
+            return 0;
+        lab0:
+            z->c = z->l - m3;
+        } break;
+    }
+    {
+        int ret = slice_del(z); /* delete, line 170 */
+        if (ret < 0)
+            return ret;
+    }
+    return 1;
+}
+
+static int r_tidy(struct SN_env *z) {
+    {
+        int mlimit; /* setlimit, line 173 */
+        int m1 = z->l - z->c;
+        (void)m1;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 173 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m1;
+        {
+            int m2 = z->l - z->c;
+            (void)m2; /* do, line 174 */
+            {
+                int m3 = z->l - z->c;
+                (void)m3; /* and, line 174 */
+                {
+                    int ret = r_LONG(z);
+                    if (ret == 0)
+                        goto lab0; /* call LONG, line 174 */
+                    if (ret < 0)
+                        return ret;
+                }
+                z->c = z->l - m3;
+                z->ket = z->c; /* [, line 174 */
+                {
+                    int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
+                    if (ret < 0)
+                        goto lab0;
+                    z->c = ret; /* next, line 174 */
+                }
+                z->bra = z->c; /* ], line 174 */
+                {
+                    int ret = slice_del(z); /* delete, line 174 */
+                    if (ret < 0)
+                        return ret;
+                }
+            }
+        lab0:
+            z->c = z->l - m2;
+        }
+        {
+            int m4 = z->l - z->c;
+            (void)m4;      /* do, line 175 */
+            z->ket = z->c; /* [, line 175 */
+            if (in_grouping_b_U(z, g_AEI, 97, 228, 0))
+                goto lab1;
+            z->bra = z->c; /* ], line 175 */
+            if (out_grouping_b_U(z, g_V1, 97, 246, 0))
+                goto lab1;
+            {
+                int ret = slice_del(z); /* delete, line 175 */
+                if (ret < 0)
+                    return ret;
+            }
+        lab1:
+            z->c = z->l - m4;
+        }
+        {
+            int m5 = z->l - z->c;
+            (void)m5;      /* do, line 176 */
+            z->ket = z->c; /* [, line 176 */
+            if (!(eq_s_b(z, 1, s_15)))
+                goto lab2;
+            z->bra = z->c; /* ], line 176 */
+            {
+                int m6 = z->l - z->c;
+                (void)m6; /* or, line 176 */
+                if (!(eq_s_b(z, 1, s_16)))
+                    goto lab4;
+                goto lab3;
+            lab4:
+                z->c = z->l - m6;
+                if (!(eq_s_b(z, 1, s_17)))
+                    goto lab2;
+            }
+        lab3: {
+            int ret = slice_del(z); /* delete, line 176 */
+            if (ret < 0)
+                return ret;
+        }
+        lab2:
+            z->c = z->l - m5;
+        }
+        {
+            int m7 = z->l - z->c;
+            (void)m7;      /* do, line 177 */
+            z->ket = z->c; /* [, line 177 */
+            if (!(eq_s_b(z, 1, s_18)))
+                goto lab5;
+            z->bra = z->c; /* ], line 177 */
+            if (!(eq_s_b(z, 1, s_19)))
+                goto lab5;
+            {
+                int ret = slice_del(z); /* delete, line 177 */
+                if (ret < 0)
+                    return ret;
+            }
+        lab5:
+            z->c = z->l - m7;
+        }
+        z->lb = mlimit;
+    }
+    if (in_grouping_b_U(z, g_V1, 97, 246, 1) < 0)
+        return 0; /* goto */ /* non V1, line 179 */
+    z->ket = z->c;           /* [, line 179 */
+    {
+        int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
+        if (ret < 0)
+            return 0;
+        z->c = ret; /* next, line 179 */
+    }
+    z->bra = z->c;                  /* ], line 179 */
+    z->S[0] = slice_to(z, z->S[0]); /* -> x, line 179 */
+    if (z->S[0] == 0)
+        return -1; /* -> x, line 179 */
+    if (!(eq_v_b(z, z->S[0])))
+        return 0; /* name x, line 179 */
+    {
+        int ret = slice_del(z); /* delete, line 179 */
+        if (ret < 0)
+            return ret;
+    }
+    return 1;
+}
+
+extern int finnish_UTF_8_stem(struct SN_env *z) {
+    {
+        int c1 = z->c; /* do, line 185 */
+        {
+            int ret = r_mark_regions(z);
+            if (ret == 0)
+                goto lab0; /* call mark_regions, line 185 */
+            if (ret < 0)
+                return ret;
+        }
+    lab0:
+        z->c = c1;
+    }
+    z->B[0] = 0; /* unset ending_removed, line 186 */
+    z->lb = z->c;
+    z->c = z->l; /* backwards, line 187 */
+
+    {
+        int m2 = z->l - z->c;
+        (void)m2; /* do, line 188 */
+        {
+            int ret = r_particle_etc(z);
+            if (ret == 0)
+                goto lab1; /* call particle_etc, line 188 */
+            if (ret < 0)
+                return ret;
+        }
+    lab1:
+        z->c = z->l - m2;
+    }
+    {
+        int m3 = z->l - z->c;
+        (void)m3; /* do, line 189 */
+        {
+            int ret = r_possessive(z);
+            if (ret == 0)
+                goto lab2; /* call possessive, line 189 */
+            if (ret < 0)
+                return ret;
+        }
+    lab2:
+        z->c = z->l - m3;
+    }
+    {
+        int m4 = z->l - z->c;
+        (void)m4; /* do, line 190 */
+        {
+            int ret = r_case_ending(z);
+            if (ret == 0)
+                goto lab3; /* call case_ending, line 190 */
+            if (ret < 0)
+                return ret;
+        }
+    lab3:
+        z->c = z->l - m4;
+    }
+    {
+        int m5 = z->l - z->c;
+        (void)m5; /* do, line 191 */
+        {
+            int ret = r_other_endings(z);
+            if (ret == 0)
+                goto lab4; /* call other_endings, line 191 */
+            if (ret < 0)
+                return ret;
+        }
+    lab4:
+        z->c = z->l - m5;
+    }
+    {
+        int m6 = z->l - z->c;
+        (void)m6; /* or, line 192 */
+        if (!(z->B[0]))
+            goto lab6; /* Boolean test ending_removed, line 192 */
+        {
+            int m7 = z->l - z->c;
+            (void)m7; /* do, line 192 */
+            {
+                int ret = r_i_plural(z);
+                if (ret == 0)
+                    goto lab7; /* call i_plural, line 192 */
+                if (ret < 0)
+                    return ret;
+            }
+        lab7:
+            z->c = z->l - m7;
+        }
+        goto lab5;
+    lab6:
+        z->c = z->l - m6;
+        {
+            int m8 = z->l - z->c;
+            (void)m8; /* do, line 192 */
+            {
+                int ret = r_t_plural(z);
+                if (ret == 0)
+                    goto lab8; /* call t_plural, line 192 */
+                if (ret < 0)
+                    return ret;
+            }
+        lab8:
+            z->c = z->l - m8;
+        }
+    }
+lab5: {
+    int m9 = z->l - z->c;
+    (void)m9; /* do, line 193 */
+    {
+        int ret = r_tidy(z);
+        if (ret == 0)
+            goto lab9; /* call tidy, line 193 */
+        if (ret < 0)
+            return ret;
+    }
+lab9:
+    z->c = z->l - m9;
+}
+    z->c = z->lb;
+    return 1;
+}
+
+extern struct SN_env *finnish_UTF_8_create_env(void) { return SN_create_env(1, 2, 1); }
+
+extern void finnish_UTF_8_close_env(struct SN_env *z) { SN_close_env(z, 1); }

internal/binding/cpp/stemmer/stem_UTF_8_finnish.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *finnish_UTF_8_create_env(void);
+extern void finnish_UTF_8_close_env(struct SN_env *z);
+
+extern int finnish_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_french.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *french_UTF_8_create_env(void);
+extern void french_UTF_8_close_env(struct SN_env *z);
+
+extern int french_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_german.cpp

@@ -0,0 +1,626 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#include "header.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern int german_UTF_8_stem(struct SN_env *z);
+#ifdef __cplusplus
+}
+#endif
+static int r_standard_suffix(struct SN_env *z);
+static int r_R2(struct SN_env *z);
+static int r_R1(struct SN_env *z);
+static int r_mark_regions(struct SN_env *z);
+static int r_postlude(struct SN_env *z);
+static int r_prelude(struct SN_env *z);
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *german_UTF_8_create_env(void);
+extern void german_UTF_8_close_env(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif
+static const symbol s_0_1[1] = {'U'};
+static const symbol s_0_2[1] = {'Y'};
+static const symbol s_0_3[2] = {0xC3, 0xA4};
+static const symbol s_0_4[2] = {0xC3, 0xB6};
+static const symbol s_0_5[2] = {0xC3, 0xBC};
+
+static const struct among a_0[6] = {
+    /*  0 */ {0, 0, -1, 6, 0},
+    /*  1 */ {1, s_0_1, 0, 2, 0},
+    /*  2 */ {1, s_0_2, 0, 1, 0},
+    /*  3 */ {2, s_0_3, 0, 3, 0},
+    /*  4 */ {2, s_0_4, 0, 4, 0},
+    /*  5 */ {2, s_0_5, 0, 5, 0}};
+
+static const symbol s_1_0[1] = {'e'};
+static const symbol s_1_1[2] = {'e', 'm'};
+static const symbol s_1_2[2] = {'e', 'n'};
+static const symbol s_1_3[3] = {'e', 'r', 'n'};
+static const symbol s_1_4[2] = {'e', 'r'};
+static const symbol s_1_5[1] = {'s'};
+static const symbol s_1_6[2] = {'e', 's'};
+
+static const struct among a_1[7] = {
+    /*  0 */ {1, s_1_0, -1, 1, 0},
+    /*  1 */ {2, s_1_1, -1, 1, 0},
+    /*  2 */ {2, s_1_2, -1, 1, 0},
+    /*  3 */ {3, s_1_3, -1, 1, 0},
+    /*  4 */ {2, s_1_4, -1, 1, 0},
+    /*  5 */ {1, s_1_5, -1, 2, 0},
+    /*  6 */ {2, s_1_6, 5, 1, 0}};
+
+static const symbol s_2_0[2] = {'e', 'n'};
+static const symbol s_2_1[2] = {'e', 'r'};
+static const symbol s_2_2[2] = {'s', 't'};
+static const symbol s_2_3[3] = {'e', 's', 't'};
+
+static const struct among a_2[4] = {
+    /*  0 */ {2, s_2_0, -1, 1, 0},
+    /*  1 */ {2, s_2_1, -1, 1, 0},
+    /*  2 */ {2, s_2_2, -1, 2, 0},
+    /*  3 */ {3, s_2_3, 2, 1, 0}};
+
+static const symbol s_3_0[2] = {'i', 'g'};
+static const symbol s_3_1[4] = {'l', 'i', 'c', 'h'};
+
+static const struct among a_3[2] = {
+    /*  0 */ {2, s_3_0, -1, 1, 0},
+    /*  1 */ {4, s_3_1, -1, 1, 0}};
+
+static const symbol s_4_0[3] = {'e', 'n', 'd'};
+static const symbol s_4_1[2] = {'i', 'g'};
+static const symbol s_4_2[3] = {'u', 'n', 'g'};
+static const symbol s_4_3[4] = {'l', 'i', 'c', 'h'};
+static const symbol s_4_4[4] = {'i', 's', 'c', 'h'};
+static const symbol s_4_5[2] = {'i', 'k'};
+static const symbol s_4_6[4] = {'h', 'e', 'i', 't'};
+static const symbol s_4_7[4] = {'k', 'e', 'i', 't'};
+
+static const struct among a_4[8] = {
+    /*  0 */ {3, s_4_0, -1, 1, 0},
+    /*  1 */ {2, s_4_1, -1, 2, 0},
+    /*  2 */ {3, s_4_2, -1, 1, 0},
+    /*  3 */ {4, s_4_3, -1, 3, 0},
+    /*  4 */ {4, s_4_4, -1, 2, 0},
+    /*  5 */ {2, s_4_5, -1, 2, 0},
+    /*  6 */ {4, s_4_6, -1, 3, 0},
+    /*  7 */ {4, s_4_7, -1, 4, 0}};
+
+static const unsigned char g_v[] = {17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 32, 8};
+
+static const unsigned char g_s_ending[] = {117, 30, 5};
+
+static const unsigned char g_st_ending[] = {117, 30, 4};
+
+static const symbol s_0[] = {0xC3, 0x9F};
+static const symbol s_1[] = {'s', 's'};
+static const symbol s_2[] = {'u'};
+static const symbol s_3[] = {'U'};
+static const symbol s_4[] = {'y'};
+static const symbol s_5[] = {'Y'};
+static const symbol s_6[] = {'y'};
+static const symbol s_7[] = {'u'};
+static const symbol s_8[] = {'a'};
+static const symbol s_9[] = {'o'};
+static const symbol s_10[] = {'u'};
+static const symbol s_11[] = {'i', 'g'};
+static const symbol s_12[] = {'e'};
+static const symbol s_13[] = {'e'};
+static const symbol s_14[] = {'e', 'r'};
+static const symbol s_15[] = {'e', 'n'};
+
+static int r_prelude(struct SN_env *z) {
+    {
+        int c_test = z->c; /* test, line 30 */
+        while (1) {        /* repeat, line 30 */
+            int c1 = z->c;
+            {
+                int c2 = z->c; /* or, line 33 */
+                z->bra = z->c; /* [, line 32 */
+                if (!(eq_s(z, 2, s_0)))
+                    goto lab2;
+                z->ket = z->c; /* ], line 32 */
+                {
+                    int ret = slice_from_s(z, 2, s_1); /* <-, line 32 */
+                    if (ret < 0)
+                        return ret;
+                }
+                goto lab1;
+            lab2:
+                z->c = c2;
+                {
+                    int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
+                    if (ret < 0)
+                        goto lab0;
+                    z->c = ret; /* next, line 33 */
+                }
+            }
+        lab1:
+            continue;
+        lab0:
+            z->c = c1;
+            break;
+        }
+        z->c = c_test;
+    }
+    while (1) { /* repeat, line 36 */
+        int c3 = z->c;
+        while (1) { /* goto, line 36 */
+            int c4 = z->c;
+            if (in_grouping_U(z, g_v, 97, 252, 0))
+                goto lab4;
+            z->bra = z->c; /* [, line 37 */
+            {
+                int c5 = z->c; /* or, line 37 */
+                if (!(eq_s(z, 1, s_2)))
+                    goto lab6;
+                z->ket = z->c; /* ], line 37 */
+                if (in_grouping_U(z, g_v, 97, 252, 0))
+                    goto lab6;
+                {
+                    int ret = slice_from_s(z, 1, s_3); /* <-, line 37 */
+                    if (ret < 0)
+                        return ret;
+                }
+                goto lab5;
+            lab6:
+                z->c = c5;
+                if (!(eq_s(z, 1, s_4)))
+                    goto lab4;
+                z->ket = z->c; /* ], line 38 */
+                if (in_grouping_U(z, g_v, 97, 252, 0))
+                    goto lab4;
+                {
+                    int ret = slice_from_s(z, 1, s_5); /* <-, line 38 */
+                    if (ret < 0)
+                        return ret;
+                }
+            }
+        lab5:
+            z->c = c4;
+            break;
+        lab4:
+            z->c = c4;
+            {
+                int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
+                if (ret < 0)
+                    goto lab3;
+                z->c = ret; /* goto, line 36 */
+            }
+        }
+        continue;
+    lab3:
+        z->c = c3;
+        break;
+    }
+    return 1;
+}
+
+static int r_mark_regions(struct SN_env *z) {
+    z->I[0] = z->l;
+    z->I[1] = z->l;
+    {
+        int c_test = z->c; /* test, line 47 */
+        {
+            int ret = skip_utf8(z->p, z->c, 0, z->l, +3);
+            if (ret < 0)
+                return 0;
+            z->c = ret; /* hop, line 47 */
+        }
+        z->I[2] = z->c; /* setmark x, line 47 */
+        z->c = c_test;
+    }
+    { /* gopast */ /* grouping v, line 49 */
+        int ret = out_grouping_U(z, g_v, 97, 252, 1);
+        if (ret < 0)
+            return 0;
+        z->c += ret;
+    }
+    { /* gopast */ /* non v, line 49 */
+        int ret = in_grouping_U(z, g_v, 97, 252, 1);
+        if (ret < 0)
+            return 0;
+        z->c += ret;
+    }
+    z->I[0] = z->c; /* setmark p1, line 49 */
+                    /* try, line 50 */
+    if (!(z->I[0] < z->I[2]))
+        goto lab0;
+    z->I[0] = z->I[2];
+lab0: { /* gopast */ /* grouping v, line 51 */
+    int ret = out_grouping_U(z, g_v, 97, 252, 1);
+    if (ret < 0)
+        return 0;
+    z->c += ret;
+}
+    { /* gopast */ /* non v, line 51 */
+        int ret = in_grouping_U(z, g_v, 97, 252, 1);
+        if (ret < 0)
+            return 0;
+        z->c += ret;
+    }
+    z->I[1] = z->c; /* setmark p2, line 51 */
+    return 1;
+}
+
+static int r_postlude(struct SN_env *z) {
+    int among_var;
+    while (1) { /* repeat, line 55 */
+        int c1 = z->c;
+        z->bra = z->c;                     /* [, line 57 */
+        among_var = find_among(z, a_0, 6); /* substring, line 57 */
+        if (!(among_var))
+            goto lab0;
+        z->ket = z->c; /* ], line 57 */
+        switch (among_var) {
+            case 0:
+                goto lab0;
+            case 1: {
+                int ret = slice_from_s(z, 1, s_6); /* <-, line 58 */
+                if (ret < 0)
+                    return ret;
+            } break;
+            case 2: {
+                int ret = slice_from_s(z, 1, s_7); /* <-, line 59 */
+                if (ret < 0)
+                    return ret;
+            } break;
+            case 3: {
+                int ret = slice_from_s(z, 1, s_8); /* <-, line 60 */
+                if (ret < 0)
+                    return ret;
+            } break;
+            case 4: {
+                int ret = slice_from_s(z, 1, s_9); /* <-, line 61 */
+                if (ret < 0)
+                    return ret;
+            } break;
+            case 5: {
+                int ret = slice_from_s(z, 1, s_10); /* <-, line 62 */
+                if (ret < 0)
+                    return ret;
+            } break;
+            case 6: {
+                int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
+                if (ret < 0)
+                    goto lab0;
+                z->c = ret; /* next, line 63 */
+            } break;
+        }
+        continue;
+    lab0:
+        z->c = c1;
+        break;
+    }
+    return 1;
+}
+
+static int r_R1(struct SN_env *z) {
+    if (!(z->I[0] <= z->c))
+        return 0;
+    return 1;
+}
+
+static int r_R2(struct SN_env *z) {
+    if (!(z->I[1] <= z->c))
+        return 0;
+    return 1;
+}
+
+static int r_standard_suffix(struct SN_env *z) {
+    int among_var;
+    {
+        int m1 = z->l - z->c;
+        (void)m1;      /* do, line 74 */
+        z->ket = z->c; /* [, line 75 */
+        if (z->c <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((811040 >> (z->p[z->c - 1] & 0x1f)) & 1))
+            goto lab0;
+        among_var = find_among_b(z, a_1, 7); /* substring, line 75 */
+        if (!(among_var))
+            goto lab0;
+        z->bra = z->c; /* ], line 75 */
+        {
+            int ret = r_R1(z);
+            if (ret == 0)
+                goto lab0; /* call R1, line 75 */
+            if (ret < 0)
+                return ret;
+        }
+        switch (among_var) {
+            case 0:
+                goto lab0;
+            case 1: {
+                int ret = slice_del(z); /* delete, line 77 */
+                if (ret < 0)
+                    return ret;
+            } break;
+            case 2:
+                if (in_grouping_b_U(z, g_s_ending, 98, 116, 0))
+                    goto lab0;
+                {
+                    int ret = slice_del(z); /* delete, line 80 */
+                    if (ret < 0)
+                        return ret;
+                }
+                break;
+        }
+    lab0:
+        z->c = z->l - m1;
+    }
+    {
+        int m2 = z->l - z->c;
+        (void)m2;      /* do, line 84 */
+        z->ket = z->c; /* [, line 85 */
+        if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((1327104 >> (z->p[z->c - 1] & 0x1f)) & 1))
+            goto lab1;
+        among_var = find_among_b(z, a_2, 4); /* substring, line 85 */
+        if (!(among_var))
+            goto lab1;
+        z->bra = z->c; /* ], line 85 */
+        {
+            int ret = r_R1(z);
+            if (ret == 0)
+                goto lab1; /* call R1, line 85 */
+            if (ret < 0)
+                return ret;
+        }
+        switch (among_var) {
+            case 0:
+                goto lab1;
+            case 1: {
+                int ret = slice_del(z); /* delete, line 87 */
+                if (ret < 0)
+                    return ret;
+            } break;
+            case 2:
+                if (in_grouping_b_U(z, g_st_ending, 98, 116, 0))
+                    goto lab1;
+                {
+                    int ret = skip_utf8(z->p, z->c, z->lb, z->l, -3);
+                    if (ret < 0)
+                        goto lab1;
+                    z->c = ret; /* hop, line 90 */
+                }
+                {
+                    int ret = slice_del(z); /* delete, line 90 */
+                    if (ret < 0)
+                        return ret;
+                }
+                break;
+        }
+    lab1:
+        z->c = z->l - m2;
+    }
+    {
+        int m3 = z->l - z->c;
+        (void)m3;      /* do, line 94 */
+        z->ket = z->c; /* [, line 95 */
+        if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((1051024 >> (z->p[z->c - 1] & 0x1f)) & 1))
+            goto lab2;
+        among_var = find_among_b(z, a_4, 8); /* substring, line 95 */
+        if (!(among_var))
+            goto lab2;
+        z->bra = z->c; /* ], line 95 */
+        {
+            int ret = r_R2(z);
+            if (ret == 0)
+                goto lab2; /* call R2, line 95 */
+            if (ret < 0)
+                return ret;
+        }
+        switch (among_var) {
+            case 0:
+                goto lab2;
+            case 1: {
+                int ret = slice_del(z); /* delete, line 97 */
+                if (ret < 0)
+                    return ret;
+            }
+                {
+                    int m_keep = z->l - z->c; /* (void) m_keep;*/ /* try, line 98 */
+                    z->ket = z->c;                                /* [, line 98 */
+                    if (!(eq_s_b(z, 2, s_11))) {
+                        z->c = z->l - m_keep;
+                        goto lab3;
+                    }
+                    z->bra = z->c; /* ], line 98 */
+                    {
+                        int m4 = z->l - z->c;
+                        (void)m4; /* not, line 98 */
+                        if (!(eq_s_b(z, 1, s_12)))
+                            goto lab4;
+                        {
+                            z->c = z->l - m_keep;
+                            goto lab3;
+                        }
+                    lab4:
+                        z->c = z->l - m4;
+                    }
+                    {
+                        int ret = r_R2(z);
+                        if (ret == 0) {
+                            z->c = z->l - m_keep;
+                            goto lab3;
+                        } /* call R2, line 98 */
+                        if (ret < 0)
+                            return ret;
+                    }
+                    {
+                        int ret = slice_del(z); /* delete, line 98 */
+                        if (ret < 0)
+                            return ret;
+                    }
+                lab3:;
+                }
+                break;
+            case 2: {
+                int m5 = z->l - z->c;
+                (void)m5; /* not, line 101 */
+                if (!(eq_s_b(z, 1, s_13)))
+                    goto lab5;
+                goto lab2;
+            lab5:
+                z->c = z->l - m5;
+            }
+                {
+                    int ret = slice_del(z); /* delete, line 101 */
+                    if (ret < 0)
+                        return ret;
+                }
+                break;
+            case 3: {
+                int ret = slice_del(z); /* delete, line 104 */
+                if (ret < 0)
+                    return ret;
+            }
+                {
+                    int m_keep = z->l - z->c; /* (void) m_keep;*/ /* try, line 105 */
+                    z->ket = z->c;                                /* [, line 106 */
+                    {
+                        int m6 = z->l - z->c;
+                        (void)m6; /* or, line 106 */
+                        if (!(eq_s_b(z, 2, s_14)))
+                            goto lab8;
+                        goto lab7;
+                    lab8:
+                        z->c = z->l - m6;
+                        if (!(eq_s_b(z, 2, s_15))) {
+                            z->c = z->l - m_keep;
+                            goto lab6;
+                        }
+                    }
+                lab7:
+                    z->bra = z->c; /* ], line 106 */
+                    {
+                        int ret = r_R1(z);
+                        if (ret == 0) {
+                            z->c = z->l - m_keep;
+                            goto lab6;
+                        } /* call R1, line 106 */
+                        if (ret < 0)
+                            return ret;
+                    }
+                    {
+                        int ret = slice_del(z); /* delete, line 106 */
+                        if (ret < 0)
+                            return ret;
+                    }
+                lab6:;
+                }
+                break;
+            case 4: {
+                int ret = slice_del(z); /* delete, line 110 */
+                if (ret < 0)
+                    return ret;
+            }
+                {
+                    int m_keep = z->l - z->c; /* (void) m_keep;*/ /* try, line 111 */
+                    z->ket = z->c;                                /* [, line 112 */
+                    if (z->c - 1 <= z->lb || (z->p[z->c - 1] != 103 && z->p[z->c - 1] != 104)) {
+                        z->c = z->l - m_keep;
+                        goto lab9;
+                    }
+                    among_var = find_among_b(z, a_3, 2); /* substring, line 112 */
+                    if (!(among_var)) {
+                        z->c = z->l - m_keep;
+                        goto lab9;
+                    }
+                    z->bra = z->c; /* ], line 112 */
+                    {
+                        int ret = r_R2(z);
+                        if (ret == 0) {
+                            z->c = z->l - m_keep;
+                            goto lab9;
+                        } /* call R2, line 112 */
+                        if (ret < 0)
+                            return ret;
+                    }
+                    switch (among_var) {
+                        case 0: {
+                            z->c = z->l - m_keep;
+                            goto lab9;
+                        }
+                        case 1: {
+                            int ret = slice_del(z); /* delete, line 114 */
+                            if (ret < 0)
+                                return ret;
+                        } break;
+                    }
+                lab9:;
+                }
+                break;
+        }
+    lab2:
+        z->c = z->l - m3;
+    }
+    return 1;
+}
+
+extern int german_UTF_8_stem(struct SN_env *z) {
+    {
+        int c1 = z->c; /* do, line 125 */
+        {
+            int ret = r_prelude(z);
+            if (ret == 0)
+                goto lab0; /* call prelude, line 125 */
+            if (ret < 0)
+                return ret;
+        }
+    lab0:
+        z->c = c1;
+    }
+    {
+        int c2 = z->c; /* do, line 126 */
+        {
+            int ret = r_mark_regions(z);
+            if (ret == 0)
+                goto lab1; /* call mark_regions, line 126 */
+            if (ret < 0)
+                return ret;
+        }
+    lab1:
+        z->c = c2;
+    }
+    z->lb = z->c;
+    z->c = z->l; /* backwards, line 127 */
+
+    {
+        int m3 = z->l - z->c;
+        (void)m3; /* do, line 128 */
+        {
+            int ret = r_standard_suffix(z);
+            if (ret == 0)
+                goto lab2; /* call standard_suffix, line 128 */
+            if (ret < 0)
+                return ret;
+        }
+    lab2:
+        z->c = z->l - m3;
+    }
+    z->c = z->lb;
+    {
+        int c4 = z->c; /* do, line 129 */
+        {
+            int ret = r_postlude(z);
+            if (ret == 0)
+                goto lab3; /* call postlude, line 129 */
+            if (ret < 0)
+                return ret;
+        }
+    lab3:
+        z->c = c4;
+    }
+    return 1;
+}
+
+extern struct SN_env *german_UTF_8_create_env(void) { return SN_create_env(0, 3, 0); }
+
+extern void german_UTF_8_close_env(struct SN_env *z) { SN_close_env(z, 0); }

internal/binding/cpp/stemmer/stem_UTF_8_german.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *german_UTF_8_create_env(void);
+extern void german_UTF_8_close_env(struct SN_env *z);
+
+extern int german_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_hungarian.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *hungarian_UTF_8_create_env(void);
+extern void hungarian_UTF_8_close_env(struct SN_env *z);
+
+extern int hungarian_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_italian.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *italian_UTF_8_create_env(void);
+extern void italian_UTF_8_close_env(struct SN_env *z);
+
+extern int italian_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_norwegian.cpp

@@ -0,0 +1,357 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#include "header.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern int norwegian_UTF_8_stem(struct SN_env *z);
+#ifdef __cplusplus
+}
+#endif
+static int r_other_suffix(struct SN_env *z);
+static int r_consonant_pair(struct SN_env *z);
+static int r_main_suffix(struct SN_env *z);
+static int r_mark_regions(struct SN_env *z);
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *norwegian_UTF_8_create_env(void);
+extern void norwegian_UTF_8_close_env(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif
+static const symbol s_0_0[1] = {'a'};
+static const symbol s_0_1[1] = {'e'};
+static const symbol s_0_2[3] = {'e', 'd', 'e'};
+static const symbol s_0_3[4] = {'a', 'n', 'd', 'e'};
+static const symbol s_0_4[4] = {'e', 'n', 'd', 'e'};
+static const symbol s_0_5[3] = {'a', 'n', 'e'};
+static const symbol s_0_6[3] = {'e', 'n', 'e'};
+static const symbol s_0_7[6] = {'h', 'e', 't', 'e', 'n', 'e'};
+static const symbol s_0_8[4] = {'e', 'r', 't', 'e'};
+static const symbol s_0_9[2] = {'e', 'n'};
+static const symbol s_0_10[5] = {'h', 'e', 't', 'e', 'n'};
+static const symbol s_0_11[2] = {'a', 'r'};
+static const symbol s_0_12[2] = {'e', 'r'};
+static const symbol s_0_13[5] = {'h', 'e', 't', 'e', 'r'};
+static const symbol s_0_14[1] = {'s'};
+static const symbol s_0_15[2] = {'a', 's'};
+static const symbol s_0_16[2] = {'e', 's'};
+static const symbol s_0_17[4] = {'e', 'd', 'e', 's'};
+static const symbol s_0_18[5] = {'e', 'n', 'd', 'e', 's'};
+static const symbol s_0_19[4] = {'e', 'n', 'e', 's'};
+static const symbol s_0_20[7] = {'h', 'e', 't', 'e', 'n', 'e', 's'};
+static const symbol s_0_21[3] = {'e', 'n', 's'};
+static const symbol s_0_22[6] = {'h', 'e', 't', 'e', 'n', 's'};
+static const symbol s_0_23[3] = {'e', 'r', 's'};
+static const symbol s_0_24[3] = {'e', 't', 's'};
+static const symbol s_0_25[2] = {'e', 't'};
+static const symbol s_0_26[3] = {'h', 'e', 't'};
+static const symbol s_0_27[3] = {'e', 'r', 't'};
+static const symbol s_0_28[3] = {'a', 's', 't'};
+
+static const struct among a_0[29] = {
+    /*  0 */ {1, s_0_0, -1, 1, 0},
+    /*  1 */ {1, s_0_1, -1, 1, 0},
+    /*  2 */ {3, s_0_2, 1, 1, 0},
+    /*  3 */ {4, s_0_3, 1, 1, 0},
+    /*  4 */ {4, s_0_4, 1, 1, 0},
+    /*  5 */ {3, s_0_5, 1, 1, 0},
+    /*  6 */ {3, s_0_6, 1, 1, 0},
+    /*  7 */ {6, s_0_7, 6, 1, 0},
+    /*  8 */ {4, s_0_8, 1, 3, 0},
+    /*  9 */ {2, s_0_9, -1, 1, 0},
+    /* 10 */ {5, s_0_10, 9, 1, 0},
+    /* 11 */ {2, s_0_11, -1, 1, 0},
+    /* 12 */ {2, s_0_12, -1, 1, 0},
+    /* 13 */ {5, s_0_13, 12, 1, 0},
+    /* 14 */ {1, s_0_14, -1, 2, 0},
+    /* 15 */ {2, s_0_15, 14, 1, 0},
+    /* 16 */ {2, s_0_16, 14, 1, 0},
+    /* 17 */ {4, s_0_17, 16, 1, 0},
+    /* 18 */ {5, s_0_18, 16, 1, 0},
+    /* 19 */ {4, s_0_19, 16, 1, 0},
+    /* 20 */ {7, s_0_20, 19, 1, 0},
+    /* 21 */ {3, s_0_21, 14, 1, 0},
+    /* 22 */ {6, s_0_22, 21, 1, 0},
+    /* 23 */ {3, s_0_23, 14, 1, 0},
+    /* 24 */ {3, s_0_24, 14, 1, 0},
+    /* 25 */ {2, s_0_25, -1, 1, 0},
+    /* 26 */ {3, s_0_26, 25, 1, 0},
+    /* 27 */ {3, s_0_27, -1, 3, 0},
+    /* 28 */ {3, s_0_28, -1, 1, 0}};
+
+static const symbol s_1_0[2] = {'d', 't'};
+static const symbol s_1_1[2] = {'v', 't'};
+
+static const struct among a_1[2] = {
+    /*  0 */ {2, s_1_0, -1, -1, 0},
+    /*  1 */ {2, s_1_1, -1, -1, 0}};
+
+static const symbol s_2_0[3] = {'l', 'e', 'g'};
+static const symbol s_2_1[4] = {'e', 'l', 'e', 'g'};
+static const symbol s_2_2[2] = {'i', 'g'};
+static const symbol s_2_3[3] = {'e', 'i', 'g'};
+static const symbol s_2_4[3] = {'l', 'i', 'g'};
+static const symbol s_2_5[4] = {'e', 'l', 'i', 'g'};
+static const symbol s_2_6[3] = {'e', 'l', 's'};
+static const symbol s_2_7[3] = {'l', 'o', 'v'};
+static const symbol s_2_8[4] = {'e', 'l', 'o', 'v'};
+static const symbol s_2_9[4] = {'s', 'l', 'o', 'v'};
+static const symbol s_2_10[7] = {'h', 'e', 't', 's', 'l', 'o', 'v'};
+
+static const struct among a_2[11] = {
+    /*  0 */ {3, s_2_0, -1, 1, 0},
+    /*  1 */ {4, s_2_1, 0, 1, 0},
+    /*  2 */ {2, s_2_2, -1, 1, 0},
+    /*  3 */ {3, s_2_3, 2, 1, 0},
+    /*  4 */ {3, s_2_4, 2, 1, 0},
+    /*  5 */ {4, s_2_5, 4, 1, 0},
+    /*  6 */ {3, s_2_6, -1, 1, 0},
+    /*  7 */ {3, s_2_7, -1, 1, 0},
+    /*  8 */ {4, s_2_8, 7, 1, 0},
+    /*  9 */ {4, s_2_9, 7, 1, 0},
+    /* 10 */ {7, s_2_10, 9, 1, 0}};
+
+static const unsigned char g_v[] = {17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 128};
+
+static const unsigned char g_s_ending[] = {119, 125, 149, 1};
+
+static const symbol s_0[] = {'k'};
+static const symbol s_1[] = {'e', 'r'};
+
+static int r_mark_regions(struct SN_env *z) {
+    z->I[0] = z->l;
+    {
+        int c_test = z->c; /* test, line 30 */
+        {
+            int ret = skip_utf8(z->p, z->c, 0, z->l, +3);
+            if (ret < 0)
+                return 0;
+            z->c = ret; /* hop, line 30 */
+        }
+        z->I[1] = z->c; /* setmark x, line 30 */
+        z->c = c_test;
+    }
+    if (out_grouping_U(z, g_v, 97, 248, 1) < 0)
+        return 0; /* goto */ /* grouping v, line 31 */
+    { /* gopast */           /* non v, line 31 */
+        int ret = in_grouping_U(z, g_v, 97, 248, 1);
+        if (ret < 0)
+            return 0;
+        z->c += ret;
+    }
+    z->I[0] = z->c; /* setmark p1, line 31 */
+                    /* try, line 32 */
+    if (!(z->I[0] < z->I[1]))
+        goto lab0;
+    z->I[0] = z->I[1];
+lab0:
+    return 1;
+}
+
+static int r_main_suffix(struct SN_env *z) {
+    int among_var;
+    {
+        int mlimit; /* setlimit, line 38 */
+        int m1 = z->l - z->c;
+        (void)m1;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 38 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m1;
+        z->ket = z->c; /* [, line 38 */
+        if (z->c <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((1851426 >> (z->p[z->c - 1] & 0x1f)) & 1)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        among_var = find_among_b(z, a_0, 29); /* substring, line 38 */
+        if (!(among_var)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        z->bra = z->c; /* ], line 38 */
+        z->lb = mlimit;
+    }
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = slice_del(z); /* delete, line 44 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 2: {
+            int m2 = z->l - z->c;
+            (void)m2; /* or, line 46 */
+            if (in_grouping_b_U(z, g_s_ending, 98, 122, 0))
+                goto lab1;
+            goto lab0;
+        lab1:
+            z->c = z->l - m2;
+            if (!(eq_s_b(z, 1, s_0)))
+                return 0;
+            if (out_grouping_b_U(z, g_v, 97, 248, 0))
+                return 0;
+        }
+        lab0: {
+            int ret = slice_del(z); /* delete, line 46 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 3: {
+            int ret = slice_from_s(z, 2, s_1); /* <-, line 48 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    return 1;
+}
+
+static int r_consonant_pair(struct SN_env *z) {
+    {
+        int m_test = z->l - z->c; /* test, line 53 */
+        {
+            int mlimit; /* setlimit, line 54 */
+            int m1 = z->l - z->c;
+            (void)m1;
+            if (z->c < z->I[0])
+                return 0;
+            z->c = z->I[0]; /* tomark, line 54 */
+            mlimit = z->lb;
+            z->lb = z->c;
+            z->c = z->l - m1;
+            z->ket = z->c; /* [, line 54 */
+            if (z->c - 1 <= z->lb || z->p[z->c - 1] != 116) {
+                z->lb = mlimit;
+                return 0;
+            }
+            if (!(find_among_b(z, a_1, 2))) {
+                z->lb = mlimit;
+                return 0;
+            } /* substring, line 54 */
+            z->bra = z->c; /* ], line 54 */
+            z->lb = mlimit;
+        }
+        z->c = z->l - m_test;
+    }
+    {
+        int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
+        if (ret < 0)
+            return 0;
+        z->c = ret; /* next, line 59 */
+    }
+    z->bra = z->c; /* ], line 59 */
+    {
+        int ret = slice_del(z); /* delete, line 59 */
+        if (ret < 0)
+            return ret;
+    }
+    return 1;
+}
+
+static int r_other_suffix(struct SN_env *z) {
+    int among_var;
+    {
+        int mlimit; /* setlimit, line 63 */
+        int m1 = z->l - z->c;
+        (void)m1;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 63 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m1;
+        z->ket = z->c; /* [, line 63 */
+        if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((4718720 >> (z->p[z->c - 1] & 0x1f)) & 1)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        among_var = find_among_b(z, a_2, 11); /* substring, line 63 */
+        if (!(among_var)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        z->bra = z->c; /* ], line 63 */
+        z->lb = mlimit;
+    }
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = slice_del(z); /* delete, line 67 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    return 1;
+}
+
+extern int norwegian_UTF_8_stem(struct SN_env *z) {
+    {
+        int c1 = z->c; /* do, line 74 */
+        {
+            int ret = r_mark_regions(z);
+            if (ret == 0)
+                goto lab0; /* call mark_regions, line 74 */
+            if (ret < 0)
+                return ret;
+        }
+    lab0:
+        z->c = c1;
+    }
+    z->lb = z->c;
+    z->c = z->l; /* backwards, line 75 */
+
+    {
+        int m2 = z->l - z->c;
+        (void)m2; /* do, line 76 */
+        {
+            int ret = r_main_suffix(z);
+            if (ret == 0)
+                goto lab1; /* call main_suffix, line 76 */
+            if (ret < 0)
+                return ret;
+        }
+    lab1:
+        z->c = z->l - m2;
+    }
+    {
+        int m3 = z->l - z->c;
+        (void)m3; /* do, line 77 */
+        {
+            int ret = r_consonant_pair(z);
+            if (ret == 0)
+                goto lab2; /* call consonant_pair, line 77 */
+            if (ret < 0)
+                return ret;
+        }
+    lab2:
+        z->c = z->l - m3;
+    }
+    {
+        int m4 = z->l - z->c;
+        (void)m4; /* do, line 78 */
+        {
+            int ret = r_other_suffix(z);
+            if (ret == 0)
+                goto lab3; /* call other_suffix, line 78 */
+            if (ret < 0)
+                return ret;
+        }
+    lab3:
+        z->c = z->l - m4;
+    }
+    z->c = z->lb;
+    return 1;
+}
+
+extern struct SN_env *norwegian_UTF_8_create_env(void) { return SN_create_env(0, 2, 0); }
+
+extern void norwegian_UTF_8_close_env(struct SN_env *z) { SN_close_env(z, 0); }

internal/binding/cpp/stemmer/stem_UTF_8_norwegian.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *norwegian_UTF_8_create_env(void);
+extern void norwegian_UTF_8_close_env(struct SN_env *z);
+
+extern int norwegian_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_porter.cpp

@@ -0,0 +1,888 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#include "header.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern int porter_UTF_8_stem(struct SN_env *z);
+#ifdef __cplusplus
+}
+#endif
+static int r_Step_5b(struct SN_env *z);
+static int r_Step_5a(struct SN_env *z);
+static int r_Step_4(struct SN_env *z);
+static int r_Step_3(struct SN_env *z);
+static int r_Step_2(struct SN_env *z);
+static int r_Step_1c(struct SN_env *z);
+static int r_Step_1b(struct SN_env *z);
+static int r_Step_1a(struct SN_env *z);
+static int r_R2(struct SN_env *z);
+static int r_R1(struct SN_env *z);
+static int r_shortv(struct SN_env *z);
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *porter_UTF_8_create_env(void);
+extern void porter_UTF_8_close_env(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif
+static const symbol s_0_0[1] = {'s'};
+static const symbol s_0_1[3] = {'i', 'e', 's'};
+static const symbol s_0_2[4] = {'s', 's', 'e', 's'};
+static const symbol s_0_3[2] = {'s', 's'};
+
+static const struct among a_0[4] = {
+    /*  0 */ {1, s_0_0, -1, 3, 0},
+    /*  1 */ {3, s_0_1, 0, 2, 0},
+    /*  2 */ {4, s_0_2, 0, 1, 0},
+    /*  3 */ {2, s_0_3, 0, -1, 0}};
+
+static const symbol s_1_1[2] = {'b', 'b'};
+static const symbol s_1_2[2] = {'d', 'd'};
+static const symbol s_1_3[2] = {'f', 'f'};
+static const symbol s_1_4[2] = {'g', 'g'};
+static const symbol s_1_5[2] = {'b', 'l'};
+static const symbol s_1_6[2] = {'m', 'm'};
+static const symbol s_1_7[2] = {'n', 'n'};
+static const symbol s_1_8[2] = {'p', 'p'};
+static const symbol s_1_9[2] = {'r', 'r'};
+static const symbol s_1_10[2] = {'a', 't'};
+static const symbol s_1_11[2] = {'t', 't'};
+static const symbol s_1_12[2] = {'i', 'z'};
+
+static const struct among a_1[13] = {
+    /*  0 */ {0, 0, -1, 3, 0},
+    /*  1 */ {2, s_1_1, 0, 2, 0},
+    /*  2 */ {2, s_1_2, 0, 2, 0},
+    /*  3 */ {2, s_1_3, 0, 2, 0},
+    /*  4 */ {2, s_1_4, 0, 2, 0},
+    /*  5 */ {2, s_1_5, 0, 1, 0},
+    /*  6 */ {2, s_1_6, 0, 2, 0},
+    /*  7 */ {2, s_1_7, 0, 2, 0},
+    /*  8 */ {2, s_1_8, 0, 2, 0},
+    /*  9 */ {2, s_1_9, 0, 2, 0},
+    /* 10 */ {2, s_1_10, 0, 1, 0},
+    /* 11 */ {2, s_1_11, 0, 2, 0},
+    /* 12 */ {2, s_1_12, 0, 1, 0}};
+
+static const symbol s_2_0[2] = {'e', 'd'};
+static const symbol s_2_1[3] = {'e', 'e', 'd'};
+static const symbol s_2_2[3] = {'i', 'n', 'g'};
+
+static const struct among a_2[3] = {
+    /*  0 */ {2, s_2_0, -1, 2, 0},
+    /*  1 */ {3, s_2_1, 0, 1, 0},
+    /*  2 */ {3, s_2_2, -1, 2, 0}};
+
+static const symbol s_3_0[4] = {'a', 'n', 'c', 'i'};
+static const symbol s_3_1[4] = {'e', 'n', 'c', 'i'};
+static const symbol s_3_2[4] = {'a', 'b', 'l', 'i'};
+static const symbol s_3_3[3] = {'e', 'l', 'i'};
+static const symbol s_3_4[4] = {'a', 'l', 'l', 'i'};
+static const symbol s_3_5[5] = {'o', 'u', 's', 'l', 'i'};
+static const symbol s_3_6[5] = {'e', 'n', 't', 'l', 'i'};
+static const symbol s_3_7[5] = {'a', 'l', 'i', 't', 'i'};
+static const symbol s_3_8[6] = {'b', 'i', 'l', 'i', 't', 'i'};
+static const symbol s_3_9[5] = {'i', 'v', 'i', 't', 'i'};
+static const symbol s_3_10[6] = {'t', 'i', 'o', 'n', 'a', 'l'};
+static const symbol s_3_11[7] = {'a', 't', 'i', 'o', 'n', 'a', 'l'};
+static const symbol s_3_12[5] = {'a', 'l', 'i', 's', 'm'};
+static const symbol s_3_13[5] = {'a', 't', 'i', 'o', 'n'};
+static const symbol s_3_14[7] = {'i', 'z', 'a', 't', 'i', 'o', 'n'};
+static const symbol s_3_15[4] = {'i', 'z', 'e', 'r'};
+static const symbol s_3_16[4] = {'a', 't', 'o', 'r'};
+static const symbol s_3_17[7] = {'i', 'v', 'e', 'n', 'e', 's', 's'};
+static const symbol s_3_18[7] = {'f', 'u', 'l', 'n', 'e', 's', 's'};
+static const symbol s_3_19[7] = {'o', 'u', 's', 'n', 'e', 's', 's'};
+
+static const struct among a_3[20] = {
+    /*  0 */ {4, s_3_0, -1, 3, 0},
+    /*  1 */ {4, s_3_1, -1, 2, 0},
+    /*  2 */ {4, s_3_2, -1, 4, 0},
+    /*  3 */ {3, s_3_3, -1, 6, 0},
+    /*  4 */ {4, s_3_4, -1, 9, 0},
+    /*  5 */ {5, s_3_5, -1, 12, 0},
+    /*  6 */ {5, s_3_6, -1, 5, 0},
+    /*  7 */ {5, s_3_7, -1, 10, 0},
+    /*  8 */ {6, s_3_8, -1, 14, 0},
+    /*  9 */ {5, s_3_9, -1, 13, 0},
+    /* 10 */ {6, s_3_10, -1, 1, 0},
+    /* 11 */ {7, s_3_11, 10, 8, 0},
+    /* 12 */ {5, s_3_12, -1, 10, 0},
+    /* 13 */ {5, s_3_13, -1, 8, 0},
+    /* 14 */ {7, s_3_14, 13, 7, 0},
+    /* 15 */ {4, s_3_15, -1, 7, 0},
+    /* 16 */ {4, s_3_16, -1, 8, 0},
+    /* 17 */ {7, s_3_17, -1, 13, 0},
+    /* 18 */ {7, s_3_18, -1, 11, 0},
+    /* 19 */ {7, s_3_19, -1, 12, 0}};
+
+static const symbol s_4_0[5] = {'i', 'c', 'a', 't', 'e'};
+static const symbol s_4_1[5] = {'a', 't', 'i', 'v', 'e'};
+static const symbol s_4_2[5] = {'a', 'l', 'i', 'z', 'e'};
+static const symbol s_4_3[5] = {'i', 'c', 'i', 't', 'i'};
+static const symbol s_4_4[4] = {'i', 'c', 'a', 'l'};
+static const symbol s_4_5[3] = {'f', 'u', 'l'};
+static const symbol s_4_6[4] = {'n', 'e', 's', 's'};
+
+static const struct among a_4[7] = {
+    /*  0 */ {5, s_4_0, -1, 2, 0},
+    /*  1 */ {5, s_4_1, -1, 3, 0},
+    /*  2 */ {5, s_4_2, -1, 1, 0},
+    /*  3 */ {5, s_4_3, -1, 2, 0},
+    /*  4 */ {4, s_4_4, -1, 2, 0},
+    /*  5 */ {3, s_4_5, -1, 3, 0},
+    /*  6 */ {4, s_4_6, -1, 3, 0}};
+
+static const symbol s_5_0[2] = {'i', 'c'};
+static const symbol s_5_1[4] = {'a', 'n', 'c', 'e'};
+static const symbol s_5_2[4] = {'e', 'n', 'c', 'e'};
+static const symbol s_5_3[4] = {'a', 'b', 'l', 'e'};
+static const symbol s_5_4[4] = {'i', 'b', 'l', 'e'};
+static const symbol s_5_5[3] = {'a', 't', 'e'};
+static const symbol s_5_6[3] = {'i', 'v', 'e'};
+static const symbol s_5_7[3] = {'i', 'z', 'e'};
+static const symbol s_5_8[3] = {'i', 't', 'i'};
+static const symbol s_5_9[2] = {'a', 'l'};
+static const symbol s_5_10[3] = {'i', 's', 'm'};
+static const symbol s_5_11[3] = {'i', 'o', 'n'};
+static const symbol s_5_12[2] = {'e', 'r'};
+static const symbol s_5_13[3] = {'o', 'u', 's'};
+static const symbol s_5_14[3] = {'a', 'n', 't'};
+static const symbol s_5_15[3] = {'e', 'n', 't'};
+static const symbol s_5_16[4] = {'m', 'e', 'n', 't'};
+static const symbol s_5_17[5] = {'e', 'm', 'e', 'n', 't'};
+static const symbol s_5_18[2] = {'o', 'u'};
+
+static const struct among a_5[19] = {
+    /*  0 */ {2, s_5_0, -1, 1, 0},
+    /*  1 */ {4, s_5_1, -1, 1, 0},
+    /*  2 */ {4, s_5_2, -1, 1, 0},
+    /*  3 */ {4, s_5_3, -1, 1, 0},
+    /*  4 */ {4, s_5_4, -1, 1, 0},
+    /*  5 */ {3, s_5_5, -1, 1, 0},
+    /*  6 */ {3, s_5_6, -1, 1, 0},
+    /*  7 */ {3, s_5_7, -1, 1, 0},
+    /*  8 */ {3, s_5_8, -1, 1, 0},
+    /*  9 */ {2, s_5_9, -1, 1, 0},
+    /* 10 */ {3, s_5_10, -1, 1, 0},
+    /* 11 */ {3, s_5_11, -1, 2, 0},
+    /* 12 */ {2, s_5_12, -1, 1, 0},
+    /* 13 */ {3, s_5_13, -1, 1, 0},
+    /* 14 */ {3, s_5_14, -1, 1, 0},
+    /* 15 */ {3, s_5_15, -1, 1, 0},
+    /* 16 */ {4, s_5_16, 15, 1, 0},
+    /* 17 */ {5, s_5_17, 16, 1, 0},
+    /* 18 */ {2, s_5_18, -1, 1, 0}};
+
+static const unsigned char g_v[] = {17, 65, 16, 1};
+
+static const unsigned char g_v_WXY[] = {1, 17, 65, 208, 1};
+
+static const symbol s_0[] = {'s', 's'};
+static const symbol s_1[] = {'i'};
+static const symbol s_2[] = {'e', 'e'};
+static const symbol s_3[] = {'e'};
+static const symbol s_4[] = {'e'};
+static const symbol s_5[] = {'y'};
+static const symbol s_6[] = {'Y'};
+static const symbol s_7[] = {'i'};
+static const symbol s_8[] = {'t', 'i', 'o', 'n'};
+static const symbol s_9[] = {'e', 'n', 'c', 'e'};
+static const symbol s_10[] = {'a', 'n', 'c', 'e'};
+static const symbol s_11[] = {'a', 'b', 'l', 'e'};
+static const symbol s_12[] = {'e', 'n', 't'};
+static const symbol s_13[] = {'e'};
+static const symbol s_14[] = {'i', 'z', 'e'};
+static const symbol s_15[] = {'a', 't', 'e'};
+static const symbol s_16[] = {'a', 'l'};
+static const symbol s_17[] = {'a', 'l'};
+static const symbol s_18[] = {'f', 'u', 'l'};
+static const symbol s_19[] = {'o', 'u', 's'};
+static const symbol s_20[] = {'i', 'v', 'e'};
+static const symbol s_21[] = {'b', 'l', 'e'};
+static const symbol s_22[] = {'a', 'l'};
+static const symbol s_23[] = {'i', 'c'};
+static const symbol s_24[] = {'s'};
+static const symbol s_25[] = {'t'};
+static const symbol s_26[] = {'e'};
+static const symbol s_27[] = {'l'};
+static const symbol s_28[] = {'l'};
+static const symbol s_29[] = {'y'};
+static const symbol s_30[] = {'Y'};
+static const symbol s_31[] = {'y'};
+static const symbol s_32[] = {'Y'};
+static const symbol s_33[] = {'Y'};
+static const symbol s_34[] = {'y'};
+
+static int r_shortv(struct SN_env *z) {
+    if (out_grouping_b_U(z, g_v_WXY, 89, 121, 0))
+        return 0;
+    if (in_grouping_b_U(z, g_v, 97, 121, 0))
+        return 0;
+    if (out_grouping_b_U(z, g_v, 97, 121, 0))
+        return 0;
+    return 1;
+}
+
+static int r_R1(struct SN_env *z) {
+    if (!(z->I[0] <= z->c))
+        return 0;
+    return 1;
+}
+
+static int r_R2(struct SN_env *z) {
+    if (!(z->I[1] <= z->c))
+        return 0;
+    return 1;
+}
+
+static int r_Step_1a(struct SN_env *z) {
+    int among_var;
+    z->ket = z->c; /* [, line 25 */
+    if (z->c <= z->lb || z->p[z->c - 1] != 115)
+        return 0;
+    among_var = find_among_b(z, a_0, 4); /* substring, line 25 */
+    if (!(among_var))
+        return 0;
+    z->bra = z->c; /* ], line 25 */
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = slice_from_s(z, 2, s_0); /* <-, line 26 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 2: {
+            int ret = slice_from_s(z, 1, s_1); /* <-, line 27 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 3: {
+            int ret = slice_del(z); /* delete, line 29 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    return 1;
+}
+
+static int r_Step_1b(struct SN_env *z) {
+    int among_var;
+    z->ket = z->c; /* [, line 34 */
+    if (z->c - 1 <= z->lb || (z->p[z->c - 1] != 100 && z->p[z->c - 1] != 103))
+        return 0;
+    among_var = find_among_b(z, a_2, 3); /* substring, line 34 */
+    if (!(among_var))
+        return 0;
+    z->bra = z->c; /* ], line 34 */
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = r_R1(z);
+            if (ret == 0)
+                return 0; /* call R1, line 35 */
+            if (ret < 0)
+                return ret;
+        }
+            {
+                int ret = slice_from_s(z, 2, s_2); /* <-, line 35 */
+                if (ret < 0)
+                    return ret;
+            }
+            break;
+        case 2: {
+            int m_test = z->l - z->c; /* test, line 38 */
+            { /* gopast */            /* grouping v, line 38 */
+                int ret = out_grouping_b_U(z, g_v, 97, 121, 1);
+                if (ret < 0)
+                    return 0;
+                z->c -= ret;
+            }
+            z->c = z->l - m_test;
+        }
+            {
+                int ret = slice_del(z); /* delete, line 38 */
+                if (ret < 0)
+                    return ret;
+            }
+            {
+                int m_test = z->l - z->c; /* test, line 39 */
+                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
+                    among_var = find_among_b(z, a_1, 13); /* substring, line 39 */
+                if (!(among_var))
+                    return 0;
+                z->c = z->l - m_test;
+            }
+            switch (among_var) {
+                case 0:
+                    return 0;
+                case 1: {
+                    int c_keep = z->c;
+                    int ret = insert_s(z, z->c, z->c, 1, s_3); /* <+, line 41 */
+                    z->c = c_keep;
+                    if (ret < 0)
+                        return ret;
+                } break;
+                case 2:
+                    z->ket = z->c; /* [, line 44 */
+                    {
+                        int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
+                        if (ret < 0)
+                            return 0;
+                        z->c = ret; /* next, line 44 */
+                    }
+                    z->bra = z->c; /* ], line 44 */
+                    {
+                        int ret = slice_del(z); /* delete, line 44 */
+                        if (ret < 0)
+                            return ret;
+                    }
+                    break;
+                case 3:
+                    if (z->c != z->I[0])
+                        return 0; /* atmark, line 45 */
+                    {
+                        int m_test = z->l - z->c; /* test, line 45 */
+                        {
+                            int ret = r_shortv(z);
+                            if (ret == 0)
+                                return 0; /* call shortv, line 45 */
+                            if (ret < 0)
+                                return ret;
+                        }
+                        z->c = z->l - m_test;
+                    }
+                    {
+                        int c_keep = z->c;
+                        int ret = insert_s(z, z->c, z->c, 1, s_4); /* <+, line 45 */
+                        z->c = c_keep;
+                        if (ret < 0)
+                            return ret;
+                    }
+                    break;
+            }
+            break;
+    }
+    return 1;
+}
+
+static int r_Step_1c(struct SN_env *z) {
+    z->ket = z->c; /* [, line 52 */
+    {
+        int m1 = z->l - z->c;
+        (void)m1; /* or, line 52 */
+        if (!(eq_s_b(z, 1, s_5)))
+            goto lab1;
+        goto lab0;
+    lab1:
+        z->c = z->l - m1;
+        if (!(eq_s_b(z, 1, s_6)))
+            return 0;
+    }
+lab0:
+    z->bra = z->c; /* ], line 52 */
+    { /* gopast */ /* grouping v, line 53 */
+        int ret = out_grouping_b_U(z, g_v, 97, 121, 1);
+        if (ret < 0)
+            return 0;
+        z->c -= ret;
+    }
+    {
+        int ret = slice_from_s(z, 1, s_7); /* <-, line 54 */
+        if (ret < 0)
+            return ret;
+    }
+    return 1;
+}
+
+static int r_Step_2(struct SN_env *z) {
+    int among_var;
+    z->ket = z->c; /* [, line 58 */
+    if (z->c - 2 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((815616 >> (z->p[z->c - 1] & 0x1f)) & 1))
+        return 0;
+    among_var = find_among_b(z, a_3, 20); /* substring, line 58 */
+    if (!(among_var))
+        return 0;
+    z->bra = z->c; /* ], line 58 */
+    {
+        int ret = r_R1(z);
+        if (ret == 0)
+            return 0; /* call R1, line 58 */
+        if (ret < 0)
+            return ret;
+    }
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = slice_from_s(z, 4, s_8); /* <-, line 59 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 2: {
+            int ret = slice_from_s(z, 4, s_9); /* <-, line 60 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 3: {
+            int ret = slice_from_s(z, 4, s_10); /* <-, line 61 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 4: {
+            int ret = slice_from_s(z, 4, s_11); /* <-, line 62 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 5: {
+            int ret = slice_from_s(z, 3, s_12); /* <-, line 63 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 6: {
+            int ret = slice_from_s(z, 1, s_13); /* <-, line 64 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 7: {
+            int ret = slice_from_s(z, 3, s_14); /* <-, line 66 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 8: {
+            int ret = slice_from_s(z, 3, s_15); /* <-, line 68 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 9: {
+            int ret = slice_from_s(z, 2, s_16); /* <-, line 69 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 10: {
+            int ret = slice_from_s(z, 2, s_17); /* <-, line 71 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 11: {
+            int ret = slice_from_s(z, 3, s_18); /* <-, line 72 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 12: {
+            int ret = slice_from_s(z, 3, s_19); /* <-, line 74 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 13: {
+            int ret = slice_from_s(z, 3, s_20); /* <-, line 76 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 14: {
+            int ret = slice_from_s(z, 3, s_21); /* <-, line 77 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    return 1;
+}
+
+static int r_Step_3(struct SN_env *z) {
+    int among_var;
+    z->ket = z->c; /* [, line 82 */
+    if (z->c - 2 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((528928 >> (z->p[z->c - 1] & 0x1f)) & 1))
+        return 0;
+    among_var = find_among_b(z, a_4, 7); /* substring, line 82 */
+    if (!(among_var))
+        return 0;
+    z->bra = z->c; /* ], line 82 */
+    {
+        int ret = r_R1(z);
+        if (ret == 0)
+            return 0; /* call R1, line 82 */
+        if (ret < 0)
+            return ret;
+    }
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = slice_from_s(z, 2, s_22); /* <-, line 83 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 2: {
+            int ret = slice_from_s(z, 2, s_23); /* <-, line 85 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 3: {
+            int ret = slice_del(z); /* delete, line 87 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    return 1;
+}
+
+static int r_Step_4(struct SN_env *z) {
+    int among_var;
+    z->ket = z->c; /* [, line 92 */
+    if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((3961384 >> (z->p[z->c - 1] & 0x1f)) & 1))
+        return 0;
+    among_var = find_among_b(z, a_5, 19); /* substring, line 92 */
+    if (!(among_var))
+        return 0;
+    z->bra = z->c; /* ], line 92 */
+    {
+        int ret = r_R2(z);
+        if (ret == 0)
+            return 0; /* call R2, line 92 */
+        if (ret < 0)
+            return ret;
+    }
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = slice_del(z); /* delete, line 95 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 2: {
+            int m1 = z->l - z->c;
+            (void)m1; /* or, line 96 */
+            if (!(eq_s_b(z, 1, s_24)))
+                goto lab1;
+            goto lab0;
+        lab1:
+            z->c = z->l - m1;
+            if (!(eq_s_b(z, 1, s_25)))
+                return 0;
+        }
+        lab0: {
+            int ret = slice_del(z); /* delete, line 96 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    return 1;
+}
+
+static int r_Step_5a(struct SN_env *z) {
+    z->ket = z->c; /* [, line 101 */
+    if (!(eq_s_b(z, 1, s_26)))
+        return 0;
+    z->bra = z->c; /* ], line 101 */
+    {
+        int m1 = z->l - z->c;
+        (void)m1; /* or, line 102 */
+        {
+            int ret = r_R2(z);
+            if (ret == 0)
+                goto lab1; /* call R2, line 102 */
+            if (ret < 0)
+                return ret;
+        }
+        goto lab0;
+    lab1:
+        z->c = z->l - m1;
+        {
+            int ret = r_R1(z);
+            if (ret == 0)
+                return 0; /* call R1, line 102 */
+            if (ret < 0)
+                return ret;
+        }
+        {
+            int m2 = z->l - z->c;
+            (void)m2; /* not, line 102 */
+            {
+                int ret = r_shortv(z);
+                if (ret == 0)
+                    goto lab2; /* call shortv, line 102 */
+                if (ret < 0)
+                    return ret;
+            }
+            return 0;
+        lab2:
+            z->c = z->l - m2;
+        }
+    }
+lab0: {
+    int ret = slice_del(z); /* delete, line 103 */
+    if (ret < 0)
+        return ret;
+}
+    return 1;
+}
+
+static int r_Step_5b(struct SN_env *z) {
+    z->ket = z->c; /* [, line 107 */
+    if (!(eq_s_b(z, 1, s_27)))
+        return 0;
+    z->bra = z->c; /* ], line 107 */
+    {
+        int ret = r_R2(z);
+        if (ret == 0)
+            return 0; /* call R2, line 108 */
+        if (ret < 0)
+            return ret;
+    }
+    if (!(eq_s_b(z, 1, s_28)))
+        return 0;
+    {
+        int ret = slice_del(z); /* delete, line 109 */
+        if (ret < 0)
+            return ret;
+    }
+    return 1;
+}
+
+extern int porter_UTF_8_stem(struct SN_env *z) {
+    z->B[0] = 0; /* unset Y_found, line 115 */
+    {
+        int c1 = z->c; /* do, line 116 */
+        z->bra = z->c; /* [, line 116 */
+        if (!(eq_s(z, 1, s_29)))
+            goto lab0;
+        z->ket = z->c; /* ], line 116 */
+        {
+            int ret = slice_from_s(z, 1, s_30); /* <-, line 116 */
+            if (ret < 0)
+                return ret;
+        }
+        z->B[0] = 1; /* set Y_found, line 116 */
+    lab0:
+        z->c = c1;
+    }
+    {
+        int c2 = z->c; /* do, line 117 */
+        while (1) {    /* repeat, line 117 */
+            int c3 = z->c;
+            while (1) { /* goto, line 117 */
+                int c4 = z->c;
+                if (in_grouping_U(z, g_v, 97, 121, 0))
+                    goto lab3;
+                z->bra = z->c; /* [, line 117 */
+                if (!(eq_s(z, 1, s_31)))
+                    goto lab3;
+                z->ket = z->c; /* ], line 117 */
+                z->c = c4;
+                break;
+            lab3:
+                z->c = c4;
+                {
+                    int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
+                    if (ret < 0)
+                        goto lab2;
+                    z->c = ret; /* goto, line 117 */
+                }
+            }
+            {
+                int ret = slice_from_s(z, 1, s_32); /* <-, line 117 */
+                if (ret < 0)
+                    return ret;
+            }
+            z->B[0] = 1; /* set Y_found, line 117 */
+            continue;
+        lab2:
+            z->c = c3;
+            break;
+        }
+        z->c = c2;
+    }
+    z->I[0] = z->l;
+    z->I[1] = z->l;
+    {
+        int c5 = z->c; /* do, line 121 */
+        { /* gopast */ /* grouping v, line 122 */
+            int ret = out_grouping_U(z, g_v, 97, 121, 1);
+            if (ret < 0)
+                goto lab4;
+            z->c += ret;
+        }
+        { /* gopast */ /* non v, line 122 */
+            int ret = in_grouping_U(z, g_v, 97, 121, 1);
+            if (ret < 0)
+                goto lab4;
+            z->c += ret;
+        }
+        z->I[0] = z->c; /* setmark p1, line 122 */
+        { /* gopast */  /* grouping v, line 123 */
+            int ret = out_grouping_U(z, g_v, 97, 121, 1);
+            if (ret < 0)
+                goto lab4;
+            z->c += ret;
+        }
+        { /* gopast */ /* non v, line 123 */
+            int ret = in_grouping_U(z, g_v, 97, 121, 1);
+            if (ret < 0)
+                goto lab4;
+            z->c += ret;
+        }
+        z->I[1] = z->c; /* setmark p2, line 123 */
+    lab4:
+        z->c = c5;
+    }
+    z->lb = z->c;
+    z->c = z->l; /* backwards, line 126 */
+
+    {
+        int m6 = z->l - z->c;
+        (void)m6; /* do, line 127 */
+        {
+            int ret = r_Step_1a(z);
+            if (ret == 0)
+                goto lab5; /* call Step_1a, line 127 */
+            if (ret < 0)
+                return ret;
+        }
+    lab5:
+        z->c = z->l - m6;
+    }
+    {
+        int m7 = z->l - z->c;
+        (void)m7; /* do, line 128 */
+        {
+            int ret = r_Step_1b(z);
+            if (ret == 0)
+                goto lab6; /* call Step_1b, line 128 */
+            if (ret < 0)
+                return ret;
+        }
+    lab6:
+        z->c = z->l - m7;
+    }
+    {
+        int m8 = z->l - z->c;
+        (void)m8; /* do, line 129 */
+        {
+            int ret = r_Step_1c(z);
+            if (ret == 0)
+                goto lab7; /* call Step_1c, line 129 */
+            if (ret < 0)
+                return ret;
+        }
+    lab7:
+        z->c = z->l - m8;
+    }
+    {
+        int m9 = z->l - z->c;
+        (void)m9; /* do, line 130 */
+        {
+            int ret = r_Step_2(z);
+            if (ret == 0)
+                goto lab8; /* call Step_2, line 130 */
+            if (ret < 0)
+                return ret;
+        }
+    lab8:
+        z->c = z->l - m9;
+    }
+    {
+        int m10 = z->l - z->c;
+        (void)m10; /* do, line 131 */
+        {
+            int ret = r_Step_3(z);
+            if (ret == 0)
+                goto lab9; /* call Step_3, line 131 */
+            if (ret < 0)
+                return ret;
+        }
+    lab9:
+        z->c = z->l - m10;
+    }
+    {
+        int m11 = z->l - z->c;
+        (void)m11; /* do, line 132 */
+        {
+            int ret = r_Step_4(z);
+            if (ret == 0)
+                goto lab10; /* call Step_4, line 132 */
+            if (ret < 0)
+                return ret;
+        }
+    lab10:
+        z->c = z->l - m11;
+    }
+    {
+        int m12 = z->l - z->c;
+        (void)m12; /* do, line 133 */
+        {
+            int ret = r_Step_5a(z);
+            if (ret == 0)
+                goto lab11; /* call Step_5a, line 133 */
+            if (ret < 0)
+                return ret;
+        }
+    lab11:
+        z->c = z->l - m12;
+    }
+    {
+        int m13 = z->l - z->c;
+        (void)m13; /* do, line 134 */
+        {
+            int ret = r_Step_5b(z);
+            if (ret == 0)
+                goto lab12; /* call Step_5b, line 134 */
+            if (ret < 0)
+                return ret;
+        }
+    lab12:
+        z->c = z->l - m13;
+    }
+    z->c = z->lb;
+    {
+        int c14 = z->c; /* do, line 137 */
+        if (!(z->B[0]))
+            goto lab13; /* Boolean test Y_found, line 137 */
+        while (1) {     /* repeat, line 137 */
+            int c15 = z->c;
+            while (1) { /* goto, line 137 */
+                int c16 = z->c;
+                z->bra = z->c; /* [, line 137 */
+                if (!(eq_s(z, 1, s_33)))
+                    goto lab15;
+                z->ket = z->c; /* ], line 137 */
+                z->c = c16;
+                break;
+            lab15:
+                z->c = c16;
+                {
+                    int ret = skip_utf8(z->p, z->c, 0, z->l, 1);
+                    if (ret < 0)
+                        goto lab14;
+                    z->c = ret; /* goto, line 137 */
+                }
+            }
+            {
+                int ret = slice_from_s(z, 1, s_34); /* <-, line 137 */
+                if (ret < 0)
+                    return ret;
+            }
+            continue;
+        lab14:
+            z->c = c15;
+            break;
+        }
+    lab13:
+        z->c = c14;
+    }
+    return 1;
+}
+
+extern struct SN_env *porter_UTF_8_create_env(void) { return SN_create_env(0, 2, 1); }
+
+extern void porter_UTF_8_close_env(struct SN_env *z) { SN_close_env(z, 0); }

internal/binding/cpp/stemmer/stem_UTF_8_porter.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *porter_UTF_8_create_env(void);
+extern void porter_UTF_8_close_env(struct SN_env *z);
+
+extern int porter_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_portuguese.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *portuguese_UTF_8_create_env(void);
+extern void portuguese_UTF_8_close_env(struct SN_env *z);
+
+extern int portuguese_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_romanian.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *romanian_UTF_8_create_env(void);
+extern void romanian_UTF_8_close_env(struct SN_env *z);
+
+extern int romanian_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_russian.cpp

@@ -0,0 +1,774 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#include "header.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern int russian_UTF_8_stem(struct SN_env *z);
+#ifdef __cplusplus
+}
+#endif
+static int r_tidy_up(struct SN_env *z);
+static int r_derivational(struct SN_env *z);
+static int r_noun(struct SN_env *z);
+static int r_verb(struct SN_env *z);
+static int r_reflexive(struct SN_env *z);
+static int r_adjectival(struct SN_env *z);
+static int r_adjective(struct SN_env *z);
+static int r_perfective_gerund(struct SN_env *z);
+static int r_R2(struct SN_env *z);
+static int r_mark_regions(struct SN_env *z);
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *russian_UTF_8_create_env(void);
+extern void russian_UTF_8_close_env(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif
+static const symbol s_0_0[10] = {0xD0, 0xB2, 0xD1, 0x88, 0xD0, 0xB8, 0xD1, 0x81, 0xD1, 0x8C};
+static const symbol s_0_1[12] = {0xD1, 0x8B, 0xD0, 0xB2, 0xD1, 0x88, 0xD0, 0xB8, 0xD1, 0x81, 0xD1, 0x8C};
+static const symbol s_0_2[12] = {0xD0, 0xB8, 0xD0, 0xB2, 0xD1, 0x88, 0xD0, 0xB8, 0xD1, 0x81, 0xD1, 0x8C};
+static const symbol s_0_3[2] = {0xD0, 0xB2};
+static const symbol s_0_4[4] = {0xD1, 0x8B, 0xD0, 0xB2};
+static const symbol s_0_5[4] = {0xD0, 0xB8, 0xD0, 0xB2};
+static const symbol s_0_6[6] = {0xD0, 0xB2, 0xD1, 0x88, 0xD0, 0xB8};
+static const symbol s_0_7[8] = {0xD1, 0x8B, 0xD0, 0xB2, 0xD1, 0x88, 0xD0, 0xB8};
+static const symbol s_0_8[8] = {0xD0, 0xB8, 0xD0, 0xB2, 0xD1, 0x88, 0xD0, 0xB8};
+
+static const struct among a_0[9] = {
+    /*  0 */ {10, s_0_0, -1, 1, 0},
+    /*  1 */ {12, s_0_1, 0, 2, 0},
+    /*  2 */ {12, s_0_2, 0, 2, 0},
+    /*  3 */ {2, s_0_3, -1, 1, 0},
+    /*  4 */ {4, s_0_4, 3, 2, 0},
+    /*  5 */ {4, s_0_5, 3, 2, 0},
+    /*  6 */ {6, s_0_6, -1, 1, 0},
+    /*  7 */ {8, s_0_7, 6, 2, 0},
+    /*  8 */ {8, s_0_8, 6, 2, 0}};
+
+static const symbol s_1_0[6] = {0xD0, 0xB5, 0xD0, 0xBC, 0xD1, 0x83};
+static const symbol s_1_1[6] = {0xD0, 0xBE, 0xD0, 0xBC, 0xD1, 0x83};
+static const symbol s_1_2[4] = {0xD1, 0x8B, 0xD1, 0x85};
+static const symbol s_1_3[4] = {0xD0, 0xB8, 0xD1, 0x85};
+static const symbol s_1_4[4] = {0xD1, 0x83, 0xD1, 0x8E};
+static const symbol s_1_5[4] = {0xD1, 0x8E, 0xD1, 0x8E};
+static const symbol s_1_6[4] = {0xD0, 0xB5, 0xD1, 0x8E};
+static const symbol s_1_7[4] = {0xD0, 0xBE, 0xD1, 0x8E};
+static const symbol s_1_8[4] = {0xD1, 0x8F, 0xD1, 0x8F};
+static const symbol s_1_9[4] = {0xD0, 0xB0, 0xD1, 0x8F};
+static const symbol s_1_10[4] = {0xD1, 0x8B, 0xD0, 0xB5};
+static const symbol s_1_11[4] = {0xD0, 0xB5, 0xD0, 0xB5};
+static const symbol s_1_12[4] = {0xD0, 0xB8, 0xD0, 0xB5};
+static const symbol s_1_13[4] = {0xD0, 0xBE, 0xD0, 0xB5};
+static const symbol s_1_14[6] = {0xD1, 0x8B, 0xD0, 0xBC, 0xD0, 0xB8};
+static const symbol s_1_15[6] = {0xD0, 0xB8, 0xD0, 0xBC, 0xD0, 0xB8};
+static const symbol s_1_16[4] = {0xD1, 0x8B, 0xD0, 0xB9};
+static const symbol s_1_17[4] = {0xD0, 0xB5, 0xD0, 0xB9};
+static const symbol s_1_18[4] = {0xD0, 0xB8, 0xD0, 0xB9};
+static const symbol s_1_19[4] = {0xD0, 0xBE, 0xD0, 0xB9};
+static const symbol s_1_20[4] = {0xD1, 0x8B, 0xD0, 0xBC};
+static const symbol s_1_21[4] = {0xD0, 0xB5, 0xD0, 0xBC};
+static const symbol s_1_22[4] = {0xD0, 0xB8, 0xD0, 0xBC};
+static const symbol s_1_23[4] = {0xD0, 0xBE, 0xD0, 0xBC};
+static const symbol s_1_24[6] = {0xD0, 0xB5, 0xD0, 0xB3, 0xD0, 0xBE};
+static const symbol s_1_25[6] = {0xD0, 0xBE, 0xD0, 0xB3, 0xD0, 0xBE};
+
+static const struct among a_1[26] = {
+    /*  0 */ {6, s_1_0, -1, 1, 0},
+    /*  1 */ {6, s_1_1, -1, 1, 0},
+    /*  2 */ {4, s_1_2, -1, 1, 0},
+    /*  3 */ {4, s_1_3, -1, 1, 0},
+    /*  4 */ {4, s_1_4, -1, 1, 0},
+    /*  5 */ {4, s_1_5, -1, 1, 0},
+    /*  6 */ {4, s_1_6, -1, 1, 0},
+    /*  7 */ {4, s_1_7, -1, 1, 0},
+    /*  8 */ {4, s_1_8, -1, 1, 0},
+    /*  9 */ {4, s_1_9, -1, 1, 0},
+    /* 10 */ {4, s_1_10, -1, 1, 0},
+    /* 11 */ {4, s_1_11, -1, 1, 0},
+    /* 12 */ {4, s_1_12, -1, 1, 0},
+    /* 13 */ {4, s_1_13, -1, 1, 0},
+    /* 14 */ {6, s_1_14, -1, 1, 0},
+    /* 15 */ {6, s_1_15, -1, 1, 0},
+    /* 16 */ {4, s_1_16, -1, 1, 0},
+    /* 17 */ {4, s_1_17, -1, 1, 0},
+    /* 18 */ {4, s_1_18, -1, 1, 0},
+    /* 19 */ {4, s_1_19, -1, 1, 0},
+    /* 20 */ {4, s_1_20, -1, 1, 0},
+    /* 21 */ {4, s_1_21, -1, 1, 0},
+    /* 22 */ {4, s_1_22, -1, 1, 0},
+    /* 23 */ {4, s_1_23, -1, 1, 0},
+    /* 24 */ {6, s_1_24, -1, 1, 0},
+    /* 25 */ {6, s_1_25, -1, 1, 0}};
+
+static const symbol s_2_0[4] = {0xD0, 0xB2, 0xD1, 0x88};
+static const symbol s_2_1[6] = {0xD1, 0x8B, 0xD0, 0xB2, 0xD1, 0x88};
+static const symbol s_2_2[6] = {0xD0, 0xB8, 0xD0, 0xB2, 0xD1, 0x88};
+static const symbol s_2_3[2] = {0xD1, 0x89};
+static const symbol s_2_4[4] = {0xD1, 0x8E, 0xD1, 0x89};
+static const symbol s_2_5[6] = {0xD1, 0x83, 0xD1, 0x8E, 0xD1, 0x89};
+static const symbol s_2_6[4] = {0xD0, 0xB5, 0xD0, 0xBC};
+static const symbol s_2_7[4] = {0xD0, 0xBD, 0xD0, 0xBD};
+
+static const struct among a_2[8] = {
+    /*  0 */ {4, s_2_0, -1, 1, 0},
+    /*  1 */ {6, s_2_1, 0, 2, 0},
+    /*  2 */ {6, s_2_2, 0, 2, 0},
+    /*  3 */ {2, s_2_3, -1, 1, 0},
+    /*  4 */ {4, s_2_4, 3, 1, 0},
+    /*  5 */ {6, s_2_5, 4, 2, 0},
+    /*  6 */ {4, s_2_6, -1, 1, 0},
+    /*  7 */ {4, s_2_7, -1, 1, 0}};
+
+static const symbol s_3_0[4] = {0xD1, 0x81, 0xD1, 0x8C};
+static const symbol s_3_1[4] = {0xD1, 0x81, 0xD1, 0x8F};
+
+static const struct among a_3[2] = {
+    /*  0 */ {4, s_3_0, -1, 1, 0},
+    /*  1 */ {4, s_3_1, -1, 1, 0}};
+
+static const symbol s_4_0[4] = {0xD1, 0x8B, 0xD1, 0x82};
+static const symbol s_4_1[4] = {0xD1, 0x8E, 0xD1, 0x82};
+static const symbol s_4_2[6] = {0xD1, 0x83, 0xD1, 0x8E, 0xD1, 0x82};
+static const symbol s_4_3[4] = {0xD1, 0x8F, 0xD1, 0x82};
+static const symbol s_4_4[4] = {0xD0, 0xB5, 0xD1, 0x82};
+static const symbol s_4_5[6] = {0xD1, 0x83, 0xD0, 0xB5, 0xD1, 0x82};
+static const symbol s_4_6[4] = {0xD0, 0xB8, 0xD1, 0x82};
+static const symbol s_4_7[4] = {0xD0, 0xBD, 0xD1, 0x8B};
+static const symbol s_4_8[6] = {0xD0, 0xB5, 0xD0, 0xBD, 0xD1, 0x8B};
+static const symbol s_4_9[4] = {0xD1, 0x82, 0xD1, 0x8C};
+static const symbol s_4_10[6] = {0xD1, 0x8B, 0xD1, 0x82, 0xD1, 0x8C};
+static const symbol s_4_11[6] = {0xD0, 0xB8, 0xD1, 0x82, 0xD1, 0x8C};
+static const symbol s_4_12[6] = {0xD0, 0xB5, 0xD1, 0x88, 0xD1, 0x8C};
+static const symbol s_4_13[6] = {0xD0, 0xB8, 0xD1, 0x88, 0xD1, 0x8C};
+static const symbol s_4_14[2] = {0xD1, 0x8E};
+static const symbol s_4_15[4] = {0xD1, 0x83, 0xD1, 0x8E};
+static const symbol s_4_16[4] = {0xD0, 0xBB, 0xD0, 0xB0};
+static const symbol s_4_17[6] = {0xD1, 0x8B, 0xD0, 0xBB, 0xD0, 0xB0};
+static const symbol s_4_18[6] = {0xD0, 0xB8, 0xD0, 0xBB, 0xD0, 0xB0};
+static const symbol s_4_19[4] = {0xD0, 0xBD, 0xD0, 0xB0};
+static const symbol s_4_20[6] = {0xD0, 0xB5, 0xD0, 0xBD, 0xD0, 0xB0};
+static const symbol s_4_21[6] = {0xD0, 0xB5, 0xD1, 0x82, 0xD0, 0xB5};
+static const symbol s_4_22[6] = {0xD0, 0xB8, 0xD1, 0x82, 0xD0, 0xB5};
+static const symbol s_4_23[6] = {0xD0, 0xB9, 0xD1, 0x82, 0xD0, 0xB5};
+static const symbol s_4_24[8] = {0xD1, 0x83, 0xD0, 0xB9, 0xD1, 0x82, 0xD0, 0xB5};
+static const symbol s_4_25[8] = {0xD0, 0xB5, 0xD0, 0xB9, 0xD1, 0x82, 0xD0, 0xB5};
+static const symbol s_4_26[4] = {0xD0, 0xBB, 0xD0, 0xB8};
+static const symbol s_4_27[6] = {0xD1, 0x8B, 0xD0, 0xBB, 0xD0, 0xB8};
+static const symbol s_4_28[6] = {0xD0, 0xB8, 0xD0, 0xBB, 0xD0, 0xB8};
+static const symbol s_4_29[2] = {0xD0, 0xB9};
+static const symbol s_4_30[4] = {0xD1, 0x83, 0xD0, 0xB9};
+static const symbol s_4_31[4] = {0xD0, 0xB5, 0xD0, 0xB9};
+static const symbol s_4_32[2] = {0xD0, 0xBB};
+static const symbol s_4_33[4] = {0xD1, 0x8B, 0xD0, 0xBB};
+static const symbol s_4_34[4] = {0xD0, 0xB8, 0xD0, 0xBB};
+static const symbol s_4_35[4] = {0xD1, 0x8B, 0xD0, 0xBC};
+static const symbol s_4_36[4] = {0xD0, 0xB5, 0xD0, 0xBC};
+static const symbol s_4_37[4] = {0xD0, 0xB8, 0xD0, 0xBC};
+static const symbol s_4_38[2] = {0xD0, 0xBD};
+static const symbol s_4_39[4] = {0xD0, 0xB5, 0xD0, 0xBD};
+static const symbol s_4_40[4] = {0xD0, 0xBB, 0xD0, 0xBE};
+static const symbol s_4_41[6] = {0xD1, 0x8B, 0xD0, 0xBB, 0xD0, 0xBE};
+static const symbol s_4_42[6] = {0xD0, 0xB8, 0xD0, 0xBB, 0xD0, 0xBE};
+static const symbol s_4_43[4] = {0xD0, 0xBD, 0xD0, 0xBE};
+static const symbol s_4_44[6] = {0xD0, 0xB5, 0xD0, 0xBD, 0xD0, 0xBE};
+static const symbol s_4_45[6] = {0xD0, 0xBD, 0xD0, 0xBD, 0xD0, 0xBE};
+
+static const struct among a_4[46] = {
+    /*  0 */ {4, s_4_0, -1, 2, 0},
+    /*  1 */ {4, s_4_1, -1, 1, 0},
+    /*  2 */ {6, s_4_2, 1, 2, 0},
+    /*  3 */ {4, s_4_3, -1, 2, 0},
+    /*  4 */ {4, s_4_4, -1, 1, 0},
+    /*  5 */ {6, s_4_5, 4, 2, 0},
+    /*  6 */ {4, s_4_6, -1, 2, 0},
+    /*  7 */ {4, s_4_7, -1, 1, 0},
+    /*  8 */ {6, s_4_8, 7, 2, 0},
+    /*  9 */ {4, s_4_9, -1, 1, 0},
+    /* 10 */ {6, s_4_10, 9, 2, 0},
+    /* 11 */ {6, s_4_11, 9, 2, 0},
+    /* 12 */ {6, s_4_12, -1, 1, 0},
+    /* 13 */ {6, s_4_13, -1, 2, 0},
+    /* 14 */ {2, s_4_14, -1, 2, 0},
+    /* 15 */ {4, s_4_15, 14, 2, 0},
+    /* 16 */ {4, s_4_16, -1, 1, 0},
+    /* 17 */ {6, s_4_17, 16, 2, 0},
+    /* 18 */ {6, s_4_18, 16, 2, 0},
+    /* 19 */ {4, s_4_19, -1, 1, 0},
+    /* 20 */ {6, s_4_20, 19, 2, 0},
+    /* 21 */ {6, s_4_21, -1, 1, 0},
+    /* 22 */ {6, s_4_22, -1, 2, 0},
+    /* 23 */ {6, s_4_23, -1, 1, 0},
+    /* 24 */ {8, s_4_24, 23, 2, 0},
+    /* 25 */ {8, s_4_25, 23, 2, 0},
+    /* 26 */ {4, s_4_26, -1, 1, 0},
+    /* 27 */ {6, s_4_27, 26, 2, 0},
+    /* 28 */ {6, s_4_28, 26, 2, 0},
+    /* 29 */ {2, s_4_29, -1, 1, 0},
+    /* 30 */ {4, s_4_30, 29, 2, 0},
+    /* 31 */ {4, s_4_31, 29, 2, 0},
+    /* 32 */ {2, s_4_32, -1, 1, 0},
+    /* 33 */ {4, s_4_33, 32, 2, 0},
+    /* 34 */ {4, s_4_34, 32, 2, 0},
+    /* 35 */ {4, s_4_35, -1, 2, 0},
+    /* 36 */ {4, s_4_36, -1, 1, 0},
+    /* 37 */ {4, s_4_37, -1, 2, 0},
+    /* 38 */ {2, s_4_38, -1, 1, 0},
+    /* 39 */ {4, s_4_39, 38, 2, 0},
+    /* 40 */ {4, s_4_40, -1, 1, 0},
+    /* 41 */ {6, s_4_41, 40, 2, 0},
+    /* 42 */ {6, s_4_42, 40, 2, 0},
+    /* 43 */ {4, s_4_43, -1, 1, 0},
+    /* 44 */ {6, s_4_44, 43, 2, 0},
+    /* 45 */ {6, s_4_45, 43, 1, 0}};
+
+static const symbol s_5_0[2] = {0xD1, 0x83};
+static const symbol s_5_1[4] = {0xD1, 0x8F, 0xD1, 0x85};
+static const symbol s_5_2[6] = {0xD0, 0xB8, 0xD1, 0x8F, 0xD1, 0x85};
+static const symbol s_5_3[4] = {0xD0, 0xB0, 0xD1, 0x85};
+static const symbol s_5_4[2] = {0xD1, 0x8B};
+static const symbol s_5_5[2] = {0xD1, 0x8C};
+static const symbol s_5_6[2] = {0xD1, 0x8E};
+static const symbol s_5_7[4] = {0xD1, 0x8C, 0xD1, 0x8E};
+static const symbol s_5_8[4] = {0xD0, 0xB8, 0xD1, 0x8E};
+static const symbol s_5_9[2] = {0xD1, 0x8F};
+static const symbol s_5_10[4] = {0xD1, 0x8C, 0xD1, 0x8F};
+static const symbol s_5_11[4] = {0xD0, 0xB8, 0xD1, 0x8F};
+static const symbol s_5_12[2] = {0xD0, 0xB0};
+static const symbol s_5_13[4] = {0xD0, 0xB5, 0xD0, 0xB2};
+static const symbol s_5_14[4] = {0xD0, 0xBE, 0xD0, 0xB2};
+static const symbol s_5_15[2] = {0xD0, 0xB5};
+static const symbol s_5_16[4] = {0xD1, 0x8C, 0xD0, 0xB5};
+static const symbol s_5_17[4] = {0xD0, 0xB8, 0xD0, 0xB5};
+static const symbol s_5_18[2] = {0xD0, 0xB8};
+static const symbol s_5_19[4] = {0xD0, 0xB5, 0xD0, 0xB8};
+static const symbol s_5_20[4] = {0xD0, 0xB8, 0xD0, 0xB8};
+static const symbol s_5_21[6] = {0xD1, 0x8F, 0xD0, 0xBC, 0xD0, 0xB8};
+static const symbol s_5_22[8] = {0xD0, 0xB8, 0xD1, 0x8F, 0xD0, 0xBC, 0xD0, 0xB8};
+static const symbol s_5_23[6] = {0xD0, 0xB0, 0xD0, 0xBC, 0xD0, 0xB8};
+static const symbol s_5_24[2] = {0xD0, 0xB9};
+static const symbol s_5_25[4] = {0xD0, 0xB5, 0xD0, 0xB9};
+static const symbol s_5_26[6] = {0xD0, 0xB8, 0xD0, 0xB5, 0xD0, 0xB9};
+static const symbol s_5_27[4] = {0xD0, 0xB8, 0xD0, 0xB9};
+static const symbol s_5_28[4] = {0xD0, 0xBE, 0xD0, 0xB9};
+static const symbol s_5_29[4] = {0xD1, 0x8F, 0xD0, 0xBC};
+static const symbol s_5_30[6] = {0xD0, 0xB8, 0xD1, 0x8F, 0xD0, 0xBC};
+static const symbol s_5_31[4] = {0xD0, 0xB0, 0xD0, 0xBC};
+static const symbol s_5_32[4] = {0xD0, 0xB5, 0xD0, 0xBC};
+static const symbol s_5_33[6] = {0xD0, 0xB8, 0xD0, 0xB5, 0xD0, 0xBC};
+static const symbol s_5_34[4] = {0xD0, 0xBE, 0xD0, 0xBC};
+static const symbol s_5_35[2] = {0xD0, 0xBE};
+
+static const struct among a_5[36] = {
+    /*  0 */ {2, s_5_0, -1, 1, 0},
+    /*  1 */ {4, s_5_1, -1, 1, 0},
+    /*  2 */ {6, s_5_2, 1, 1, 0},
+    /*  3 */ {4, s_5_3, -1, 1, 0},
+    /*  4 */ {2, s_5_4, -1, 1, 0},
+    /*  5 */ {2, s_5_5, -1, 1, 0},
+    /*  6 */ {2, s_5_6, -1, 1, 0},
+    /*  7 */ {4, s_5_7, 6, 1, 0},
+    /*  8 */ {4, s_5_8, 6, 1, 0},
+    /*  9 */ {2, s_5_9, -1, 1, 0},
+    /* 10 */ {4, s_5_10, 9, 1, 0},
+    /* 11 */ {4, s_5_11, 9, 1, 0},
+    /* 12 */ {2, s_5_12, -1, 1, 0},
+    /* 13 */ {4, s_5_13, -1, 1, 0},
+    /* 14 */ {4, s_5_14, -1, 1, 0},
+    /* 15 */ {2, s_5_15, -1, 1, 0},
+    /* 16 */ {4, s_5_16, 15, 1, 0},
+    /* 17 */ {4, s_5_17, 15, 1, 0},
+    /* 18 */ {2, s_5_18, -1, 1, 0},
+    /* 19 */ {4, s_5_19, 18, 1, 0},
+    /* 20 */ {4, s_5_20, 18, 1, 0},
+    /* 21 */ {6, s_5_21, 18, 1, 0},
+    /* 22 */ {8, s_5_22, 21, 1, 0},
+    /* 23 */ {6, s_5_23, 18, 1, 0},
+    /* 24 */ {2, s_5_24, -1, 1, 0},
+    /* 25 */ {4, s_5_25, 24, 1, 0},
+    /* 26 */ {6, s_5_26, 25, 1, 0},
+    /* 27 */ {4, s_5_27, 24, 1, 0},
+    /* 28 */ {4, s_5_28, 24, 1, 0},
+    /* 29 */ {4, s_5_29, -1, 1, 0},
+    /* 30 */ {6, s_5_30, 29, 1, 0},
+    /* 31 */ {4, s_5_31, -1, 1, 0},
+    /* 32 */ {4, s_5_32, -1, 1, 0},
+    /* 33 */ {6, s_5_33, 32, 1, 0},
+    /* 34 */ {4, s_5_34, -1, 1, 0},
+    /* 35 */ {2, s_5_35, -1, 1, 0}};
+
+static const symbol s_6_0[6] = {0xD0, 0xBE, 0xD1, 0x81, 0xD1, 0x82};
+static const symbol s_6_1[8] = {0xD0, 0xBE, 0xD1, 0x81, 0xD1, 0x82, 0xD1, 0x8C};
+
+static const struct among a_6[2] = {
+    /*  0 */ {6, s_6_0, -1, 1, 0},
+    /*  1 */ {8, s_6_1, -1, 1, 0}};
+
+static const symbol s_7_0[6] = {0xD0, 0xB5, 0xD0, 0xB9, 0xD1, 0x88};
+static const symbol s_7_1[2] = {0xD1, 0x8C};
+static const symbol s_7_2[8] = {0xD0, 0xB5, 0xD0, 0xB9, 0xD1, 0x88, 0xD0, 0xB5};
+static const symbol s_7_3[2] = {0xD0, 0xBD};
+
+static const struct among a_7[4] = {
+    /*  0 */ {6, s_7_0, -1, 1, 0},
+    /*  1 */ {2, s_7_1, -1, 3, 0},
+    /*  2 */ {8, s_7_2, -1, 1, 0},
+    /*  3 */ {2, s_7_3, -1, 2, 0}};
+
+static const unsigned char g_v[] = {33, 65, 8, 232};
+
+static const symbol s_0[] = {0xD0, 0xB0};
+static const symbol s_1[] = {0xD1, 0x8F};
+static const symbol s_2[] = {0xD0, 0xB0};
+static const symbol s_3[] = {0xD1, 0x8F};
+static const symbol s_4[] = {0xD0, 0xB0};
+static const symbol s_5[] = {0xD1, 0x8F};
+static const symbol s_6[] = {0xD0, 0xBD};
+static const symbol s_7[] = {0xD0, 0xBD};
+static const symbol s_8[] = {0xD0, 0xBD};
+static const symbol s_9[] = {0xD0, 0xB8};
+
+static int r_mark_regions(struct SN_env *z) {
+    z->I[0] = z->l;
+    z->I[1] = z->l;
+    {
+        int c1 = z->c; /* do, line 61 */
+        { /* gopast */ /* grouping v, line 62 */
+            int ret = out_grouping_U(z, g_v, 1072, 1103, 1);
+            if (ret < 0)
+                goto lab0;
+            z->c += ret;
+        }
+        z->I[0] = z->c; /* setmark pV, line 62 */
+        { /* gopast */  /* non v, line 62 */
+            int ret = in_grouping_U(z, g_v, 1072, 1103, 1);
+            if (ret < 0)
+                goto lab0;
+            z->c += ret;
+        }
+        { /* gopast */ /* grouping v, line 63 */
+            int ret = out_grouping_U(z, g_v, 1072, 1103, 1);
+            if (ret < 0)
+                goto lab0;
+            z->c += ret;
+        }
+        { /* gopast */ /* non v, line 63 */
+            int ret = in_grouping_U(z, g_v, 1072, 1103, 1);
+            if (ret < 0)
+                goto lab0;
+            z->c += ret;
+        }
+        z->I[1] = z->c; /* setmark p2, line 63 */
+    lab0:
+        z->c = c1;
+    }
+    return 1;
+}
+
+static int r_R2(struct SN_env *z) {
+    if (!(z->I[1] <= z->c))
+        return 0;
+    return 1;
+}
+
+static int r_perfective_gerund(struct SN_env *z) {
+    int among_var;
+    z->ket = z->c;                       /* [, line 72 */
+    among_var = find_among_b(z, a_0, 9); /* substring, line 72 */
+    if (!(among_var))
+        return 0;
+    z->bra = z->c; /* ], line 72 */
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int m1 = z->l - z->c;
+            (void)m1; /* or, line 76 */
+            if (!(eq_s_b(z, 2, s_0)))
+                goto lab1;
+            goto lab0;
+        lab1:
+            z->c = z->l - m1;
+            if (!(eq_s_b(z, 2, s_1)))
+                return 0;
+        }
+        lab0: {
+            int ret = slice_del(z); /* delete, line 76 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 2: {
+            int ret = slice_del(z); /* delete, line 83 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    return 1;
+}
+
+static int r_adjective(struct SN_env *z) {
+    int among_var;
+    z->ket = z->c;                        /* [, line 88 */
+    among_var = find_among_b(z, a_1, 26); /* substring, line 88 */
+    if (!(among_var))
+        return 0;
+    z->bra = z->c; /* ], line 88 */
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = slice_del(z); /* delete, line 97 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    return 1;
+}
+
+static int r_adjectival(struct SN_env *z) {
+    int among_var;
+    {
+        int ret = r_adjective(z);
+        if (ret == 0)
+            return 0; /* call adjective, line 102 */
+        if (ret < 0)
+            return ret;
+    }
+    {
+        int m_keep = z->l - z->c; /* (void) m_keep;*/ /* try, line 109 */
+        z->ket = z->c;                                /* [, line 110 */
+        among_var = find_among_b(z, a_2, 8);          /* substring, line 110 */
+        if (!(among_var)) {
+            z->c = z->l - m_keep;
+            goto lab0;
+        }
+        z->bra = z->c; /* ], line 110 */
+        switch (among_var) {
+            case 0: {
+                z->c = z->l - m_keep;
+                goto lab0;
+            }
+            case 1: {
+                int m1 = z->l - z->c;
+                (void)m1; /* or, line 115 */
+                if (!(eq_s_b(z, 2, s_2)))
+                    goto lab2;
+                goto lab1;
+            lab2:
+                z->c = z->l - m1;
+                if (!(eq_s_b(z, 2, s_3))) {
+                    z->c = z->l - m_keep;
+                    goto lab0;
+                }
+            }
+            lab1: {
+                int ret = slice_del(z); /* delete, line 115 */
+                if (ret < 0)
+                    return ret;
+            } break;
+            case 2: {
+                int ret = slice_del(z); /* delete, line 122 */
+                if (ret < 0)
+                    return ret;
+            } break;
+        }
+    lab0:;
+    }
+    return 1;
+}
+
+static int r_reflexive(struct SN_env *z) {
+    int among_var;
+    z->ket = z->c; /* [, line 129 */
+    if (z->c - 3 <= z->lb || (z->p[z->c - 1] != 140 && z->p[z->c - 1] != 143))
+        return 0;
+    among_var = find_among_b(z, a_3, 2); /* substring, line 129 */
+    if (!(among_var))
+        return 0;
+    z->bra = z->c; /* ], line 129 */
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = slice_del(z); /* delete, line 132 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    return 1;
+}
+
+static int r_verb(struct SN_env *z) {
+    int among_var;
+    z->ket = z->c;                        /* [, line 137 */
+    among_var = find_among_b(z, a_4, 46); /* substring, line 137 */
+    if (!(among_var))
+        return 0;
+    z->bra = z->c; /* ], line 137 */
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int m1 = z->l - z->c;
+            (void)m1; /* or, line 143 */
+            if (!(eq_s_b(z, 2, s_4)))
+                goto lab1;
+            goto lab0;
+        lab1:
+            z->c = z->l - m1;
+            if (!(eq_s_b(z, 2, s_5)))
+                return 0;
+        }
+        lab0: {
+            int ret = slice_del(z); /* delete, line 143 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 2: {
+            int ret = slice_del(z); /* delete, line 151 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    return 1;
+}
+
+static int r_noun(struct SN_env *z) {
+    int among_var;
+    z->ket = z->c;                        /* [, line 160 */
+    among_var = find_among_b(z, a_5, 36); /* substring, line 160 */
+    if (!(among_var))
+        return 0;
+    z->bra = z->c; /* ], line 160 */
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = slice_del(z); /* delete, line 167 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    return 1;
+}
+
+static int r_derivational(struct SN_env *z) {
+    int among_var;
+    z->ket = z->c; /* [, line 176 */
+    if (z->c - 5 <= z->lb || (z->p[z->c - 1] != 130 && z->p[z->c - 1] != 140))
+        return 0;
+    among_var = find_among_b(z, a_6, 2); /* substring, line 176 */
+    if (!(among_var))
+        return 0;
+    z->bra = z->c; /* ], line 176 */
+    {
+        int ret = r_R2(z);
+        if (ret == 0)
+            return 0; /* call R2, line 176 */
+        if (ret < 0)
+            return ret;
+    }
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = slice_del(z); /* delete, line 179 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    return 1;
+}
+
+static int r_tidy_up(struct SN_env *z) {
+    int among_var;
+    z->ket = z->c;                       /* [, line 184 */
+    among_var = find_among_b(z, a_7, 4); /* substring, line 184 */
+    if (!(among_var))
+        return 0;
+    z->bra = z->c; /* ], line 184 */
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = slice_del(z); /* delete, line 188 */
+            if (ret < 0)
+                return ret;
+        }
+            z->ket = z->c; /* [, line 189 */
+            if (!(eq_s_b(z, 2, s_6)))
+                return 0;
+            z->bra = z->c; /* ], line 189 */
+            if (!(eq_s_b(z, 2, s_7)))
+                return 0;
+            {
+                int ret = slice_del(z); /* delete, line 189 */
+                if (ret < 0)
+                    return ret;
+            }
+            break;
+        case 2:
+            if (!(eq_s_b(z, 2, s_8)))
+                return 0;
+            {
+                int ret = slice_del(z); /* delete, line 192 */
+                if (ret < 0)
+                    return ret;
+            }
+            break;
+        case 3: {
+            int ret = slice_del(z); /* delete, line 194 */
+            if (ret < 0)
+                return ret;
+        } break;
+    }
+    return 1;
+}
+
+extern int russian_UTF_8_stem(struct SN_env *z) {
+    {
+        int c1 = z->c; /* do, line 201 */
+        {
+            int ret = r_mark_regions(z);
+            if (ret == 0)
+                goto lab0; /* call mark_regions, line 201 */
+            if (ret < 0)
+                return ret;
+        }
+    lab0:
+        z->c = c1;
+    }
+    z->lb = z->c;
+    z->c = z->l; /* backwards, line 202 */
+
+    {
+        int mlimit; /* setlimit, line 202 */
+        int m2 = z->l - z->c;
+        (void)m2;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 202 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m2;
+        {
+            int m3 = z->l - z->c;
+            (void)m3; /* do, line 203 */
+            {
+                int m4 = z->l - z->c;
+                (void)m4; /* or, line 204 */
+                {
+                    int ret = r_perfective_gerund(z);
+                    if (ret == 0)
+                        goto lab3; /* call perfective_gerund, line 204 */
+                    if (ret < 0)
+                        return ret;
+                }
+                goto lab2;
+            lab3:
+                z->c = z->l - m4;
+                {
+                    int m_keep = z->l - z->c; /* (void) m_keep;*/ /* try, line 205 */
+                    {
+                        int ret = r_reflexive(z);
+                        if (ret == 0) {
+                            z->c = z->l - m_keep;
+                            goto lab4;
+                        } /* call reflexive, line 205 */
+                        if (ret < 0)
+                            return ret;
+                    }
+                lab4:;
+                }
+                {
+                    int m5 = z->l - z->c;
+                    (void)m5; /* or, line 206 */
+                    {
+                        int ret = r_adjectival(z);
+                        if (ret == 0)
+                            goto lab6; /* call adjectival, line 206 */
+                        if (ret < 0)
+                            return ret;
+                    }
+                    goto lab5;
+                lab6:
+                    z->c = z->l - m5;
+                    {
+                        int ret = r_verb(z);
+                        if (ret == 0)
+                            goto lab7; /* call verb, line 206 */
+                        if (ret < 0)
+                            return ret;
+                    }
+                    goto lab5;
+                lab7:
+                    z->c = z->l - m5;
+                    {
+                        int ret = r_noun(z);
+                        if (ret == 0)
+                            goto lab1; /* call noun, line 206 */
+                        if (ret < 0)
+                            return ret;
+                    }
+                }
+            lab5:;
+            }
+        lab2:
+        lab1:
+            z->c = z->l - m3;
+        }
+        {
+            int m_keep = z->l - z->c; /* (void) m_keep;*/ /* try, line 209 */
+            z->ket = z->c;                                /* [, line 209 */
+            if (!(eq_s_b(z, 2, s_9))) {
+                z->c = z->l - m_keep;
+                goto lab8;
+            }
+            z->bra = z->c; /* ], line 209 */
+            {
+                int ret = slice_del(z); /* delete, line 209 */
+                if (ret < 0)
+                    return ret;
+            }
+        lab8:;
+        }
+        {
+            int m6 = z->l - z->c;
+            (void)m6; /* do, line 212 */
+            {
+                int ret = r_derivational(z);
+                if (ret == 0)
+                    goto lab9; /* call derivational, line 212 */
+                if (ret < 0)
+                    return ret;
+            }
+        lab9:
+            z->c = z->l - m6;
+        }
+        {
+            int m7 = z->l - z->c;
+            (void)m7; /* do, line 213 */
+            {
+                int ret = r_tidy_up(z);
+                if (ret == 0)
+                    goto lab10; /* call tidy_up, line 213 */
+                if (ret < 0)
+                    return ret;
+            }
+        lab10:
+            z->c = z->l - m7;
+        }
+        z->lb = mlimit;
+    }
+    z->c = z->lb;
+    return 1;
+}
+
+extern struct SN_env *russian_UTF_8_create_env(void) { return SN_create_env(0, 2, 0); }
+
+extern void russian_UTF_8_close_env(struct SN_env *z) { SN_close_env(z, 0); }

internal/binding/cpp/stemmer/stem_UTF_8_russian.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *russian_UTF_8_create_env(void);
+extern void russian_UTF_8_close_env(struct SN_env *z);
+
+extern int russian_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_spanish.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *spanish_UTF_8_create_env(void);
+extern void spanish_UTF_8_close_env(struct SN_env *z);
+
+extern int spanish_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_swedish.cpp

@@ -0,0 +1,371 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#include "header.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern int swedish_UTF_8_stem(struct SN_env *z);
+#ifdef __cplusplus
+}
+#endif
+static int r_other_suffix(struct SN_env *z);
+static int r_consonant_pair(struct SN_env *z);
+static int r_main_suffix(struct SN_env *z);
+static int r_mark_regions(struct SN_env *z);
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *swedish_UTF_8_create_env(void);
+extern void swedish_UTF_8_close_env(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif
+static const symbol s_0_0[1] = {'a'};
+static const symbol s_0_1[4] = {'a', 'r', 'n', 'a'};
+static const symbol s_0_2[4] = {'e', 'r', 'n', 'a'};
+static const symbol s_0_3[7] = {'h', 'e', 't', 'e', 'r', 'n', 'a'};
+static const symbol s_0_4[4] = {'o', 'r', 'n', 'a'};
+static const symbol s_0_5[2] = {'a', 'd'};
+static const symbol s_0_6[1] = {'e'};
+static const symbol s_0_7[3] = {'a', 'd', 'e'};
+static const symbol s_0_8[4] = {'a', 'n', 'd', 'e'};
+static const symbol s_0_9[4] = {'a', 'r', 'n', 'e'};
+static const symbol s_0_10[3] = {'a', 'r', 'e'};
+static const symbol s_0_11[4] = {'a', 's', 't', 'e'};
+static const symbol s_0_12[2] = {'e', 'n'};
+static const symbol s_0_13[5] = {'a', 'n', 'd', 'e', 'n'};
+static const symbol s_0_14[4] = {'a', 'r', 'e', 'n'};
+static const symbol s_0_15[5] = {'h', 'e', 't', 'e', 'n'};
+static const symbol s_0_16[3] = {'e', 'r', 'n'};
+static const symbol s_0_17[2] = {'a', 'r'};
+static const symbol s_0_18[2] = {'e', 'r'};
+static const symbol s_0_19[5] = {'h', 'e', 't', 'e', 'r'};
+static const symbol s_0_20[2] = {'o', 'r'};
+static const symbol s_0_21[1] = {'s'};
+static const symbol s_0_22[2] = {'a', 's'};
+static const symbol s_0_23[5] = {'a', 'r', 'n', 'a', 's'};
+static const symbol s_0_24[5] = {'e', 'r', 'n', 'a', 's'};
+static const symbol s_0_25[5] = {'o', 'r', 'n', 'a', 's'};
+static const symbol s_0_26[2] = {'e', 's'};
+static const symbol s_0_27[4] = {'a', 'd', 'e', 's'};
+static const symbol s_0_28[5] = {'a', 'n', 'd', 'e', 's'};
+static const symbol s_0_29[3] = {'e', 'n', 's'};
+static const symbol s_0_30[5] = {'a', 'r', 'e', 'n', 's'};
+static const symbol s_0_31[6] = {'h', 'e', 't', 'e', 'n', 's'};
+static const symbol s_0_32[4] = {'e', 'r', 'n', 's'};
+static const symbol s_0_33[2] = {'a', 't'};
+static const symbol s_0_34[5] = {'a', 'n', 'd', 'e', 't'};
+static const symbol s_0_35[3] = {'h', 'e', 't'};
+static const symbol s_0_36[3] = {'a', 's', 't'};
+
+static const struct among a_0[37] = {
+    /*  0 */ {1, s_0_0, -1, 1, 0},
+    /*  1 */ {4, s_0_1, 0, 1, 0},
+    /*  2 */ {4, s_0_2, 0, 1, 0},
+    /*  3 */ {7, s_0_3, 2, 1, 0},
+    /*  4 */ {4, s_0_4, 0, 1, 0},
+    /*  5 */ {2, s_0_5, -1, 1, 0},
+    /*  6 */ {1, s_0_6, -1, 1, 0},
+    /*  7 */ {3, s_0_7, 6, 1, 0},
+    /*  8 */ {4, s_0_8, 6, 1, 0},
+    /*  9 */ {4, s_0_9, 6, 1, 0},
+    /* 10 */ {3, s_0_10, 6, 1, 0},
+    /* 11 */ {4, s_0_11, 6, 1, 0},
+    /* 12 */ {2, s_0_12, -1, 1, 0},
+    /* 13 */ {5, s_0_13, 12, 1, 0},
+    /* 14 */ {4, s_0_14, 12, 1, 0},
+    /* 15 */ {5, s_0_15, 12, 1, 0},
+    /* 16 */ {3, s_0_16, -1, 1, 0},
+    /* 17 */ {2, s_0_17, -1, 1, 0},
+    /* 18 */ {2, s_0_18, -1, 1, 0},
+    /* 19 */ {5, s_0_19, 18, 1, 0},
+    /* 20 */ {2, s_0_20, -1, 1, 0},
+    /* 21 */ {1, s_0_21, -1, 2, 0},
+    /* 22 */ {2, s_0_22, 21, 1, 0},
+    /* 23 */ {5, s_0_23, 22, 1, 0},
+    /* 24 */ {5, s_0_24, 22, 1, 0},
+    /* 25 */ {5, s_0_25, 22, 1, 0},
+    /* 26 */ {2, s_0_26, 21, 1, 0},
+    /* 27 */ {4, s_0_27, 26, 1, 0},
+    /* 28 */ {5, s_0_28, 26, 1, 0},
+    /* 29 */ {3, s_0_29, 21, 1, 0},
+    /* 30 */ {5, s_0_30, 29, 1, 0},
+    /* 31 */ {6, s_0_31, 29, 1, 0},
+    /* 32 */ {4, s_0_32, 21, 1, 0},
+    /* 33 */ {2, s_0_33, -1, 1, 0},
+    /* 34 */ {5, s_0_34, -1, 1, 0},
+    /* 35 */ {3, s_0_35, -1, 1, 0},
+    /* 36 */ {3, s_0_36, -1, 1, 0}};
+
+static const symbol s_1_0[2] = {'d', 'd'};
+static const symbol s_1_1[2] = {'g', 'd'};
+static const symbol s_1_2[2] = {'n', 'n'};
+static const symbol s_1_3[2] = {'d', 't'};
+static const symbol s_1_4[2] = {'g', 't'};
+static const symbol s_1_5[2] = {'k', 't'};
+static const symbol s_1_6[2] = {'t', 't'};
+
+static const struct among a_1[7] = {
+    /*  0 */ {2, s_1_0, -1, -1, 0},
+    /*  1 */ {2, s_1_1, -1, -1, 0},
+    /*  2 */ {2, s_1_2, -1, -1, 0},
+    /*  3 */ {2, s_1_3, -1, -1, 0},
+    /*  4 */ {2, s_1_4, -1, -1, 0},
+    /*  5 */ {2, s_1_5, -1, -1, 0},
+    /*  6 */ {2, s_1_6, -1, -1, 0}};
+
+static const symbol s_2_0[2] = {'i', 'g'};
+static const symbol s_2_1[3] = {'l', 'i', 'g'};
+static const symbol s_2_2[3] = {'e', 'l', 's'};
+static const symbol s_2_3[5] = {'f', 'u', 'l', 'l', 't'};
+static const symbol s_2_4[5] = {'l', 0xC3, 0xB6, 's', 't'};
+
+static const struct among a_2[5] = {
+    /*  0 */ {2, s_2_0, -1, 1, 0},
+    /*  1 */ {3, s_2_1, 0, 1, 0},
+    /*  2 */ {3, s_2_2, -1, 1, 0},
+    /*  3 */ {5, s_2_3, -1, 3, 0},
+    /*  4 */ {5, s_2_4, -1, 2, 0}};
+
+static const unsigned char g_v[] = {17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 32};
+
+static const unsigned char g_s_ending[] = {119, 127, 149};
+
+static const symbol s_0[] = {'l', 0xC3, 0xB6, 's'};
+static const symbol s_1[] = {'f', 'u', 'l', 'l'};
+
+static int r_mark_regions(struct SN_env *z) {
+    z->I[0] = z->l;
+    {
+        int c_test = z->c; /* test, line 29 */
+        {
+            int ret = skip_utf8(z->p, z->c, 0, z->l, +3);
+            if (ret < 0)
+                return 0;
+            z->c = ret; /* hop, line 29 */
+        }
+        z->I[1] = z->c; /* setmark x, line 29 */
+        z->c = c_test;
+    }
+    if (out_grouping_U(z, g_v, 97, 246, 1) < 0)
+        return 0; /* goto */ /* grouping v, line 30 */
+    { /* gopast */           /* non v, line 30 */
+        int ret = in_grouping_U(z, g_v, 97, 246, 1);
+        if (ret < 0)
+            return 0;
+        z->c += ret;
+    }
+    z->I[0] = z->c; /* setmark p1, line 30 */
+                    /* try, line 31 */
+    if (!(z->I[0] < z->I[1]))
+        goto lab0;
+    z->I[0] = z->I[1];
+lab0:
+    return 1;
+}
+
+static int r_main_suffix(struct SN_env *z) {
+    int among_var;
+    {
+        int mlimit; /* setlimit, line 37 */
+        int m1 = z->l - z->c;
+        (void)m1;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 37 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m1;
+        z->ket = z->c; /* [, line 37 */
+        if (z->c <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((1851442 >> (z->p[z->c - 1] & 0x1f)) & 1)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        among_var = find_among_b(z, a_0, 37); /* substring, line 37 */
+        if (!(among_var)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        z->bra = z->c; /* ], line 37 */
+        z->lb = mlimit;
+    }
+    switch (among_var) {
+        case 0:
+            return 0;
+        case 1: {
+            int ret = slice_del(z); /* delete, line 44 */
+            if (ret < 0)
+                return ret;
+        } break;
+        case 2:
+            if (in_grouping_b_U(z, g_s_ending, 98, 121, 0))
+                return 0;
+            {
+                int ret = slice_del(z); /* delete, line 46 */
+                if (ret < 0)
+                    return ret;
+            }
+            break;
+    }
+    return 1;
+}
+
+static int r_consonant_pair(struct SN_env *z) {
+    {
+        int mlimit; /* setlimit, line 50 */
+        int m1 = z->l - z->c;
+        (void)m1;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 50 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m1;
+        {
+            int m2 = z->l - z->c;
+            (void)m2; /* and, line 52 */
+            if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((1064976 >> (z->p[z->c - 1] & 0x1f)) & 1)) {
+                z->lb = mlimit;
+                return 0;
+            }
+            if (!(find_among_b(z, a_1, 7))) {
+                z->lb = mlimit;
+                return 0;
+            } /* among, line 51 */
+            z->c = z->l - m2;
+            z->ket = z->c; /* [, line 52 */
+            {
+                int ret = skip_utf8(z->p, z->c, z->lb, 0, -1);
+                if (ret < 0) {
+                    z->lb = mlimit;
+                    return 0;
+                }
+                z->c = ret; /* next, line 52 */
+            }
+            z->bra = z->c; /* ], line 52 */
+            {
+                int ret = slice_del(z); /* delete, line 52 */
+                if (ret < 0)
+                    return ret;
+            }
+        }
+        z->lb = mlimit;
+    }
+    return 1;
+}
+
+static int r_other_suffix(struct SN_env *z) {
+    int among_var;
+    {
+        int mlimit; /* setlimit, line 55 */
+        int m1 = z->l - z->c;
+        (void)m1;
+        if (z->c < z->I[0])
+            return 0;
+        z->c = z->I[0]; /* tomark, line 55 */
+        mlimit = z->lb;
+        z->lb = z->c;
+        z->c = z->l - m1;
+        z->ket = z->c; /* [, line 56 */
+        if (z->c - 1 <= z->lb || z->p[z->c - 1] >> 5 != 3 || !((1572992 >> (z->p[z->c - 1] & 0x1f)) & 1)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        among_var = find_among_b(z, a_2, 5); /* substring, line 56 */
+        if (!(among_var)) {
+            z->lb = mlimit;
+            return 0;
+        }
+        z->bra = z->c; /* ], line 56 */
+        switch (among_var) {
+            case 0: {
+                z->lb = mlimit;
+                return 0;
+            }
+            case 1: {
+                int ret = slice_del(z); /* delete, line 57 */
+                if (ret < 0)
+                    return ret;
+            } break;
+            case 2: {
+                int ret = slice_from_s(z, 4, s_0); /* <-, line 58 */
+                if (ret < 0)
+                    return ret;
+            } break;
+            case 3: {
+                int ret = slice_from_s(z, 4, s_1); /* <-, line 59 */
+                if (ret < 0)
+                    return ret;
+            } break;
+        }
+        z->lb = mlimit;
+    }
+    return 1;
+}
+
+extern int swedish_UTF_8_stem(struct SN_env *z) {
+    {
+        int c1 = z->c; /* do, line 66 */
+        {
+            int ret = r_mark_regions(z);
+            if (ret == 0)
+                goto lab0; /* call mark_regions, line 66 */
+            if (ret < 0)
+                return ret;
+        }
+    lab0:
+        z->c = c1;
+    }
+    z->lb = z->c;
+    z->c = z->l; /* backwards, line 67 */
+
+    {
+        int m2 = z->l - z->c;
+        (void)m2; /* do, line 68 */
+        {
+            int ret = r_main_suffix(z);
+            if (ret == 0)
+                goto lab1; /* call main_suffix, line 68 */
+            if (ret < 0)
+                return ret;
+        }
+    lab1:
+        z->c = z->l - m2;
+    }
+    {
+        int m3 = z->l - z->c;
+        (void)m3; /* do, line 69 */
+        {
+            int ret = r_consonant_pair(z);
+            if (ret == 0)
+                goto lab2; /* call consonant_pair, line 69 */
+            if (ret < 0)
+                return ret;
+        }
+    lab2:
+        z->c = z->l - m3;
+    }
+    {
+        int m4 = z->l - z->c;
+        (void)m4; /* do, line 70 */
+        {
+            int ret = r_other_suffix(z);
+            if (ret == 0)
+                goto lab3; /* call other_suffix, line 70 */
+            if (ret < 0)
+                return ret;
+        }
+    lab3:
+        z->c = z->l - m4;
+    }
+    z->c = z->lb;
+    return 1;
+}
+
+extern struct SN_env *swedish_UTF_8_create_env(void) { return SN_create_env(0, 2, 0); }
+
+extern void swedish_UTF_8_close_env(struct SN_env *z) { SN_close_env(z, 0); }

internal/binding/cpp/stemmer/stem_UTF_8_swedish.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *swedish_UTF_8_create_env(void);
+extern void swedish_UTF_8_close_env(struct SN_env *z);
+
+extern int swedish_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stem_UTF_8_turkish.h

@@ -0,0 +1,17 @@
+
+/* This file was generated automatically by the Snowball to ANSI C compiler */
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env *turkish_UTF_8_create_env(void);
+extern void turkish_UTF_8_close_env(struct SN_env *z);
+
+extern int turkish_UTF_8_stem(struct SN_env *z);
+
+#ifdef __cplusplus
+}
+#endif

internal/binding/cpp/stemmer/stemmer.cpp

@@ -0,0 +1,149 @@
+// Copyright(C) 2023 InfiniFlow, Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "api.h"
+#include "stem_UTF_8_danish.h"
+#include "stem_UTF_8_dutch.h"
+#include "stem_UTF_8_english.h"
+#include "stem_UTF_8_finnish.h"
+#include "stem_UTF_8_french.h"
+#include "stem_UTF_8_german.h"
+#include "stem_UTF_8_hungarian.h"
+#include "stem_UTF_8_italian.h"
+#include "stem_UTF_8_norwegian.h"
+#include "stem_UTF_8_porter.h"
+#include "stem_UTF_8_portuguese.h"
+#include "stem_UTF_8_romanian.h"
+#include "stem_UTF_8_russian.h"
+#include "stem_UTF_8_spanish.h"
+#include "stem_UTF_8_swedish.h"
+#include "stem_UTF_8_turkish.h"
+#include "stemmer.h"
+
+#ifdef __cplusplus
+
+extern "C" {
+#endif
+struct StemFunc {
+
+    struct SN_env *(*create)(void);
+    void (*close)(struct SN_env *);
+    int (*stem)(struct SN_env *);
+
+    struct SN_env *env;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+StemFunc STEM_FUNCTION[STEM_LANG_EOS] = {
+    {0, 0, 0, 0},
+    {danish_UTF_8_create_env, danish_UTF_8_close_env, danish_UTF_8_stem, 0},
+    {dutch_UTF_8_create_env, dutch_UTF_8_close_env, dutch_UTF_8_stem, 0},
+    {english_UTF_8_create_env, english_UTF_8_close_env, english_UTF_8_stem, 0},
+    {finnish_UTF_8_create_env, finnish_UTF_8_close_env, finnish_UTF_8_stem, 0},
+    {french_UTF_8_create_env, french_UTF_8_close_env, french_UTF_8_stem, 0},
+    {german_UTF_8_create_env, german_UTF_8_close_env, german_UTF_8_stem, 0},
+    {hungarian_UTF_8_create_env, hungarian_UTF_8_close_env, hungarian_UTF_8_stem, 0},
+    {italian_UTF_8_create_env, italian_UTF_8_close_env, italian_UTF_8_stem, 0},
+    {norwegian_UTF_8_create_env, norwegian_UTF_8_close_env, norwegian_UTF_8_stem, 0},
+    {porter_UTF_8_create_env, porter_UTF_8_close_env, porter_UTF_8_stem, 0},
+    {portuguese_UTF_8_create_env, portuguese_UTF_8_close_env, portuguese_UTF_8_stem, 0},
+    {romanian_UTF_8_create_env, romanian_UTF_8_close_env, romanian_UTF_8_stem, 0},
+    {russian_UTF_8_create_env, russian_UTF_8_close_env, russian_UTF_8_stem, 0},
+    {spanish_UTF_8_create_env, spanish_UTF_8_close_env, spanish_UTF_8_stem, 0},
+    {swedish_UTF_8_create_env, swedish_UTF_8_close_env, swedish_UTF_8_stem, 0},
+    {turkish_UTF_8_create_env, turkish_UTF_8_close_env, turkish_UTF_8_stem, 0},
+};
+
+Stemmer::Stemmer() {
+    // stemLang_ = STEM_LANG_UNKNOWN;
+    stem_function_ = 0;
+}
+
+Stemmer::~Stemmer() { DeInit(); }
+
+bool Stemmer::Init(Language language) {
+    // create stemming function structure
+    stem_function_ = static_cast<void *>(new StemFunc);
+    if (stem_function_ == 0) {
+        return false;
+    }
+
+    // set stemming functions
+    if (language > 0 && language < STEM_LANG_EOS) {
+        static_cast<StemFunc *>(stem_function_)->create = STEM_FUNCTION[language].create;
+        static_cast<StemFunc *>(stem_function_)->close = STEM_FUNCTION[language].close;
+        static_cast<StemFunc *>(stem_function_)->stem = STEM_FUNCTION[language].stem;
+        static_cast<StemFunc *>(stem_function_)->env = STEM_FUNCTION[language].env;
+    } else {
+        delete static_cast<StemFunc *>(stem_function_);
+        stem_function_ = 0;
+        return false;
+    }
+
+    // create env
+    static_cast<StemFunc *>(stem_function_)->env = static_cast<StemFunc *>(stem_function_)->create();
+    if (static_cast<StemFunc *>(stem_function_)->env == 0) {
+        DeInit();
+        return false;
+    }
+
+    return true;
+}
+////////////
+// struct SN_env {
+//     symbol *p;
+//     int c;
+//     int l;
+//     int lb;
+//     int bra;
+//     int ket;
+//     symbol **S;
+//     int *I;
+//     unsigned char *B;
+// };
+////////////
+
+void Stemmer::DeInit(void) {
+    if (stem_function_) {
+        static_cast<StemFunc *>(stem_function_)->close(((StemFunc *)stem_function_)->env);
+        delete static_cast<StemFunc *>(stem_function_);
+        stem_function_ = 0;
+    }
+}
+
+bool Stemmer::Stem(const std::string &term, std::string &resultWord) {
+    if (!stem_function_) {
+        return false;
+    }
+
+    // set environment
+    if (SN_set_current(static_cast<StemFunc *>(stem_function_)->env, term.length(), (const symbol *)term.c_str())) {
+        static_cast<StemFunc *>(stem_function_)->env->l = 0;
+        return false;
+    }
+
+    // stemming
+    if (((StemFunc *)stem_function_)->stem(((StemFunc *)stem_function_)->env) < 0) {
+        return false;
+    }
+
+    ((StemFunc *)stem_function_)->env->p[((StemFunc *)stem_function_)->env->l] = 0;
+
+    resultWord = (char *)((StemFunc *)stem_function_)->env->p;
+
+    return true;
+}

internal/binding/cpp/stemmer/stemmer.h

@@ -0,0 +1,58 @@
+// Copyright(C) 2023 InfiniFlow, Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <string>
+
+enum Language
+{
+    STEM_LANG_UNKNOWN = 0,
+    STEM_LANG_DANISH = 1,
+    STEM_LANG_DUTCH = 2,
+    STEM_LANG_ENGLISH,
+    STEM_LANG_FINNISH,
+    STEM_LANG_FRENCH,
+    STEM_LANG_GERMAN,
+    STEM_LANG_HUNGARIAN,
+    STEM_LANG_ITALIAN,
+    STEM_LANG_NORWEGIAN,
+    STEM_LANG_PORT,
+    STEM_LANG_PORTUGUESE,
+    STEM_LANG_ROMANIAN,
+    STEM_LANG_RUSSIAN,
+    STEM_LANG_SPANISH,
+    STEM_LANG_SWEDISH,
+    STEM_LANG_TURKISH,
+    STEM_LANG_EOS,
+};
+
+class Stemmer
+{
+public:
+    Stemmer();
+
+    virtual ~Stemmer();
+
+    bool Init(Language language);
+
+    void DeInit();
+
+    bool Stem(const std::string& term, std::string& resultWord);
+
+private:
+    // int stemLang_; ///< language for stemming
+
+    void* stem_function_; ///< stemming function
+};

internal/binding/cpp/stemmer/utilities.cpp

@@ -0,0 +1,509 @@
+// Copyright(C) 2023 InfiniFlow, Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "header.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define unless(C) if (!(C))
+
+#define CREATE_SIZE 1
+
+extern symbol *create_s(void) {
+    symbol *p;
+    void *mem = malloc(HEAD + (CREATE_SIZE + 1) * sizeof(symbol));
+    if (mem == NULL)
+        return NULL;
+    p = (symbol *)(HEAD + (char *)mem);
+    CAPACITY(p) = CREATE_SIZE;
+    SET_SIZE(p, CREATE_SIZE);
+    return p;
+}
+
+extern void lose_s(symbol *p) {
+    if (p == NULL)
+        return;
+    free((char *)p - HEAD);
+}
+
+/*
+   new_p = skip_utf8(p, c, lb, l, n); skips n characters forwards from p + c
+   if n +ve, or n characters backwards from p + c - 1 if n -ve. new_p is the new
+   position, or 0 on failure.
+
+   -- used to implement hop and next in the utf8 case.
+*/
+
+extern int skip_utf8(const symbol *p, int c, int lb, int l, int n) {
+    int b;
+    if (n >= 0) {
+        for (; n > 0; n--) {
+            if (c >= l)
+                return -1;
+            b = p[c++];
+            if (b >= 0xC0) { /* 1100 0000 */
+                while (c < l) {
+                    b = p[c];
+                    if (b >= 0xC0 || b < 0x80)
+                        break;
+                    /* break unless b is 10------ */
+                    c++;
+                }
+            }
+        }
+    } else {
+        for (; n < 0; n++) {
+            if (c <= lb)
+                return -1;
+            b = p[--c];
+            if (b >= 0x80) { /* 1000 0000 */
+                while (c > lb) {
+                    b = p[c];
+                    if (b >= 0xC0)
+                        break; /* 1100 0000 */
+                    c--;
+                }
+            }
+        }
+    }
+    return c;
+}
+
+/* Code for character groupings: utf8 cases */
+
+static int get_utf8(const symbol *p, int c, int l, int *slot) {
+    int b0, b1;
+    if (c >= l)
+        return 0;
+    b0 = p[c++];
+    if (b0 < 0xC0 || c == l) { /* 1100 0000 */
+        *slot = b0;
+        return 1;
+    }
+    b1 = p[c++];
+    if (b0 < 0xE0 || c == l) { /* 1110 0000 */
+        *slot = (b0 & 0x1F) << 6 | (b1 & 0x3F);
+        return 2;
+    }
+    *slot = (b0 & 0xF) << 12 | (b1 & 0x3F) << 6 | (p[c] & 0x3F);
+    return 3;
+}
+
+static int get_b_utf8(const symbol *p, int c, int lb, int *slot) {
+    int b0, b1;
+    if (c <= lb)
+        return 0;
+    b0 = p[--c];
+    if (b0 < 0x80 || c == lb) { /* 1000 0000 */
+        *slot = b0;
+        return 1;
+    }
+    b1 = p[--c];
+    if (b1 >= 0xC0 || c == lb) { /* 1100 0000 */
+        *slot = (b1 & 0x1F) << 6 | (b0 & 0x3F);
+        return 2;
+    }
+    *slot = (p[c] & 0xF) << 12 | (b1 & 0x3F) << 6 | (b0 & 0x3F);
+    return 3;
+}
+
+extern int in_grouping_U(struct SN_env *z, const unsigned char *s, int min, int max, int repeat) {
+    do {
+        int ch;
+        int w = get_utf8(z->p, z->c, z->l, &ch);
+        unless(w) return -1;
+        if (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0)
+            return w;
+        z->c += w;
+    } while (repeat);
+    return 0;
+}
+
+extern int in_grouping_b_U(struct SN_env *z, const unsigned char *s, int min, int max, int repeat) {
+    do {
+        int ch;
+        int w = get_b_utf8(z->p, z->c, z->lb, &ch);
+        unless(w) return -1;
+        if (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0)
+            return w;
+        z->c -= w;
+    } while (repeat);
+    return 0;
+}
+
+extern int out_grouping_U(struct SN_env *z, const unsigned char *s, int min, int max, int repeat) {
+    do {
+        int ch;
+        int w = get_utf8(z->p, z->c, z->l, &ch);
+        unless(w) return -1;
+        unless(ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return w;
+        z->c += w;
+    } while (repeat);
+    return 0;
+}
+
+extern int out_grouping_b_U(struct SN_env *z, const unsigned char *s, int min, int max, int repeat) {
+    do {
+        int ch;
+        int w = get_b_utf8(z->p, z->c, z->lb, &ch);
+        unless(w) return -1;
+        unless(ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return w;
+        z->c -= w;
+    } while (repeat);
+    return 0;
+}
+
+/* Code for character groupings: non-utf8 cases */
+
+extern int in_grouping(struct SN_env *z, const unsigned char *s, int min, int max, int repeat) {
+    do {
+        int ch;
+        if (z->c >= z->l)
+            return -1;
+        ch = z->p[z->c];
+        if (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0)
+            return 1;
+        z->c++;
+    } while (repeat);
+    return 0;
+}
+
+extern int in_grouping_b(struct SN_env *z, const unsigned char *s, int min, int max, int repeat) {
+    do {
+        int ch;
+        if (z->c <= z->lb)
+            return -1;
+        ch = z->p[z->c - 1];
+        if (ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0)
+            return 1;
+        z->c--;
+    } while (repeat);
+    return 0;
+}
+
+extern int out_grouping(struct SN_env *z, const unsigned char *s, int min, int max, int repeat) {
+    do {
+        int ch;
+        if (z->c >= z->l)
+            return -1;
+        ch = z->p[z->c];
+        unless(ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 1;
+        z->c++;
+    } while (repeat);
+    return 0;
+}
+
+extern int out_grouping_b(struct SN_env *z, const unsigned char *s, int min, int max, int repeat) {
+    do {
+        int ch;
+        if (z->c <= z->lb)
+            return -1;
+        ch = z->p[z->c - 1];
+        unless(ch > max || (ch -= min) < 0 || (s[ch >> 3] & (0X1 << (ch & 0X7))) == 0) return 1;
+        z->c--;
+    } while (repeat);
+    return 0;
+}
+
+extern int eq_s(struct SN_env *z, int s_size, const symbol *s) {
+    if (z->l - z->c < s_size || memcmp(z->p + z->c, s, s_size * sizeof(symbol)) != 0)
+        return 0;
+    z->c += s_size;
+    return 1;
+}
+
+extern int eq_s_b(struct SN_env *z, int s_size, const symbol *s) {
+    if (z->c - z->lb < s_size || memcmp(z->p + z->c - s_size, s, s_size * sizeof(symbol)) != 0)
+        return 0;
+    z->c -= s_size;
+    return 1;
+}
+
+extern int eq_v(struct SN_env *z, const symbol *p) { return eq_s(z, SIZE(p), p); }
+
+extern int eq_v_b(struct SN_env *z, const symbol *p) { return eq_s_b(z, SIZE(p), p); }
+
+extern int find_among(struct SN_env *z, const struct among *v, int v_size) {
+
+    int i = 0;
+    int j = v_size;
+
+    int c = z->c;
+    int l = z->l;
+    symbol *q = z->p + c;
+
+    const struct among *w;
+
+    int common_i = 0;
+    int common_j = 0;
+
+    int first_key_inspected = 0;
+
+    while (1) {
+        int k = i + ((j - i) >> 1);
+        int diff = 0;
+        int common = common_i < common_j ? common_i : common_j; /* smaller */
+        w = v + k;
+        {
+            int i2;
+            for (i2 = common; i2 < w->s_size; i2++) {
+                if (c + common == l) {
+                    diff = -1;
+                    break;
+                }
+                diff = q[common] - w->s[i2];
+                if (diff != 0)
+                    break;
+                common++;
+            }
+        }
+        if (diff < 0) {
+            j = k;
+            common_j = common;
+        } else {
+            i = k;
+            common_i = common;
+        }
+        if (j - i <= 1) {
+            if (i > 0)
+                break; /* v->s has been inspected */
+            if (j == i)
+                break; /* only one item in v */
+
+            /* - but now we need to go round once more to get
+               v->s inspected. This looks messy, but is actually
+               the optimal approach.  */
+
+            if (first_key_inspected)
+                break;
+            first_key_inspected = 1;
+        }
+    }
+    while (1) {
+        w = v + i;
+        if (common_i >= w->s_size) {
+            z->c = c + w->s_size;
+            if (w->function == 0)
+                return w->result;
+            {
+                int res = w->function(z);
+                z->c = c + w->s_size;
+                if (res)
+                    return w->result;
+            }
+        }
+        i = w->substring_i;
+        if (i < 0)
+            return 0;
+    }
+}
+
+/* find_among_b is for backwards processing. Same comments apply */
+
+extern int find_among_b(struct SN_env *z, const struct among *v, int v_size) {
+
+    int i = 0;
+    int j = v_size;
+
+    int c = z->c;
+    int lb = z->lb;
+    symbol *q = z->p + c - 1;
+
+    const struct among *w;
+
+    int common_i = 0;
+    int common_j = 0;
+
+    int first_key_inspected = 0;
+
+    while (1) {
+        int k = i + ((j - i) >> 1);
+        int diff = 0;
+        int common = common_i < common_j ? common_i : common_j;
+        w = v + k;
+        {
+            int i2;
+            for (i2 = w->s_size - 1 - common; i2 >= 0; i2--) {
+                if (c - common == lb) {
+                    diff = -1;
+                    break;
+                }
+                diff = q[-common] - w->s[i2];
+                if (diff != 0)
+                    break;
+                common++;
+            }
+        }
+        if (diff < 0) {
+            j = k;
+            common_j = common;
+        } else {
+            i = k;
+            common_i = common;
+        }
+        if (j - i <= 1) {
+            if (i > 0)
+                break;
+            if (j == i)
+                break;
+            if (first_key_inspected)
+                break;
+            first_key_inspected = 1;
+        }
+    }
+    while (1) {
+        w = v + i;
+        if (common_i >= w->s_size) {
+            z->c = c - w->s_size;
+            if (w->function == 0)
+                return w->result;
+            {
+                int res = w->function(z);
+                z->c = c - w->s_size;
+                if (res)
+                    return w->result;
+            }
+        }
+        i = w->substring_i;
+        if (i < 0)
+            return 0;
+    }
+}
+
+/* Increase the size of the buffer pointed to by p to at least n symbols.
+ * If insufficient memory, returns NULL and frees the old buffer.
+ */
+static symbol *increase_size(symbol *p, int n) {
+    symbol *q;
+    int new_size = n + 20;
+    void *mem = realloc((char *)p - HEAD, HEAD + (new_size + 1) * sizeof(symbol));
+    if (mem == NULL) {
+        lose_s(p);
+        return NULL;
+    }
+    q = (symbol *)(HEAD + (char *)mem);
+    CAPACITY(q) = new_size;
+    return q;
+}
+
+/* to replace symbols between c_bra and c_ket in z->p by the
+   s_size symbols at s.
+   Returns 0 on success, -1 on error.
+   Also, frees z->p (and sets it to NULL) on error.
+*/
+extern int replace_s(struct SN_env *z, int c_bra, int c_ket, int s_size, const symbol *s, int *adjptr) {
+    int adjustment;
+    int len;
+    if (z->p == NULL) {
+        z->p = create_s();
+        if (z->p == NULL)
+            return -1;
+    }
+    adjustment = s_size - (c_ket - c_bra);
+    len = SIZE(z->p);
+    if (adjustment != 0) {
+        if (adjustment + len > CAPACITY(z->p)) {
+            z->p = increase_size(z->p, adjustment + len);
+            if (z->p == NULL)
+                return -1;
+        }
+        memmove(z->p + c_ket + adjustment, z->p + c_ket, (len - c_ket) * sizeof(symbol));
+        SET_SIZE(z->p, adjustment + len);
+        z->l += adjustment;
+        if (z->c >= c_ket)
+            z->c += adjustment;
+        else if (z->c > c_bra)
+            z->c = c_bra;
+    }
+    unless(s_size == 0) memmove(z->p + c_bra, s, s_size * sizeof(symbol));
+    if (adjptr != NULL)
+        *adjptr = adjustment;
+    return 0;
+}
+
+static int slice_check(struct SN_env *z) {
+
+    if (z->bra < 0 || z->bra > z->ket || z->ket > z->l || z->p == NULL || z->l > SIZE(z->p)) /* this line could be removed */
+    {
+#if 0
+        fprintf(stderr, "faulty slice operation:\n");
+        debug(z, -1, 0);
+#endif
+        return -1;
+    }
+    return 0;
+}
+
+extern int slice_from_s(struct SN_env *z, int s_size, const symbol *s) {
+    if (slice_check(z))
+        return -1;
+    return replace_s(z, z->bra, z->ket, s_size, s, NULL);
+}
+
+extern int slice_from_v(struct SN_env *z, const symbol *p) { return slice_from_s(z, SIZE(p), p); }
+
+extern int slice_del(struct SN_env *z) { return slice_from_s(z, 0, 0); }
+
+extern int insert_s(struct SN_env *z, int bra, int ket, int s_size, const symbol *s) {
+    int adjustment;
+    if (replace_s(z, bra, ket, s_size, s, &adjustment))
+        return -1;
+    if (bra <= z->bra)
+        z->bra += adjustment;
+    if (bra <= z->ket)
+        z->ket += adjustment;
+    return 0;
+}
+
+extern int insert_v(struct SN_env *z, int bra, int ket, const symbol *p) {
+    int adjustment;
+    if (replace_s(z, bra, ket, SIZE(p), p, &adjustment))
+        return -1;
+    if (bra <= z->bra)
+        z->bra += adjustment;
+    if (bra <= z->ket)
+        z->ket += adjustment;
+    return 0;
+}
+
+extern symbol *slice_to(struct SN_env *z, symbol *p) {
+    if (slice_check(z)) {
+        lose_s(p);
+        return NULL;
+    }
+    {
+        int len = z->ket - z->bra;
+        if (CAPACITY(p) < len) {
+            p = increase_size(p, len);
+            if (p == NULL)
+                return NULL;
+        }
+        memmove(p, z->p + z->bra, len * sizeof(symbol));
+        SET_SIZE(p, len);
+    }
+    return p;
+}
+
+extern symbol *assign_to(struct SN_env *z, symbol *p) {
+    int len = z->l;
+    if (CAPACITY(p) < len) {
+        p = increase_size(p, len);
+        if (p == NULL)
+            return NULL;
+    }
+    memmove(p, z->p, len * sizeof(symbol));
+    SET_SIZE(p, len);
+    return p;
+}