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

  Generated from the canonical Snowball algorithm source.
  """

  alias Snowball.Runtime


  # Among tables
  @a_0 [
    {"ى", -1, 1, nil}
  ]
  @a_1 [
    {"و", -1, 1, nil},
    {"تمو", 0, 2, nil}
  ]
  @a_2 [
    {"تم", -1, 1, nil},
    {"وا", -1, 1, nil}
  ]
  @a_3 [
    {"ن", -1, 2, nil},
    {"ون", 0, 4, nil},
    {"ين", 0, 4, nil},
    {"ان", 0, 4, nil},
    {"تن", 0, 3, nil},
    {"ي", -1, 2, nil},
    {"ا", -1, 2, nil},
    {"تما", 6, 5, nil},
    {"نا", 6, 3, nil},
    {"تا", 6, 3, nil},
    {"ت", -1, 1, nil}
  ]
  @a_4 [
    {"ك", -1, 1, nil},
    {"كم", -1, 2, nil},
    {"هم", -1, 2, nil},
    {"كن", -1, 2, nil},
    {"هن", -1, 2, nil},
    {"ه", -1, 1, nil},
    {"كمو", -1, 3, nil},
    {"ني", -1, 2, nil},
    {"كما", -1, 3, nil},
    {"هما", -1, 3, nil},
    {"نا", -1, 2, nil},
    {"ها", -1, 2, nil}
  ]
  @a_5 [
    {"ي", -1, 1, nil}
  ]
  @a_6 [
    {"ة", -1, 1, nil}
  ]
  @a_7 [
    {"ت", -1, 1, nil}
  ]
  @a_8 [
    {"ات", -1, 1, nil}
  ]
  @a_9 [
    {"و", -1, 1, nil},
    {"ي", -1, 1, nil},
    {"ا", -1, 1, nil}
  ]
  @a_10 [
    {"ن", -1, 1, nil}
  ]
  @a_11 [
    {"ك", -1, 1, nil},
    {"كم", -1, 2, nil},
    {"هم", -1, 2, nil},
    {"هن", -1, 2, nil},
    {"ه", -1, 1, nil},
    {"ي", -1, 1, nil},
    {"كما", -1, 3, nil},
    {"هما", -1, 3, nil},
    {"نا", -1, 2, nil},
    {"ها", -1, 2, nil}
  ]
  @a_13 [
    {"آ", -1, 1, nil},
    {"أ", -1, 1, nil},
    {"ؤ", -1, 2, nil},
    {"إ", -1, 1, nil},
    {"ئ", -1, 3, nil}
  ]
  @a_15 [
    {"ال", -1, 2, nil},
    {"بال", -1, 1, nil},
    {"كال", -1, 1, nil},
    {"لل", -1, 2, nil}
  ]
  @a_16 [
    {"أآ", -1, 2, nil},
    {"أأ", -1, 1, nil},
    {"أؤ", -1, 3, nil},
    {"أإ", -1, 5, nil},
    {"أا", -1, 4, nil}
  ]
  @a_17 [
    {"ف", -1, 1, nil},
    {"و", -1, 1, nil}
  ]
  @a_18 [
    {"ال", -1, 2, nil},
    {"بال", -1, 1, nil},
    {"كال", -1, 1, nil},
    {"لل", -1, 2, nil}
  ]
  @a_19 [
    {"ب", -1, 1, nil},
    {"با", 0, -1, nil},
    {"بب", 0, 2, nil},
    {"كك", -1, 3, nil}
  ]
  @a_20 [
    {"سأ", -1, 4, nil},
    {"ست", -1, 2, nil},
    {"سن", -1, 3, nil},
    {"سي", -1, 1, nil}
  ]
  @a_21 [
    {"تست", -1, 1, nil},
    {"نست", -1, 1, nil},
    {"يست", -1, 1, nil}
  ]


  # Scan-and-replace character maps
  @scan_0 %{1600 => "", 1611 => "", 1612 => "", 1613 => "", 1614 => "", 1615 => "", 1616 => "", 1617 => "", 1618 => "", 1632 => "0", 1633 => "1", 1634 => "2", 1635 => "3", 1636 => "4", 1637 => "5", 1638 => "6", 1639 => "7", 1640 => "8", 1641 => "9", 65152 => "ء", 65153 => "آ", 65154 => "آ", 65155 => "أ", 65156 => "أ", 65157 => "ؤ", 65158 => "ؤ", 65159 => "إ", 65160 => "إ", 65161 => "ئ", 65162 => "ئ", 65163 => "ئ", 65164 => "ئ", 65165 => "ا", 65166 => "ا", 65167 => "ب", 65168 => "ب", 65169 => "ب", 65170 => "ب", 65171 => "ة", 65172 => "ة", 65173 => "ت", 65174 => "ت", 65175 => "ت", 65176 => "ت", 65177 => "ث", 65178 => "ث", 65179 => "ث", 65180 => "ث", 65181 => "ج", 65182 => "ج", 65183 => "ج", 65184 => "ج", 65185 => "ح", 65186 => "ح", 65187 => "ح", 65188 => "ح", 65189 => "خ", 65190 => "خ", 65191 => "خ", 65192 => "خ", 65193 => "د", 65194 => "د", 65195 => "ذ", 65196 => "ذ", 65197 => "ر", 65198 => "ر", 65199 => "ز", 65200 => "ز", 65201 => "س", 65202 => "س", 65203 => "س", 65204 => "س", 65205 => "ش", 65206 => "ش", 65207 => "ش", 65208 => "ش", 65209 => "ص", 65210 => "ص", 65211 => "ص", 65212 => "ص", 65213 => "ض", 65214 => "ض", 65215 => "ض", 65216 => "ض", 65217 => "ط", 65218 => "ط", 65219 => "ط", 65220 => "ط", 65221 => "ظ", 65222 => "ظ", 65223 => "ظ", 65224 => "ظ", 65225 => "ع", 65226 => "ع", 65227 => "ع", 65228 => "ع", 65229 => "غ", 65230 => "غ", 65231 => "غ", 65232 => "غ", 65233 => "ف", 65234 => "ف", 65235 => "ف", 65236 => "ف", 65237 => "ق", 65238 => "ق", 65239 => "ق", 65240 => "ق", 65241 => "ك", 65242 => "ك", 65243 => "ك", 65244 => "ك", 65245 => "ل", 65246 => "ل", 65247 => "ل", 65248 => "ل", 65249 => "م", 65250 => "م", 65251 => "م", 65252 => "م", 65253 => "ن", 65254 => "ن", 65255 => "ن", 65256 => "ن", 65257 => "ه", 65258 => "ه", 65259 => "ه", 65260 => "ه", 65261 => "و", 65262 => "و", 65263 => "ى", 65264 => "ى", 65265 => "ي", 65266 => "ي", 65267 => "ي", 65268 => "ي", 65269 => "لآ", 65270 => "لآ", 65271 => "لأ", 65272 => "لأ", 65273 => "لإ", 65274 => "لإ", 65275 => "لا", 65276 => "لا"}
  @scan_1 %{1570 => "ا", 1571 => "ا", 1572 => "و", 1573 => "ا", 1574 => "ي"}

  @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: %{is_defined: false, is_noun: false, is_verb: 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_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_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_Suffix_All_alef_maqsura(%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 result do
                    1 ->
                      {:ok, Runtime.slice_from(state, "ي")}
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Suffix_Verb_Step2c(%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 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) >= 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    2 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) >= 6, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Suffix_Verb_Step2b(%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 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) >= 5, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Suffix_Verb_Step2a(%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 result do
                    1 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) >= 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    2 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) >= 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    3 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) >= 5, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    4 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 5, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    5 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) >= 6, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Suffix_Verb_Step1(%Runtime{} = state) do
    (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 ->
                        if Runtime.codepoint_length(state.current) >= 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    2 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) >= 5, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    3 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) >= 6, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Suffix_Noun_Step3(%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 ->
                        if Runtime.codepoint_length(state.current) >= 3, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Suffix_Noun_Step2c2(%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 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) >= 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Suffix_Noun_Step2c1(%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 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) >= 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Suffix_Noun_Step2b(%Runtime{} = state) do
    (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 ->
                        if Runtime.codepoint_length(state.current) >= 5, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Suffix_Noun_Step2a(%Runtime{} = state) do
    (fn ->
      state = %{state | ket: state.cursor}
      case Runtime.find_among_b(state, @a_9) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | bra: s.cursor}
          case result do
                    1 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Suffix_Noun_Step1b(%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 result do
                    1 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 5, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Suffix_Noun_Step1a(%Runtime{} = state) do
    (fn ->
      state = %{state | ket: state.cursor}
      case Runtime.find_among_b(state, @a_11) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | bra: s.cursor}
          case result do
                    1 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) >= 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    2 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) >= 5, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    3 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) >= 6, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Normalize_pre(%Runtime{} = state) do
    {:ok, snowball_do_f(state, fn state ->
      {:ok, Runtime.scan_and_replace_forward(state, @scan_0)}
    end)}
  end

  defp r_Normalize_post(%Runtime{} = state) do
    case (fn state ->
      {:ok, snowball_do_f(state, 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 ->
            (fn ->
              state = %{state | ket: state.cursor}
              case Runtime.find_among_b(state, @a_13) do
                :fail -> {:fail, state}
                {%Runtime{} = s, result} ->
                  state = %{s | bra: s.cursor}
                  case result do
                            1 ->
                              {:ok, Runtime.slice_from(state, "ء")}
                            2 ->
                              {:ok, Runtime.slice_from(state, "ء")}
                            3 ->
                              {:ok, Runtime.slice_from(state, "ء")}
                    _ -> {:ok, state}
                  end
              end
            end).()
          end).(state)
          {tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
        end).(state)
      end)}
    end).(state) do
      {:ok, state} ->
      {:ok, snowball_do_f(state, fn state ->
        {:ok, Runtime.scan_and_replace_forward(state, @scan_1)}
      end)}
    end
  end

  defp r_Checks1(%Runtime{} = state) do
    (fn ->
      state = %{state | bra: state.cursor}
      case Runtime.find_among(state, @a_15) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | ket: s.cursor}
          case result do
                    1 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, put_in(state.vars[:is_noun], true)}
                        end).(state) do
                          {:ok, state} ->
                          case (fn state ->
                            {:ok, put_in(state.vars[:is_verb], false)}
                          end).(state) do
                            {:ok, state} ->
                            {:ok, put_in(state.vars[:is_defined], true)}
                          end
                        end
                        r -> r
                      end
                    2 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 3, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, put_in(state.vars[:is_noun], true)}
                        end).(state) do
                          {:ok, state} ->
                          case (fn state ->
                            {:ok, put_in(state.vars[:is_verb], false)}
                          end).(state) do
                            {:ok, state} ->
                            {:ok, put_in(state.vars[:is_defined], true)}
                          end
                        end
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Prefix_Step1(%Runtime{} = state) do
    (fn ->
      state = %{state | bra: state.cursor}
      case Runtime.find_among(state, @a_16) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | ket: s.cursor}
          case result do
                    1 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 3, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "أ")}
                        r -> r
                      end
                    2 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 3, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "آ")}
                        r -> r
                      end
                    3 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 3, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "أ")}
                        r -> r
                      end
                    4 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 3, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "ا")}
                        r -> r
                      end
                    5 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 3, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "إ")}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Prefix_Step2(%Runtime{} = state) do
    (fn ->
      state = %{state | bra: state.cursor}
      case Runtime.find_among(state, @a_17) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | ket: s.cursor}
          case result do
                    1 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 3, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          (fn state ->
                            saved_c = state.cursor
                            case (fn state ->
                            lift(state, Runtime.eq_s(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} ->
                          {:ok, Runtime.slice_del(state)}
                          r -> r
                        end
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Prefix_Step3a_Noun(%Runtime{} = state) do
    (fn ->
      state = %{state | bra: state.cursor}
      case Runtime.find_among(state, @a_18) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | ket: s.cursor}
          case result do
                    1 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 5, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    2 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Prefix_Step3b_Noun(%Runtime{} = state) do
    (fn ->
      state = %{state | bra: state.cursor}
      case Runtime.find_among(state, @a_19) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | ket: s.cursor}
          case result do
                    1 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 3, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    2 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 3, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "ب")}
                        r -> r
                      end
                    3 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 3, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "ك")}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Prefix_Step3_Verb(%Runtime{} = state) do
    (fn ->
      state = %{state | bra: state.cursor}
      case Runtime.find_among(state, @a_20) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | ket: s.cursor}
          case result do
                    1 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "ي")}
                        r -> r
                      end
                    2 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "ت")}
                        r -> r
                      end
                    3 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "ن")}
                        r -> r
                      end
                    4 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "أ")}
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_Prefix_Step4_Verb(%Runtime{} = state) do
    (fn ->
      state = %{state | bra: state.cursor}
      case Runtime.find_among(state, @a_21) do
        :fail -> {:fail, state}
        {%Runtime{} = s, result} ->
          state = %{s | ket: s.cursor}
          case result do
                    1 ->
                      case (fn state ->
                        if Runtime.codepoint_length(state.current) > 4, do: {:ok, state}, else: {:fail, state}
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, put_in(state.vars[:is_verb], true)}
                        end).(state) do
                          {:ok, state} ->
                          case (fn state ->
                            {:ok, put_in(state.vars[:is_noun], false)}
                          end).(state) do
                            {:ok, state} ->
                            {:ok, Runtime.slice_from(state, "است")}
                          end
                        end
                        r -> r
                      end
            _ -> {:ok, state}
          end
      end
    end).()
  end

  defp r_stem(%Runtime{} = state) do
    case (fn state ->
      {:ok, put_in(state.vars[:is_noun], true)}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, put_in(state.vars[:is_verb], true)}
      end).(state) do
        {:ok, state} ->
        case (fn state ->
          {:ok, put_in(state.vars[:is_defined], false)}
        end).(state) do
          {:ok, state} ->
          case (fn state ->
            {:ok, snowball_do_f(state, fn state ->
              r_Checks1(state)
            end)}
          end).(state) do
            {:ok, state} ->
            case (fn state ->
              {:ok, snowball_do_f(state, fn state ->
                r_Normalize_pre(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 ->
                      snowball_or(state,
                        fn state ->
                          snowball_or(state,
                            fn state ->
                              case (fn state ->
                                if state.vars[:is_verb], do: {:ok, state}, else: {:fail, state}
                              end).(state) do
                                {:ok, state} ->
                                snowball_or(state,
                                  fn state ->
                                    snowball_or(state,
                                      fn state ->
                                        case (fn state ->
                                          (fn ->
                                            n = 1
                                            case Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
                                              case (fn state ->
                                              r_Suffix_Verb_Step1(state)
                                              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 ->
                                                r_Suffix_Verb_Step1(state)
                                                  end).(state) do
                                                    {:ok, s} -> loop_fn.(loop_fn, s)
                                                    {:fail, _} -> {:ok, state}
                                                  end
                                                end)
                                            end
                                          end).()
                                        end).(state) do
                                          {:ok, state} ->
                                          snowball_or(state,
                                            fn state ->
                                              snowball_or(state,
                                                fn state ->
                                                  r_Suffix_Verb_Step2a(state)
                                                end,
                                                fn state ->
                                                  r_Suffix_Verb_Step2c(state)
                                                end)
                                            end,
                                            fn state ->
                                              next_codepoint_b(state)
                                            end)
                                          r -> r
                                        end
                                      end,
                                      fn state ->
                                        r_Suffix_Verb_Step2b(state)
                                      end)
                                  end,
                                  fn state ->
                                    r_Suffix_Verb_Step2a(state)
                                  end)
                                r -> r
                              end
                            end,
                            fn state ->
                              case (fn state ->
                                if state.vars[:is_noun], do: {:ok, state}, else: {:fail, state}
                              end).(state) do
                                {:ok, state} ->
                                case (fn state ->
                                  {:ok, snowball_try(state, fn state ->
                                    snowball_or(state,
                                      fn state ->
                                        snowball_or(state,
                                          fn state ->
                                            snowball_or(state,
                                              fn state ->
                                                snowball_or(state,
                                                  fn state ->
                                                    r_Suffix_Noun_Step2c2(state)
                                                  end,
                                                  fn state ->
                                                    case (fn state ->
                                                      (fn state ->
                                                        saved_c = state.cursor
                                                        case (fn state ->
                                                        if state.vars[:is_defined], 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).(state) do
                                                      {:ok, state} ->
                                                      case (fn state ->
                                                        r_Suffix_Noun_Step1a(state)
                                                      end).(state) do
                                                        {:ok, state} ->
                                                        snowball_or(state,
                                                          fn state ->
                                                            snowball_or(state,
                                                              fn state ->
                                                                snowball_or(state,
                                                                  fn state ->
                                                                    r_Suffix_Noun_Step2a(state)
                                                                  end,
                                                                  fn state ->
                                                                    r_Suffix_Noun_Step2b(state)
                                                                  end)
                                                              end,
                                                              fn state ->
                                                                r_Suffix_Noun_Step2c1(state)
                                                              end)
                                                          end,
                                                          fn state ->
                                                            next_codepoint_b(state)
                                                          end)
                                                        r -> r
                                                      end
                                                      r -> r
                                                    end
                                                  end)
                                              end,
                                              fn state ->
                                                case (fn state ->
                                                  r_Suffix_Noun_Step1b(state)
                                                end).(state) do
                                                  {:ok, state} ->
                                                  snowball_or(state,
                                                    fn state ->
                                                      snowball_or(state,
                                                        fn state ->
                                                          r_Suffix_Noun_Step2a(state)
                                                        end,
                                                        fn state ->
                                                          r_Suffix_Noun_Step2b(state)
                                                        end)
                                                    end,
                                                    fn state ->
                                                      r_Suffix_Noun_Step2c1(state)
                                                    end)
                                                  r -> r
                                                end
                                              end)
                                          end,
                                          fn state ->
                                            case (fn state ->
                                              (fn state ->
                                                saved_c = state.cursor
                                                case (fn state ->
                                                if state.vars[:is_defined], 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).(state) do
                                              {:ok, state} ->
                                              r_Suffix_Noun_Step2a(state)
                                              r -> r
                                            end
                                          end)
                                      end,
                                      fn state ->
                                        r_Suffix_Noun_Step2b(state)
                                      end)
                                  end)}
                                end).(state) do
                                  {:ok, state} ->
                                  r_Suffix_Noun_Step3(state)
                                end
                                r -> r
                              end
                            end)
                        end,
                        fn state ->
                          r_Suffix_All_alef_maqsura(state)
                        end)
                    end)}
                  end).(state)
                  {tag, %{s | cursor: old_cursor, limit_backward: old_lb}}
                end).(state)
              end).(state) do
                {:ok, state} ->
                case (fn state ->
                  {:ok, snowball_do_f(state, fn state ->
                    case (fn state ->
                      {:ok, snowball_try(state, fn state ->
                        r_Prefix_Step1(state)
                      end)}
                    end).(state) do
                      {:ok, state} ->
                      case (fn state ->
                        {:ok, snowball_try(state, fn state ->
                          r_Prefix_Step2(state)
                        end)}
                      end).(state) do
                        {:ok, state} ->
                        snowball_or(state,
                          fn state ->
                            snowball_or(state,
                              fn state ->
                                r_Prefix_Step3a_Noun(state)
                              end,
                              fn state ->
                                case (fn state ->
                                  if state.vars[:is_noun], do: {:ok, state}, else: {:fail, state}
                                end).(state) do
                                  {:ok, state} ->
                                  r_Prefix_Step3b_Noun(state)
                                  r -> r
                                end
                              end)
                          end,
                          fn state ->
                            case (fn state ->
                              if state.vars[:is_verb], do: {:ok, state}, else: {:fail, state}
                            end).(state) do
                              {:ok, state} ->
                              case (fn state ->
                                {:ok, snowball_try(state, fn state ->
                                  r_Prefix_Step3_Verb(state)
                                end)}
                              end).(state) do
                                {:ok, state} ->
                                r_Prefix_Step4_Verb(state)
                              end
                              r -> r
                            end
                          end)
                      end
                    end
                  end)}
                end).(state) do
                  {:ok, state} ->
                  {:ok, snowball_do_f(state, fn state ->
                    r_Normalize_post(state)
                  end)}
                end
              end
            end
          end
        end
      end
    end
  end

end