#include <bits/stdc++.h>
#ifndef ONLINE_JUDGE
#ifdef CPH
#include "/home/floze3/OI/debug.hpp"
#else 
#include "/home/floze3/OI/debug_colored.hpp"
#endif
#else
#define debug(...) 42
#define debugArr(...) 42
#define look_time 42
#define look_memory 42
#endif
#define mp(x, y) std::make_pair(x, y)
#define mt std::make_tuple
#define eb emplace_back
#define fi first
#define se second
#define all(s) s.begin(), s.end()
#define rall(s) s.rbegin(), s.rend()
#define file(name)                 \
  freopen(name ".in", "r", stdin); \
  freopen(name ".out", "w", stdout);
#define fs(x) std::fixed << std::setprecision(x)
#define il inline
#define Avada_Kedavra return 0
#define _IOS                        \
  std::ios::sync_with_stdio(false); \
  std::cin.tie(nullptr), std::cout.tie(nullptr)
#define RANDOM_SEED std::chrono::steady_clock::now().time_since_epoch().count()
#define multitask    \
  int _; rd >> _; \
  while (_--)
using std::cerr;

namespace TYPEDEF {

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned int;
using i128 = __int128;
using pii = std::pair<int, int>;
using pi64 = std::pair<i64, i64>;
using vi = std::vector<int>;
using vi64 = std::vector<i64>;
using vu64 = std::vector<u64>;
using vpii = std::vector<pii>;
using vpi64 = std::vector<pi64>;
using si = std::stack<int>;
using si64 = std::stack<i64>;
using su64 = std::stack<u64>;
using spii = std::stack<pii>;
using spi64 = std::stack<pi64>;
using qi = std::queue<int>;
using qi64 = std::queue<i64>;
using qu64 = std::queue<u64>;
using qpii = std::queue<pii>;
using qpi64 = std::queue<pi64>;
using siset = std::set<int>;
using si64set = std::set<i64>;
using su64set = std::set<u64>;
using spiiset = std::set<pii>;
using spi64set = std::set<pi64>;
using str = std::string;
using vstr = std::vector<str>;
using f64 = long double;

} // namespaec TYPEDEF

using namespace TYPEDEF;

/*===============================ALGOS===============================*/

namespace basic_algorithm {
template <typename T> il T abs(T a) { return a >= 0 ? a : -a; }
template <typename T> il void chmin(T &a, T b) { if (a > b) a = b; }
template <typename T> il void chmax(T &a, T b) { if (a < b) a = b; }
template <typename T> il T lowbit(T x) { return (x & (-x)); }
il int pct(int x) { return __builtin_popcount(x); }
il int pct(u32 x) { return __builtin_popcount(x); }
il int pct(i64 x) { return __builtin_popcountll(x); }
il int pct(u64 x) { return __builtin_popcountll(x); }
}  // namespace basic_algorithm

using namespace basic_algorithm;

/*================================END================================*/

constexpr int N = 1e6 + 5;
constexpr int mod = 1e9 + 7;
constexpr int inf = 0x3f3f3f3f;
constexpr i64 inf64 = 0x3f3f3f3f3f3f3f3fll;
constexpr f64 eps = 1e-8;

std::mt19937 rng(RANDOM_SEED);

bool mst;

f64 f, ans;
int s[N], n, pos[N], id = -1;
char c[N];

bool med;

signed main() {
  _IOS;
  int _; std::cin >> _;
  for (int testid = 1; testid <= _; ++testid) {
    std::cin >> n >> f >> c, id = -1;
    for (int i = 1; i <= n; ++i) s[i] = s[i - 1] + c[i - 1] - '0';
    for (int i = 1; i <= n; ++i) pos[i] = i;
    std::sort(pos + 1, pos + 1 + n, [](int x, int y) {
      return -f * x + s[x] < -f * y + s[y];
    });
    for (int i = 1; i <= n; ++i) {
      for (int j = i - 1; j >= std::max(0, i - 100); --j) {
        f64 res = (f64)(s[pos[i]] - s[pos[j]]) / (pos[i] - pos[j]);
        if (id == -1) id = pos[i], ans = res;
        else {
          f64 p1 = fabs(f - res), p2 = fabs(f - ans);
          if (fabs(p1 - p2) > eps) {
            if (p1 < p2) ans = res, id = std::min(pos[i], pos[j]);
          }
          else chmin(id, std::min(pos[i], pos[j]));
        }
        // cerr << id << '\n';
      }
    }
    std::cout << "Case #" << testid << ": " << id << '\n';
  }
  
  Avada_Kedavra;
}

/*
all the things you do
the words you say
it all comes back to you
*/