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

  Generated from the canonical Snowball algorithm source.
  """

  alias Snowball.Runtime
  alias Snowball.Grouping


  # Groupings
  @g_elision_char Grouping.from_string("cdjlmnst")
  @g_keep_with_s Grouping.from_string("aiouès")
  @g_oux_ending Grouping.from_string("bhjlnp")
  @g_v Grouping.from_string("aeiouyâàëéêèïîôûù")


  # Among tables
  @a_0 [
    {"ell", -1, -1, nil},
    {"eill", -1, -1, nil},
    {"enn", -1, -1, nil},
    {"onn", -1, -1, nil},
    {"ett", -1, -1, nil}
  ]
  @a_1 [
    {"e", -1, 3, nil},
    {"Ière", 0, 2, nil},
    {"ière", 0, 2, nil},
    {"ion", -1, 1, nil},
    {"Ier", -1, 2, nil},
    {"ier", -1, 2, nil}
  ]
  @a_2 [
    {"al", -1, 1, nil},
    {"épl", -1, -1, nil},
    {"auv", -1, -1, nil}
  ]
  @a_3 [
    {"a", -1, 3, nil},
    {"era", 0, 2, nil},
    {"aise", -1, 4, nil},
    {"asse", -1, 3, nil},
    {"ante", -1, 3, nil},
    {"ée", -1, 2, nil},
    {"ai", -1, 3, nil},
    {"erai", 6, 2, nil},
    {"er", -1, 2, nil},
    {"as", -1, 3, nil},
    {"eras", 9, 2, nil},
    {"âmes", -1, 3, nil},
    {"aises", -1, 4, nil},
    {"asses", -1, 3, nil},
    {"antes", -1, 3, nil},
    {"âtes", -1, 3, nil},
    {"ées", -1, 2, nil},
    {"ais", -1, 4, nil},
    {"eais", 17, 5, nil},
    {"erais", 17, 2, nil},
    {"ions", -1, 1, nil},
    {"erions", 20, 2, nil},
    {"assions", 20, 3, nil},
    {"erons", -1, 2, nil},
    {"ants", -1, 3, nil},
    {"és", -1, 2, nil},
    {"ait", -1, 3, nil},
    {"erait", 26, 2, nil},
    {"ant", -1, 3, nil},
    {"aIent", -1, 3, nil},
    {"eraIent", 29, 2, nil},
    {"èrent", -1, 2, nil},
    {"assent", -1, 3, nil},
    {"eront", -1, 2, nil},
    {"ât", -1, 3, nil},
    {"ez", -1, 2, nil},
    {"iez", 35, 2, nil},
    {"eriez", 36, 2, nil},
    {"assiez", 36, 3, nil},
    {"erez", 35, 2, nil},
    {"é", -1, 2, nil}
  ]
  @a_4 [
    {"ira", -1, 1, nil},
    {"ie", -1, 1, nil},
    {"isse", -1, 1, nil},
    {"issante", -1, 1, nil},
    {"i", -1, 1, nil},
    {"irai", 4, 1, nil},
    {"ir", -1, 1, nil},
    {"iras", -1, 1, nil},
    {"ies", -1, 1, nil},
    {"îmes", -1, 1, nil},
    {"isses", -1, 1, nil},
    {"issantes", -1, 1, nil},
    {"îtes", -1, 1, nil},
    {"is", -1, 1, nil},
    {"irais", 13, 1, nil},
    {"issais", 13, 1, nil},
    {"irions", -1, 1, nil},
    {"issions", -1, 1, nil},
    {"irons", -1, 1, nil},
    {"issons", -1, 1, nil},
    {"issants", -1, 1, nil},
    {"it", -1, 1, nil},
    {"irait", 21, 1, nil},
    {"issait", 21, 1, nil},
    {"issant", -1, 1, nil},
    {"iraIent", -1, 1, nil},
    {"issaIent", -1, 1, nil},
    {"irent", -1, 1, nil},
    {"issent", -1, 1, nil},
    {"iront", -1, 1, nil},
    {"ît", -1, 1, nil},
    {"iriez", -1, 1, nil},
    {"issiez", -1, 1, nil},
    {"irez", -1, 1, nil},
    {"issez", -1, 1, nil}
  ]
  @a_5 [
    {"iqU", -1, 3, nil},
    {"abl", -1, 3, nil},
    {"Ièr", -1, 4, nil},
    {"ièr", -1, 4, nil},
    {"eus", -1, 2, nil},
    {"iv", -1, 1, nil}
  ]
  @a_6 [
    {"ic", -1, 2, nil},
    {"abil", -1, 1, nil},
    {"iv", -1, 3, nil}
  ]
  @a_7 [
    {"iqUe", -1, 1, nil},
    {"atrice", -1, 2, nil},
    {"ance", -1, 1, nil},
    {"ence", -1, 5, nil},
    {"logie", -1, 3, nil},
    {"able", -1, 1, nil},
    {"isme", -1, 1, nil},
    {"euse", -1, 12, nil},
    {"iste", -1, 1, nil},
    {"ive", -1, 8, nil},
    {"if", -1, 8, nil},
    {"usion", -1, 4, nil},
    {"ation", -1, 2, nil},
    {"ution", -1, 4, nil},
    {"ateur", -1, 2, nil},
    {"iqUes", -1, 1, nil},
    {"atrices", -1, 2, nil},
    {"ances", -1, 1, nil},
    {"ences", -1, 5, nil},
    {"logies", -1, 3, nil},
    {"ables", -1, 1, nil},
    {"ismes", -1, 1, nil},
    {"euses", -1, 12, nil},
    {"istes", -1, 1, nil},
    {"ives", -1, 8, nil},
    {"ifs", -1, 8, nil},
    {"usions", -1, 4, nil},
    {"ations", -1, 2, nil},
    {"utions", -1, 4, nil},
    {"ateurs", -1, 2, nil},
    {"ments", -1, 16, nil},
    {"ements", 30, 6, nil},
    {"issements", 31, 13, nil},
    {"ités", -1, 7, nil},
    {"ment", -1, 16, nil},
    {"ement", 34, 6, nil},
    {"issement", 35, 13, nil},
    {"amment", 34, 14, nil},
    {"emment", 34, 15, nil},
    {"aux", -1, 10, nil},
    {"eaux", 39, 9, nil},
    {"eux", -1, 1, nil},
    {"oux", -1, 11, nil},
    {"ité", -1, 7, nil}
  ]
  @a_8 [
    {"col", -1, -1, nil},
    {"ni", -1, 1, nil},
    {"par", -1, -1, nil},
    {"tap", -1, -1, nil}
  ]
  @a_9 [
    {"", -1, 7, nil},
    {"H", 0, 6, nil},
    {"He", 1, 4, nil},
    {"Hi", 1, 5, nil},
    {"I", 0, 1, nil},
    {"U", 0, 2, nil},
    {"Y", 0, 3, 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, pV: 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_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_un_accent(%Runtime{} = state) do
    case (fn state ->
      (fn ->
        n = 1
        case Enum.reduce_while(1..max(n, 0)//1, {:ok, state}, fn _, {:ok, s} ->
          case (fn state ->
          lift(state, Runtime.out_grouping_b(state, @g_v))
          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 ->
            lift(state, Runtime.out_grouping_b(state, @g_v))
              end).(state) do
                {:ok, s} -> loop_fn.(loop_fn, s)
                {:fail, _} -> {:ok, state}
              end
            end)
        end
      end).()
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {: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, "é"))
            end,
            fn state ->
              lift(state, Runtime.eq_s_b(state, "è"))
            end)
        end).(state) do
          {:ok, state} ->
          case (fn state ->
            {:ok, %{state | bra: state.cursor}}
          end).(state) do
            {:ok, state} ->
            {:ok, Runtime.slice_from(state, "e")}
          end
          r -> r
        end
      end
      r -> r
    end
  end

  defp r_un_double(%Runtime{} = state) do
    case (fn state ->
      snowball_test_b(state, fn state ->
        (fn ->
          case Runtime.find_among_b(state, @a_0) do
            :fail -> {:fail, state}
            {%Runtime{} = s, _} -> {:ok, s}
          end
        end).()
      end)
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        {:ok, %{state | ket: state.cursor}}
      end).(state) do
        {:ok, state} ->
        case (fn state ->
          next_codepoint_b(state)
        end).(state) do
          {:ok, state} ->
          case (fn state ->
            {:ok, %{state | bra: state.cursor}}
          end).(state) do
            {:ok, state} ->
            {:ok, Runtime.slice_del(state)}
          end
          r -> r
        end
      end
      r -> r
    end
  end

  defp r_residual_suffix(%Runtime{} = state) do
    case (fn 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 ->
                snowball_test_b(state, fn state ->
                  snowball_or(state,
                    fn state ->
                      lift(state, Runtime.eq_s_b(state, "Hi"))
                    end,
                    fn state ->
                      lift(state, Runtime.out_grouping_b(state, @g_keep_with_s))
                    end)
                end)
              end).(state) do
                {:ok, state} ->
                {:ok, Runtime.slice_del(state)}
                r -> r
              end
            end
            r -> r
          end
        end
      end)}
    end).(state) do
      {:ok, state} ->
      (fn ->
        case (fn state ->
          (fn ->
            target = state.vars[:pV]
            if target < state.limit_backward or target > state.limit do
              {:fail, state}
            else
              {:ok, %{state | cursor: target}}
            end
          end).()
        end).(state) do
          {:fail, _} -> {:fail, state}
          {:ok, limit_state} ->
            old_lb = state.limit_backward
            state = %{state | limit_backward: limit_state.cursor}
            case (fn state ->
          (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 ->
                              r_R2(state)
                            end).(state) do
                              {:ok, state} ->
                              case (fn state ->
                                snowball_or(state,
                                  fn state ->
                                    lift(state, Runtime.eq_s_b(state, "s"))
                                  end,
                                  fn state ->
                                    lift(state, Runtime.eq_s_b(state, "t"))
                                  end)
                              end).(state) do
                                {:ok, state} ->
                                {:ok, Runtime.slice_del(state)}
                                r -> r
                              end
                              r -> r
                            end
                          2 ->
                            {:ok, Runtime.slice_from(state, "i")}
                          3 ->
                            {:ok, Runtime.slice_del(state)}
                  _ -> {:ok, state}
                end
            end
          end).()
            end).(state) do
              {:ok, s} -> {:ok, %{s | limit_backward: old_lb}}
              {:fail, s} -> {:fail, %{s | limit_backward: old_lb}}
            end
        end
      end).()
    end
  end

  defp r_verb_suffix(%Runtime{} = state) do
    (fn ->
      old_limit = state.limit_backward
      case (fn state ->
        (fn ->
          target = state.vars[:pV]
          if target < state.limit_backward or target > state.limit do
            {:fail, state}
          else
            {:ok, %{state | cursor: target}}
          end
        end).()
      end).(state) do
        {:fail, _} -> {:fail, state}
        {:ok, limit_state} ->
          state = %{state | ket: state.cursor, limit_backward: limit_state.cursor}
          case Runtime.find_among_b(state, @a_3) do
            :fail -> {:fail, %{state | limit_backward: old_limit}}
            {%Runtime{} = s, result} ->
              state = %{s | bra: s.cursor, limit_backward: old_limit}
          case result do
                    1 ->
                      case (fn state ->
                        r_R2(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, snowball_try(state, fn state ->
                          case (fn state ->
                            lift(state, Runtime.eq_s_b(state, "e"))
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              r_RV(state)
                            end).(state) do
                              {:ok, state} ->
                              {:ok, %{state | bra: state.cursor}}
                              r -> r
                            end
                            r -> r
                          end
                        end)}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                      end
                    4 ->
                      case (fn state ->
                        (fn state ->
                          saved_c = state.cursor
                          case (fn state ->
                          (fn ->
                            case Runtime.find_among_b(state, @a_2) do
                              :fail -> {:fail, state}
                              {%Runtime{} = s, result} ->
                                state = s
                                case result do
                                  1 ->
                                    case (fn state ->
                                      next_codepoint_b(state)
                                    end).(state) do
                                      {:ok, state} ->
                                      if state.cursor <= state.limit_backward, do: {:ok, state}, else: {:fail, state}
                                      r -> r
                                    end
                                  _ -> {:ok, s}
                                end
                            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
                    5 ->
                      {:ok, Runtime.slice_del(state)}
            _ -> {:ok, state}
          end
          end
      end
    end).()
  end

  defp r_i_verb_suffix(%Runtime{} = state) do
    (fn ->
      case (fn state ->
        (fn ->
          target = state.vars[:pV]
          if target < state.limit_backward or target > state.limit do
            {:fail, state}
          else
            {:ok, %{state | cursor: target}}
          end
        end).()
      end).(state) do
        {:fail, _} -> {:fail, state}
        {:ok, limit_state} ->
          old_lb = state.limit_backward
          state = %{state | limit_backward: limit_state.cursor}
          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 result do
                        1 ->
                          case (fn state ->
                            (fn state ->
                              saved_c = state.cursor
                              case (fn state ->
                              lift(state, Runtime.eq_s_b(state, "H"))
                              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 ->
                              lift(state, Runtime.out_grouping_b(state, @g_v))
                            end).(state) do
                              {:ok, state} ->
                              {:ok, Runtime.slice_del(state)}
                              r -> r
                            end
                            r -> r
                          end
                _ -> {:ok, state}
              end
          end
        end).()
          end).(state) do
            {:ok, s} -> {:ok, %{s | limit_backward: old_lb}}
            {:fail, s} -> {:fail, %{s | limit_backward: old_lb}}
          end
      end
    end).()
  end

  defp r_standard_suffix(%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 ->
                        r_R2(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_del(state)}
                        r -> r
                      end
                    2 ->
                      case (fn state ->
                        r_R2(state)
                      end).(state) do
                        {:ok, state} ->
                        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, "ic"))
                              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 ->
                                        r_R2(state)
                                      end).(state) do
                                        {:ok, state} ->
                                        {:ok, Runtime.slice_del(state)}
                                        r -> r
                                      end
                                    end,
                                    fn state ->
                                      {:ok, Runtime.slice_from(state, "iqU")}
                                    end)
                                end
                                r -> r
                              end
                            end
                          end)}
                        end
                        r -> r
                      end
                    3 ->
                      case (fn state ->
                        r_R2(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "log")}
                        r -> r
                      end
                    4 ->
                      case (fn state ->
                        r_R2(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "u")}
                        r -> r
                      end
                    5 ->
                      case (fn state ->
                        r_R2(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "ent")}
                        r -> r
                      end
                    6 ->
                      case (fn state ->
                        r_RV(state)
                      end).(state) do
                        {:ok, state} ->
                        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_5) do
                                :fail -> {:fail, state}
                                {%Runtime{} = s, result} ->
                                  state = %{s | bra: s.cursor}
                                  case result do
                                            1 ->
                                              case (fn state ->
                                                r_R2(state)
                                              end).(state) do
                                                {:ok, state} ->
                                                case (fn state ->
                                                  {:ok, Runtime.slice_del(state)}
                                                end).(state) do
                                                  {:ok, state} ->
                                                  case (fn state ->
                                                    {:ok, %{state | ket: state.cursor}}
                                                  end).(state) do
                                                    {:ok, state} ->
                                                    case (fn state ->
                                                      lift(state, Runtime.eq_s_b(state, "at"))
                                                    end).(state) do
                                                      {:ok, state} ->
                                                      case (fn state ->
                                                        {:ok, %{state | bra: state.cursor}}
                                                      end).(state) do
                                                        {:ok, state} ->
                                                        case (fn state ->
                                                          r_R2(state)
                                                        end).(state) do
                                                          {:ok, state} ->
                                                          {:ok, Runtime.slice_del(state)}
                                                          r -> r
                                                        end
                                                      end
                                                      r -> r
                                                    end
                                                  end
                                                end
                                                r -> r
                                              end
                                            2 ->
                                              snowball_or(state,
                                                fn state ->
                                                  case (fn state ->
                                                    r_R2(state)
                                                  end).(state) do
                                                    {:ok, state} ->
                                                    {:ok, Runtime.slice_del(state)}
                                                    r -> r
                                                  end
                                                end,
                                                fn state ->
                                                  case (fn state ->
                                                    r_R1(state)
                                                  end).(state) do
                                                    {:ok, state} ->
                                                    {:ok, Runtime.slice_from(state, "eux")}
                                                    r -> r
                                                  end
                                                end)
                                            3 ->
                                              case (fn state ->
                                                r_R2(state)
                                              end).(state) do
                                                {:ok, state} ->
                                                {:ok, Runtime.slice_del(state)}
                                                r -> r
                                              end
                                            4 ->
                                              case (fn state ->
                                                r_RV(state)
                                              end).(state) do
                                                {:ok, state} ->
                                                {:ok, Runtime.slice_from(state, "i")}
                                                r -> r
                                              end
                                    _ -> {:ok, state}
                                  end
                              end
                            end).()
                          end)}
                        end
                        r -> r
                      end
                    7 ->
                      case (fn state ->
                        r_R2(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, Runtime.slice_del(state)}
                        end).(state) do
                          {:ok, state} ->
                          {:ok, snowball_try(state, fn state ->
                            (fn ->
                              state = %{state | ket: state.cursor}
                              case Runtime.find_among_b(state, @a_6) do
                                :fail -> {:fail, state}
                                {%Runtime{} = s, result} ->
                                  state = %{s | bra: s.cursor}
                                  case result do
                                            1 ->
                                              snowball_or(state,
                                                fn state ->
                                                  case (fn state ->
                                                    r_R2(state)
                                                  end).(state) do
                                                    {:ok, state} ->
                                                    {:ok, Runtime.slice_del(state)}
                                                    r -> r
                                                  end
                                                end,
                                                fn state ->
                                                  {:ok, Runtime.slice_from(state, "abl")}
                                                end)
                                            2 ->
                                              snowball_or(state,
                                                fn state ->
                                                  case (fn state ->
                                                    r_R2(state)
                                                  end).(state) do
                                                    {:ok, state} ->
                                                    {:ok, Runtime.slice_del(state)}
                                                    r -> r
                                                  end
                                                end,
                                                fn state ->
                                                  {:ok, Runtime.slice_from(state, "iqU")}
                                                end)
                                            3 ->
                                              case (fn state ->
                                                r_R2(state)
                                              end).(state) do
                                                {:ok, state} ->
                                                {:ok, Runtime.slice_del(state)}
                                                r -> r
                                              end
                                    _ -> {:ok, state}
                                  end
                              end
                            end).()
                          end)}
                        end
                        r -> r
                      end
                    8 ->
                      case (fn state ->
                        r_R2(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, Runtime.slice_del(state)}
                        end).(state) do
                          {:ok, state} ->
                          {: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, "at"))
                              end).(state) do
                                {:ok, state} ->
                                case (fn state ->
                                  {:ok, %{state | bra: state.cursor}}
                                end).(state) do
                                  {:ok, state} ->
                                  case (fn state ->
                                    r_R2(state)
                                  end).(state) do
                                    {:ok, state} ->
                                    case (fn state ->
                                      {:ok, Runtime.slice_del(state)}
                                    end).(state) do
                                      {:ok, state} ->
                                      case (fn state ->
                                        {:ok, %{state | ket: state.cursor}}
                                      end).(state) do
                                        {:ok, state} ->
                                        case (fn state ->
                                          lift(state, Runtime.eq_s_b(state, "ic"))
                                        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 ->
                                                  r_R2(state)
                                                end).(state) do
                                                  {:ok, state} ->
                                                  {:ok, Runtime.slice_del(state)}
                                                  r -> r
                                                end
                                              end,
                                              fn state ->
                                                {:ok, Runtime.slice_from(state, "iqU")}
                                              end)
                                          end
                                          r -> r
                                        end
                                      end
                                    end
                                    r -> r
                                  end
                                end
                                r -> r
                              end
                            end
                          end)}
                        end
                        r -> r
                      end
                    9 ->
                      {:ok, Runtime.slice_from(state, "eau")}
                    10 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "al")}
                        r -> r
                      end
                    11 ->
                      case (fn state ->
                        lift(state, Runtime.in_grouping_b(state, @g_oux_ending))
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "ou")}
                        r -> r
                      end
                    12 ->
                      snowball_or(state,
                        fn state ->
                          case (fn state ->
                            r_R2(state)
                          end).(state) do
                            {:ok, state} ->
                            {:ok, Runtime.slice_del(state)}
                            r -> r
                          end
                        end,
                        fn state ->
                          case (fn state ->
                            r_R1(state)
                          end).(state) do
                            {:ok, state} ->
                            {:ok, Runtime.slice_from(state, "eux")}
                            r -> r
                          end
                        end)
                    13 ->
                      case (fn state ->
                        r_R1(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          lift(state, Runtime.out_grouping_b(state, @g_v))
                        end).(state) do
                          {:ok, state} ->
                          {:ok, Runtime.slice_del(state)}
                          r -> r
                        end
                        r -> r
                      end
                    14 ->
                      case (fn state ->
                        r_RV(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, Runtime.slice_from(state, "ant")}
                        end).(state) do
                          {:ok, s} -> {:fail, s}
                        end
                        r -> r
                      end
                    15 ->
                      case (fn state ->
                        r_RV(state)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, Runtime.slice_from(state, "ent")}
                        end).(state) do
                          {:ok, s} -> {:fail, s}
                        end
                        r -> r
                      end
                    16 ->
                      case (fn state ->
                        snowball_test_b(state, fn state ->
                          case (fn state ->
                            lift(state, Runtime.in_grouping_b(state, @g_v))
                          end).(state) do
                            {:ok, state} ->
                            r_RV(state)
                            r -> r
                          end
                        end)
                      end).(state) do
                        {:ok, state} ->
                        case (fn state ->
                          {:ok, Runtime.slice_del(state)}
                        end).(state) do
                          {:ok, s} -> {:fail, s}
                        end
                        r -> r
                      end
            _ -> {:ok, state}
          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_RV(%Runtime{} = state) do
    if state.vars[:pV] <= state.cursor, do: {:ok, state}, else: {:fail, state}
  end

  defp r_elisions(%Runtime{} = state) do
    case (fn state ->
      {:ok, %{state | bra: state.cursor}}
    end).(state) do
      {:ok, state} ->
      case (fn state ->
        snowball_or(state,
          fn state ->
            lift(state, Runtime.in_grouping(state, @g_elision_char))
          end,
          fn state ->
            lift(state, Runtime.eq_s(state, "qu"))
          end)
      end).(state) do
        {:ok, state} ->
        case (fn state ->
          lift(state, Runtime.eq_s(state, "'"))
        end).(state) do
          {:ok, state} ->
          case (fn state ->
            {:ok, %{state | ket: state.cursor}}
          end).(state) do
            {:ok, state} ->
            case (fn state ->
              (fn state ->
                saved_c = state.cursor
                case (fn state ->
                if state.cursor >= state.limit, do: {:ok, state}, else: {:fail, state}
                end).(state) do
                  {:ok, s} -> {:fail, %{s | cursor: saved_c}}
                  {:fail, s} -> {:ok, %{s | cursor: saved_c}}
                end
              end).(state)
            end).(state) do
              {:ok, state} ->
              {:ok, Runtime.slice_del(state)}
              r -> r
            end
          end
          r -> r
        end
        r -> r
      end
    end
  end

  defp r_prelude(%Runtime{} = state) do
    (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 ->
            snowball_or(state,
              fn state ->
                snowball_or(state,
                  fn state ->
                    snowball_or(state,
                      fn state ->
                        snowball_or(state,
                          fn state ->
                            case (fn state ->
                              lift(state, Runtime.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 ->
                                    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, "i"))
                                        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, "I")}
                                              r -> r
                                            end
                                          end
                                          r -> r
                                        end
                                      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} ->
                                        {:ok, Runtime.slice_from(state, "Y")}
                                      end
                                      r -> r
                                    end
                                  end)
                              end
                              r -> r
                            end
                          end,
                          fn state ->
                            case (fn state ->
                              {:ok, %{state | bra: state.cursor}}
                            end).(state) do
                              {:ok, state} ->
                              case (fn state ->
                                lift(state, Runtime.eq_s(state, "ë"))
                              end).(state) do
                                {:ok, state} ->
                                case (fn state ->
                                  {:ok, %{state | ket: state.cursor}}
                                end).(state) do
                                  {:ok, state} ->
                                  {:ok, Runtime.slice_from(state, "He")}
                                end
                                r -> r
                              end
                            end
                          end)
                      end,
                      fn state ->
                        case (fn state ->
                          {:ok, %{state | bra: state.cursor}}
                        end).(state) do
                          {:ok, state} ->
                          case (fn state ->
                            lift(state, Runtime.eq_s(state, "ï"))
                          end).(state) do
                            {:ok, state} ->
                            case (fn state ->
                              {:ok, %{state | ket: state.cursor}}
                            end).(state) do
                              {:ok, state} ->
                              {:ok, Runtime.slice_from(state, "Hi")}
                            end
                            r -> r
                          end
                        end
                      end)
                  end,
                  fn state ->
                    case (fn state ->
                      {:ok, %{state | bra: state.cursor}}
                    end).(state) do
                      {:ok, 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)
              end,
              fn state ->
                case (fn state ->
                  lift(state, Runtime.eq_s(state, "q"))
                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(state, "u"))
                    end).(state) do
                      {:ok, state} ->
                      case (fn state ->
                        {:ok, %{state | ket: state.cursor}}
                      end).(state) do
                        {:ok, state} ->
                        {:ok, Runtime.slice_from(state, "U")}
                      end
                      r -> r
                    end
                  end
                  r -> r
                end
              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

  defp r_mark_regions(%Runtime{} = state) do
    case (fn state ->
      {:ok, put_in(state.vars[:pV], state.limit)}
    end).(state) do
      {:ok, state} ->
      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 ->
            {:ok, snowball_do_f(state, fn state ->
              case (fn state ->
                snowball_or(state,
                  fn state ->
                    snowball_or(state,
                      fn state ->
                        case (fn state ->
                          lift(state, Runtime.in_grouping(state, @g_v))
                        end).(state) do
                          {:ok, state} ->
                          case (fn state ->
                            lift(state, Runtime.in_grouping(state, @g_v))
                          end).(state) do
                            {:ok, state} ->
                            next_codepoint(state)
                            r -> r
                          end
                          r -> r
                        end
                      end,
                      fn state ->
                        (fn ->
                          case Runtime.find_among(state, @a_8) do
                            :fail -> {:fail, state}
                            {%Runtime{} = s, result} ->
                              state = s
                              case result do
                                1 ->
                                  lift(state, Runtime.in_grouping(state, @g_v))
                                _ -> {:ok, s}
                              end
                          end
                        end).()
                      end)
                  end,
                  fn state ->
                    case (fn state ->
                      next_codepoint(state)
                    end).(state) do
                      {:ok, state} ->
                      case Runtime.go_out_grouping(state, @g_v) do
                        :fail -> {:fail, state}
                        %Runtime{} = s -> next_codepoint(s)
                      end
                      r -> r
                    end
                  end)
              end).(state) do
                {:ok, state} ->
                {:ok, put_in(state.vars[:pV], state.cursor)}
                r -> r
              end
            end)}
          end).(state) do
            {:ok, state} ->
            {:ok, snowball_do_f(state, 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} ->
                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 ->
                      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
                  r -> r
                end
                r -> r
              end
            end)}
          end
        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_9) do
            :fail -> {:fail, state}
            {%Runtime{} = s, result} ->
              state = %{s | ket: s.cursor}
              case result do
                        1 ->
                          {:ok, Runtime.slice_from(state, "i")}
                        2 ->
                          {:ok, Runtime.slice_from(state, "u")}
                        3 ->
                          {:ok, Runtime.slice_from(state, "y")}
                        4 ->
                          {:ok, Runtime.slice_from(state, "ë")}
                        5 ->
                          {:ok, Runtime.slice_from(state, "ï")}
                        6 ->
                          {:ok, Runtime.slice_del(state)}
                        7 ->
                          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_elisions(state)
      end)}
    end).(state) do
      {:ok, state} ->
      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 ->
                case (fn state ->
                  {:ok, snowball_do_b(state, fn state ->
                    snowball_or(state,
                      fn state ->
                        case (fn state ->
                          snowball_test_b(state, fn state ->
                            snowball_or(state,
                              fn state ->
                                snowball_or(state,
                                  fn state ->
                                    r_standard_suffix(state)
                                  end,
                                  fn state ->
                                    r_i_verb_suffix(state)
                                  end)
                              end,
                              fn state ->
                                r_verb_suffix(state)
                              end)
                          end)
                        end).(state) do
                          {:ok, state} ->
                          {:ok, snowball_try(state, fn state ->
                            case (fn state ->
                              {:ok, %{state | ket: state.cursor}}
                            end).(state) do
                              {:ok, state} ->
                              snowball_or(state,
                                fn state ->
                                  case (fn state ->
                                    lift(state, Runtime.eq_s_b(state, "Y"))
                                  end).(state) do
                                    {:ok, state} ->
                                    case (fn state ->
                                      {:ok, %{state | bra: state.cursor}}
                                    end).(state) do
                                      {:ok, state} ->
                                      {:ok, Runtime.slice_from(state, "i")}
                                    end
                                    r -> r
                                  end
                                end,
                                fn state ->
                                  case (fn state ->
                                    lift(state, Runtime.eq_s_b(state, "ç"))
                                  end).(state) do
                                    {:ok, state} ->
                                    case (fn state ->
                                      {:ok, %{state | bra: state.cursor}}
                                    end).(state) do
                                      {:ok, state} ->
                                      {:ok, Runtime.slice_from(state, "c")}
                                    end
                                    r -> r
                                  end
                                end)
                            end
                          end)}
                          r -> r
                        end
                      end,
                      fn state ->
                        r_residual_suffix(state)
                      end)
                  end)}
                end).(state) do
                  {:ok, state} ->
                  case (fn state ->
                    {:ok, snowball_do_b(state, fn state ->
                      r_un_double(state)
                    end)}
                  end).(state) do
                    {:ok, state} ->
                    {:ok, snowball_do_b(state, fn state ->
                      r_un_accent(state)
                    end)}
                  end
                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

end