#include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <vector>
using namespace std;

typedef long long int64;

const int64 kInf = 12345678912345LL;
const int64 MAXK = 50, KLIM = (MAXK + 1) << 1, NLIM = 1000;

int N, M, K;
vector<int> weights;
vector<vector<int>> adj;
int64 f[2][KLIM][KLIM][NLIM];
int timer;
vector<int> tin, tout, par;
vector<int> cycle_ids, cycle_lens, cycle_rev, dist_to_par;
vector<vector<int>> edge_lnks;
vector<pair<int, int>> dp_edges;

void dfs(int x) {
  tin[x] = timer++;
  for (int y : adj[x]) {
    if (tin[y] != -1) {
      continue;
    }
    dfs(y);
  }
  tout[x] = timer++;
}

int cycle_counter;
vector<int> dfs_stack;

void dfs_cycles(int x, int p) {
  tin[x] = timer++;
  dfs_stack.push_back(x);
  for (int y : adj[x]) {
    if (y == p) {
      continue;
    }
    if (y == par[x]) {
      int cur_len = 1;
      int rev_cycle = -1;
      for (int z = (int)dfs_stack.size() - 1; dfs_stack[z] != par[x]; z--) {
        int edge_id = edge_lnks[dfs_stack[z - 1]][dfs_stack[z]];
        int rev_edge_id = edge_lnks[dfs_stack[z]][dfs_stack[z - 1]];
        if (rev_edge_id != -1 && cycle_ids[rev_edge_id] != -1) {
          rev_cycle = cycle_ids[rev_edge_id];
          cycle_rev[rev_cycle] = cycle_counter;
        }
        cycle_ids[edge_id] = cycle_counter;
        dist_to_par[edge_id] = cur_len++;
      }
      cycle_lens.push_back(cur_len);
      cycle_rev.push_back(rev_cycle);
      cycle_counter++;
    } else {
      if (tin[y] != -1) {
        continue;
      }
      if (edge_lnks[x][y] == -1) {
        edge_lnks[x][y] = dp_edges.size();
        dp_edges.emplace_back(x, y);
        cycle_ids.push_back(-1);
        dist_to_par.push_back(-1);
      }
      dfs_cycles(y, x);
    }
  }
  dfs_stack.pop_back();
}

int lazy_max_dist;

int64 lazy_dp(int edge_id, int dist_to_last, int par_dist, int promised) {
  if (dist_to_last > K + 1) {
    promised = 1;
  }
  if (f[promised][dist_to_last][par_dist][edge_id] != -1LL) {
    return f[promised][dist_to_last][par_dist][edge_id];
  }
  const int base_cycle_id = cycle_ids[edge_id];
  if (!dist_to_last && base_cycle_id != -1 &&
      cycle_lens[base_cycle_id] - dist_to_par[edge_id] < par_dist) {
    return f[promised][dist_to_last][par_dist][edge_id] = lazy_dp(
               edge_id, dist_to_last,
               cycle_lens[base_cycle_id] - dist_to_par[edge_id], promised);
  }
  if (!promised && base_cycle_id != -1 &&
      dist_to_par[edge_id] + par_dist < dist_to_last) {
    return f[promised][dist_to_last][par_dist][edge_id] = lazy_dp(
               edge_id, dist_to_par[edge_id] + par_dist, par_dist, promised);
  }
  const int x = dp_edges[edge_id].second;
  int64 res = kInf;
  if (dist_to_last) {
    res = min(res, lazy_dp(edge_id, 0, par_dist, 0) + weights[x]);
  }
  if (dist_to_last == lazy_max_dist) {
    return f[promised][dist_to_last][par_dist][edge_id] = res;
  }
  const int p = dp_edges[edge_id].first;
  vector<int> edge_list;
  vector<pair<int, int>> edge_groups;
  map<int, int> cycle_to_ind;
  for (int y : adj[x]) {
    if (y == p) {
      continue;
    }
    int new_edge_id = edge_lnks[x][y];
    if (new_edge_id == -1) {
      continue;
    }
    int cycle_id = cycle_ids[new_edge_id];
    if (cycle_id != -1) {
      auto mit = cycle_to_ind.find(cycle_id);
      if (mit != cycle_to_ind.end()) {
        edge_groups[mit->second].second = edge_list.size();
        edge_list.push_back(new_edge_id);
        continue;
      }
    }
    int rev_cycle_id = (cycle_id == -1 ? -1 : cycle_rev[cycle_id]);
    cycle_to_ind[rev_cycle_id] = edge_groups.size();
    edge_groups.emplace_back(edge_list.size(), -1);
    edge_list.push_back(new_edge_id);
  }
  const int esz = edge_list.size();
  if (!esz) {
    return f[promised][dist_to_last][par_dist][edge_id] =
               (promised || dist_to_last > K) ? res : 0LL;
  }
  const int egsz = edge_groups.size();
  vector<int64> edge_f(esz), edge_f2(esz);
  for (int new_dist_to_last = dist_to_last + 1, new_promised = promised;
       new_dist_to_last <= lazy_max_dist && res;
       ++new_dist_to_last, new_promised = 1) {
    const int inv_dist_to_last = lazy_max_dist - new_dist_to_last;
    const int min_dist_to_last = min(dist_to_last + 1, 2 + inv_dist_to_last);
    for (int i = 0; i < esz; ++i) {
      const int new_edge_id = edge_list[i];
      const int new_cycle_id = cycle_ids[new_edge_id];
      int new_par_dist = lazy_max_dist;
      if (new_cycle_id != -1) {
        if (new_cycle_id == base_cycle_id) {
          new_par_dist = par_dist;
          new_par_dist =
              min(new_par_dist, 1 + cycle_lens[base_cycle_id] -
                                    dist_to_par[edge_id] + inv_dist_to_last);
        } else {
          new_par_dist = min_dist_to_last - 1;
        }
      }
      edge_f[i] = lazy_dp(new_edge_id, min_dist_to_last, new_par_dist, 0);
    }
    for (int i = 0; i < esz; i++) {
      const int new_edge_id = edge_list[i];
      const int new_cycle_id = cycle_ids[new_edge_id];
      int new_par_dist = lazy_max_dist;
      if (new_cycle_id != -1) {
        if (new_cycle_id == base_cycle_id) {
          new_par_dist = par_dist;
        } else {
          new_par_dist = dist_to_last;
        }
      }
      edge_f2[i] =
          lazy_dp(new_edge_id, new_dist_to_last, new_par_dist, new_promised);
    }
    int64 f_sum = 0LL, min_diff = kInf;
    for (int i = 0; i < egsz; i++) {
      const int ind1 = edge_groups[i].first;
      int64 edge_group_f = edge_f[ind1], edge_group_f2 = edge_f2[ind1];
      const int ind2 = edge_groups[i].second;
      if (ind2 != -1) {
        edge_group_f = min(edge_group_f, edge_f[ind2]);
        edge_group_f2 = min(edge_group_f2, edge_f2[ind2]);
      }
      min_diff = min(min_diff, edge_group_f2 - edge_group_f);
      f_sum += edge_group_f;
    }
    res = min(res, f_sum + min_diff);
  }
  return f[promised][dist_to_last][par_dist][edge_id] = res;
}

