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

  Generated from the canonical Snowball algorithm source.
  """

  alias Snowball.Runtime
  alias Snowball.Grouping


  # Groupings
  @g_v Grouping.from_string("aeiouáéíóöőúüű")


  # Among tables
  @a_0 [
    {"id", -1, 10, nil},
    {"aid", 0, 9, nil},
    {"jaid", 1, 6, nil},
    {"eid", 0, 9, nil},
    {"jeid", 3, 6, nil},
    {"áid", 0, 7, nil},
    {"éid", 0, 8, nil},
    {"i", -1, 15, nil},
    {"ai", 7, 14, nil},
    {"jai", 8, 11, nil},
    {"ei", 7, 14, nil},
    {"jei", 10, 11, nil},
    {"ái", 7, 12, nil},
    {"éi", 7, 13, nil},
    {"itek", -1, 24, nil},
    {"eitek", 14, 21, nil},
    {"jeitek", 15, 20, nil},
    {"éitek", 14, 23, nil},
    {"ik", -1, 29, nil},
    {"aik", 18, 26, nil},
    {"jaik", 19, 25, nil},
    {"eik", 18, 26, nil},
    {"jeik", 21, 25, nil},
    {"áik", 18, 27, nil},
    {"éik", 18, 28, nil},
    {"ink", -1, 20, nil},
    {"aink", 25, 17, nil},
    {"jaink", 26, 16, nil},
    {"eink", 25, 17, nil},
    {"jeink", 28, 16, nil},
    {"áink", 25, 18, nil},
    {"éink", 25, 19, nil},
    {"aitok", -1, 21, nil},
    {"jaitok", 32, 20, nil},
    {"áitok", -1, 22, nil},
    {"im", -1, 5, nil},
    {"aim", 35, 4, nil},
    {"jaim", 36, 1, nil},
    {"eim", 35, 4, nil},
    {"jeim", 38, 1, nil},
    {"áim", 35, 2, nil},
    {"éim", 35, 3, nil}
  ]
  @a_1 [
    {"a", -1, 18, nil},
    {"ja", 0, 17, nil},
    {"d", -1, 16, nil},
    {"ad", 2, 13, nil},
    {"ed", 2, 13, nil},
    {"od", 2, 13, nil},
    {"ád", 2, 14, nil},
    {"éd", 2, 15, nil},
    {"öd", 2, 13, nil},
    {"e", -1, 18, nil},
    {"je", 9, 17, nil},
    {"nk", -1, 4, nil},
    {"unk", 11, 1, nil},
    {"ánk", 11, 2, nil},
    {"énk", 11, 3, nil},
    {"ünk", 11, 1, nil},
    {"uk", -1, 8, nil},
    {"juk", 16, 7, nil},
    {"ájuk", 17, 5, nil},
    {"ük", -1, 8, nil},
    {"jük", 19, 7, nil},
    {"éjük", 20, 6, nil},
    {"m", -1, 12, nil},
    {"am", 22, 9, nil},
    {"em", 22, 9, nil},
    {"om", 22, 9, nil},
    {"ám", 22, 10, nil},
    {"ém", 22, 11, nil},
    {"o", -1, 18, nil},
    {"á", -1, 19, nil},
    {"é", -1, 20, nil}
  ]
  @a_2 [
    {"éi", -1, 7, nil},
    {"áéi", 0, 6, nil},
    {"ééi", 0, 5, nil},
    {"é", -1, 9, nil},
    {"ké", 3, 4, nil},
    {"aké", 4, 1, nil},
    {"eké", 4, 1, nil},
    {"oké", 4, 1, nil},
    {"áké", 4, 3, nil},
    {"éké", 4, 2, nil},
    {"öké", 4, 1, nil},
    {"éé", 3, 8, nil}
  ]
  @a_3 [
    {"k", -1, 7, nil},
    {"ak", 0, 4, nil},
    {"ek", 0, 6, nil},
    {"ok", 0, 5, nil},
    {"ák", 0, 1, nil},
    {"ék", 0, 2, nil},
    {"ök", 0, 3, nil}
  ]
  @a_4 [
    {"á", -1, 1, nil},
    {"é", -1, 2, nil}
  ]
  @a_5 [
    {"stul", -1, 2, nil},
    {"astul", 0, 1, nil},
    {"ástul", 0, 3, nil},
    {"stül", -1, 2, nil},
    {"estül", 3, 1, nil},
    {"éstül", 3, 4, nil}
  ]
  @a_6 [
    {"án", -1, 2, nil},
    {"én", -1, 1, nil},
    {"ánként", -1, 3, nil}
  ]
  @a_7 [
    {"ba", -1, -1, nil},
    {"ra", -1, -1, nil},
    {"be", -1, -1, nil},
    {"re", -1, -1, nil},
    {"ig", -1, -1, nil},
    {"nak", -1, -1, nil},
    {"nek", -1, -1, nil},
    {"val", -1, -1, nil},
    {"vel", -1, -1, nil},
    {"ul", -1, -1, nil},
    {"ből", -1, -1, nil},
    {"ről", -1, -1, nil},
    {"től", -1, -1, nil},
    {"nál", -1, -1, nil},
    {"nél", -1, -1, nil},
    {"ból", -1, -1, nil},
    {"ról", -1, -1, nil},
    {"tól", -1, -1, nil},
    {"ül", -1, -1, nil},
    {"n", -1, -1, nil},
    {"an", 19, -1, nil},
    {"ban", 20, -1, nil},
    {"en", 19, -1, nil},
    {"ben", 22, -1, nil},
    {"képpen", 22, -1, nil},
    {"on", 19, -1, nil},
    {"ön", 19, -1, nil},
    {"képp", -1, -1, nil},
    {"kor", -1, -1, nil},
    {"t", -1, -1, nil},
    {"at", 29, -1, nil},
    {"et", 29, -1, nil},
    {"ként", 29, -1, nil},
    {"anként", 32, -1, nil},
    {"enként", 32, -1, nil},
    {"onként", 32, -1, nil},
    {"ot", 29, -1, nil},
    {"ért", 29, -1, nil},
    {"öt", 29, -1, nil},
    {"hez", -1, -1, nil},
    {"hoz", -1, -1, nil},
    {"höz", -1, -1, nil},
    {"vá", -1, -1, nil},
    {"vé", -1, -1, nil}
  ]
  @a_8 [
    {"al", -1, 1, nil},
    {"el", -1, 2, nil}
  ]
  @a_9 [
    {"bb", -1, -1, nil},
    {"cc", -1, -1, nil},
    {"dd", -1, -1, nil},
    {"ff", -1, -1, nil},
    {"gg", -1, -1, nil},
    {"jj", -1, -1, nil},
    {"kk", -1, -1, nil},
    {"ll", -1, -1, nil},
    {"mm", -1, -1, nil},
    {"nn", -1, -1, nil},
    {"pp", -1, -1, nil},
    {"rr", -1, -1, nil},
    {"ccs", -1, -1, nil},
    {"ss", -1, -1, nil},
    {"zzs", -1, -1, nil},
    {"tt", -1, -1, nil},
    {"vv", -1, -1, nil},
    {"ggy", -1, -1, nil},
    {"lly", -1, -1, nil},
    {"nny", -1, -1, nil},
    {"tty", -1, -1, nil},
    {"ssz", -1, -1, nil},
    {"zz", -1, -1, nil}
  ]
  @a_10 [
    {"á", -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}}

  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_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_plur_owner(%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 ->
            r_R1(state)
          end).(state) do
            {:ok, state} ->
          case result do
                    1 ->
                      {:ok, Runtime.slice_del(state)}
                    2 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    3 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    4 ->
                      {:ok, Runtime.slice_del(state)}
                    5 ->
                      {:ok, Runtime.slice_del(state)}
                    6 ->
                      {:ok, Runtime.slice_del(state)}
                    7 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    8 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    9 ->
                      {:ok, Runtime.slice_del(state)}
                    10 ->
                      {:ok, Runtime.slice_del(state)}
                    11 ->
                      {:ok, Runtime.slice_del(state)}
                    12 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    13 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    14 ->
                      {:ok, Runtime.slice_del(state)}
                    15 ->
                      {:ok, Runtime.slice_del(state)}
                    16 ->
                      {:ok, Runtime.slice_del(state)}
                    17 ->
                      {:ok, Runtime.slice_del(state)}
                    18 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    19 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    20 ->
                      {:ok, Runtime.slice_del(state)}
                    21 ->
                      {:ok, Runtime.slice_del(state)}
                    22 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    23 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    24 ->
                      {:ok, Runtime.slice_del(state)}
                    25 ->
                      {:ok, Runtime.slice_del(state)}
                    26 ->
                      {:ok, Runtime.slice_del(state)}
                    27 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    28 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    29 ->
                      {:ok, Runtime.slice_del(state)}
            _ -> {:ok, state}
          end
            r -> r
          end
      end
    end).()
  end

  defp r_sing_owner(%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 (fn state ->
            r_R1(state)
          end).(state) do
            {:ok, state} ->
          case result do
                    1 ->
                      {:ok, Runtime.slice_del(state)}
                    2 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    3 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    4 ->
                      {:ok, Runtime.slice_del(state)}
                    5 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    6 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    7 ->
                      {:ok, Runtime.slice_del(state)}
                    8 ->
                      {:ok, Runtime.slice_del(state)}
                    9 ->
                      {:ok, Runtime.slice_del(state)}
                    10 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    11 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    12 ->
                      {:ok, Runtime.slice_del(state)}
                    13 ->
                      {:ok, Runtime.slice_del(state)}
                    14 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    15 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    16 ->
                      {:ok, Runtime.slice_del(state)}
                    17 ->
                      {:ok, Runtime.slice_del(state)}
                    18 ->
                      {:ok, Runtime.slice_del(state)}
                    19 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    20 ->
                      {:ok, Runtime.slice_from(state, "e")}
            _ -> {:ok, state}
          end
            r -> r
          end
      end
    end).()
  end

  defp r_owned(%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 (fn state ->
            r_R1(state)
          end).(state) do
            {:ok, state} ->
          case result do
                    1 ->
                      {:ok, Runtime.slice_del(state)}
                    2 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    3 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    4 ->
                      {:ok, Runtime.slice_del(state)}
                    5 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    6 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    7 ->
                      {:ok, Runtime.slice_del(state)}
                    8 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    9 ->
                      {:ok, Runtime.slice_del(state)}
            _ -> {:ok, state}
          end
            r -> r
          end
      end
    end).()
  end

  defp r_plural(%Runtime{} = state) do
    (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 (fn state ->
            r_R1(state)
          end).(state) do
            {:ok, state} ->
          case result do
                    1 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    2 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    3 ->
                      {:ok, Runtime.slice_del(state)}
                    4 ->
                      {:ok, Runtime.slice_del(state)}
                    5 ->
                      {:ok, Runtime.slice_del(state)}
                    6 ->
                      {:ok, Runtime.slice_del(state)}
                    7 ->
                      {:ok, Runtime.slice_del(state)}
            _ -> {:ok, state}
          end
            r -> r
          end
      end
    end).()
  end

  defp r_factive(%Runtime{} = state) do
    case (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 (fn state ->
              r_R1(state)
            end).(state) do
              {:ok, state} ->
            case result do
                      1 ->
                        r_double(state)
                      2 ->
                        r_double(state)
              _ -> {:ok, state}
            end
              r -> r
            end
        end
      end).()
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, Runtime.slice_del(state)}
      end).(state) do
        {:ok, state} ->
        r_undouble(state)
      end
      r -> r
    end
  end

  defp r_case_other(%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 (fn state ->
            r_R1(state)
          end).(state) do
            {:ok, state} ->
          case result do
                    1 ->
                      {:ok, Runtime.slice_del(state)}
                    2 ->
                      {:ok, Runtime.slice_del(state)}
                    3 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    4 ->
                      {:ok, Runtime.slice_from(state, "e")}
            _ -> {:ok, state}
          end
            r -> r
          end
      end
    end).()
  end

  defp r_case_special(%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 (fn state ->
            r_R1(state)
          end).(state) do
            {:ok, state} ->
          case result do
                    1 ->
                      {:ok, Runtime.slice_from(state, "e")}
                    2 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    3 ->
                      {:ok, Runtime.slice_from(state, "a")}
            _ -> {:ok, state}
          end
            r -> r
          end
      end
    end).()
  end

  defp r_case(%Runtime{} = state) do
    case (fn state ->
      (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 (fn state ->
              r_R1(state)
            end).(state) do
              {:ok, state} ->
            {:ok, state}
              r -> r
            end
        end
      end).()
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, Runtime.slice_del(state)}
      end).(state) do
        {:ok, state} ->
        r_v_ending(state)
      end
      r -> r
    end
  end

  defp r_instrum(%Runtime{} = state) do
    case (fn 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 (fn state ->
              r_R1(state)
            end).(state) do
              {:ok, state} ->
            case result do
                      1 ->
                        r_double(state)
                      2 ->
                        r_double(state)
              _ -> {:ok, state}
            end
              r -> r
            end
        end
      end).()
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, Runtime.slice_del(state)}
      end).(state) do
        {:ok, state} ->
        r_undouble(state)
      end
      r -> r
    end
  end

  defp r_undouble(%Runtime{} = state) do
    case (fn state ->
      next_codepoint_b(state)
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, %{state | ket: state.cursor}}
      end).(state) do
        {:ok, state} ->
        case (fn state ->
          (fn ->
            n = 1
            Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
              case next_codepoint_b(s) do
                {:ok, s2} -> {:cont, {:ok, s2}}
                {:fail, _} -> {:halt, {:fail, state}}
              end
            end)
          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
          r -> r
        end
      end
      r -> r
    end
  end

  defp r_double(%Runtime{} = state) do
    snowball_test_b(state, fn state ->
      (fn ->
        case Runtime.find_among_b(state, @a_9) do
          :fail -> {:fail, state}
          {%Runtime{} = s, _} -> {:ok, s}
        end
      end).()
    end)
  end

  defp r_v_ending(%Runtime{} = state) do
    (fn ->
      state = %{state | ket: state.cursor}
      case Runtime.find_among_b(state, @a_10) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | bra: s.cursor}
          case (fn state ->
            r_R1(state)
          end).(state) do
            {:ok, state} ->
          case result do
                    1 ->
                      {:ok, Runtime.slice_from(state, "a")}
                    2 ->
                      {:ok, Runtime.slice_from(state, "e")}
            _ -> {:ok, state}
          end
            r -> r
          end
      end
    end).()
  end

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

  defp r_mark_regions(%Runtime{} = state) do
    case (fn state ->
      {:ok, put_in(state.vars[:p1], state.limit)}
    end).(state) do
      {:ok, state} ->
      snowball_or(state,
        fn state ->
          case (fn state ->
            lift(state, Runtime.in_grouping(state, @g_v))
          end).(state) do
            {:ok, state} ->
            {:ok, snowball_do_f(state, fn state ->
              case (fn state ->
                case Runtime.go_in_grouping(state, @g_v) do
                  :fail -> {:fail, state}
                  %Runtime{} = s -> next_codepoint(s)
                end
              end).(state) do
                {:ok, state} ->
                {:ok, put_in(state.vars[:p1], state.cursor)}
                r -> r
              end
            end)}
            r -> r
          end
        end,
        fn state ->
          case (fn state ->
            case Runtime.go_out_grouping(state, @g_v) do
              :fail -> {:fail, state}
              %Runtime{} = s -> next_codepoint(s)
            end
          end).(state) do
            {:ok, state} ->
            {:ok, put_in(state.vars[:p1], state.cursor)}
            r -> r
          end
        end)
    end
  end

  defp r_stem(%Runtime{} = state) do
    case (fn state ->
      {:ok, snowball_do_f(state, fn state ->
        r_mark_regions(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 ->
            {:ok, snowball_do_b(state, fn state ->
              r_instrum(state)
            end)}
          end).(state) do
            {:ok, state} ->
            case (fn state ->
              {:ok, snowball_do_b(state, fn state ->
                r_case(state)
              end)}
            end).(state) do
              {:ok, state} ->
              case (fn state ->
                {:ok, snowball_do_b(state, fn state ->
                  r_case_special(state)
                end)}
              end).(state) do
                {:ok, state} ->
                case (fn state ->
                  {:ok, snowball_do_b(state, fn state ->
                    r_case_other(state)
                  end)}
                end).(state) do
                  {:ok, state} ->
                  case (fn state ->
                    {:ok, snowball_do_b(state, fn state ->
                      r_factive(state)
                    end)}
                  end).(state) do
                    {:ok, state} ->
                    case (fn state ->
                      {:ok, snowball_do_b(state, fn state ->
                        r_owned(state)
                      end)}
                    end).(state) do
                      {:ok, state} ->
                      case (fn state ->
                        {:ok, snowball_do_b(state, fn state ->
                          r_sing_owner(state)
                        end)}
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, snowball_do_b(state, fn state ->
                            r_plur_owner(state)
                          end)}
                        end).(state) do
                          {:ok, state} ->
                          {:ok, snowball_do_b(state, fn state ->
                            r_plural(state)
                          end)}
                        end
                      end
                    end
                  end
                end
              end
            end
          end
        end).(state)
        {tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
      end).(state)
    end
  end

end