```go
package main

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

func main() {
	var t int
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	fmt.Fscan(in, &t)
	for i := 0; i < t; i++ {
		var l, r int
		var m int64
		fmt.Fscan(in, &l, &r, &m)

		// We iterate over every possible value of a in [l, r].
		// The equation is m = n*a + b - c.
		// This can be rewritten as m - (b - c) = n*a.
		// So (b - c) must be congruent to m modulo a.
		// Let rem = m % a.
		// Then b - c can be rem, or rem - a, or rem + a, etc.
		// Since l <= b, c <= r, the difference b - c is in [-(r-l), r-l].
		// We check if rem fits in this range or rem - a fits in this range.

		for a := l; a <= r; a++ {
			aa := int64(a)
			rem := m % aa
			diff := int64(r - l)

			// Case 1: b - c = rem
			// We need 0 <= rem <= r - l. (0 <= rem is guaranteed by modulo)
			// Also we need n > 0.
			// m = n*a + rem implies n = (m - rem) / a.
			// Since rem >= 0, n = m / a.
			// We need n > 0, so m / a > 0 => m >= a.
			if rem <= diff && m >= aa {
				// We set c = l, b = l + rem.
				// Then b is within [l, l + r - l] = [l, r].
				fmt.Fprintln(out, a, l+int(rem), l)
				break
			}

			// Case 2: b - c = rem - a
			// We need -(r - l) <= rem - a < 0.
			// This is equivalent to a - rem <= r - l.
			// n = (m - (rem - a)) / a = (m - rem)/a + 1.
			// Since m >= 1 and rem < a, n is at least 1 (even if m < a).
			if aa-rem <= diff {
				// We set b = l, c = l + (a - rem).
				// Then c is within [l, r].
				fmt.Fprintln(out, a, l, l+int(aa-rem))
				break
			}
		}
	}
}
```