   def decr_cas(server, key, cas, opts \\ []) do
     defaults = [by: 1, default: 0]
     opts = Keyword.merge(defaults, opts)
-    execute_k(server, :DECREMENT, [key, Keyword.get(opts, :by), Keyword.get(opts, :default), cas, ttl_or_default(server, opts)], opts)
+    server_options = get_server_options(server)
+    execute_k(server, :DECREMENT, [key, Keyword.get(opts, :by), Keyword.get(opts, :default), cas, ttl_or_default(server_options, opts)], opts, server_options)
   end
 
   @doc """

  end

  ## Private
  defp get_option(server, option) do
    Registry.lookup(server)
    |> Map.get(option)
  end

  defp normalize_coder(spec) when is_tuple(spec), do: spec
  defp normalize_coder(module) when is_atom(module), do: {module, []}

  defp encode(server, value) do
    coder = get_option(server, :coder)
    apply(elem(coder, 0), :encode, [value, elem(coder, 1)])
  end

  defp decode(server, value) do
    coder = get_option(server, :coder)
    apply(elem(coder, 0), :decode, [value, elem(coder, 1)])
  end

  defp decode_response({:ok, value}, server) when is_binary(value) do
    {:ok, decode(server, value)}
  end
  defp decode_response({:ok, value, cas}, server) when is_binary(value) do
    {:ok, decode(server, value), cas}
  end
  defp decode_response(rest, _server), do: rest


  defp decode_multi_response({:ok, values}, server) when is_list(values) do
    {:ok, Enum.map(values, &(decode_response(&1, server)))}
  end
  defp decode_multi_response(rest, _server), do: rest

  defp ttl_or_default(server, opts) do
    if Keyword.has_key?(opts, :ttl) do
      opts[:ttl]
    else
      get_option(server, :ttl)
    end
  end

  defp key_with_namespace(server, key) do
    namespace = get_option(server, :namespace)
    if namespace do
      "#{namespace}:#{key}"
    else

    end
  end

  defp execute_k(server, command, args, opts \\ []), do: execute_k(server, command, args, opts, get_server_options(server))
  defp execute_k(server, command, [key | rest], opts, server_options) do
    execute(server, command, [key_with_namespace(server_options, key) | rest], opts)
    |> decode_response(server_options)
  end

  defp execute_kv(server, command, args, opts), do: execute_kv(server, command, args, opts, get_server_options(server))
  defp execute_kv(server, command, [key | [value | rest]], opts, server_options) do
    execute(server, command, [key_with_namespace(server_options, key) | [encode(server_options, value) | rest]], opts)
    |> decode_response(server_options)
  end

  defp execute(server, command, args, opts \\ []) do
    Connection.execute(server, command, args, opts)
  end

  defp execute_quiet_k(server, commands), do: execute_quiet_k(server, commands, get_server_options(server))
  defp execute_quiet_k(server, commands, server_options) do
    commands = Enum.map(commands, fn ({command, [key | rest], opts}) ->
      {command, [key_with_namespace(server_options, key) | rest], opts}
    end)
    execute_quiet(server, commands)
    |> decode_multi_response(server_options)
  end

  defp execute_quiet_kv(server, commands, server_options) do
    commands = Enum.map(commands, fn ({command, [key | [value | rest]], opts}) ->
      {command, [key_with_namespace(server_options, key) | [encode(server_options, value) | rest]], opts}
    end)
    execute_quiet(server, commands)
    |> decode_multi_response(server_options)
  end

  defp execute_quiet(server, commands) do
