For problem statement at 1000-1999/1500-1599/1550-1559/1555/problemE.txt this is a correct solution, but verifier at 1000-1999/1500-1599/1550-1559/1555/verifierE.go ends with case 1 failed: expected 1000000007 got 1073741824
exit status 1 can you fix the verifier? package main

import (
	"io"
	"os"
	"sort"
)

type Seg struct {
	l, r, w int
}

type SegTree struct {
	n  int
	mn []int
	lz []int
}

func NewSegTree(n int) *SegTree {
	if n < 0 {
		n = 0
	}
	size := n*4 + 5
	return &SegTree{
		n:  n,
		mn: make([]int, size),
		lz: make([]int, size),
	}
}

func (st *SegTree) Add(l, r, val int) {
	if st.n == 0 || l > r {
		return
	}
	st.add(1, 1, st.n, l, r, val)
}

func (st *SegTree) add(idx, l, r, ql, qr, val int) {
	if ql > r || qr < l {
		return
	}
	if ql <= l && r <= qr {
		st.mn[idx] += val
		st.lz[idx] += val
		return
	}
	mid := (l + r) >> 1
	left := idx << 1
	right := left | 1
	if st.lz[idx] != 0 {
		v := st.lz[idx]
		st.mn[left] += v
		st.lz[left] += v
		st.mn[right] += v
		st.lz[right] += v
		st.lz[idx] = 0
	}
	if ql <= mid {
		st.add(left, l, mid, ql, qr, val)
	}
	if qr > mid {
		st.add(right, mid+1, r, ql, qr, val)
	}
	if st.mn[left] < st.mn[right] {
		st.mn[idx] = st.mn[left]
	} else {
		st.mn[idx] = st.mn[right]
	}
}

func (st *SegTree) Min() int {
	if st.n == 0 {
		return 0
	}
	return st.mn[1]
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	pos := 0
	nextInt := func() int {
		sign := 1
		val := 0
		for pos < len(data) && (data[pos] < '0' || data[pos] > '9') && data[pos] != '-' {
			pos++
		}
		if pos < len(data) && data[pos] == '-' {
			sign = -1
			pos++
		}
		for pos < len(data) && data[pos] >= '0' && data[pos] <= '9' {
			val = val*10 + int(data[pos]-'0')
			pos++
		}
		return sign * val
	}

	n := nextInt()
	m := nextInt()
	segs := make([]Seg, n)
	for i := 0; i < n; i++ {
		l := nextInt()
		r := nextInt()
		w := nextInt()
		segs[i] = Seg{l: l, r: r, w: w}
	}
	sort.Slice(segs, func(i, j int) bool { return segs[i].w < segs[j].w })

	st := NewSegTree(m - 1)
	const INF = int(1 << 30)
	ans := INF
	L := 0
	for R := 0; R < n; R++ {
		st.Add(segs[R].l, segs[R].r-1, 1)
		for L <= R && st.Min() > 0 {
			diff := segs[R].w - segs[L].w
			if diff < ans {
				ans = diff
			}
			st.Add(segs[L].l, segs[L].r-1, -1)
			L++
		}
	}

	out := []byte{}
	out = appendInt(out, ans)
	out = append(out, '\n')
	os.Stdout.Write(out)
}

func appendInt(b []byte, v int) []byte {
	if v == 0 {
		return append(b, '0')
	}
	if v < 0 {
		b = append(b, '-')
		v = -v
	}
	var buf [20]byte
	i := len(buf)
	for v > 0 {
		i--
		buf[i] = byte('0' + v%10)
		v /= 10
	}
	return append(b, buf[i:]...)
}