#include <bits/stdc++.h>
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, const std::pair<T1, T2>& p) {
  return os << "(" << p.first << ", " << p.second << ")";
}
template <typename C>
std::ostream& _debug_go(std::ostream& os, const C& v) {
  bool first = true;
  os << "[";
  for (auto i : v) {
    if (!first) os << ", ";
    os << i;
    first = false;
  }
  return os << "]";
}
template <typename T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
  return _debug_go(os, v);
}
template <typename T>
std::ostream& operator<<(std::ostream& os, const std::set<T>& v) {
  return _debug_go(os, v);
}
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, const std::map<T1, T2>& v) {
  return _debug_go(os, v);
}
struct Debugger {
  template <typename T>
  Debugger& operator,(const T& v) {
    std::cerr << v << " ";
    return *this;
  }
} dbg;
using namespace std;
using uint = uint32_t;
using llint = int64_t;
using ullint = uint64_t;
template <typename T>
using Pt = complex<T>;
template <typename T>
T cross(const Pt<T>& a, const Pt<T>& b) {
  return a.real() * b.imag() - a.imag() * b.real();
}
template <int M>
struct Modulo {
  int val;
  Modulo() : val(0) {}
  Modulo(llint val) : val((val % M + M) % M) {}
  Modulo operator+(const Modulo& rhs) const { return Modulo(val + rhs.val); }
  Modulo operator-() const { return Modulo(-val); }
  Modulo operator-(const Modulo& rhs) const { return *this + (-rhs); }
  Modulo operator*(const Modulo& rhs) const {
    return Modulo(1LL * val * rhs.val);
  }
  Modulo inv() const {
    int a = val, b = M;
    int r0 = a, s0 = 1, t0 = 0;
    int r1 = b, s1 = 0, t1 = 1;
    int q, rtmp, stmp, ttmp;
    while (r1) {
      q = r0 / r1;
      assert(abs(1LL * q * r1) <= llint(M) && abs(1LL * q * s1) <= llint(M) &&
             abs(1LL * q * t1) <= llint(M));
      rtmp = r0 - q * r1, stmp = s0 - q * s1, ttmp = t0 - q * t1;
      r0 = r1, s0 = s1, t0 = t1;
      r1 = rtmp, s1 = stmp, t1 = ttmp;
    }
    assert(val * s0 + M * t0 == r0);
    assert(r0 == 1);
    return Modulo(s0);
  }
  Modulo operator/(const Modulo& rhs) const { return *this * rhs.inv(); }
  Modulo pow(llint n) {
    if (n == 0) return 1;
    if (n < 0) return this->inv().pow(-n);
    Modulo x = this->pow(n >> 1);
    x *= x;
    if (n & 1) x *= *this;
    return x;
  }
  Modulo& operator++() { return *this = Modulo(val + 1); }
  Modulo operator++(int) {
    int tmp = val;
    ++*this;
    return Modulo(tmp);
  }
  Modulo& operator--() { return *this = Modulo(val - 1); }
  Modulo operator--(int) {
    int tmp = val;
    --*this;
    return Modulo(tmp);
  }
  Modulo& operator+=(const Modulo& rhs) { return *this = *this + rhs; }
  Modulo& operator-=(const Modulo& rhs) { return *this = *this - rhs; }
  Modulo& operator*=(const Modulo& rhs) { return *this = *this * rhs; }
  Modulo& operator/=(const Modulo& rhs) { return *this = *this / rhs; }
  bool operator==(const Modulo& rhs) const { return val == rhs.val; }
  bool operator!=(const Modulo& rhs) const { return val != rhs.val; }
};
template <int M>
std::ostream& operator<<(std::ostream& os, const Modulo<M>& x) {
  return os << x.val;
}
using Num = Modulo<998244353>;
const int MAX_N = 2e3 + 10;
pair<bool, Num> binomMemo[MAX_N][MAX_N];
Num binom(int n, int k) {
  assert(n >= 0 && k >= 0);
  if (k == 0) return 1;
  if (k > n) return 0;
  if (!binomMemo[n][k].first) {
    binomMemo[n][k].second = binom(n - 1, k - 1) + binom(n - 1, k);
    binomMemo[n][k].first = true;
  }
  return binomMemo[n][k].second;
}
pair<bool, Num> facMemo[2 * MAX_N];
Num fac(int n) {
  assert(n >= 0);
  if (n == 0) return 1;
  if (!facMemo[n].first) {
    facMemo[n].second = fac(n - 1) * n;
    facMemo[n].first = true;
  }
  return facMemo[n].second;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  int n, k, l;
  cin >> n >> k >> l;
  Num ans = 0;
  Num prod = 1;
  for (int i = (0); i < (k); ++i) {
    Num prod_ = prod;
    for (int j = (0); j < (n - i + 1); ++j) {
      Num term = binom(n, i) * binom(n - i, j) * prod_ * fac(i + j).pow(2) /
                 fac(2 * (i + j) + 1);
      ans += term;
      prod_ *= -2;
    }
    prod *= 2;
  }
  ans = Num(1) - ans;
  ans *= l;
  cout << ans << '\n';
  return 0;
}
