# Generated by Snowball.Generator — do not edit by hand.
defmodule Text.Stemmer.Stemmers.Dutch do
  @moduledoc """
  Snowball stemmer for dutch.

  Generated from the canonical Snowball algorithm source.
  """

  alias Snowball.Runtime
  alias Snowball.Grouping

  @dialyzer {:no_match, {:r_stem, 1}}


  # Groupings
  @g_AEIOU Grouping.from_string("aäáàâeëéèêiïíìîoöóòôuüúùû")
  @g_AIOU Grouping.from_string("aäáàâiïíìîoöóòôuüúùû")
  @g_E Grouping.from_string("eëéèê")
  @g_v Grouping.from_string("aäáàâeëéèêiïíìîoöóòôuüúùûy")
  @g_v_WX Grouping.from_string("aäáàâeëéèêiïíìîoöóòôuüúùûywx")


  # Among tables
  @a_0 [
    {"d", -1, 1, nil},
    {"t", -1, 2, nil}
  ]
  @a_1 [
    {"bb", -1, 1, nil},
    {"cc", -1, 2, nil},
    {"dd", -1, 3, nil},
    {"ff", -1, 4, nil},
    {"gg", -1, 5, nil},
    {"hh", -1, 6, nil},
    {"jj", -1, 7, nil},
    {"kk", -1, 8, nil},
    {"ll", -1, 9, nil},
    {"mm", -1, 10, nil},
    {"nn", -1, 11, nil},
    {"pp", -1, 12, nil},
    {"qq", -1, 13, nil},
    {"rr", -1, 14, nil},
    {"ss", -1, 15, nil},
    {"tt", -1, 16, nil},
    {"v", -1, 21, nil},
    {"vv", 16, 17, nil},
    {"ww", -1, 18, nil},
    {"xx", -1, 19, nil},
    {"z", -1, 22, nil},
    {"zz", 20, 20, nil}
  ]
  @a_2 [
    {"ft", -1, 2, nil},
    {"kt", -1, 1, nil},
    {"pt", -1, 3, nil}
  ]
  @a_3 [
    {"end", -1, 10, nil},
    {"atief", -1, 2, nil},
    {"erig", -1, 10, nil},
    {"achtig", -1, 9, nil},
    {"ioneel", -1, 1, nil},
    {"baar", -1, 3, nil},
    {"laar", -1, 5, nil},
    {"naar", -1, 4, nil},
    {"raar", -1, 6, nil},
    {"eriger", -1, 10, nil},
    {"achtiger", -1, 9, nil},
    {"lijker", -1, 8, nil},
    {"tant", -1, 7, nil},
    {"erigst", -1, 10, nil},
    {"achtigst", -1, 9, nil},
    {"lijkst", -1, 8, nil}
  ]
  @a_4 [
    {"ig", -1, 1, nil},
    {"iger", -1, 1, nil},
    {"igst", -1, 1, nil}
  ]
  @a_5 [
    {"heid", -1, 3, nil},
    {"fie", -1, 7, nil},
    {"gie", -1, 8, nil},
    {"atie", -1, 1, nil},
    {"isme", -1, 5, nil},
    {"ing", -1, 5, nil},
    {"arij", -1, 6, nil},
    {"erij", -1, 5, nil},
    {"sel", -1, 3, nil},
    {"rder", -1, 4, nil},
    {"ster", -1, 3, nil},
    {"iteit", -1, 2, nil},
    {"dst", -1, 10, nil},
    {"tst", -1, 9, nil}
  ]
  @a_6 [
    {"de", -1, 5, nil},
    {"ge", -1, 2, nil},
    {"ische", -1, 4, nil},
    {"je", -1, 1, nil},
    {"lijke", -1, 3, nil},
    {"le", -1, 9, nil},
    {"ene", -1, 10, nil},
    {"re", -1, 8, nil},
    {"se", -1, 7, nil},
    {"te", -1, 6, nil},
    {"ieve", -1, 11, nil}
  ]
  @a_7 [
    {"nde", -1, 8, nil},
    {"en", -1, 7, nil},
    {"s", -1, 2, nil},
    {"'s", 2, 1, nil},
    {"es", 2, 4, nil},
    {"ies", 4, 3, nil},
    {"aus", 2, 6, nil},
    {"és", 2, 5, nil}
  ]
  @a_8 [
    {"a", -1, 1, nil},
    {"e", -1, 2, nil},
    {"o", -1, 1, nil},
    {"u", -1, 1, nil},
    {"à", -1, 1, nil},
    {"á", -1, 1, nil},
    {"â", -1, 1, nil},
    {"ä", -1, 1, nil},
    {"è", -1, 2, nil},
    {"é", -1, 2, nil},
    {"ê", -1, 2, nil},
    {"eë", -1, 3, nil},
    {"ië", -1, 4, nil},
    {"ò", -1, 1, nil},
    {"ó", -1, 1, nil},
    {"ô", -1, 1, nil},
    {"ö", -1, 1, nil},
    {"ù", -1, 1, nil},
    {"ú", -1, 1, nil},
    {"û", -1, 1, nil},
    {"ü", -1, 1, nil}
  ]
  @a_9 [
    {"", -1, 5, nil},
    {"eft", 0, 1, nil},
    {"vaa", 0, 4, nil},
    {"val", 0, 2, nil},
    {"vali", 3, 3, nil},
    {"vare", 0, 4, nil}
  ]
  @a_10 [
    {"ë", -1, 1, nil},
    {"ï", -1, 2, nil}
  ]
  @a_11 [
    {"ë", -1, 1, nil},
    {"ï", -1, 2, nil}
  ]

  @doc """
  Stem a word.

  ### Arguments

  * `word` is a UTF-8 binary.

  ### Returns

  * The stemmed UTF-8 binary.

  """
  @spec stem(binary()) :: binary()
  def stem(word) when is_binary(word) do
    state = Runtime.new(word) |> init_vars()
    state = run_stem(state)
    Runtime.assign_to(state)
  end

  defp init_vars(state), do: %{state | vars: %{p1: 0, p2: 0, GE_removed: false, stemmed: false, ch: ""}}

  defp run_stem(%Runtime{} = state) do
    {_, state} = r_stem(state)
    state
  end

  # Snowball runtime helpers.
  defp snowball_do_f(state, fun) do
    saved_c = state.cursor
    {_, s} = fun.(state)
    %{s | cursor: saved_c}
  end

  defp snowball_do_b(state, fun) do
    rel = state.limit - state.cursor
    {_, s} = fun.(state)
    %{s | cursor: s.limit - rel}
  end

  defp snowball_test_f(state, fun) do
    saved_c = state.cursor
    case fun.(state) do
      {:ok, s} -> {:ok, %{s | cursor: saved_c}}
      {:fail, s} -> {:fail, %{s | cursor: saved_c}}
    end
  end

  defp snowball_test_b(state, fun) do
    rel = state.limit - state.cursor
    case fun.(state) do
      {:ok, s} -> {:ok, %{s | cursor: s.limit - rel}}
      {:fail, s} -> {:fail, %{s | cursor: s.limit - rel}}
    end
  end

  defp snowball_or(state, fun1, fun2) do
    rel = state.limit - state.cursor
    case fun1.(state) do
      {:ok, s} -> {:ok, s}
      {:fail, s} -> fun2.(%{s | cursor: s.limit - rel})
    end
  end

  defp lift(state, :fail), do: {:fail, state}
  defp lift(_state, %Runtime{} = s), do: {:ok, s}

  defp next_codepoint(%Runtime{cursor: c, limit: lim, current: cur} = state) do
    case Runtime.codepoint_at(cur, c, lim) do
      {_cp, size} -> {:ok, %{state | cursor: c + size}}
      :error -> {:fail, state}
    end
  end

  defp next_codepoint_b(%Runtime{cursor: c, limit_backward: lb, current: cur} = state) do
    case Runtime.codepoint_before(cur, c, lb) do
      {_cp, size} -> {:ok, %{state | cursor: c - size}}
      :error -> {:fail, state}
    end
  end

  defp r_Step_1c(%Runtime{} = state) do
    (fn ->
      state = %{state | ket: state.cursor}
      case Runtime.find_among_b(state, @a_0) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | bra: s.cursor}
          case (fn state ->
            case (fn state ->
              r_R1(state)
            end).(state) do
              {:ok, state} ->
              r_C(state)
              r -> r
            end
          end).(state) do
            {:ok, state} ->
          case result do
                    1 ->
                      case (fn state ->
                        (fn state ->
                          saved_c = state.cursor
                          case (fn state ->
                          case (fn state ->
                            lift(state, Runtime.eq_s_b(state, "n"))
                          end).(state) do
                            {:ok, state} ->
                            r_R1(state)
                            r -> r
                          end
                          end).(state) do
                            {:ok, s} -> {:fail, %{s | cursor: saved_c}}
                            {:fail, s} -> {:ok, %{s | cursor: saved_c}}
                          end
                        end).(state)
                      end).(state) do
                        {:ok, state} ->
                        snowball_or(state,
                          fn state ->
                            case (fn state ->
                              lift(state, Runtime.eq_s_b(state, "in"))
                            end).(state) do
                              {:ok, state} ->
                              case (fn state ->
                                if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
                              end).(state) do
                                {:ok, state} ->
                                {:ok, Runtime.slice_from(state, "n")}
                                r -> r
                              end
                              r -> r
                            end
                          end,
                          fn state ->
                            {:ok, Runtime.slice_del(state)}
                          end)
                        r -> r
                      end
                    2 ->
                      case (fn state ->
                        (fn state ->
                          saved_c = state.cursor
                          case (fn state ->
                          case (fn state ->
                            lift(state, Runtime.eq_s_b(state, "h"))
                          end).(state) do
                            {:ok, state} ->
                            r_R1(state)
                            r -> r
                          end
                          end).(state) do
                            {:ok, s} -> {:fail, %{s | cursor: saved_c}}
                            {:fail, s} -> {:ok, %{s | cursor: saved_c}}
                          end
                        end).(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          (fn state ->
                            saved_c = state.cursor
                            case (fn state ->
                            case (fn state ->
                              lift(state, Runtime.eq_s_b(state, "en"))
                            end).(state) do
                              {:ok, state} ->
                              if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
                              r -> r
                            end
                            end).(state) do
                              {:ok, s} -> {:fail, %{s | cursor: saved_c}}
                              {:fail, s} -> {:ok, %{s | cursor: saved_c}}
                            end
                          end).(state)
                        end).(state) do
                          {:ok, state} ->
                          {:ok, Runtime.slice_del(state)}
                          r -> r
                        end
                        r -> r
                      end
            _ -> {:ok, state}
          end
            r -> r
          end
      end
    end).()
  end

  defp r_Step_6(%Runtime{} = state) do
    (fn ->
      state = %{state | ket: state.cursor}
      case Runtime.find_among_b(state, @a_1) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | bra: s.cursor}
          case result do
                    1 ->
                      {:ok, Runtime.slice_from(state, "b")}
                    2 ->
                      {:ok, Runtime.slice_from(state, "c")}
                    3 ->
                      {:ok, Runtime.slice_from(state, "d")}
                    4 ->
                      {:ok, Runtime.slice_from(state, "f")}
                    5 ->
                      {:ok, Runtime.slice_from(state, "g")}
                    6 ->
                      {:ok, Runtime.slice_from(state, "h")}
                    7 ->
                      {:ok, Runtime.slice_from(state, "j")}
                    8 ->
                      {:ok, Runtime.slice_from(state, "k")}
                    9 ->
                      {:ok, Runtime.slice_from(state, "l")}
                    10 ->
                      {:ok, Runtime.slice_from(state, "m")}
                    11 ->
                      case (fn state ->
                        (fn state ->
                          saved_c = state.cursor
                          case (fn state ->
                          case (fn state ->
                            lift(state, Runtime.eq_s_b(state, "i"))
                          end).(state) do
                            {:ok, state} ->
                            if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
                            r -> r
                          end
                          end).(state) do
                            {:ok, s} -> {:fail, %{s | cursor: saved_c}}
                            {:fail, s} -> {:ok, %{s | cursor: saved_c}}
                          end
                        end).(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "n")}
                        r -> r
                      end
                    12 ->
                      {:ok, Runtime.slice_from(state, "p")}
                    13 ->
                      {:ok, Runtime.slice_from(state, "q")}
                    14 ->
                      {:ok, Runtime.slice_from(state, "r")}
                    15 ->
                      {:ok, Runtime.slice_from(state, "s")}
                    16 ->
                      {:ok, Runtime.slice_from(state, "t")}
                    17 ->
                      {:ok, Runtime.slice_from(state, "v")}
                    18 ->
                      {:ok, Runtime.slice_from(state, "w")}
                    19 ->
                      {:ok, Runtime.slice_from(state, "x")}
                    20 ->
                      {:ok, Runtime.slice_from(state, "z")}
                    21 ->
                      {:ok, Runtime.slice_from(state, "f")}
                    22 ->
                      {:ok, Runtime.slice_from(state, "s")}
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Step_7(%Runtime{} = state) do
    (fn ->
      state = %{state | ket: state.cursor}
      case Runtime.find_among_b(state, @a_2) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | bra: s.cursor}
          case result do
                    1 ->
                      {:ok, Runtime.slice_from(state, "k")}
                    2 ->
                      {:ok, Runtime.slice_from(state, "f")}
                    3 ->
                      {:ok, Runtime.slice_from(state, "p")}
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Step_4(%Runtime{} = state) do
    snowball_or(state,
      fn state ->
        (fn ->
          state = %{state | ket: state.cursor}
          case Runtime.find_among_b(state, @a_3) do
            :fail -> {:fail, state}
            {%Runtime{} = s, result} ->
              state = %{s | bra: s.cursor}
              case result do
                        1 ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            {:ok, Runtime.slice_from(state, "ie")}
                            r -> r
                          end
                        2 ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            {:ok, Runtime.slice_from(state, "eer")}
                            r -> r
                          end
                        3 ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            {:ok, Runtime.slice_del(state)}
                            r -> r
                          end
                        4 ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              r_V(state)
                            end).(state) do
                              {:ok, state} ->
                              {:ok, Runtime.slice_from(state, "n")}
                              r -> r
                            end
                            r -> r
                          end
                        5 ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              r_V(state)
                            end).(state) do
                              {:ok, state} ->
                              {:ok, Runtime.slice_from(state, "l")}
                              r -> r
                            end
                            r -> r
                          end
                        6 ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              r_V(state)
                            end).(state) do
                              {:ok, state} ->
                              {:ok, Runtime.slice_from(state, "r")}
                              r -> r
                            end
                            r -> r
                          end
                        7 ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            {:ok, Runtime.slice_from(state, "teer")}
                            r -> r
                          end
                        8 ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            {:ok, Runtime.slice_from(state, "lijk")}
                            r -> r
                          end
                        9 ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            {:ok, Runtime.slice_del(state)}
                            r -> r
                          end
                        10 ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              r_C(state)
                            end).(state) do
                              {:ok, state} ->
                              case (fn state ->
                                {:ok, Runtime.slice_del(state)}
                              end).(state) do
                                {:ok, state} ->
                                r_lengthen_V(state)
                              end
                              r -> r
                            end
                            r -> r
                          end
                _ -> {:ok, state}
              end
          end
        end).()
      end,
      fn state ->
        (fn ->
          state = %{state | ket: state.cursor}
          case Runtime.find_among_b(state, @a_4) do
            :fail -> {:fail, state}
            {%Runtime{} = s, result} ->
              state = %{s | bra: s.cursor}
              case result do
                        1 ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              (fn state ->
                                saved_c = state.cursor
                                case (fn state ->
                                case (fn state ->
                                  lift(state, Runtime.eq_s_b(state, "inn"))
                                end).(state) do
                                  {:ok, state} ->
                                  if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
                                  r -> r
                                end
                                end).(state) do
                                  {:ok, s} -> {:fail, %{s | cursor: saved_c}}
                                  {:fail, s} -> {:ok, %{s | cursor: saved_c}}
                                end
                              end).(state)
                            end).(state) do
                              {:ok, state} ->
                              case (fn state ->
                                r_C(state)
                              end).(state) do
                                {:ok, state} ->
                                case (fn state ->
                                  {:ok, Runtime.slice_del(state)}
                                end).(state) do
                                  {:ok, state} ->
                                  r_lengthen_V(state)
                                end
                                r -> r
                              end
                              r -> r
                            end
                            r -> r
                          end
                _ -> {:ok, state}
              end
          end
        end).()
      end)
  end

  defp r_Step_3(%Runtime{} = state) do
    (fn ->
      state = %{state | ket: state.cursor}
      case Runtime.find_among_b(state, @a_5) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | bra: s.cursor}
          case result do
                    1 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "eer")}
                        r -> r
                      end
                    2 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, Runtime.slice_del(state)}
                        end).(state) do
                          {:ok, state} ->
                          r_lengthen_V(state)
                        end
                        r -> r
                      end
                    3 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    4 ->
                      {:ok, Runtime.slice_from(state, "r")}
                    5 ->
                      snowball_or(state,
                        fn state ->
                          case (fn state ->
                            lift(state, Runtime.eq_s_b(state, "ild"))
                          end).(state) do
                            {:ok, state} ->
                            {:ok, Runtime.slice_from(state, "er")}
                            r -> r
                          end
                        end,
                        fn state ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              {:ok, Runtime.slice_del(state)}
                            end).(state) do
                              {:ok, state} ->
                              r_lengthen_V(state)
                            end
                            r -> r
                          end
                        end)
                    6 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          r_C(state)
                        end).(state) do
                          {:ok, state} ->
                          {:ok, Runtime.slice_from(state, "aar")}
                          r -> r
                        end
                        r -> r
                      end
                    7 ->
                      case (fn state ->
                        r_R2(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, Runtime.slice_del(state)}
                        end).(state) do
                          {:ok, state} ->
                          case (fn state ->
                            (fn ->
                              saved_c = state.cursor
                              new_state = Runtime.insert(state, saved_c, saved_c, "f")
                              {:ok, %{new_state | cursor: saved_c + byte_size("f")}}
                            end).()
                          end).(state) do
                            {:ok, state} ->
                            r_lengthen_V(state)
                          end
                        end
                        r -> r
                      end
                    8 ->
                      case (fn state ->
                        r_R2(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, Runtime.slice_del(state)}
                        end).(state) do
                          {:ok, state} ->
                          case (fn state ->
                            (fn ->
                              saved_c = state.cursor
                              new_state = Runtime.insert(state, saved_c, saved_c, "g")
                              {:ok, %{new_state | cursor: saved_c + byte_size("g")}}
                            end).()
                          end).(state) do
                            {:ok, state} ->
                            r_lengthen_V(state)
                          end
                        end
                        r -> r
                      end
                    9 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          r_C(state)
                        end).(state) do
                          {:ok, state} ->
                          {:ok, Runtime.slice_from(state, "t")}
                          r -> r
                        end
                        r -> r
                      end
                    10 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          r_C(state)
                        end).(state) do
                          {:ok, state} ->
                          {:ok, Runtime.slice_from(state, "d")}
                          r -> r
                        end
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Step_2(%Runtime{} = state) do
    (fn ->
      state = %{state | ket: state.cursor}
      case Runtime.find_among_b(state, @a_6) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | bra: s.cursor}
          case result do
                    1 ->
                      snowball_or(state,
                        fn state ->
                          snowball_or(state,
                            fn state ->
                              snowball_or(state,
                                fn state ->
                                  snowball_or(state,
                                    fn state ->
                                      snowball_or(state,
                                        fn state ->
                                          snowball_or(state,
                                            fn state ->
                                              snowball_or(state,
                                                fn state ->
                                                  case (fn state ->
                                                    lift(state, Runtime.eq_s_b(state, "'t"))
                                                  end).(state) do
                                                    {:ok, state} ->
                                                    case (fn state ->
                                                      {:ok, %{state | bra: state.cursor}}
                                                    end).(state) do
                                                      {:ok, state} ->
                                                      {:ok, Runtime.slice_del(state)}
                                                    end
                                                    r -> r
                                                  end
                                                end,
                                                fn state ->
                                                  case (fn state ->
                                                    lift(state, Runtime.eq_s_b(state, "et"))
                                                  end).(state) do
                                                    {:ok, state} ->
                                                    case (fn state ->
                                                      {:ok, %{state | bra: state.cursor}}
                                                    end).(state) do
                                                      {:ok, state} ->
                                                      case (fn state ->
                                                        r_R1(state)
                                                      end).(state) do
                                                        {:ok, state} ->
                                                        case (fn state ->
                                                          r_C(state)
                                                        end).(state) do
                                                          {:ok, state} ->
                                                          {:ok, Runtime.slice_del(state)}
                                                          r -> r
                                                        end
                                                        r -> r
                                                      end
                                                    end
                                                    r -> r
                                                  end
                                                end)
                                            end,
                                            fn state ->
                                              case (fn state ->
                                                lift(state, Runtime.eq_s_b(state, "rnt"))
                                              end).(state) do
                                                {:ok, state} ->
                                                case (fn state ->
                                                  {:ok, %{state | bra: state.cursor}}
                                                end).(state) do
                                                  {:ok, state} ->
                                                  {:ok, Runtime.slice_from(state, "rn")}
                                                end
                                                r -> r
                                              end
                                            end)
                                        end,
                                        fn state ->
                                          case (fn state ->
                                            lift(state, Runtime.eq_s_b(state, "t"))
                                          end).(state) do
                                            {:ok, state} ->
                                            case (fn state ->
                                              {:ok, %{state | bra: state.cursor}}
                                            end).(state) do
                                              {:ok, state} ->
                                              case (fn state ->
                                                r_R1(state)
                                              end).(state) do
                                                {:ok, state} ->
                                                case (fn state ->
                                                  r_VX(state)
                                                end).(state) do
                                                  {:ok, state} ->
                                                  {:ok, Runtime.slice_del(state)}
                                                  r -> r
                                                end
                                                r -> r
                                              end
                                            end
                                            r -> r
                                          end
                                        end)
                                    end,
                                    fn state ->
                                      case (fn state ->
                                        lift(state, Runtime.eq_s_b(state, "ink"))
                                      end).(state) do
                                        {:ok, state} ->
                                        case (fn state ->
                                          {:ok, %{state | bra: state.cursor}}
                                        end).(state) do
                                          {:ok, state} ->
                                          {:ok, Runtime.slice_from(state, "ing")}
                                        end
                                        r -> r
                                      end
                                    end)
                                end,
                                fn state ->
                                  case (fn state ->
                                    lift(state, Runtime.eq_s_b(state, "mp"))
                                  end).(state) do
                                    {:ok, state} ->
                                    case (fn state ->
                                      {:ok, %{state | bra: state.cursor}}
                                    end).(state) do
                                      {:ok, state} ->
                                      {:ok, Runtime.slice_from(state, "m")}
                                    end
                                    r -> r
                                  end
                                end)
                            end,
                            fn state ->
                              case (fn state ->
                                lift(state, Runtime.eq_s_b(state, "'"))
                              end).(state) do
                                {:ok, state} ->
                                case (fn state ->
                                  {:ok, %{state | bra: state.cursor}}
                                end).(state) do
                                  {:ok, state} ->
                                  case (fn state ->
                                    r_R1(state)
                                  end).(state) do
                                    {:ok, state} ->
                                    {:ok, Runtime.slice_del(state)}
                                    r -> r
                                  end
                                end
                                r -> r
                              end
                            end)
                        end,
                        fn state ->
                          case (fn state ->
                            {:ok, %{state | bra: state.cursor}}
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              r_R1(state)
                            end).(state) do
                              {:ok, state} ->
                              case (fn state ->
                                r_C(state)
                              end).(state) do
                                {:ok, state} ->
                                {:ok, Runtime.slice_del(state)}
                                r -> r
                              end
                              r -> r
                            end
                          end
                        end)
                    2 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "g")}
                        r -> r
                      end
                    3 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "lijk")}
                        r -> r
                      end
                    4 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "isch")}
                        r -> r
                      end
                    5 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          r_C(state)
                        end).(state) do
                          {:ok, state} ->
                          {:ok, Runtime.slice_del(state)}
                          r -> r
                        end
                        r -> r
                      end
                    6 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "t")}
                        r -> r
                      end
                    7 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "s")}
                        r -> r
                      end
                    8 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "r")}
                        r -> r
                      end
                    9 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, Runtime.slice_del(state)}
                        end).(state) do
                          {:ok, state} ->
                          case (fn state ->
                            (fn ->
                              saved_c = state.cursor
                              new_state = Runtime.insert(state, saved_c, saved_c, "l")
                              {:ok, %{new_state | cursor: saved_c + byte_size("l")}}
                            end).()
                          end).(state) do
                            {:ok, state} ->
                            r_lengthen_V(state)
                          end
                        end
                        r -> r
                      end
                    10 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          r_C(state)
                        end).(state) do
                          {:ok, state} ->
                          case (fn state ->
                            {:ok, Runtime.slice_del(state)}
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              (fn ->
                                saved_c = state.cursor
                                new_state = Runtime.insert(state, saved_c, saved_c, "en")
                                {:ok, %{new_state | cursor: saved_c + byte_size("en")}}
                              end).()
                            end).(state) do
                              {:ok, state} ->
                              r_lengthen_V(state)
                            end
                          end
                          r -> r
                        end
                        r -> r
                      end
                    11 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          r_C(state)
                        end).(state) do
                          {:ok, state} ->
                          {:ok, Runtime.slice_from(state, "ief")}
                          r -> r
                        end
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Step_1(%Runtime{} = state) do
    (fn ->
      state = %{state | ket: state.cursor}
      case Runtime.find_among_b(state, @a_7) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | bra: s.cursor}
          case result do
                    1 ->
                      {:ok, Runtime.slice_del(state)}
                    2 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          (fn state ->
                            saved_c = state.cursor
                            case (fn state ->
                            case (fn state ->
                              lift(state, Runtime.eq_s_b(state, "t"))
                            end).(state) do
                              {:ok, state} ->
                              r_R1(state)
                              r -> r
                            end
                            end).(state) do
                              {:ok, s} -> {:fail, %{s | cursor: saved_c}}
                              {:fail, s} -> {:ok, %{s | cursor: saved_c}}
                            end
                          end).(state)
                        end).(state) do
                          {:ok, state} ->
                          case (fn state ->
                            r_C(state)
                          end).(state) do
                            {:ok, state} ->
                            {:ok, Runtime.slice_del(state)}
                            r -> r
                          end
                          r -> r
                        end
                        r -> r
                      end
                    3 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "ie")}
                        r -> r
                      end
                    4 ->
                      snowball_or(state,
                        fn state ->
                          snowball_or(state,
                            fn state ->
                              case (fn state ->
                                snowball_test_b(state, fn state ->
                                  case (fn state ->
                                    lift(state, Runtime.eq_s_b(state, "ar"))
                                  end).(state) do
                                    {:ok, state} ->
                                    case (fn state ->
                                      r_R1(state)
                                    end).(state) do
                                      {:ok, state} ->
                                      r_C(state)
                                      r -> r
                                    end
                                    r -> r
                                  end
                                end)
                              end).(state) do
                                {:ok, state} ->
                                case (fn state ->
                                  {:ok, Runtime.slice_del(state)}
                                end).(state) do
                                  {:ok, state} ->
                                  r_lengthen_V(state)
                                end
                                r -> r
                              end
                            end,
                            fn state ->
                              case (fn state ->
                                snowball_test_b(state, fn state ->
                                  case (fn state ->
                                    lift(state, Runtime.eq_s_b(state, "er"))
                                  end).(state) do
                                    {:ok, state} ->
                                    case (fn state ->
                                      r_R1(state)
                                    end).(state) do
                                      {:ok, state} ->
                                      r_C(state)
                                      r -> r
                                    end
                                    r -> r
                                  end
                                end)
                              end).(state) do
                                {:ok, state} ->
                                {:ok, Runtime.slice_del(state)}
                                r -> r
                              end
                            end)
                        end,
                        fn state ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              r_C(state)
                            end).(state) do
                              {:ok, state} ->
                              {:ok, Runtime.slice_from(state, "e")}
                              r -> r
                            end
                            r -> r
                          end
                        end)
                    5 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "é")}
                        r -> r
                      end
                    6 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          r_V(state)
                        end).(state) do
                          {:ok, state} ->
                          {:ok, Runtime.slice_from(state, "au")}
                          r -> r
                        end
                        r -> r
                      end
                    7 ->
                      snowball_or(state,
                        fn state ->
                          snowball_or(state,
                            fn state ->
                              snowball_or(state,
                                fn state ->
                                  snowball_or(state,
                                    fn state ->
                                      case (fn state ->
                                        lift(state, Runtime.eq_s_b(state, "hed"))
                                      end).(state) do
                                        {:ok, state} ->
                                        case (fn state ->
                                          r_R1(state)
                                        end).(state) do
                                          {:ok, state} ->
                                          case (fn state ->
                                            {:ok, %{state | bra: state.cursor}}
                                          end).(state) do
                                            {:ok, state} ->
                                            {:ok, Runtime.slice_from(state, "heid")}
                                          end
                                          r -> r
                                        end
                                        r -> r
                                      end
                                    end,
                                    fn state ->
                                      case (fn state ->
                                        lift(state, Runtime.eq_s_b(state, "nd"))
                                      end).(state) do
                                        {:ok, state} ->
                                        {:ok, Runtime.slice_del(state)}
                                        r -> r
                                      end
                                    end)
                                end,
                                fn state ->
                                  case (fn state ->
                                    lift(state, Runtime.eq_s_b(state, "d"))
                                  end).(state) do
                                    {:ok, state} ->
                                    case (fn state ->
                                      r_R1(state)
                                    end).(state) do
                                      {:ok, state} ->
                                      case (fn state ->
                                        r_C(state)
                                      end).(state) do
                                        {:ok, state} ->
                                        case (fn state ->
                                          {:ok, %{state | bra: state.cursor}}
                                        end).(state) do
                                          {:ok, state} ->
                                          {:ok, Runtime.slice_del(state)}
                                        end
                                        r -> r
                                      end
                                      r -> r
                                    end
                                    r -> r
                                  end
                                end)
                            end,
                            fn state ->
                              case (fn state ->
                                snowball_or(state,
                                  fn state ->
                                    lift(state, Runtime.eq_s_b(state, "i"))
                                  end,
                                  fn state ->
                                    lift(state, Runtime.eq_s_b(state, "j"))
                                  end)
                              end).(state) do
                                {:ok, state} ->
                                case (fn state ->
                                  r_V(state)
                                end).(state) do
                                  {:ok, state} ->
                                  {:ok, Runtime.slice_del(state)}
                                  r -> r
                                end
                                r -> r
                              end
                            end)
                        end,
                        fn state ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              r_C(state)
                            end).(state) do
                              {:ok, state} ->
                              case (fn state ->
                                {:ok, Runtime.slice_del(state)}
                              end).(state) do
                                {:ok, state} ->
                                r_lengthen_V(state)
                              end
                              r -> r
                            end
                            r -> r
                          end
                        end)
                    8 ->
                      {:ok, Runtime.slice_from(state, "nd")}
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_lengthen_V(%Runtime{} = state) do
    {:ok, snowball_do_b(state, fn state ->
      case (fn state ->
        lift(state, Runtime.out_grouping_b(state, @g_v_WX))
      end).(state) do
        {:ok, state} ->
        (fn ->
          state = %{state | ket: state.cursor}
          case Runtime.find_among_b(state, @a_8) do
            :fail -> {:fail, state}
            {%Runtime{} = s, result} ->
              state = %{s | bra: s.cursor}
              case result do
                        1 ->
                          case (fn state ->
                            snowball_test_b(state, fn state ->
                              snowball_or(state,
                                fn state ->
                                  lift(state, Runtime.out_grouping_b(state, @g_AEIOU))
                                end,
                                fn state ->
                                  if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
                                end)
                            end)
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              {:ok, put_in(state.vars[:ch], Runtime.slice_to(state))}
                            end).(state) do
                              {:ok, state} ->
                              (fn ->
                                saved_c = state.cursor
                                {:ok, %{Runtime.insert(state, state.cursor, state.cursor, state.vars[:ch]) | cursor: saved_c}}
                              end).()
                            end
                            r -> r
                          end
                        2 ->
                          case (fn state ->
                            snowball_test_b(state, fn state ->
                              case (fn state ->
                                snowball_or(state,
                                  fn state ->
                                    lift(state, Runtime.out_grouping_b(state, @g_AEIOU))
                                  end,
                                  fn state ->
                                    if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
                                  end)
                              end).(state) do
                                {:ok, state} ->
                                case (fn state ->
                                  (fn state ->
                                    saved_c = state.cursor
                                    case (fn state ->
                                    snowball_or(state,
                                      fn state ->
                                        lift(state, Runtime.in_grouping_b(state, @g_AIOU))
                                      end,
                                      fn state ->
                                        case (fn state ->
                                          lift(state, Runtime.in_grouping_b(state, @g_E))
                                        end).(state) do
                                          {:ok, state} ->
                                          if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
                                          r -> r
                                        end
                                      end)
                                    end).(state) do
                                      {:ok, s} -> {:fail, %{s | cursor: saved_c}}
                                      {:fail, s} -> {:ok, %{s | cursor: saved_c}}
                                    end
                                  end).(state)
                                end).(state) do
                                  {:ok, state} ->
                                  (fn state ->
                                    saved_c = state.cursor
                                    case (fn state ->
                                    case (fn state ->
                                      next_codepoint_b(state)
                                    end).(state) do
                                      {:ok, state} ->
                                      case (fn state ->
                                        lift(state, Runtime.in_grouping_b(state, @g_AIOU))
                                      end).(state) do
                                        {:ok, state} ->
                                        lift(state, Runtime.out_grouping_b(state, @g_AEIOU))
                                        r -> r
                                      end
                                      r -> r
                                    end
                                    end).(state) do
                                      {:ok, s} -> {:fail, %{s | cursor: saved_c}}
                                      {:fail, s} -> {:ok, %{s | cursor: saved_c}}
                                    end
                                  end).(state)
                                  r -> r
                                end
                                r -> r
                              end
                            end)
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              {:ok, put_in(state.vars[:ch], Runtime.slice_to(state))}
                            end).(state) do
                              {:ok, state} ->
                              (fn ->
                                saved_c = state.cursor
                                {:ok, %{Runtime.insert(state, state.cursor, state.cursor, state.vars[:ch]) | cursor: saved_c}}
                              end).()
                            end
                            r -> r
                          end
                        3 ->
                          {:ok, Runtime.slice_from(state, "eëe")}
                        4 ->
                          {:ok, Runtime.slice_from(state, "iee")}
                _ -> {:ok, state}
              end
          end
        end).()
        r -> r
      end
    end)}
  end

  defp r_C(%Runtime{} = state) do
    snowball_test_b(state, fn state ->
      case (fn state ->
        (fn state ->
          saved_c = state.cursor
          case (fn state ->
          lift(state, Runtime.eq_s_b(state, "ij"))
          end).(state) do
            {:ok, s} -> {:fail, %{s | cursor: saved_c}}
            {:fail, s} -> {:ok, %{s | cursor: saved_c}}
          end
        end).(state)
      end).(state) do
        {:ok, state} ->
        lift(state, Runtime.out_grouping_b(state, @g_v))
        r -> r
      end
    end)
  end

  defp r_VX(%Runtime{} = state) do
    snowball_test_b(state, fn state ->
      case (fn state ->
        next_codepoint_b(state)
      end).(state) do
        {:ok, state} ->
        snowball_or(state,
          fn state ->
            lift(state, Runtime.in_grouping_b(state, @g_v))
          end,
          fn state ->
            lift(state, Runtime.eq_s_b(state, "ij"))
          end)
        r -> r
      end
    end)
  end

  defp r_V(%Runtime{} = state) do
    snowball_test_b(state, fn state ->
      snowball_or(state,
        fn state ->
          lift(state, Runtime.in_grouping_b(state, @g_v))
        end,
        fn state ->
          lift(state, Runtime.eq_s_b(state, "ij"))
        end)
    end)
  end

  defp r_R2(%Runtime{} = state) do
    if state.vars[:p2] <= state.cursor, do: {:ok, state}, else: {:fail, state}
  end

  defp r_R1(%Runtime{} = state) do
    if state.vars[:p1] <= state.cursor, do: {:ok, state}, else: {:fail, state}
  end

  defp r_Lose_prefix(%Runtime{} = state) do
    case (fn state ->
      {:ok, %{state | bra: state.cursor}}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        lift(state, Runtime.eq_s(state, "ge"))
      end).(state) do
        {:ok, state} ->
        case (fn state ->
          {:ok, %{state | ket: state.cursor}}
        end).(state) do
          {:ok, state} ->
          case (fn state ->
            snowball_test_f(state, fn state ->
              (fn ->
                n = 3
                Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
                  case next_codepoint(s) do
                    {:ok, s2} -> {:cont, {:ok, s2}}
                    {:fail, _} -> {:halt, {:fail, state}}
                  end
                end)
              end).()
            end)
          end).(state) do
            {:ok, state} ->
            case (fn state ->
              snowball_test_f(state, fn state ->
                case (fn state ->
                  (fn loop_fn ->
                    loop_fn.(loop_fn, state)
                  end).(fn loop_fn, state ->
                    v = state.cursor
                    case (fn state ->
                      snowball_or(state,
                        fn state ->
                          lift(state, Runtime.eq_s(state, "ij"))
                        end,
                        fn state ->
                          lift(state, Runtime.in_grouping(state, @g_v))
                        end)
                    end).(state) do
                      {:ok, s} -> {:ok, s}
                      {:fail, _} ->
                        case next_codepoint(%{state | cursor: v}) do
                          {:ok, s} -> loop_fn.(loop_fn, s)
                          {:fail, _} -> {:fail, state}
                        end
                    end
                  end)
                end).(state) do
                  {:ok, state} ->
                  case (fn state ->
                    (fn loop_fn ->
                      loop_fn.(loop_fn, state)
                    end).(fn loop_fn, state ->
                      case (fn state ->
                        snowball_or(state,
                          fn state ->
                            lift(state, Runtime.eq_s(state, "ij"))
                          end,
                          fn state ->
                            lift(state, Runtime.in_grouping(state, @g_v))
                          end)
                      end).(state) do
                        {:ok, s} -> loop_fn.(loop_fn, s)
                        {:fail, s} -> {:ok, %{s | cursor: state.cursor}}
                      end
                    end)
                  end).(state) do
                    {:ok, state} ->
                    (fn state ->
                      saved_c = state.cursor
                      case (fn state ->
                      if state.cursor >= state.limit, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, s} -> {:fail, %{s | cursor: saved_c}}
                        {:fail, s} -> {:ok, %{s | cursor: saved_c}}
                      end
                    end).(state)
                  end
                  r -> r
                end
              end)
            end).(state) do
              {:ok, state} ->
              case (fn state ->
                (fn ->
                  case Runtime.find_among(state, @a_9) do
                    :fail -> {:fail, state}
                    {%Runtime{} = s, result} ->
                      state = s
                      case result do
                        1 ->
                          {:fail, state}
                        2 ->
                          {:fail, state}
                        3 ->
                          {:ok, state}
                        4 ->
                          {:fail, state}
                        5 ->
                          {:ok, state}
                        _ -> {:ok, s}
                      end
                  end
                end).()
              end).(state) do
                {:ok, state} ->
                case (fn state ->
                  {:ok, put_in(state.vars[:GE_removed], true)}
                end).(state) do
                  {:ok, state} ->
                  case (fn state ->
                    {:ok, Runtime.slice_del(state)}
                  end).(state) do
                    {:ok, state} ->
                    {:ok, snowball_do_f(state, fn state ->
                      (fn ->
                        state = %{state | bra: state.cursor}
                        case Runtime.find_among(state, @a_10) do
                          :fail -> {:fail, state}
                          {%Runtime{} = s, result} ->
                            state = %{s | ket: s.cursor}
                            case result do
                                      1 ->
                                        {:ok, Runtime.slice_from(state, "e")}
                                      2 ->
                                        {:ok, Runtime.slice_from(state, "i")}
                              _ -> {:ok, state}
                            end
                        end
                      end).()
                    end)}
                  end
                end
                r -> r
              end
              r -> r
            end
            r -> r
          end
        end
        r -> r
      end
    end
  end

  defp r_Lose_infix(%Runtime{} = state) do
    case (fn state ->
      next_codepoint(state)
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        (fn loop_fn ->
          loop_fn.(loop_fn, state)
        end).(fn loop_fn, state ->
          v = state.cursor
          case (fn state ->
            case (fn state ->
              {:ok, %{state | bra: state.cursor}}
            end).(state) do
              {:ok, state} ->
              case (fn state ->
                lift(state, Runtime.eq_s(state, "ge"))
              end).(state) do
                {:ok, state} ->
                {:ok, %{state | ket: state.cursor}}
                r -> r
              end
            end
          end).(state) do
            {:ok, s} -> {:ok, s}
            {:fail, _} ->
              case next_codepoint(%{state | cursor: v}) do
                {:ok, s} -> loop_fn.(loop_fn, s)
                {:fail, _} -> {:fail, state}
              end
          end
        end)
      end).(state) do
        {:ok, state} ->
        case (fn state ->
          snowball_test_f(state, fn state ->
            (fn ->
              n = 3
              Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
                case next_codepoint(s) do
                  {:ok, s2} -> {:cont, {:ok, s2}}
                  {:fail, _} -> {:halt, {:fail, state}}
                end
              end)
            end).()
          end)
        end).(state) do
          {:ok, state} ->
          case (fn state ->
            snowball_test_f(state, fn state ->
              case (fn state ->
                (fn loop_fn ->
                  loop_fn.(loop_fn, state)
                end).(fn loop_fn, state ->
                  v = state.cursor
                  case (fn state ->
                    snowball_or(state,
                      fn state ->
                        lift(state, Runtime.eq_s(state, "ij"))
                      end,
                      fn state ->
                        lift(state, Runtime.in_grouping(state, @g_v))
                      end)
                  end).(state) do
                    {:ok, s} -> {:ok, s}
                    {:fail, _} ->
                      case next_codepoint(%{state | cursor: v}) do
                        {:ok, s} -> loop_fn.(loop_fn, s)
                        {:fail, _} -> {:fail, state}
                      end
                  end
                end)
              end).(state) do
                {:ok, state} ->
                case (fn state ->
                  (fn loop_fn ->
                    loop_fn.(loop_fn, state)
                  end).(fn loop_fn, state ->
                    case (fn state ->
                      snowball_or(state,
                        fn state ->
                          lift(state, Runtime.eq_s(state, "ij"))
                        end,
                        fn state ->
                          lift(state, Runtime.in_grouping(state, @g_v))
                        end)
                    end).(state) do
                      {:ok, s} -> loop_fn.(loop_fn, s)
                      {:fail, s} -> {:ok, %{s | cursor: state.cursor}}
                    end
                  end)
                end).(state) do
                  {:ok, state} ->
                  (fn state ->
                    saved_c = state.cursor
                    case (fn state ->
                    if state.cursor >= state.limit, do: {:ok, state}, else: {:fail, state}
                    end).(state) do
                      {:ok, s} -> {:fail, %{s | cursor: saved_c}}
                      {:fail, s} -> {:ok, %{s | cursor: saved_c}}
                    end
                  end).(state)
                end
                r -> r
              end
            end)
          end).(state) do
            {:ok, state} ->
            case (fn state ->
              {:ok, put_in(state.vars[:GE_removed], true)}
            end).(state) do
              {:ok, state} ->
              case (fn state ->
                {:ok, Runtime.slice_del(state)}
              end).(state) do
                {:ok, state} ->
                {:ok, snowball_do_f(state, fn state ->
                  (fn ->
                    state = %{state | bra: state.cursor}
                    case Runtime.find_among(state, @a_11) do
                      :fail -> {:fail, state}
                      {%Runtime{} = s, result} ->
                        state = %{s | ket: s.cursor}
                        case result do
                                  1 ->
                                    {:ok, Runtime.slice_from(state, "e")}
                                  2 ->
                                    {:ok, Runtime.slice_from(state, "i")}
                          _ -> {:ok, state}
                        end
                    end
                  end).()
                end)}
              end
            end
            r -> r
          end
          r -> r
        end
        r -> r
      end
      r -> r
    end
  end

  defp r_measure(%Runtime{} = state) do
    case (fn state ->
      {:ok, put_in(state.vars[:p1], state.limit)}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, put_in(state.vars[:p2], state.limit)}
      end).(state) do
        {:ok, state} ->
        {:ok, snowball_do_f(state, fn state ->
          case (fn state ->
            (fn loop_fn ->
              loop_fn.(loop_fn, state)
            end).(fn loop_fn, state ->
              case (fn state ->
                lift(state, Runtime.out_grouping(state, @g_v))
              end).(state) do
                {:ok, s} -> loop_fn.(loop_fn, s)
                {:fail, s} -> {:ok, %{s | cursor: state.cursor}}
              end
            end)
          end).(state) do
            {:ok, state} ->
            case (fn state ->
              (fn ->
                n = 1
                case Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
                  case (fn state ->
                  snowball_or(state,
                    fn state ->
                      lift(state, Runtime.eq_s(state, "ij"))
                    end,
                    fn state ->
                      lift(state, Runtime.in_grouping(state, @g_v))
                    end)
                  end).(s) do
                    {:ok, s2} -> {:cont, {:ok, s2}}
                    {:fail, s2} -> {:halt, {:fail, s2}}
                  end
                end) do
                  {:fail, s} -> {:fail, s}
                  {:ok, state} ->
                    (fn loop_fn ->
                      loop_fn.(loop_fn, state)
                    end).(fn loop_fn, state ->
                      case (fn state ->
                    snowball_or(state,
                      fn state ->
                        lift(state, Runtime.eq_s(state, "ij"))
                      end,
                      fn state ->
                        lift(state, Runtime.in_grouping(state, @g_v))
                      end)
                      end).(state) do
                        {:ok, s} -> loop_fn.(loop_fn, s)
                        {:fail, _} -> {:ok, state}
                      end
                    end)
                end
              end).()
            end).(state) do
              {:ok, state} ->
              case (fn state ->
                lift(state, Runtime.out_grouping(state, @g_v))
              end).(state) do
                {:ok, state} ->
                case (fn state ->
                  {:ok, put_in(state.vars[:p1], state.cursor)}
                end).(state) do
                  {:ok, state} ->
                  case (fn state ->
                    (fn loop_fn ->
                      loop_fn.(loop_fn, state)
                    end).(fn loop_fn, state ->
                      case (fn state ->
                        lift(state, Runtime.out_grouping(state, @g_v))
                      end).(state) do
                        {:ok, s} -> loop_fn.(loop_fn, s)
                        {:fail, s} -> {:ok, %{s | cursor: state.cursor}}
                      end
                    end)
                  end).(state) do
                    {:ok, state} ->
                    case (fn state ->
                      (fn ->
                        n = 1
                        case Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
                          case (fn state ->
                          snowball_or(state,
                            fn state ->
                              lift(state, Runtime.eq_s(state, "ij"))
                            end,
                            fn state ->
                              lift(state, Runtime.in_grouping(state, @g_v))
                            end)
                          end).(s) do
                            {:ok, s2} -> {:cont, {:ok, s2}}
                            {:fail, s2} -> {:halt, {:fail, s2}}
                          end
                        end) do
                          {:fail, s} -> {:fail, s}
                          {:ok, state} ->
                            (fn loop_fn ->
                              loop_fn.(loop_fn, state)
                            end).(fn loop_fn, state ->
                              case (fn state ->
                            snowball_or(state,
                              fn state ->
                                lift(state, Runtime.eq_s(state, "ij"))
                              end,
                              fn state ->
                                lift(state, Runtime.in_grouping(state, @g_v))
                              end)
                              end).(state) do
                                {:ok, s} -> loop_fn.(loop_fn, s)
                                {:fail, _} -> {:ok, state}
                              end
                            end)
                        end
                      end).()
                    end).(state) do
                      {:ok, state} ->
                      case (fn state ->
                        lift(state, Runtime.out_grouping(state, @g_v))
                      end).(state) do
                        {:ok, state} ->
                        {:ok, put_in(state.vars[:p2], state.cursor)}
                        r -> r
                      end
                      r -> r
                    end
                  end
                end
                r -> r
              end
              r -> r
            end
          end
        end)}
      end
    end
  end

  defp r_stem(%Runtime{} = state) do
    case (fn state ->
      {:ok, put_in(state.vars[:stemmed], false)}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        r_measure(state)
      end).(state) do
        {:ok, state} ->
        case (fn state ->
          (fn state ->
            old_cursor = state.cursor
            old_lb = state.limit_backward
            state = %{state | cursor: state.limit, limit_backward: old_cursor}
            {tag, s} = (fn state ->
              case (fn state ->
                {:ok, snowball_do_b(state, fn state ->
                  case (fn state ->
                    r_Step_1(state)
                  end).(state) do
                    {:ok, state} ->
                    {:ok, put_in(state.vars[:stemmed], true)}
                    r -> r
                  end
                end)}
              end).(state) do
                {:ok, state} ->
                case (fn state ->
                  {:ok, snowball_do_b(state, fn state ->
                    case (fn state ->
                      r_Step_2(state)
                    end).(state) do
                      {:ok, state} ->
                      {:ok, put_in(state.vars[:stemmed], true)}
                      r -> r
                    end
                  end)}
                end).(state) do
                  {:ok, state} ->
                  case (fn state ->
                    {:ok, snowball_do_b(state, fn state ->
                      case (fn state ->
                        r_Step_3(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, put_in(state.vars[:stemmed], true)}
                        r -> r
                      end
                    end)}
                  end).(state) do
                    {:ok, state} ->
                    {:ok, snowball_do_b(state, fn state ->
                      case (fn state ->
                        r_Step_4(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, put_in(state.vars[:stemmed], true)}
                        r -> r
                      end
                    end)}
                  end
                end
              end
            end).(state)
            {tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
          end).(state)
        end).(state) do
          {:ok, state} ->
          case (fn state ->
            {:ok, put_in(state.vars[:GE_removed], false)}
          end).(state) do
            {:ok, state} ->
            case (fn state ->
              {:ok, snowball_do_f(state, fn state ->
                case (fn state ->
                  snowball_test_f(state, fn state ->
                    r_Lose_prefix(state)
                  end)
                end).(state) do
                  {:ok, state} ->
                  r_measure(state)
                  r -> r
                end
              end)}
            end).(state) do
              {:ok, state} ->
              case (fn state ->
                (fn state ->
                  old_cursor = state.cursor
                  old_lb = state.limit_backward
                  state = %{state | cursor: state.limit, limit_backward: old_cursor}
                  {tag, s} = (fn state ->
                    {:ok, snowball_do_b(state, fn state ->
                      case (fn state ->
                        if state.vars[:GE_removed], do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, put_in(state.vars[:stemmed], true)}
                        end).(state) do
                          {:ok, state} ->
                          r_Step_1c(state)
                        end
                        r -> r
                      end
                    end)}
                  end).(state)
                  {tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
                end).(state)
              end).(state) do
                {:ok, state} ->
                case (fn state ->
                  {:ok, put_in(state.vars[:GE_removed], false)}
                end).(state) do
                  {:ok, state} ->
                  case (fn state ->
                    {:ok, snowball_do_f(state, fn state ->
                      case (fn state ->
                        snowball_test_f(state, fn state ->
                          r_Lose_infix(state)
                        end)
                      end).(state) do
                        {:ok, state} ->
                        r_measure(state)
                        r -> r
                      end
                    end)}
                  end).(state) do
                    {:ok, state} ->
                    case (fn state ->
                      (fn state ->
                        old_cursor = state.cursor
                        old_lb = state.limit_backward
                        state = %{state | cursor: state.limit, limit_backward: old_cursor}
                        {tag, s} = (fn state ->
                          {:ok, snowball_do_b(state, fn state ->
                            case (fn state ->
                              if state.vars[:GE_removed], do: {:ok, state}, else: {:fail, state}
                            end).(state) do
                              {:ok, state} ->
                              case (fn state ->
                                {:ok, put_in(state.vars[:stemmed], true)}
                              end).(state) do
                                {:ok, state} ->
                                r_Step_1c(state)
                              end
                              r -> r
                            end
                          end)}
                        end).(state)
                        {tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
                      end).(state)
                    end).(state) do
                      {:ok, state} ->
                      (fn state ->
                        old_cursor = state.cursor
                        old_lb = state.limit_backward
                        state = %{state | cursor: state.limit, limit_backward: old_cursor}
                        {tag, s} = (fn state ->
                          case (fn state ->
                            {:ok, snowball_do_b(state, fn state ->
                              case (fn state ->
                                r_Step_7(state)
                              end).(state) do
                                {:ok, state} ->
                                {:ok, put_in(state.vars[:stemmed], true)}
                                r -> r
                              end
                            end)}
                          end).(state) do
                            {:ok, state} ->
                            {:ok, snowball_do_b(state, fn state ->
                              case (fn state ->
                                if state.vars[:stemmed], do: {:ok, state}, else: {:fail, state}
                              end).(state) do
                                {:ok, state} ->
                                r_Step_6(state)
                                r -> r
                              end
                            end)}
                          end
                        end).(state)
                        {tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
                      end).(state)
                    end
                  end
                end
              end
            end
          end
        end
        r -> r
      end
    end
  end

end