// PEAKS
// Peaks
// Author: Kanstantsin Sokal
// Complexity: O(N * A * log N)
// Expected Verdict: AC

#include <bits/stdc++.h>

using namespace std;

const int MAX_N = 5010;
const int MAX_A = 201;

const int MOD = 1000000009;

void add(int &a, int b) {
  a += b;

  if (a >= MOD) {
    a -= MOD;
  }
}

int absolute(int x) {
  return max(x, -x);
}

struct FenwickTree {
  int tree[MAX_N];
  int sum_all;

  FenwickTree() { }

  void clear() {
    memset(tree, 0, sizeof(tree));
    sum_all = 0;
  }

  void modify(int position, int delta) {
    if (delta == 0) {
      return;
    }
    
    while (position < MAX_N) {
      add(tree[position], delta);
      position = position + position - (position & (position - 1));
    }

    add(sum_all, delta);
  }

  int find_sum_on_prefix(int position) {
    int result = 0;

    while (position) {
      add(result, tree[position]);
      position = position & (position - 1);
    }

    return result;
  }

  int find_sum_on_suffix(int position) {
    int result = sum_all - find_sum_on_prefix(position - 1);
    add(result, MOD);

    return result;
  }
};

int arr[MAX_N];
FenwickTree fenwick_trees[MAX_A][3][2];
int f[MAX_A][3][2];

pair<int, int> buffer[MAX_N];

void compress(int n, int arr[]) {
  for (int i = 0; i < n; i++) {
    buffer[i] = make_pair(arr[i], i);
  }

  sort(buffer, buffer + n);

  int last_value = buffer[0].first;
  int last_compressed_value = 1;

  for (int i = 0; i < n; i++) {
    if (last_value < buffer[i].first) {
      last_value = buffer[i].first;
      last_compressed_value += 1;
    }

    arr[buffer[i].second] = last_compressed_value;
  }

  assert(last_compressed_value == n);
}

void solve() {
  int n, a, b; scanf("%d%d%d", &n, &a, &b);

  for (int i = 0; i < n; i++) {
    scanf("%d", &arr[i]);
  }

  if (absolute(a - b) > 1) {
    printf("0\n");
    return;
  }

  compress(n, arr);

  for (int i = 0; i <= a; i++) {
    for (int j = 0; j < 3; j++) {
      fenwick_trees[i][j][0].clear();
      fenwick_trees[i][j][1].clear();
    }
  }

  int answer = 0;
  for (int i = 0; i < n; i++) {
    for (int j = 0; j <= a; j++) {
      for (int k = max(0, j - 1); k <= min(j + 1, b); k++) {
        f[j][k - j + 1][0] = fenwick_trees[j][k - j + 1][0].find_sum_on_prefix(arr[i] - 1);
        f[j][k - j + 1][1] = fenwick_trees[j][k - j + 1][1].find_sum_on_suffix(arr[i] + 1);
      }
    }

    add(answer, f[a][b - a + 1][0]);
    add(answer, f[a][b - a + 1][1]);
    if (a + b == 0) {
      add(answer, 1);
    }

    fenwick_trees[0][1][0].modify(arr[i], 1);
    fenwick_trees[0][1][1].modify(arr[i], 1);
    for (int j = 0; j <= a; j++) {
      for (int k = max(0, j - 1); k <= min(j + 1, b); k++) {
        fenwick_trees[j][k - j + 1][0].modify(arr[i], f[j][k - j + 1][0]);
        fenwick_trees[j][k - j + 1][1].modify(arr[i], f[j][k - j + 1][1]);

        if (j + 1 <= a && absolute(j - k + 1) <= 1) {
          fenwick_trees[j + 1][k - j][0].modify(arr[i], f[j][k - j + 1][1]);
        }

        if (k + 1 <= b && absolute(j - k - 1) <= 1) {
          fenwick_trees[j][k - j + 2][1].modify(arr[i], f[j][k - j + 1][0]);
        }
      }
    }
  }

  printf("%d\n", answer);
}

int main() {
  int cases; scanf("%d", &cases);

  for (int i = 0; i < cases; i++) {
    solve();
  }

  return 0;
}