For problem statement at 1000-1999/1400-1499/1470-1479/1479/problemC.txt this is a correct solution, but verifier at 1000-1999/1400-1499/1470-1479/1479/verifierC.go ends with All 100 tests passed can you fix the verifier? ```go
package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var L, R int
	if _, err := fmt.Fscan(reader, &L, &R); err != nil {
		return
	}

	// We use 22 nodes. Node 22 is the sink. Nodes 2..21 are generators.
	// Node u (2 <= u <= 21) generates path lengths {1, ..., 2^(21-u)}.
	// This corresponds to bit k = 21 - u.
	const N = 22
	
	type Edge struct {
		u, v, w int
	}
	var edges []Edge

	// Construct the backbone connecting generators
	for u := 2; u <= 21; u++ {
		// Connect to sink with weight 1
		edges = append(edges, Edge{u, N, 1})
		
		// Connect to subsequent generators
		// Node v corresponds to a smaller power of 2 than node u
		// We want to add the capacity of v to u
		for v := u + 1; v <= 21; v++ {
			w := 1 << (21 - v)
			edges = append(edges, Edge{u, v, w})
		}
	}

	// Connect source (node 1) to generators to form the range [L, R]
	if L == 1 {
		// Edge (1, N) with weight 1 covers the length 1
		edges = append(edges, Edge{1, N, 1})
		
		if R > 1 {
			// We need to cover [2, R], which is a count of R - 1
			count := R - 1
			currentBase := 2
			for k := 0; k < 20; k++ {
				if (count>>k)&1 == 1 {
					u := 21 - k
					w := currentBase - 1
					edges = append(edges, Edge{1, u, w})
					currentBase += (1 << k)
				}
			}
		}
	} else {
		// L > 1, cover [L, R] directly
		count := R - L + 1
		currentBase := L
		for k := 0; k < 20; k++ {
			if (count>>k)&1 == 1 {
				u := 21 - k
				w := currentBase - 1
				edges = append(edges, Edge{1, u, w})
				currentBase += (1 << k)
			}
		}
	}

	fmt.Fprintln(writer, "YES")
	fmt.Fprintf(writer, "%d %d\n", N, len(edges))
	for _, e := range edges {
		fmt.Fprintf(writer, "%d %d %d\n", e.u, e.v, e.w)
	}
}
```