from collections import deque, defaultdict
import sys

def distance_squared(x1, y1, x2, y2):
    return (x1 - x2) ** 2 + (y1 - y2) ** 2

class MaxFlow:
    def __init__(self):
        self.graph = defaultdict(dict)

    def add_edge(self, u, v, capacity):
        if v not in self.graph[u]:
            self.graph[u][v] = 0
        if u not in self.graph[v]:
            self.graph[v][u] = 0
        self.graph[u][v] += capacity  # in case of multiple edges, accumulate

    def bfs(self, s, t, parent):
        visited = set()
        queue = deque([s])
        visited.add(s)

        while queue:
            u = queue.popleft()
            for v in self.graph[u]:
                if v not in visited and self.graph[u][v] > 0:
                    parent[v] = u
                    visited.add(v)
                    if v == t:
                        return True
                    queue.append(v)
        return False

    def edmonds_karp(self, s, t):
        flow = 0
        parent = {}
        while self.bfs(s, t, parent):
            # Find bottleneck
            path_flow = float('inf')
            v = t
            while v != s:
                u = parent[v]
                path_flow = min(path_flow, self.graph[u][v])
                v = u
            # Update residual capacities
            v = t
            while v != s:
                u = parent[v]
                self.graph[u][v] -= path_flow
                self.graph[v][u] += path_flow
                v = u
            flow += path_flow
            parent.clear()
        return flow

def suiting_weavers(w, p, weavers, fiber_places):
    S = "S"
    T = "T"
    mf = MaxFlow()

    # Compute Willy's max fiber count
    willy_initial = weavers[0][2]
    willy_x, willy_y, _, willy_r = weavers[0]
    W = willy_initial
    total_collectable_fibers = 0

    fiber_nodes = []
    weaver_nodes = [f"w{j}" for j in range(w)]

    for i, (fx, fy, ff) in enumerate(fiber_places):
        fiber_node = f"f{i}"
        fiber_nodes.append(fiber_node)
        reachable = False

        # Source to fiber pile
        mf.add_edge(S, fiber_node, ff)

        # Check if Willy can reach it
        if distance_squared(fx, fy, willy_x, willy_y) <= willy_r ** 2:
            W += ff

        # Fiber pile to all reachable weavers
        for j, (wx, wy, wf, wr) in enumerate(weavers):
            if distance_squared(fx, fy, wx, wy) <= wr ** 2:
                mf.add_edge(fiber_node, f"w{j}", ff)
                reachable = True

        if reachable:
            total_collectable_fibers += ff

    # Weavers to sink
    for j in range(w):
        initial_fibers = weavers[j][2]
        capacity = W - initial_fibers
        if capacity < 0:
            return "Lonesome Willy"  # Already has more than Willy can possibly get
        mf.add_edge(f"w{j}", T, capacity)

    flow = mf.edmonds_karp(S, T)

    if flow == total_collectable_fibers:
        return "Suiting Success"
    else:
        return "Lonesome Willy"

def main():
    input_lines = sys.stdin.read().splitlines()
    t = int(input_lines[0])
    idx = 1
    for _ in range(t):
        w, p = map(int, input_lines[idx].split())
        idx += 1
        weavers = [tuple(map(int, input_lines[idx + i].split())) for i in range(w)]
        idx += w
        fiber_places = [tuple(map(int, input_lines[idx + i].split())) for i in range(p)]
        idx += p
        result = suiting_weavers(w, p, weavers, fiber_places)
        print(result)

if __name__ == "__main__":
    main()