#include <cstdio>
#include <vector>
#include <cassert>
#include <algorithm>
using namespace std;

template<typename T>
class Memory
{
public:
    Memory(int size = 1000000) : top(0) {
        memory.resize(size);
    }
    
    T & get_new() {
        return memory[top++];
    }

private:
    int top;
    vector<T> memory;
};


inline bool overlap(int from1, int to1, int from2, int to2)
{
    return !((from1 < from2 && to1 <= from2) || (to1 > to2 && from1 >= to2));
}


template<int N>
class MaxTree
{
public:
    
    class Node {
    public:
        Node() : max(0), left(0), from(0), to(0), right(0) {}
        int max, from, to;
        Node *left, *right;
    };
    
    MaxTree() { root = init_node(0, N); }
    
    void set_max(int from, int to, int value)
    {
        set_max_rec(from, to, value, root);
    }
    
    void update_max(int where, int value)
    {
        update_max_rec(where, value, root);
    }
    
    int get_max(int from, int to)
    {
        return get_max_rec(from, to, root);
    }
    
    void test_overlap()
    {
        assert(overlap(1, 3, 1, 2));
        assert(overlap(1, 3, 2, 3));
        assert(overlap(1, 3, 0, 4));
        assert(overlap(0, 4, 1, 3));
        assert(!overlap(1, 3, 3, 4));
        assert(!overlap(3, 4, 1, 3));
        assert(!overlap(1, 3, 100, 200));
    }
    
private:
    
    Node *init_node(int from, int to)
    {
        Node & node = memory.get_new();
        node.from = from;
        node.to = to;
        if (from + 1 < to) {
            int mid = from + (to - from) / 2;
            node.left = init_node(from, mid);
            node.right = init_node(mid, to);
        }
        return &node;
    }
    
    void set_max_rec(int from, int to, int value, Node *node)
    {
        if (!node)
            return;
        
        if (!overlap(from, to, node->from, node->to))
            return;
        
        if (value > node->max)
            node->max = value;
        
        set_max_rec(from, to, value, node->left);
        set_max_rec(from, to, value, node->right);
    }
    
    void update_max_rec(int where, int value, Node *node)
    {
        assert(node != NULL);
        
        if (!overlap(where, where + 1, node->from, node->to))
            return;
        
        if (node->from == where && node->to == where + 1) {
            node->max = value;
        } else {
            update_max_rec(where, value, node->left);
            update_max_rec(where, value, node->right);
            node->max = max(node->left->max, node->right->max);
        }
    }
    
    int get_max_rec(int from, int to, Node *node)
    {
        if (!node)
            return 0;
        
        if (!overlap(from, to, node->from, node->to))
            return 0;
        
        if (node->from >= from && node->to <= to) {
            return node->max;
        } else {
            return max(get_max_rec(from, to, node->left), get_max_rec(from, to, node->right));
        }
    }
    
    Memory<Node> memory;
    Node *root;
};

void test_tree1()
{
    MaxTree<32> max_tree;
    max_tree.test_overlap();
    
    int from = 10, to = 20, the_max = 100;
    max_tree.set_max(from, to, the_max);
    
    for (int i = 0; i < 32; i++) {
        for (int j = i + 1; j < 32; j++) {
            if (overlap(i, j, from, to))
                assert(max_tree.get_max(i, j) == the_max);
            else
                assert(max_tree.get_max(i, j) == 0);
        }
    }
}

void test_tree2()
{
    for (int where = 0; where < 100; where++)
    {
        MaxTree<512> max_tree;
        
        int the_max = 100;
        max_tree.update_max(where, the_max);
        
        for (int i = 0; i < 512; i++) {
            for (int j = i + 1; j < 512; j++) {
                if (overlap(i, j, where, where + 1))
                    assert(max_tree.get_max(i, j) == the_max);
                else
                    assert(max_tree.get_max(i, j) == 0);
            }
        }
    }
}

struct Car
{
    Car() {}
    Car(int id, int start_x, int desired_x, int height)
        : id(id), start_x(start_x), desired_x(desired_x), height(height) {}
    int id, start_x, desired_x, height;
};

struct CmpCars_desired_x
{
    bool operator() (Car *c1, Car *c2) {
        return c1->desired_x < c2->desired_x;
    }
};

struct CmpCars_start_x
{
    bool operator() (Car *c1, Car *c2) {
        return c1->start_x < c2->start_x;
    }
};

bool alg()
{
    //vector<int> start_x, desired_x, height;
    MaxTree<100000> max_tree;
    
    vector<Car*> cars;
    
    int n, w;
    scanf("%d%d", &n, &w);
    
    Memory<Car> car_memory(n);
    
    for (int i = 0; i < n; i++) {
        int x1, y1, x2, y2;
        
        scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
        
        if (x2 < x1)
            swap(x1, x2);

        int height = abs(y2 - y1);
        
        Car &new_car = car_memory.get_new();
        new_car = Car(i, x1, 0, height);
        cars.push_back(&new_car);
        
       // max_tree.update_max(x1, height);
        
        //max_tree.set_max(x1, x2, height.back());
    }
    
    for(int i = 0; i < n; i++) {
        int x1, y1, x2, y2;
        
        scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
        
        if (x2 < x1)
            swap(x1, x2);
        
        cars[i]->desired_x = x1;
    }
    
    sort(cars.begin(), cars.end(), CmpCars_start_x());
    
    /*
    int zipped_x = -1;
    int prev_start_x = -1;
    for (int i = 0; i < cars.size(); i++) {
        if (cars[i]->start_x != prev_start_x) {
            prev_start_x = cars[i]->start_x;
            zipped_x++;
        }
        
        cars[i]->start_x = zipped_x;
    }*/
    
    for (int i = 0; i < cars.size(); i++) {
        cars[i]->start_x = i;
        max_tree.update_max(i, cars[i]->height);
    }
    
    
    
    sort(cars.begin(), cars.end(), CmpCars_desired_x());
    
    for (int i = 0; i < cars.size(); i++) {
        int max_to_cross = max_tree.get_max(0, cars[i]->start_x);
        if (max_to_cross + cars[i]->height > w)
            return false;
        max_tree.update_max(cars[i]->start_x, 0);
    }
    
    return true;
}


int main()
{
//    test_tree1();
//    test_tree2();
    
    int t;
    scanf("%d", &t);
    
    while (t--) {
        if (alg()) printf("TAK\n");
        else printf("NIE\n");
    }
}