/<> 1006 (DP circular -> linear)

#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <unordered_map>
#include <numeric>
#include <iomanip>
using namespace std;
#define pii pair<int , int>
#define ll long long
#define FAST ios_base::sync_with_stdio(false); cin.tie(NULL)
const long long dx[4] = {1, 0, -1, 0}, dy[4] = {0, -1, 0, 1};
const long long dl[2] = {1, -1};
const long long MOD = 1000000007;
const long long MAXN = 10005;

int t;
int n, w;
vector<int> inside, outside;
int dp[MAXN][2][2];

void init(){
    inside.clear();
    outside.clear();
    cin >> n >> w;
    inside.push_back(-1);
    for(int x, i = 0; i < n; i++){
        cin >> x;
        inside.push_back(x);
    }
    outside.push_back(-1);
    for(int x, i = 0; i < n; i++){
        cin >> x;
        outside.push_back(x);
    }
    inside[0] = inside.back();
    outside[0] = outside.back();
}

int DP1(){
    for(int i = 0; i <= n; i++){
        dp[i][0][0] = 2e9;
        dp[i][0][1] = 2e9;
        dp[i][1][0] = 2e9;
        dp[i][1][1] = 2e9;
    }
    // idx, inside, outside
    dp[1][1][0] = 1;
    dp[1][0][1] = 1;
    dp[0][1][1] = 0;
    if(inside[1] + outside[1] <= w){
        dp[1][1][1] = 1;
    }
    else{
        dp[1][1][1] = 2;
    }
    for(int i = 2; i <= n; i++){
        dp[i][1][0] = min(dp[i][1][0], dp[i - 1][1][1] + 1);
        if(inside[i] + inside[i - 1] <= w){
            dp[i][1][0] = min(dp[i][1][0], dp[i - 1][0][1] + 1);
        }
        dp[i][0][1] = min(dp[i][0][1], dp[i - 1][1][1] + 1);
        if(outside[i] + outside[i - 1] <= w){
            dp[i][0][1] = min(dp[i][0][1], dp[i - 1][1][0] + 1);
        }
        dp[i][1][1] = min(dp[i][1][1], min(dp[i][0][1] + 1, dp[i][1][0] + 1));
        if(inside[i] + outside[i] <= w){
            dp[i][1][1] = min(dp[i][1][1], dp[i - 1][1][1] + 1);
        }
        if(inside[i] + inside[i - 1] <= w && outside[i] + outside[i - 1] <= w){
            dp[i][1][1] = min(dp[i][1][1], dp[i - 2][1][1] + 2);
        }
    }
    return dp[n][1][1];
}

int DP2(){
    if(inside[0] + inside[1] > w){
        return 2e9;
    }
    for(int i = 0; i <= n; i++){
        dp[i][0][0] = 2e9;
        dp[i][0][1] = 2e9;
        dp[i][1][0] = 2e9;
        dp[i][1][1] = 2e9;
    }
    dp[1][1][0] = 1;
    dp[1][1][1] = 2;
    for(int i = 2; i <= n; i++){
        dp[i][1][0] = min(dp[i][1][0], dp[i - 1][1][1] + 1);
        if(inside[i] + inside[i - 1] <= w){
            dp[i][1][0] = min(dp[i][1][0], dp[i - 1][0][1] + 1);
        }
        dp[i][0][1] = min(dp[i][0][1], dp[i - 1][1][1] + 1);
        if(outside[i] + outside[i - 1] <= w){
            dp[i][0][1] = min(dp[i][0][1], dp[i - 1][1][0] + 1);
        }
        dp[i][1][1] = min(dp[i][1][1], min(dp[i][0][1] + 1, dp[i][1][0] + 1));
        if(inside[i] + outside[i] <= w){
            dp[i][1][1] = min(dp[i][1][1], dp[i - 1][1][1] + 1);
        }
        if(inside[i] + inside[i - 1] <= w && outside[i] + outside[i - 1] <= w){
            dp[i][1][1] = min(dp[i][1][1], dp[i - 2][1][1] + 2);
        }
    }
    return dp[n][0][1];
}

int DP3(){
    if(outside[0] + outside[1] > w){
        return 2e9;
    }
    for(int i = 0; i <= n; i++){
        dp[i][0][0] = 2e9;
        dp[i][0][1] = 2e9;
        dp[i][1][0] = 2e9;
        dp[i][1][1] = 2e9;
    }
    dp[1][0][1] = 1;
    dp[1][1][1] = 2;
    for(int i = 2; i <= n; i++){
        dp[i][1][0] = min(dp[i][1][0], dp[i - 1][1][1] + 1);
        if(inside[i] + inside[i - 1] <= w){
            dp[i][1][0] = min(dp[i][1][0], dp[i - 1][0][1] + 1);
        }
        dp[i][0][1] = min(dp[i][0][1], dp[i - 1][1][1] + 1);
        if(outside[i] + outside[i - 1] <= w){
            dp[i][0][1] = min(dp[i][0][1], dp[i - 1][1][0] + 1);
        }
        dp[i][1][1] = min(dp[i][1][1], min(dp[i][0][1] + 1, dp[i][1][0] + 1));
        if(inside[i] + outside[i] <= w){
            dp[i][1][1] = min(dp[i][1][1], dp[i - 1][1][1] + 1);
        }
        if(inside[i] + inside[i - 1] <= w && outside[i] + outside[i - 1] <= w){
            dp[i][1][1] = min(dp[i][1][1], dp[i - 2][1][1] + 2);
        }
    }
    return dp[n][1][0];
}

int DP4(){
    if(inside[0] + inside[1] > w or outside[0] + outside[1] > w){
        return 2e9;
    }
    for(int i = 0; i <= n; i++){
        dp[i][0][0] = 2e9;
        dp[i][0][1] = 2e9;
        dp[i][1][0] = 2e9;
        dp[i][1][1] = 2e9;
    }
    dp[1][1][1] = 2;
    for(int i = 2; i <= n; i++){
        dp[i][1][0] = min(dp[i][1][0], dp[i - 1][1][1] + 1);
        if(inside[i] + inside[i - 1] <= w){
            dp[i][1][0] = min(dp[i][1][0], dp[i - 1][0][1] + 1);
        }
        dp[i][0][1] = min(dp[i][0][1], dp[i - 1][1][1] + 1);
        if(outside[i] + outside[i - 1] <= w){
            dp[i][0][1] = min(dp[i][0][1], dp[i - 1][1][0] + 1);
        }
        dp[i][1][1] = min(dp[i][1][1], min(dp[i][0][1] + 1, dp[i][1][0] + 1));
        if(inside[i] + outside[i] <= w){
            dp[i][1][1] = min(dp[i][1][1], dp[i - 1][1][1] + 1);
        }
        if(inside[i] + inside[i - 1] <= w && outside[i] + outside[i - 1] <= w){
            dp[i][1][1] = min(dp[i][1][1], dp[i - 2][1][1] + 2);
        }
    }
    return dp[n - 1][1][1];
}

void solve(){
    init();
    if(n == 1){
        cout << DP1() << "\n";
        return;
    }
    cout << min(min(DP1(), DP2()), min(DP3(), DP4())) << "\n";
}

int main() {
    FAST;
    cin >> t;
    for(int i = 0; i < t; i++){
        solve();
    }
}