int64 solve() {
  vector<pair<int, int>> edges;
  cin >> N >> M >> K;
  weights.resize(N);
  for (int i = 0; i < N; ++i) {
    cin >> weights[i];
  }
  edges.resize(M);
  for (int i = 0; i < M; ++i) {
    cin >> edges[i].first >> edges[i].second;
    --edges[i].first;
    --edges[i].second;
  }
  int root = N;
  edges.emplace_back(N++, 0);
  M++;
  adj.assign(N, {});
  for (int i = 0; i < M; i++) {
    adj[edges[i].first].push_back(edges[i].second);
    adj[edges[i].second].push_back(edges[i].first);
  }
  timer = 0;
  tin.assign(N, -1);
  tout.resize(N, -1);
  dfs(root);
  vector<int> tin0 = tin, tout0 = tout;
  for (int x = 0; x < N; x++) {
    reverse(adj[x].begin(), adj[x].end());
  }
  timer = 0;
  tin.assign(N, -1);
  tout.resize(N, -1);
  dfs(root);
  par.assign(N, -1);
  for (int x = 0; x < N; x++) {
    for (int y : adj[x]) {
      if (tin0[y] < tin0[x] && tin[y] < tin[x]) {
        par[x] = y;
      }
    }
  }
  cycle_counter = 0;
  dp_edges.clear();
  edge_lnks.assign(N, vector<int>(N, -1));
  cycle_ids.clear();
  cycle_lens.clear();
  cycle_rev.clear();
  dist_to_par.clear();
  timer = 0;
  tin.assign(N, -1);
  dfs_stack.clear();
  dfs_cycles(root, root);
  for (int x = 0; x < N; x++) {
    reverse(adj[x].begin(), adj[x].end());
  }
  timer = 0;
  tin.assign(N, -1);
  dfs_cycles(root, root);
  memset(f, -1, sizeof f);
  lazy_max_dist = ((K + 1) << 1) - 1;
  int64 res = kInf;
  for (int i = 0; i <= K; i++) {
    res = min(res, lazy_dp(edge_lnks[root][0], i + K + 1, lazy_max_dist, 1));
  }
  return res;
}

int main() {
  int T;
  cin >> T;
  for (int t = 1; t <= T; t++) {
    cout << "Case #" << t << ": " << solve() << endl;
  }
  return 0;
}