```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

func scanInt(scanner *bufio.Scanner) int {
	scanner.Scan()
	b := scanner.Bytes()
	res := 0
	for _, v := range b {
		res = res*10 + int(v-'0')
	}
	return res
}

func scanInt64(scanner *bufio.Scanner) int64 {
	scanner.Scan()
	b := scanner.Bytes()
	var res int64
	for _, v := range b {
		res = res*10 + int64(v-'0')
	}
	return res
}

type Event struct {
	x    int64
	diff int64
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	if !scanner.Scan() {
		return
	}
	t := 0
	for _, v := range scanner.Bytes() {
		t = t*10 + int(v-'0')
	}

	for tc := 0; tc < t; tc++ {
		n := scanInt(scanner)
		m := scanInt64(scanner)

		x := make([]int64, n)
		p := make([]int64, n)
		events := make([]Event, 0, 3*n)

		for i := 0; i < n; i++ {
			x[i] = scanInt64(scanner)
			p[i] = scanInt64(scanner)
			events = append(events, Event{x[i] - p[i], 1})
			events = append(events, Event{x[i], -2})
			events = append(events, Event{x[i] + p[i], 1})
		}

		sort.Slice(events, func(i, j int) bool {
			return events[i].x < events[j].x
		})

		compacted := make([]Event, 0, len(events))
		for i := 0; i < len(events); {
			j := i
			sum := int64(0)
			for j < len(events) && events[j].x == events[i].x {
				sum += events[j].diff
				j++
			}
			compacted = append(compacted, Event{events[i].x, sum})
			i = j
		}

		S_arr := make([]int64, len(compacted))
		var slope int64 = 0
		var S int64 = 0
		last_x := compacted[0].x

		for i, ev := range compacted {
			S += slope * (ev.x - last_x)
			last_x = ev.x
			S_arr[i] = S
			slope += ev.diff
		}

		hasFlood := false
		var M1 int64 = -3000000000000000000
		var M2 int64 = -3000000000000000000

		for i := 0; i < n; i++ {
			left, right := 0, len(compacted)-1
			idx := -1
			for left <= right {
				mid := (left + right) / 2
				if compacted[mid].x == x[i] {
					idx = mid
					break
				} else if compacted[mid].x < x[i] {
					left = mid + 1
				} else {
					right = mid - 1
				}
			}

			Sx := S_arr[idx]
			if Sx > m {
				hasFlood = true
				if Sx-x[i] > M1 {
					M1 = Sx - x[i]
				}
				if Sx+x[i] > M2 {
					M2 = Sx + x[i]
				}
			}
		}

		res := make([]byte, n)
		for i := 0; i < n; i++ {
			if !hasFlood {
				res[i] = '1'
			} else {
				if p[i]-x[i] >= M1-m && p[i]+x[i] >= M2-m {
					res[i] = '1'
				} else {
					res[i] = '0'
				}
			}
		}
		fmt.Fprintln(writer, string(res))
	}
}
```