For problem statement at 1000-1999/1100-1199/1130-1139/1132/problemG.txt this is a correct solution, but verifier at 1000-1999/1100-1199/1130-1139/1132/verifierG.go ends with All 100 tests passed can you fix the verifier? package main

import (
	"io"
	"os"
	"strconv"
)

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < fs.n && (fs.data[fs.idx] < '0' || fs.data[fs.idx] > '9') {
		fs.idx++
	}
	val := 0
	for fs.idx < fs.n && fs.data[fs.idx] >= '0' && fs.data[fs.idx] <= '9' {
		val = val*10 + int(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return val
}

type SegTree struct {
	n    int
	h    int
	tree []int
	lazy []int
}

func NewSegTree(sz int) *SegTree {
	n := 1
	h := 0
	for n < sz {
		n <<= 1
		h++
	}
	return &SegTree{
		n:    n,
		h:    h,
		tree: make([]int, 2*n),
		lazy: make([]int, 2*n),
	}
}

func (st *SegTree) apply(p, v int) {
	st.tree[p] += v
	if p < st.n {
		st.lazy[p] += v
	}
}

func (st *SegTree) build(p int) {
	for p > 1 {
		p >>= 1
		if st.tree[p<<1] > st.tree[p<<1|1] {
			st.tree[p] = st.tree[p<<1] + st.lazy[p]
		} else {
			st.tree[p] = st.tree[p<<1|1] + st.lazy[p]
		}
	}
}

func (st *SegTree) push(p int) {
	for s := st.h; s > 0; s-- {
		i := p >> s
		if st.lazy[i] != 0 {
			v := st.lazy[i]
			st.apply(i<<1, v)
			st.apply(i<<1|1, v)
			st.lazy[i] = 0
		}
	}
}

func (st *SegTree) RangeAdd(l, r, v int) {
	if l >= r {
		return
	}
	l += st.n
	r += st.n
	l0, r0 := l, r
	for l < r {
		if l&1 == 1 {
			st.apply(l, v)
			l++
		}
		if r&1 == 1 {
			r--
			st.apply(r, v)
		}
		l >>= 1
		r >>= 1
	}
	st.build(l0)
	st.build(r0 - 1)
}

func (st *SegTree) PointAdd(pos, v int) {
	p := pos + st.n
	st.tree[p] += v
	st.build(p)
}

func (st *SegTree) RangeMax(l, r int) int {
	if l >= r {
		return 0
	}
	l += st.n
	r += st.n
	st.push(l)
	st.push(r - 1)
	resL, resR := 0, 0
	for l < r {
		if l&1 == 1 {
			if st.tree[l] > resL {
				resL = st.tree[l]
			}
			l++
		}
		if r&1 == 1 {
			r--
			if st.tree[r] > resR {
				resR = st.tree[r]
			}
		}
		l >>= 1
		r >>= 1
	}
	if resL > resR {
		return resL
	}
	return resR
}

func main() {
	fs := NewFastScanner()
	n := fs.NextInt()
	k := fs.NextInt()

	seg := NewSegTree(n)
	stackIdx := make([]int, n)
	stackVal := make([]int, n)
	top := 0

	out := make([]byte, 0, (n-k+1)*4)

	for i := 1; i <= n; i++ {
		x := fs.NextInt()

		for top > 0 && stackVal[top-1] < x {
			top--
		}

		prev := 0
		if top > 0 {
			prev = stackIdx[top-1]
		}

		if prev < i-1 {
			seg.RangeAdd(prev, i-1, 1)
		}

		seg.PointAdd(i-1, 1)

		stackIdx[top] = i
		stackVal[top] = x
		top++

		if i >= k {
			ans := seg.RangeMax(i-k, i)
			if len(out) > 0 {
				out = append(out, ' ')
			}
			out = strconv.AppendInt(out, int64(ans), 10)
		}
	}

	out = append(out, '\n')
	os.Stdout.Write(out)
}