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

  Generated from the canonical Snowball algorithm source.
  """

  alias Snowball.Runtime
  alias Snowball.Grouping


  # Groupings
  @g_et_ending Grouping.from_string("dfgklmnrstUzä")
  @g_s_ending Grouping.from_string("bdfghklmnrt")
  @g_st_ending Grouping.from_string("bdfghklmnt")
  @g_v Grouping.from_string("aeiouyäöü")


  # Among tables
  @a_0 [
    {"e", -1, 3, nil},
    {"em", -1, 1, nil},
    {"en", -1, 3, nil},
    {"erinnen", 2, 2, nil},
    {"erin", -1, 2, nil},
    {"ln", -1, 5, nil},
    {"ern", -1, 2, nil},
    {"er", -1, 2, nil},
    {"s", -1, 4, nil},
    {"es", 8, 3, nil},
    {"lns", 8, 5, nil}
  ]
  @a_1 [
    {"tick", -1, -1, nil},
    {"plan", -1, -1, nil},
    {"geordn", -1, -1, nil},
    {"intern", -1, -1, nil},
    {"tr", -1, -1, nil}
  ]
  @a_2 [
    {"en", -1, 1, nil},
    {"er", -1, 1, nil},
    {"et", -1, 3, nil},
    {"st", -1, 2, nil},
    {"est", 3, 1, nil}
  ]
  @a_3 [
    {"ig", -1, 1, nil},
    {"lich", -1, 1, nil}
  ]
  @a_4 [
    {"end", -1, 1, nil},
    {"ig", -1, 2, nil},
    {"ung", -1, 1, nil},
    {"lich", -1, 3, nil},
    {"isch", -1, 2, nil},
    {"ik", -1, 2, nil},
    {"heit", -1, 3, nil},
    {"keit", -1, 4, nil}
  ]
  @a_5 [
    {"", -1, 5, nil},
    {"ae", 0, 2, nil},
    {"oe", 0, 3, nil},
    {"qu", 0, -1, nil},
    {"ue", 0, 4, nil},
    {"ß", 0, 1, nil}
  ]
  @a_6 [
    {"", -1, 6, nil},
    {"U", 0, 2, nil},
    {"Y", 0, 1, nil},
    {"ä", 0, 3, nil},
    {"ö", 0, 4, nil},
    {"ü", 0, 5, 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, x: 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_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, snowball_do_b(state, fn state ->
        (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 ->
                          case (fn state ->
                            (fn state ->
                              saved_c = state.cursor
                              case (fn state ->
                              lift(state, Runtime.eq_s_b(state, "syst"))
                              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
                        2 ->
                          {:ok, Runtime.slice_del(state)}
                        3 ->
                          case (fn state ->
                            {:ok, Runtime.slice_del(state)}
                          end).(state) do
                            {:ok, state} ->
                            {:ok, snowball_try(state, fn state ->
                              case (fn state ->
                                {:ok, %{state | ket: state.cursor}}
                              end).(state) do
                                {:ok, state} ->
                                case (fn state ->
                                  lift(state, Runtime.eq_s_b(state, "s"))
                                end).(state) do
                                  {:ok, state} ->
                                  case (fn state ->
                                    {:ok, %{state | bra: state.cursor}}
                                  end).(state) do
                                    {:ok, state} ->
                                    case (fn state ->
                                      lift(state, Runtime.eq_s_b(state, "nis"))
                                    end).(state) do
                                      {:ok, state} ->
                                      {:ok, Runtime.slice_del(state)}
                                      r -> r
                                    end
                                  end
                                  r -> r
                                end
                              end
                            end)}
                          end
                        4 ->
                          case (fn state ->
                            lift(state, Runtime.in_grouping_b(state, @g_s_ending))
                          end).(state) do
                            {:ok, state} ->
                            {:ok, Runtime.slice_del(state)}
                            r -> r
                          end
                        5 ->
                          {:ok, Runtime.slice_from(state, "l")}
                _ -> {:ok, state}
              end
                r -> r
              end
          end
        end).()
      end)}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, snowball_do_b(state, fn state ->
          (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 ->
                            case (fn state ->
                              lift(state, Runtime.in_grouping_b(state, @g_st_ending))
                            end).(state) do
                              {:ok, state} ->
                              case (fn state ->
                                (fn ->
                                  n = 3
                                  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} ->
                                {:ok, Runtime.slice_del(state)}
                                r -> r
                              end
                              r -> r
                            end
                          3 ->
                            case (fn state ->
                              snowball_test_b(state, fn state ->
                                lift(state, Runtime.in_grouping_b(state, @g_et_ending))
                              end)
                            end).(state) do
                              {:ok, state} ->
                              case (fn state ->
                                (fn state ->
                                  saved_c = state.cursor
                                  case (fn state ->
                                  (fn ->
                                    case Runtime.find_among_b(state, @a_1) do
                                      :fail -> {:fail, state}
                                      {%Runtime{} = s, _} -> {:ok, s}
                                    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} ->
                                {:ok, Runtime.slice_del(state)}
                                r -> r
                              end
                              r -> r
                            end
                  _ -> {:ok, state}
                end
                  r -> r
                end
            end
          end).()
        end)}
      end).(state) do
        {:ok, state} ->
        {:ok, snowball_do_b(state, 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_R2(state)
                end).(state) do
                  {:ok, state} ->
                case result do
                          1 ->
                            case (fn state ->
                              {:ok, Runtime.slice_del(state)}
                            end).(state) do
                              {:ok, state} ->
                              {:ok, snowball_try(state, fn state ->
                                case (fn state ->
                                  {:ok, %{state | ket: state.cursor}}
                                end).(state) do
                                  {:ok, state} ->
                                  case (fn state ->
                                    lift(state, Runtime.eq_s_b(state, "ig"))
                                  end).(state) do
                                    {:ok, state} ->
                                    case (fn state ->
                                      {:ok, %{state | bra: state.cursor}}
                                    end).(state) do
                                      {:ok, state} ->
                                      case (fn state ->
                                        (fn state ->
                                          saved_c = state.cursor
                                          case (fn state ->
                                          lift(state, Runtime.eq_s_b(state, "e"))
                                          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_R2(state)
                                        end).(state) do
                                          {:ok, state} ->
                                          {:ok, Runtime.slice_del(state)}
                                          r -> r
                                        end
                                        r -> r
                                      end
                                    end
                                    r -> r
                                  end
                                end
                              end)}
                            end
                          2 ->
                            case (fn state ->
                              (fn state ->
                                saved_c = state.cursor
                                case (fn state ->
                                lift(state, Runtime.eq_s_b(state, "e"))
                                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
                          3 ->
                            case (fn state ->
                              {:ok, Runtime.slice_del(state)}
                            end).(state) do
                              {:ok, state} ->
                              {:ok, snowball_try(state, fn state ->
                                case (fn state ->
                                  {:ok, %{state | ket: state.cursor}}
                                end).(state) do
                                  {:ok, state} ->
                                  case (fn state ->
                                    snowball_or(state,
                                      fn state ->
                                        lift(state, Runtime.eq_s_b(state, "er"))
                                      end,
                                      fn state ->
                                        lift(state, Runtime.eq_s_b(state, "en"))
                                      end)
                                  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)}
                            end
                          4 ->
                            case (fn state ->
                              {:ok, Runtime.slice_del(state)}
                            end).(state) do
                              {:ok, state} ->
                              {:ok, snowball_try(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 (fn state ->
                                        r_R2(state)
                                      end).(state) do
                                        {:ok, state} ->
                                      case result do
                                                1 ->
                                                  {:ok, Runtime.slice_del(state)}
                                        _ -> {:ok, state}
                                      end
                                        r -> r
                                      end
                                  end
                                end).()
                              end)}
                            end
                  _ -> {:ok, state}
                end
                  r -> r
                end
            end
          end).()
        end)}
      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_prelude(%Runtime{} = state) do
    case (fn state ->
      snowball_test_f(state, fn state ->
        (fn loop_fn ->
          loop_fn.(loop_fn, state)
        end).(fn loop_fn, 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 ->
                  lift(state, Runtime.in_grouping(state, @g_v))
                end).(state) do
                  {:ok, state} ->
                  case (fn state ->
                    {:ok, %{state | bra: state.cursor}}
                  end).(state) do
                    {:ok, state} ->
                    snowball_or(state,
                      fn state ->
                        case (fn state ->
                          lift(state, Runtime.eq_s(state, "u"))
                        end).(state) do
                          {:ok, state} ->
                          case (fn state ->
                            {:ok, %{state | ket: state.cursor}}
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              lift(state, Runtime.in_grouping(state, @g_v))
                            end).(state) do
                              {:ok, state} ->
                              {:ok, Runtime.slice_from(state, "U")}
                              r -> r
                            end
                          end
                          r -> r
                        end
                      end,
                      fn state ->
                        case (fn state ->
                          lift(state, Runtime.eq_s(state, "y"))
                        end).(state) do
                          {:ok, state} ->
                          case (fn state ->
                            {:ok, %{state | ket: state.cursor}}
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              lift(state, Runtime.in_grouping(state, @g_v))
                            end).(state) do
                              {:ok, state} ->
                              {:ok, Runtime.slice_from(state, "Y")}
                              r -> r
                            end
                          end
                          r -> r
                        end
                      end)
                  end
                  r -> r
                end
              end).(state) do
                {:ok, s} -> {:ok, %{s | cursor: v}}
                {: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, s} -> loop_fn.(loop_fn, s)
            {:fail, s} -> {:ok, %{s | cursor: state.cursor}}
          end
        end)
      end)
    end).(state) do
      {:ok, 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_5) do
              :fail -> {:fail, state}
              {%Runtime{} = s, result} ->
                state = %{s | ket: s.cursor}
                case result do
                          1 ->
                            {:ok, Runtime.slice_from(state, "ss")}
                          2 ->
                            {:ok, Runtime.slice_from(state, "ä")}
                          3 ->
                            {:ok, Runtime.slice_from(state, "ö")}
                          4 ->
                            {:ok, Runtime.slice_from(state, "ü")}
                          5 ->
                            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)
      r -> r
    end
  end

  defp r_mark_regions(%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} ->
        case (fn state ->
          snowball_test_f(state, fn state ->
            case (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).(state) do
              {:ok, state} ->
              {:ok, put_in(state.vars[:x], state.cursor)}
              r -> r
            end
          end)
        end).(state) do
          {:ok, 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} ->
            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} ->
              case (fn state ->
                {:ok, put_in(state.vars[:p1], state.cursor)}
              end).(state) do
                {:ok, state} ->
                case (fn state ->
                  {:ok, snowball_try(state, fn state ->
                    case (fn state ->
                      if state.vars[:p1] < state.vars[:x], do: {:ok, state}, else: {:fail, state}
                    end).(state) do
                      {:ok, state} ->
                      {:ok, put_in(state.vars[:p1], state.vars[:x])}
                      r -> r
                    end
                  end)}
                end).(state) do
                  {:ok, 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} ->
                    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[:p2], state.cursor)}
                      r -> r
                    end
                    r -> r
                  end
                end
              end
              r -> r
            end
            r -> r
          end
          r -> r
        end
      end
    end
  end

  defp r_postlude(%Runtime{} = state) do
    (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_6) do
            :fail -> {:fail, state}
            {%Runtime{} = s, result} ->
              state = %{s | ket: s.cursor}
              case result do
                        1 ->
                          {:ok, Runtime.slice_from(state, "y")}
                        2 ->
                          {:ok, Runtime.slice_from(state, "u")}
                        3 ->
                          {:ok, Runtime.slice_from(state, "a")}
                        4 ->
                          {:ok, Runtime.slice_from(state, "o")}
                        5 ->
                          {:ok, Runtime.slice_from(state, "u")}
                        6 ->
                          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

  defp r_stem(%Runtime{} = state) do
    case (fn state ->
      {:ok, snowball_do_f(state, fn state ->
        r_prelude(state)
      end)}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, snowball_do_f(state, fn state ->
          r_mark_regions(state)
        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 ->
                r_standard_suffix(state)
              end)}
            end).(state)
            {tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
          end).(state)
        end).(state) do
          {:ok, state} ->
          {:ok, snowball_do_f(state, fn state ->
            r_postlude(state)
          end)}
        end
      end
    end
  end

end