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

  Generated from the canonical Snowball algorithm source.
  """

  alias Snowball.Runtime
  alias Snowball.Grouping


  # Groupings
  @g_aou Grouping.from_string("aou")
  @g_digit Grouping.from_string("0123456789")
  @g_vowel Grouping.from_string("aeiou")


  # Among tables
  @a_0 [
    {"a", -1, -1, nil},
    {"e", -1, -1, nil},
    {"i", -1, -1, nil},
    {"j", -1, 1, nil},
    {"aj", 3, -1, nil},
    {"oj", 3, -1, nil},
    {"n", -1, 1, nil},
    {"an", 6, -1, nil},
    {"en", 6, -1, nil},
    {"jn", 6, 1, nil},
    {"ajn", 9, -1, nil},
    {"ojn", 9, -1, nil},
    {"on", 6, -1, nil},
    {"o", -1, -1, nil},
    {"as", -1, -1, nil},
    {"is", -1, -1, nil},
    {"os", -1, -1, nil},
    {"us", -1, -1, nil},
    {"u", -1, -1, nil}
  ]
  @a_1 [
    {"k", -1, -1, nil},
    {"kelk", 0, -1, nil},
    {"nen", -1, -1, nil},
    {"t", -1, -1, nil},
    {"mult", 3, -1, nil},
    {"samt", 3, -1, nil},
    {"ĉ", -1, -1, nil}
  ]
  @a_2 [
    {"tri", -1, -1, nil},
    {"du", -1, -1, nil},
    {"unu", -1, -1, nil}
  ]
  @a_3 [
    {"dek", -1, -1, nil},
    {"cent", -1, -1, nil}
  ]
  @a_4 [
    {"aha", -1, -1, nil},
    {"haha", 0, -1, nil},
    {"haleluja", -1, -1, nil},
    {"hola", -1, -1, nil},
    {"hosana", -1, -1, nil},
    {"maltra", -1, -1, nil},
    {"hura", -1, -1, nil},
    {"ĥaĥa", -1, -1, nil},
    {"ekde", -1, -1, nil},
    {"elde", -1, -1, nil},
    {"disde", -1, -1, nil},
    {"ehe", -1, -1, nil},
    {"maltre", -1, -1, nil},
    {"dirlididi", -1, -1, nil},
    {"malpli", -1, -1, nil},
    {"malĉi", -1, -1, nil},
    {"malkaj", -1, -1, nil},
    {"amen", -1, -1, nil},
    {"tamen", 17, -1, nil},
    {"oho", -1, -1, nil},
    {"maltro", -1, -1, nil},
    {"minus", -1, -1, nil},
    {"uhu", -1, -1, nil},
    {"muu", -1, -1, nil}
  ]
  @a_5 [
    {"aliu", -1, -1, nil},
    {"unu", -1, -1, nil}
  ]
  @a_6 [
    {"amb", -1, -1, nil},
    {"bald", -1, -1, nil},
    {"malbald", 1, -1, nil},
    {"morg", -1, -1, nil},
    {"postmorg", 3, -1, nil},
    {"adi", -1, -1, nil},
    {"hodi", -1, -1, nil},
    {"ank", -1, -1, nil},
    {"ĉirk", -1, -1, nil},
    {"tutĉirk", 8, -1, nil},
    {"presk", -1, -1, nil},
    {"almen", -1, -1, nil},
    {"apen", -1, -1, nil},
    {"hier", -1, -1, nil},
    {"antaŭhier", 13, -1, nil},
    {"malgr", -1, -1, nil},
    {"ankor", -1, -1, nil},
    {"kontr", -1, -1, nil},
    {"anstat", -1, -1, nil},
    {"kvaz", -1, -1, nil}
  ]
  @a_7 [
    {"ci", -1, -1, nil},
    {"gi", -1, -1, nil},
    {"hi", -1, -1, nil},
    {"li", -1, -1, nil},
    {"ili", 3, -1, nil},
    {"ŝli", 3, -1, nil},
    {"mi", -1, -1, nil},
    {"ni", -1, -1, nil},
    {"oni", 7, -1, nil},
    {"ri", -1, -1, nil},
    {"si", -1, -1, nil},
    {"vi", -1, -1, nil},
    {"ivi", 11, -1, nil},
    {"ĝi", -1, -1, nil},
    {"ŝi", -1, -1, nil},
    {"iŝi", 14, -1, nil},
    {"malŝi", 14, -1, nil}
  ]
  @a_8 [
    {"", -1, 14, nil},
    {"-", 0, 13, nil},
    {"cx", 0, 1, nil},
    {"gx", 0, 2, nil},
    {"hx", 0, 3, nil},
    {"jx", 0, 4, nil},
    {"q", 0, 12, nil},
    {"sx", 0, 5, nil},
    {"ux", 0, 6, nil},
    {"w", 0, 12, nil},
    {"x", 0, 12, nil},
    {"y", 0, 12, nil},
    {"á", 0, 7, nil},
    {"é", 0, 8, nil},
    {"í", 0, 9, nil},
    {"ó", 0, 10, nil},
    {"ú", 0, 11, nil}
  ]
  @a_9 [
    {"as", -1, -1, nil},
    {"i", -1, -1, nil},
    {"is", 1, -1, nil},
    {"os", -1, -1, nil},
    {"u", -1, -1, nil},
    {"us", 4, -1, 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: %{foreign: false}}

  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_try(state, fun) do
    rel = state.limit - state.cursor
    case fun.(state) do
      {:ok, s} -> s
      {:fail, s} -> %{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_standard_suffix(%Runtime{} = state) do
    case (fn state ->
      {:ok, %{state | ket: state.cursor}}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        (fn ->
          case Runtime.find_among_b(state, @a_0) do
            :fail -> {:fail, state}
            {%Runtime{} = s, result} ->
              state = s
              case result do
                1 ->
                  snowball_test_b(state, fn state ->
                    snowball_or(state,
                      fn state ->
                        lift(state, Runtime.eq_s_b(state, "-"))
                      end,
                      fn state ->
                        lift(state, Runtime.in_grouping_b(state, @g_digit))
                      end)
                  end)
                _ -> {:ok, s}
              end
          end
        end).()
      end).(state) do
        {:ok, state} ->
        case (fn state ->
          {:ok, snowball_try(state, fn state ->
            lift(state, Runtime.eq_s_b(state, "-"))
          end)}
        end).(state) do
          {:ok, state} ->
          case (fn state ->
            {:ok, %{state | bra: state.cursor}}
          end).(state) do
            {:ok, state} ->
            {:ok, Runtime.slice_del(state)}
          end
        end
        r -> r
      end
    end
  end

  defp r_long_word(%Runtime{} = state) do
    snowball_or(state,
      fn state ->
        snowball_or(state,
          fn state ->
            (fn ->
              n = 2
              Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
                case (fn state ->
                case Runtime.go_out_grouping_b(state, @g_vowel) do
                  :fail -> {:fail, state}
                  %Runtime{} = s -> next_codepoint_b(s)
                end
                end).(s) do
                  {:ok, s2} -> {:cont, {:ok, s2}}
                  {:fail, s2} -> {:halt, {:fail, s2}}
                end
              end)
            end).()
          end,
          fn state ->
            case (fn state ->
              (fn loop_fn ->
                loop_fn.(loop_fn, state)
              end).(fn loop_fn, state ->
                v = state.cursor
                case (fn state ->
                  lift(state, Runtime.eq_s_b(state, "-"))
                end).(state) do
                  {:ok, s} -> {:ok, s}
                  {:fail, _} ->
                    case next_codepoint_b(%{state | cursor: v}) do
                      {:ok, s} -> loop_fn.(loop_fn, s)
                      {:fail, _} -> {:fail, state}
                    end
                end
              end)
            end).(state) do
              {:ok, state} ->
              next_codepoint_b(state)
              r -> r
            end
          end)
      end,
      fn state ->
        case Runtime.go_out_grouping_b(state, @g_digit) do
          :fail -> {:fail, state}
          %Runtime{} = s -> next_codepoint_b(s)
        end
      end)
  end

  defp r_correlative(%Runtime{} = state) do
    case (fn state ->
      {:ok, %{state | ket: state.cursor}}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, %{state | bra: state.cursor}}
      end).(state) do
        {:ok, state} ->
        case (fn state ->
          snowball_test_b(state, fn state ->
            case (fn state ->
              snowball_or(state,
                fn state ->
                  case (fn state ->
                    {:ok, snowball_try(state, fn state ->
                      lift(state, Runtime.eq_s_b(state, "n"))
                    end)}
                  end).(state) do
                    {:ok, state} ->
                    case (fn state ->
                      {:ok, %{state | bra: state.cursor}}
                    end).(state) do
                      {:ok, state} ->
                      lift(state, Runtime.eq_s_b(state, "e"))
                    end
                  end
                end,
                fn state ->
                  case (fn state ->
                    {:ok, snowball_try(state, fn state ->
                      lift(state, Runtime.eq_s_b(state, "n"))
                    end)}
                  end).(state) do
                    {:ok, state} ->
                    case (fn state ->
                      {:ok, snowball_try(state, fn state ->
                        lift(state, Runtime.eq_s_b(state, "j"))
                      end)}
                    end).(state) do
                      {:ok, state} ->
                      case (fn state ->
                        {:ok, %{state | bra: state.cursor}}
                      end).(state) do
                        {:ok, state} ->
                        lift(state, Runtime.in_grouping_b(state, @g_aou))
                      end
                    end
                  end
                end)
            end).(state) do
              {:ok, state} ->
              case (fn state ->
                lift(state, Runtime.eq_s_b(state, "i"))
              end).(state) do
                {:ok, state} ->
                case (fn state ->
                  {:ok, snowball_try(state, fn state ->
                    (fn ->
                      case Runtime.find_among_b(state, @a_1) do
                        :fail -> {:fail, state}
                        {%Runtime{} = s, _} -> {:ok, s}
                      end
                    end).()
                  end)}
                end).(state) do
                  {:ok, state} ->
                  snowball_or(state,
                    fn state ->
                      if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
                    end,
                    fn state ->
                      lift(state, Runtime.eq_s_b(state, "-"))
                    end)
                end
                r -> r
              end
              r -> r
            end
          end)
        end).(state) do
          {:ok, state} ->
          {:ok, Runtime.slice_del(state)}
          r -> r
        end
      end
    end
  end

  defp r_merged_numeral(%Runtime{} = state) do
    case (fn state ->
      (fn ->
        case Runtime.find_among_b(state, @a_2) do
          :fail -> {:fail, state}
          {%Runtime{} = s, _} -> {:ok, s}
        end
      end).()
    end).(state) do
      {:ok, state} ->
      (fn ->
        case Runtime.find_among_b(state, @a_3) do
          :fail -> {:fail, state}
          {%Runtime{} = s, _} -> {:ok, s}
        end
      end).()
      r -> r
    end
  end

  defp r_uninflected(%Runtime{} = state) do
    case (fn state ->
      (fn ->
        case Runtime.find_among_b(state, @a_4) do
          :fail -> {:fail, state}
          {%Runtime{} = s, _} -> {:ok, s}
        end
      end).()
    end).(state) do
      {:ok, state} ->
      snowball_or(state,
        fn state ->
          if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
        end,
        fn state ->
          lift(state, Runtime.eq_s_b(state, "-"))
        end)
      r -> r
    end
  end

  defp r_ujn_suffix(%Runtime{} = state) do
    case (fn state ->
      {:ok, %{state | ket: state.cursor}}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, snowball_try(state, fn state ->
          lift(state, Runtime.eq_s_b(state, "n"))
        end)}
      end).(state) do
        {:ok, state} ->
        case (fn state ->
          {:ok, snowball_try(state, fn state ->
            lift(state, Runtime.eq_s_b(state, "j"))
          end)}
        end).(state) do
          {:ok, state} ->
          case (fn state ->
            {:ok, %{state | bra: state.cursor}}
          end).(state) do
            {:ok, state} ->
            case (fn state ->
              (fn ->
                case Runtime.find_among_b(state, @a_5) do
                  :fail -> {:fail, state}
                  {%Runtime{} = s, _} -> {:ok, s}
                end
              end).()
            end).(state) do
              {:ok, state} ->
              case (fn state ->
                snowball_or(state,
                  fn state ->
                    if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
                  end,
                  fn state ->
                    lift(state, Runtime.eq_s_b(state, "-"))
                  end)
              end).(state) do
                {:ok, state} ->
                {:ok, Runtime.slice_del(state)}
                r -> r
              end
              r -> r
            end
          end
        end
      end
    end
  end

  defp r_final_apostrophe(%Runtime{} = state) do
    case (fn state ->
      {:ok, %{state | ket: state.cursor}}
    end).(state) do
      {:ok, 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} ->
          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, "l"))
                      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, "a")}
                          r -> r
                        end
                        r -> r
                      end
                    end,
                    fn state ->
                      case (fn state ->
                        lift(state, Runtime.eq_s_b(state, "un"))
                      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, "u")}
                          r -> r
                        end
                        r -> r
                      end
                    end)
                end,
                fn state ->
                  case (fn state ->
                    (fn ->
                      case Runtime.find_among_b(state, @a_6) do
                        :fail -> {:fail, state}
                        {%Runtime{} = s, _} -> {:ok, s}
                      end
                    end).()
                  end).(state) do
                    {:ok, state} ->
                    case (fn state ->
                      snowball_or(state,
                        fn state ->
                          if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
                        end,
                        fn state ->
                          lift(state, Runtime.eq_s_b(state, "-"))
                        end)
                    end).(state) do
                      {:ok, state} ->
                      {:ok, Runtime.slice_from(state, "aŭ")}
                      r -> r
                    end
                    r -> r
                  end
                end)
            end,
            fn state ->
              {:ok, Runtime.slice_from(state, "o")}
            end)
        end
        r -> r
      end
    end
  end

  defp r_pronoun(%Runtime{} = state) do
    case (fn state ->
      {:ok, %{state | ket: state.cursor}}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, snowball_try(state, fn state ->
          lift(state, Runtime.eq_s_b(state, "n"))
        end)}
      end).(state) do
        {:ok, state} ->
        case (fn state ->
          {:ok, %{state | bra: state.cursor}}
        end).(state) do
          {:ok, state} ->
          case (fn state ->
            (fn ->
              case Runtime.find_among_b(state, @a_7) do
                :fail -> {:fail, state}
                {%Runtime{} = s, _} -> {:ok, s}
              end
            end).()
          end).(state) do
            {:ok, state} ->
            case (fn state ->
              snowball_or(state,
                fn state ->
                  if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
                end,
                fn state ->
                  lift(state, Runtime.eq_s_b(state, "-"))
                end)
            end).(state) do
              {:ok, state} ->
              {:ok, Runtime.slice_del(state)}
              r -> r
            end
            r -> r
          end
        end
      end
    end
  end

  defp r_canonical_form(%Runtime{} = state) do
    case (fn state ->
      {:ok, put_in(state.vars[:foreign], false)}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        (fn loop_fn ->
          loop_fn.(loop_fn, state)
        end).(fn loop_fn, state ->
          case (fn state ->
            (fn ->
              state = %{state | bra: state.cursor}
              case Runtime.find_among(state, @a_8) do
                :fail -> {:fail, state}
                {%Runtime{} = s, result} ->
                  state = %{s | ket: s.cursor}
                  case result do
                            1 ->
                              {:ok, Runtime.slice_from(state, "ĉ")}
                            2 ->
                              {:ok, Runtime.slice_from(state, "ĝ")}
                            3 ->
                              {:ok, Runtime.slice_from(state, "ĥ")}
                            4 ->
                              {:ok, Runtime.slice_from(state, "ĵ")}
                            5 ->
                              {:ok, Runtime.slice_from(state, "ŝ")}
                            6 ->
                              {:ok, Runtime.slice_from(state, "ŭ")}
                            7 ->
                              case (fn state ->
                                {:ok, Runtime.slice_from(state, "a")}
                              end).(state) do
                                {:ok, state} ->
                                {:ok, put_in(state.vars[:foreign], true)}
                              end
                            8 ->
                              case (fn state ->
                                {:ok, Runtime.slice_from(state, "e")}
                              end).(state) do
                                {:ok, state} ->
                                {:ok, put_in(state.vars[:foreign], true)}
                              end
                            9 ->
                              case (fn state ->
                                {:ok, Runtime.slice_from(state, "i")}
                              end).(state) do
                                {:ok, state} ->
                                {:ok, put_in(state.vars[:foreign], true)}
                              end
                            10 ->
                              case (fn state ->
                                {:ok, Runtime.slice_from(state, "o")}
                              end).(state) do
                                {:ok, state} ->
                                {:ok, put_in(state.vars[:foreign], true)}
                              end
                            11 ->
                              case (fn state ->
                                {:ok, Runtime.slice_from(state, "u")}
                              end).(state) do
                                {:ok, state} ->
                                {:ok, put_in(state.vars[:foreign], true)}
                              end
                            12 ->
                              {:ok, put_in(state.vars[:foreign], true)}
                            13 ->
                              {:ok, put_in(state.vars[:foreign], false)}
                            14 ->
                              next_codepoint(state)
                    _ -> {:ok, state}
                  end
              end
            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.vars[:foreign], 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
    end
  end

  defp r_initial_apostrophe(%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, "'"))
      end).(state) do
        {:ok, state} ->
        case (fn state ->
          {:ok, %{state | ket: state.cursor}}
        end).(state) do
          {:ok, state} ->
          case (fn state ->
            lift(state, Runtime.eq_s(state, "st"))
          end).(state) do
            {:ok, state} ->
            case (fn state ->
              (fn ->
                case Runtime.find_among(state, @a_9) do
                  :fail -> {:fail, state}
                  {%Runtime{} = s, _} -> {:ok, s}
                end
              end).()
            end).(state) do
              {:ok, state} ->
              case (fn state ->
                if state.cursor >= state.limit, do: {:ok, state}, else: {:fail, state}
              end).(state) do
                {:ok, state} ->
                {:ok, Runtime.slice_from(state, "e")}
                r -> r
              end
              r -> r
            end
            r -> r
          end
        end
        r -> r
      end
    end
  end

  defp r_stem(%Runtime{} = state) do
    case (fn state ->
      snowball_test_f(state, fn state ->
        r_canonical_form(state)
      end)
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, snowball_do_f(state, fn state ->
          r_initial_apostrophe(state)
        end)}
      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 ->
              (fn state ->
                saved_c = state.cursor
                case (fn state ->
                r_pronoun(state)
                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 ->
                {:ok, snowball_do_b(state, fn state ->
                  r_final_apostrophe(state)
                end)}
              end).(state) do
                {:ok, state} ->
                case (fn state ->
                  (fn state ->
                    saved_c = state.cursor
                    case (fn state ->
                    r_correlative(state)
                    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 ->
                      r_uninflected(state)
                      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 ->
                        r_merged_numeral(state)
                        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 ->
                          r_ujn_suffix(state)
                          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 ->
                          snowball_test_b(state, fn state ->
                            r_long_word(state)
                          end)
                        end).(state) do
                          {:ok, state} ->
                          r_standard_suffix(state)
                          r -> r
                        end
                        r -> r
                      end
                      r -> r
                    end
                    r -> r
                  end
                  r -> r
                end
              end
              r -> r
            end
          end).(state)
          {tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
        end).(state)
      end
      r -> r
    end
  end

end